November 2014 - tor-commits - lists.torproject.org

[tor/master] Fix a likely bug found by coverity in test_scheduler.c.
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 49976fabc4457713347fe6d0c8e16939de852393 Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Nov 27 23:21:46 2014 -0500 Fix a likely bug found by coverity in test_scheduler.c. Andrea, do you agree with this? This is CID 1256186 --- src/test/test_scheduler.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/test_scheduler.c b/src/test/test_scheduler.c index da5c4e8..d031214 100644 --- a/src/test/test_scheduler.c +++ b/src/test/test_scheduler.c @@ -258,7 +258,7 @@ circuitmux_compare_muxes_mock(circuitmux_t *cmux_1, else if (cmux_1 == mock_ccm_tgt_2 && cmux_2 == mock_ccm_tgt_1) { result = 1; } else { - if (cmux_1 == mock_ccm_tgt_1 || cmux_1 == mock_ccm_tgt_1) result = -1; + if (cmux_1 == mock_ccm_tgt_1 || cmux_1 == mock_ccm_tgt_2) result = -1; else if (cmux_2 == mock_ccm_tgt_1 || cmux_2 == mock_ccm_tgt_2) { result = 1; } else {

1 0

[tor/master] Tweak global_scheduler changes file
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 95ead313490accfb9ec43630a702b6d735dd34fb Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Nov 27 23:05:21 2014 -0500 Tweak global_scheduler changes file --- changes/global_scheduler | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/changes/global_scheduler b/changes/global_scheduler index d0b8305..df3b464 100644 --- a/changes/global_scheduler +++ b/changes/global_scheduler @@ -1,4 +1,12 @@ - o Major changes: + o Major features (relay, infrastructure): - Implement a new inter-cmux comparison API, a global high/low watermark mechanism and a global scheduler loop for transmission prioritization - across all channels as well as among circuits on one channel. + across all channels as well as among circuits on one channel. This + schedule is currently tuned to (tolerantly) avoid making changes + in the current network performance, but it should form the basis + major circuit performance increases. Code by Andrea; implements + ticket 9262. + + o Testing: + - New tests for many parts of channel, relay, and circuit mux + functionality. Code by Andrea; part of 9262.

1 0

[tor/master] One more, appease "make check-spaces"
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit e2641484a72c342ad6313eea135709f21c3a225a Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Nov 27 22:57:04 2014 -0500 One more, appease "make check-spaces" --- src/or/main.c | 1 - src/or/scheduler.c | 1 + 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/src/or/main.c b/src/or/main.c index 64ccbd4..e78e9bf 100644 --- a/src/or/main.c +++ b/src/or/main.c @@ -224,7 +224,6 @@ set_buffer_lengths_to_zero(tor_socket_t s) } #endif - /** Return 1 if we have successfully built a circuit, and nothing has changed * to make us think that maybe we can't. */ diff --git a/src/or/scheduler.c b/src/or/scheduler.c index c2ede84..61f69b3 100644 --- a/src/or/scheduler.c +++ b/src/or/scheduler.c @@ -706,3 +706,4 @@ scheduler_set_watermarks(uint32_t lo, uint32_t hi, uint32_t max_flush) sched_q_high_water = hi; sched_max_flush_cells = max_flush; } +

1 0

[tor/master] Make queue thresholds and flush size for global scheduler into config options
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 12b6c7df4aaf3224bc5649ef69a06dccc58ae961 Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Oct 7 09:53:57 2014 -0700 Make queue thresholds and flush size for global scheduler into config options --- src/or/config.c | 22 ++++++++++++++++++++++ src/or/or.h | 13 +++++++++++++ src/or/scheduler.c | 38 +++++++++++++++++++++++++++++--------- src/or/scheduler.h | 3 +++ 4 files changed, 67 insertions(+), 9 deletions(-) diff --git a/src/or/config.c b/src/or/config.c index 86d7c6e..c124372 100644 --- a/src/or/config.c +++ b/src/or/config.c @@ -367,6 +367,9 @@ static config_var_t option_vars_[] = { V(ServerDNSSearchDomains, BOOL, "0"), V(ServerDNSTestAddresses, CSV, "www.google.com,www.mit.edu,www.yahoo.com,www.slashdot.org"), + V(SchedulerLowWaterMark, MEMUNIT, "16 kB"), + V(SchedulerHighWaterMark, MEMUNIT, "32 kB"), + V(SchedulerMaxFlushCells, UINT, "16"), V(ShutdownWaitLength, INTERVAL, "30 seconds"), V(SocksListenAddress, LINELIST, NULL), V(SocksPolicy, LINELIST, NULL), @@ -1522,6 +1525,25 @@ options_act(const or_options_t *old_options) return -1; } + /* Set up scheduler thresholds */ + if (options->SchedulerLowWaterMark > 0 && + options->SchedulerHighWaterMark > options->SchedulerLowWaterMark) { + scheduler_set_watermarks(options->SchedulerLowWaterMark, + options->SchedulerHighWaterMark, + (options->SchedulerMaxFlushCells > 0) ? + options->SchedulerMaxFlushCells : 16); + } else { + if (options->SchedulerLowWaterMark == 0) { + log_warn(LD_GENERAL, "Bad SchedulerLowWaterMark option"); + } + + if (options->SchedulerHighWaterMark <= options->SchedulerLowWaterMark) { + log_warn(LD_GENERAL, "Bad SchedulerHighWaterMark option"); + } + + return -1; + } + /* Set up accounting */ if (accounting_parse_options(options, 0)<0) { log_warn(LD_CONFIG,"Error in accounting options"); diff --git a/src/or/or.h b/src/or/or.h index 320931d..25df54a 100644 --- a/src/or/or.h +++ b/src/or/or.h @@ -4229,6 +4229,19 @@ typedef struct { /** Should we send the timestamps that pre-023 hidden services want? */ int Support022HiddenServices; + + /** Low-water mark for global scheduler - start sending when estimated + * queued size falls below this threshold. + */ + uint32_t SchedulerLowWaterMark; + /** High-water mark for global scheduler - stop sending when estimated + * queued size exceeds this threshold. + */ + uint32_t SchedulerHighWaterMark; + /** Flush size for global scheduler - flush this many cells at a time + * when sending. + */ + unsigned int SchedulerMaxFlushCells; } or_options_t; /** Persistent state for an onion router, as saved to disk. */ diff --git a/src/or/scheduler.c b/src/or/scheduler.c index c161393..c2ede84 100644 --- a/src/or/scheduler.c +++ b/src/or/scheduler.c @@ -21,16 +21,20 @@ #include <event.h> #endif -#define SCHED_Q_LOW_WATER 16384 -#define SCHED_Q_HIGH_WATER (2 * SCHED_Q_LOW_WATER) +/* + * Scheduler high/low watermarks + */ + +static uint32_t sched_q_low_water = 16384; +static uint32_t sched_q_high_water = 32768; /* * Maximum cells to flush in a single call to channel_flush_some_cells(); * setting this low means more calls, but too high and we could overshoot - * SCHED_Q_HIGH_WATER. + * sched_q_high_water. */ -#define SCHED_MAX_FLUSH_CELLS 16 +static uint32_t sched_max_flush_cells = 16; /* * Write scheduling works by keeping track of which channels can @@ -343,7 +347,7 @@ scheduler_more_work(void) { tor_assert(channels_pending); - return ((scheduler_get_queue_heuristic() < SCHED_Q_LOW_WATER) && + return ((scheduler_get_queue_heuristic() < sched_q_low_water) && ((smartlist_len(channels_pending) > 0))) ? 1 : 0; } @@ -387,12 +391,12 @@ scheduler_run, (void)) log_debug(LD_SCHED, "We have a chance to run the scheduler"); - if (scheduler_get_queue_heuristic() < SCHED_Q_LOW_WATER) { + if (scheduler_get_queue_heuristic() < sched_q_low_water) { n_chans_before = smartlist_len(channels_pending); q_len_before = channel_get_global_queue_estimate(); q_heur_before = scheduler_get_queue_heuristic(); - while (scheduler_get_queue_heuristic() <= SCHED_Q_HIGH_WATER && + while (scheduler_get_queue_heuristic() <= sched_q_high_water && smartlist_len(channels_pending) > 0) { /* Pop off a channel */ chan = smartlist_pqueue_pop(channels_pending, @@ -410,10 +414,10 @@ scheduler_run, (void)) flushed = 0; while (flushed < n_cells && - scheduler_get_queue_heuristic() <= SCHED_Q_HIGH_WATER) { + scheduler_get_queue_heuristic() <= sched_q_high_water) { flushed_this_time = channel_flush_some_cells(chan, - MIN(SCHED_MAX_FLUSH_CELLS, + MIN(sched_max_flush_cells, n_cells - flushed)); if (flushed_this_time <= 0) break; flushed += flushed_this_time; @@ -686,3 +690,19 @@ scheduler_update_queue_heuristic(time_t now) /* else no update needed, or time went backward */ } +/** + * Set scheduler watermarks and flush size + */ + +void +scheduler_set_watermarks(uint32_t lo, uint32_t hi, uint32_t max_flush) +{ + /* Sanity assertions - caller should ensure these are true */ + tor_assert(lo > 0); + tor_assert(hi > lo); + tor_assert(max_flush > 0); + + sched_q_low_water = lo; + sched_q_high_water = hi; + sched_max_flush_cells = max_flush; +} diff --git a/src/or/scheduler.h b/src/or/scheduler.h index 8854d5a..404776b 100644 --- a/src/or/scheduler.h +++ b/src/or/scheduler.h @@ -34,6 +34,9 @@ void scheduler_adjust_queue_size(channel_t *chan, char dir, uint64_t adj); /* Notify scheduler that a channel's queue position may have changed */ void scheduler_touch_channel(channel_t *chan); +/* Adjust the watermarks from config file*/ +void scheduler_set_watermarks(uint32_t lo, uint32_t hi, uint32_t max_flush); + /* Things only scheduler.c and its test suite should see */ #ifdef SCHEDULER_PRIVATE_

1 0

[tor/master] Fix a 64-bit clang warning
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 0e0dc7d787ef867a24b2e630bf1db72227b24fef Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Nov 27 22:42:03 2014 -0500 Fix a 64-bit clang warning --- src/or/channeltls.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/or/channeltls.c b/src/or/channeltls.c index 719a153..90ad1e6 100644 --- a/src/or/channeltls.c +++ b/src/or/channeltls.c @@ -741,7 +741,7 @@ static int channel_tls_num_cells_writeable_method(channel_t *chan) { size_t outbuf_len; - int n; + ssize_t n; channel_tls_t *tlschan = BASE_CHAN_TO_TLS(chan); size_t cell_network_size; @@ -753,8 +753,11 @@ channel_tls_num_cells_writeable_method(channel_t *chan) /* Get the number of cells */ n = CEIL_DIV(OR_CONN_HIGHWATER - outbuf_len, cell_network_size); if (n < 0) n = 0; +#if SIZEOF_SIZE_T > SIZEOF_INT + if (n > INT_MAX) n = INT_MAX; +#endif - return n; + return (int)n; } /**

1 0

[tor/master] Update test_relay.c for recent test suite changes and --enable-mempools support
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit a28cfa128f55c64cfd9562dff7e3b5515d1615ad Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Sep 23 21:03:09 2014 -0700 Update test_relay.c for recent test suite changes and --enable-mempools support --- src/test/test_scheduler.c | 162 ++++++++++++++++++++++----------------------- 1 file changed, 81 insertions(+), 81 deletions(-) diff --git a/src/test/test_scheduler.c b/src/test/test_scheduler.c index 79fc453..da5c4e8 100644 --- a/src/test/test_scheduler.c +++ b/src/test/test_scheduler.c @@ -80,14 +80,14 @@ static void test_scheduler_queue_heuristic(void *arg); static void mock_event_free_all(void) { - test_assert(mock_event_base != NULL); + tt_assert(mock_event_base != NULL); if (mock_event_base) { event_base_free(mock_event_base); mock_event_base = NULL; } - test_eq(mock_event_base, NULL); + tt_ptr_op(mock_event_base, ==, NULL); done: return; @@ -100,7 +100,7 @@ mock_event_init(void) struct event_config *cfg = NULL; #endif - test_eq(mock_event_base, NULL); + tt_ptr_op(mock_event_base, ==, NULL); /* * Really cut down from tor_libevent_initialize of @@ -122,7 +122,7 @@ mock_event_init(void) #endif } - test_assert(mock_event_base != NULL); + tt_assert(mock_event_base != NULL); done: return; @@ -197,7 +197,7 @@ channel_flush_some_cells_mock(channel_t *chan, ssize_t num_cells) char unlimited = 0; flush_mock_channel_t *found = NULL; - test_assert(chan != NULL); + tt_assert(chan != NULL); if (chan) { if (num_cells < 0) { num_cells = 0; @@ -250,8 +250,8 @@ circuitmux_compare_muxes_mock(circuitmux_t *cmux_1, { int result = 0; - test_assert(cmux_1 != NULL); - test_assert(cmux_2 != NULL); + tt_assert(cmux_1 != NULL); + tt_assert(cmux_2 != NULL); if (cmux_1 != cmux_2) { if (cmux_1 == mock_ccm_tgt_1 && cmux_2 == mock_ccm_tgt_2) result = -1; @@ -277,7 +277,7 @@ circuitmux_get_policy_mock(circuitmux_t *cmux) { const circuitmux_policy_t *result = NULL; - test_assert(cmux != NULL); + tt_assert(cmux != NULL); if (cmux) { if (cmux == mock_cgp_tgt_1) result = mock_cgp_val_1; else if (cmux == mock_cgp_tgt_2) result = mock_cgp_val_2; @@ -342,11 +342,11 @@ test_scheduler_channel_states(void *arg) */ MOCK(scheduler_run, scheduler_run_noop_mock); - test_eq(smartlist_len(channels_pending), 0); + tt_int_op(smartlist_len(channels_pending), ==, 0); /* Set up a fake channel */ ch1 = new_fake_channel(); - test_assert(ch1); + tt_assert(ch1); /* Start it off in OPENING */ ch1->state = CHANNEL_STATE_OPENING; @@ -354,70 +354,70 @@ test_scheduler_channel_states(void *arg) ch1->cmux = circuitmux_alloc(); /* Try to register it */ channel_register(ch1); - test_assert(ch1->registered); + tt_assert(ch1->registered); /* It should start off in SCHED_CHAN_IDLE */ - test_eq(ch1->scheduler_state, SCHED_CHAN_IDLE); + tt_int_op(ch1->scheduler_state, ==, SCHED_CHAN_IDLE); /* Now get another one */ ch2 = new_fake_channel(); - test_assert(ch2); + tt_assert(ch2); ch2->state = CHANNEL_STATE_OPENING; ch2->cmux = circuitmux_alloc(); channel_register(ch2); - test_assert(ch2->registered); + tt_assert(ch2->registered); /* Send it to SCHED_CHAN_WAITING_TO_WRITE */ scheduler_channel_has_waiting_cells(ch1); - test_eq(ch1->scheduler_state, SCHED_CHAN_WAITING_TO_WRITE); + tt_int_op(ch1->scheduler_state, ==, SCHED_CHAN_WAITING_TO_WRITE); /* This should send it to SCHED_CHAN_PENDING */ scheduler_channel_wants_writes(ch1); - test_eq(ch1->scheduler_state, SCHED_CHAN_PENDING); - test_eq(smartlist_len(channels_pending), 1); + tt_int_op(ch1->scheduler_state, ==, SCHED_CHAN_PENDING); + tt_int_op(smartlist_len(channels_pending), ==, 1); /* Now send ch2 to SCHED_CHAN_WAITING_FOR_CELLS */ scheduler_channel_wants_writes(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_WAITING_FOR_CELLS); /* Drop ch2 back to idle */ scheduler_channel_doesnt_want_writes(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_IDLE); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_IDLE); /* ...and back to SCHED_CHAN_WAITING_FOR_CELLS */ scheduler_channel_wants_writes(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_WAITING_FOR_CELLS); /* ...and this should kick ch2 into SCHED_CHAN_PENDING */ scheduler_channel_has_waiting_cells(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_PENDING); - test_eq(smartlist_len(channels_pending), 2); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_PENDING); + tt_int_op(smartlist_len(channels_pending), ==, 2); /* This should send ch2 to SCHED_CHAN_WAITING_TO_WRITE */ scheduler_channel_doesnt_want_writes(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_TO_WRITE); - test_eq(smartlist_len(channels_pending), 1); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_WAITING_TO_WRITE); + tt_int_op(smartlist_len(channels_pending), ==, 1); /* ...and back to SCHED_CHAN_PENDING */ scheduler_channel_wants_writes(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_PENDING); - test_eq(smartlist_len(channels_pending), 2); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_PENDING); + tt_int_op(smartlist_len(channels_pending), ==, 2); /* Now we exercise scheduler_touch_channel */ old_count = scheduler_compare_channels_mock_ctr; scheduler_touch_channel(ch1); - test_assert(scheduler_compare_channels_mock_ctr > old_count); + tt_assert(scheduler_compare_channels_mock_ctr > old_count); /* Close */ channel_mark_for_close(ch1); - test_eq(ch1->state, CHANNEL_STATE_CLOSING); + tt_int_op(ch1->state, ==, CHANNEL_STATE_CLOSING); channel_mark_for_close(ch2); - test_eq(ch2->state, CHANNEL_STATE_CLOSING); + tt_int_op(ch2->state, ==, CHANNEL_STATE_CLOSING); channel_closed(ch1); - test_eq(ch1->state, CHANNEL_STATE_CLOSED); + tt_int_op(ch1->state, ==, CHANNEL_STATE_CLOSED); ch1 = NULL; channel_closed(ch2); - test_eq(ch2->state, CHANNEL_STATE_CLOSED); + tt_int_op(ch2->state, ==, CHANNEL_STATE_CLOSED); ch2 = NULL; /* Shut things down */ @@ -474,20 +474,20 @@ test_scheduler_compare_channels(void *arg) /* Equal-channel case */ result = scheduler_compare_channels(&c1, &c1); - test_eq(result, 0); + tt_int_op(result, ==, 0); /* Distinct channels, distinct policies */ result = scheduler_compare_channels(&c1, &c2); - test_eq(result, -1); + tt_int_op(result, ==, -1); result = scheduler_compare_channels(&c2, &c1); - test_eq(result, 1); + tt_int_op(result, ==, 1); /* Distinct channels, same policy */ mock_cgp_val_2 = mock_cgp_val_1; result = scheduler_compare_channels(&c1, &c2); - test_eq(result, -1); + tt_int_op(result, ==, -1); result = scheduler_compare_channels(&c2, &c1); - test_eq(result, 1); + tt_int_op(result, ==, 1); done: @@ -512,24 +512,24 @@ test_scheduler_initfree(void *arg) { (void)arg; - test_eq(channels_pending, NULL); - test_eq(run_sched_ev, NULL); + tt_ptr_op(channels_pending, ==, NULL); + tt_ptr_op(run_sched_ev, ==, NULL); mock_event_init(); MOCK(tor_libevent_get_base, tor_libevent_get_base_mock); scheduler_init(); - test_assert(channels_pending != NULL); - test_assert(run_sched_ev != NULL); + tt_assert(channels_pending != NULL); + tt_assert(run_sched_ev != NULL); scheduler_free_all(); UNMOCK(tor_libevent_get_base); mock_event_free_all(); - test_eq(channels_pending, NULL); - test_eq(run_sched_ev, NULL); + tt_ptr_op(channels_pending, ==, NULL); + tt_ptr_op(run_sched_ev, ==, NULL); done: return; @@ -558,11 +558,11 @@ test_scheduler_loop(void *arg) */ MOCK(scheduler_run, scheduler_run_noop_mock); - test_eq(smartlist_len(channels_pending), 0); + tt_int_op(smartlist_len(channels_pending), ==, 0); /* Set up a fake channel */ ch1 = new_fake_channel(); - test_assert(ch1); + tt_assert(ch1); /* Start it off in OPENING */ ch1->state = CHANNEL_STATE_OPENING; @@ -570,53 +570,53 @@ test_scheduler_loop(void *arg) ch1->cmux = circuitmux_alloc(); /* Try to register it */ channel_register(ch1); - test_assert(ch1->registered); + tt_assert(ch1->registered); /* Finish opening it */ channel_change_state(ch1, CHANNEL_STATE_OPEN); /* It should start off in SCHED_CHAN_IDLE */ - test_eq(ch1->scheduler_state, SCHED_CHAN_IDLE); + tt_int_op(ch1->scheduler_state, ==, SCHED_CHAN_IDLE); /* Now get another one */ ch2 = new_fake_channel(); - test_assert(ch2); + tt_assert(ch2); ch2->state = CHANNEL_STATE_OPENING; ch2->cmux = circuitmux_alloc(); channel_register(ch2); - test_assert(ch2->registered); + tt_assert(ch2->registered); /* * Don't open ch2; then channel_num_cells_writeable() will return * zero and we'll get coverage of that exception case in scheduler_run() */ - test_eq(ch1->state, CHANNEL_STATE_OPEN); - test_eq(ch2->state, CHANNEL_STATE_OPENING); + tt_int_op(ch1->state, ==, CHANNEL_STATE_OPEN); + tt_int_op(ch2->state, ==, CHANNEL_STATE_OPENING); /* Send it to SCHED_CHAN_WAITING_TO_WRITE */ scheduler_channel_has_waiting_cells(ch1); - test_eq(ch1->scheduler_state, SCHED_CHAN_WAITING_TO_WRITE); + tt_int_op(ch1->scheduler_state, ==, SCHED_CHAN_WAITING_TO_WRITE); /* This should send it to SCHED_CHAN_PENDING */ scheduler_channel_wants_writes(ch1); - test_eq(ch1->scheduler_state, SCHED_CHAN_PENDING); - test_eq(smartlist_len(channels_pending), 1); + tt_int_op(ch1->scheduler_state, ==, SCHED_CHAN_PENDING); + tt_int_op(smartlist_len(channels_pending), ==, 1); /* Now send ch2 to SCHED_CHAN_WAITING_FOR_CELLS */ scheduler_channel_wants_writes(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_WAITING_FOR_CELLS); /* Drop ch2 back to idle */ scheduler_channel_doesnt_want_writes(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_IDLE); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_IDLE); /* ...and back to SCHED_CHAN_WAITING_FOR_CELLS */ scheduler_channel_wants_writes(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_WAITING_FOR_CELLS); /* ...and this should kick ch2 into SCHED_CHAN_PENDING */ scheduler_channel_has_waiting_cells(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_PENDING); - test_eq(smartlist_len(channels_pending), 2); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_PENDING); + tt_int_op(smartlist_len(channels_pending), ==, 2); /* * Now we've got two pending channels and need to fire off @@ -634,11 +634,11 @@ test_scheduler_loop(void *arg) * Assert that they're still in the states we left and aren't still * pending */ - test_eq(ch1->state, CHANNEL_STATE_OPEN); - test_eq(ch2->state, CHANNEL_STATE_OPENING); - test_assert(ch1->scheduler_state != SCHED_CHAN_PENDING); - test_assert(ch2->scheduler_state != SCHED_CHAN_PENDING); - test_eq(smartlist_len(channels_pending), 0); + tt_int_op(ch1->state, ==, CHANNEL_STATE_OPEN); + tt_int_op(ch2->state, ==, CHANNEL_STATE_OPENING); + tt_assert(ch1->scheduler_state != SCHED_CHAN_PENDING); + tt_assert(ch2->scheduler_state != SCHED_CHAN_PENDING); + tt_int_op(smartlist_len(channels_pending), ==, 0); /* Now, finish opening ch2, and get both back to pending */ channel_change_state(ch2, CHANNEL_STATE_OPEN); @@ -646,11 +646,11 @@ test_scheduler_loop(void *arg) scheduler_channel_wants_writes(ch2); scheduler_channel_has_waiting_cells(ch1); scheduler_channel_has_waiting_cells(ch2); - test_eq(ch1->state, CHANNEL_STATE_OPEN); - test_eq(ch2->state, CHANNEL_STATE_OPEN); - test_eq(ch1->scheduler_state, SCHED_CHAN_PENDING); - test_eq(ch2->scheduler_state, SCHED_CHAN_PENDING); - test_eq(smartlist_len(channels_pending), 2); + tt_int_op(ch1->state, ==, CHANNEL_STATE_OPEN); + tt_int_op(ch2->state, ==, CHANNEL_STATE_OPEN); + tt_int_op(ch1->scheduler_state, ==, SCHED_CHAN_PENDING); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_PENDING); + tt_int_op(smartlist_len(channels_pending), ==, 2); /* Now, set up the channel_flush_some_cells() mock */ MOCK(channel_flush_some_cells, channel_flush_some_cells_mock); @@ -680,24 +680,24 @@ test_scheduler_loop(void *arg) * ch1 should have gone to SCHED_CHAN_WAITING_FOR_CELLS, with 16 flushed * and 32 writeable. */ - test_eq(ch1->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + tt_int_op(ch1->scheduler_state, ==, SCHED_CHAN_WAITING_FOR_CELLS); /* * ...ch2 should also have gone to SCHED_CHAN_WAITING_FOR_CELLS, with * channel_more_to_flush() returning false and channel_num_cells_writeable() * > 0/ */ - test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_WAITING_FOR_CELLS); /* Close */ channel_mark_for_close(ch1); - test_eq(ch1->state, CHANNEL_STATE_CLOSING); + tt_int_op(ch1->state, ==, CHANNEL_STATE_CLOSING); channel_mark_for_close(ch2); - test_eq(ch2->state, CHANNEL_STATE_CLOSING); + tt_int_op(ch2->state, ==, CHANNEL_STATE_CLOSING); channel_closed(ch1); - test_eq(ch1->state, CHANNEL_STATE_CLOSED); + tt_int_op(ch1->state, ==, CHANNEL_STATE_CLOSED); ch1 = NULL; channel_closed(ch2); - test_eq(ch2->state, CHANNEL_STATE_CLOSED); + tt_int_op(ch2->state, ==, CHANNEL_STATE_CLOSED); ch2 = NULL; /* Shut things down */ @@ -729,22 +729,22 @@ test_scheduler_queue_heuristic(void *arg) /* Not yet inited case */ scheduler_update_queue_heuristic(now - 180); - test_eq(queue_heuristic, 0); - test_eq(queue_heuristic_timestamp, now - 180); + tt_int_op(queue_heuristic, ==, 0); + tt_int_op(queue_heuristic_timestamp, ==, now - 180); queue_heuristic = 1000000000L; queue_heuristic_timestamp = now - 120; scheduler_update_queue_heuristic(now - 119); - test_eq(queue_heuristic, 500000000L); - test_eq(queue_heuristic_timestamp, now - 119); + tt_int_op(queue_heuristic, ==, 500000000L); + tt_int_op(queue_heuristic_timestamp, ==, now - 119); scheduler_update_queue_heuristic(now - 116); - test_eq(queue_heuristic, 62500000L); - test_eq(queue_heuristic_timestamp, now - 116); + tt_int_op(queue_heuristic, ==, 62500000L); + tt_int_op(queue_heuristic_timestamp, ==, now - 116); qh = scheduler_get_queue_heuristic(); - test_eq(qh, 0); + tt_int_op(qh, ==, 0); done: return;

1 0

[tor/master] Update test_channeltls.c for recent test suite changes and --enable-mempools support
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit faea058baabec9eeb180a0e1812ca7857f3894e0 Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Sep 23 07:18:57 2014 -0700 Update test_channeltls.c for recent test suite changes and --enable-mempools support --- src/test/test_channeltls.c | 44 ++++++++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/src/test/test_channeltls.c b/src/test/test_channeltls.c index 4dcf4c5..45e24df 100644 --- a/src/test/test_channeltls.c +++ b/src/test/test_channeltls.c @@ -69,7 +69,7 @@ test_channeltls_create(void *arg) /* Try connecting */ ch = channel_tls_connect(&test_addr, 567, test_digest); - test_assert(ch != NULL); + tt_assert(ch != NULL); done: if (ch) { @@ -118,7 +118,7 @@ test_channeltls_num_bytes_queued(void *arg) /* Try connecting */ ch = channel_tls_connect(&test_addr, 567, test_digest); - test_assert(ch != NULL); + tt_assert(ch != NULL); /* * Next, we have to test ch->num_bytes_queued, which is @@ -128,9 +128,9 @@ test_channeltls_num_bytes_queued(void *arg) * if bufferevents ever work, this will break with them enabled. */ - test_assert(ch->num_bytes_queued != NULL); + tt_assert(ch->num_bytes_queued != NULL); tlschan = BASE_CHAN_TO_TLS(ch); - test_assert(tlschan != NULL); + tt_assert(tlschan != NULL); if (TO_CONN(tlschan->conn)->outbuf == NULL) { /* We need an outbuf to make sure buf_datalen() gets called */ fake_outbuf = 1; @@ -140,7 +140,7 @@ test_channeltls_num_bytes_queued(void *arg) tlschan_buf_datalen_mock_size = 1024; MOCK(buf_datalen, tlschan_buf_datalen_mock); len = ch->num_bytes_queued(ch); - test_eq(len, tlschan_buf_datalen_mock_size); + tt_int_op(len, ==, tlschan_buf_datalen_mock_size); /* * We also cover num_cells_writeable here; since wide_circ_ids = 0 on * the fake tlschans, cell_network_size returns 512, and so with @@ -149,7 +149,7 @@ test_channeltls_num_bytes_queued(void *arg) * - 2 cells. */ n = ch->num_cells_writeable(ch); - test_eq(n, CEIL_DIV(OR_CONN_HIGHWATER, 512) - 2); + tt_int_op(n, ==, CEIL_DIV(OR_CONN_HIGHWATER, 512) - 2); UNMOCK(buf_datalen); tlschan_buf_datalen_mock_target = NULL; tlschan_buf_datalen_mock_size = 0; @@ -204,33 +204,33 @@ test_channeltls_overhead_estimate(void *arg) /* Try connecting */ ch = channel_tls_connect(&test_addr, 567, test_digest); - test_assert(ch != NULL); + tt_assert(ch != NULL); /* First case: silly low ratios should get clamped to 1.0f */ tlschan = BASE_CHAN_TO_TLS(ch); - test_assert(tlschan != NULL); + tt_assert(tlschan != NULL); tlschan->conn->bytes_xmitted = 128; tlschan->conn->bytes_xmitted_by_tls = 64; r = ch->get_overhead_estimate(ch); - test_assert(fabsf(r - 1.0f) < 1E-12); + tt_assert(fabsf(r - 1.0f) < 1E-12); tlschan->conn->bytes_xmitted_by_tls = 127; r = ch->get_overhead_estimate(ch); - test_assert(fabsf(r - 1.0f) < 1E-12); + tt_assert(fabsf(r - 1.0f) < 1E-12); /* Now middle of the range */ tlschan->conn->bytes_xmitted_by_tls = 192; r = ch->get_overhead_estimate(ch); - test_assert(fabsf(r - 1.5f) < 1E-12); + tt_assert(fabsf(r - 1.5f) < 1E-12); /* Now above the 2.0f clamp */ tlschan->conn->bytes_xmitted_by_tls = 257; r = ch->get_overhead_estimate(ch); - test_assert(fabsf(r - 2.0f) < 1E-12); + tt_assert(fabsf(r - 2.0f) < 1E-12); tlschan->conn->bytes_xmitted_by_tls = 512; r = ch->get_overhead_estimate(ch); - test_assert(fabsf(r - 2.0f) < 1E-12); + tt_assert(fabsf(r - 2.0f) < 1E-12); done: if (ch) { @@ -256,7 +256,7 @@ tlschan_buf_datalen_mock(const buf_t *buf) { if (buf != NULL && buf == tlschan_buf_datalen_mock_target) { return tlschan_buf_datalen_mock_size; - }else { + } else { return buf_datalen__real(buf); } } @@ -269,10 +269,10 @@ tlschan_connection_or_connect_mock(const tor_addr_t *addr, { or_connection_t *result = NULL; - test_assert(addr != NULL); - test_assert(port != 0); - test_assert(digest != NULL); - test_assert(tlschan != NULL); + tt_assert(addr != NULL); + tt_assert(port != 0); + tt_assert(digest != NULL); + tt_assert(tlschan != NULL); /* Make a fake orconn */ result = tor_malloc_zero(sizeof(*result)); @@ -297,11 +297,11 @@ tlschan_fake_close_method(channel_t *chan) { channel_tls_t *tlschan = NULL; - test_assert(chan != NULL); - test_eq(chan->magic, TLS_CHAN_MAGIC); + tt_assert(chan != NULL); + tt_int_op(chan->magic, ==, TLS_CHAN_MAGIC); tlschan = BASE_CHAN_TO_TLS(chan); - test_assert(tlschan != NULL); + tt_assert(tlschan != NULL); /* Just free the fake orconn */ tor_free(tlschan->conn); @@ -315,7 +315,7 @@ tlschan_fake_close_method(channel_t *chan) static int tlschan_is_local_addr_mock(const tor_addr_t *addr) { - test_assert(addr != NULL); + tt_assert(addr != NULL); done: return tlschan_local;

1 0

[tor/master] Fix some issues with the scheduler configuration options
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit b1e1b439b892624b7dbe2f631a9ddb41b16ecdd6 Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Nov 27 22:51:13 2014 -0500 Fix some issues with the scheduler configuration options 1) Set them to the values that (according to Rob) avoided performance regressions. This means that the scheduler won't get much exercise until we implement KIST or something like it. 2) Rename the options to end with a __, since I think they might be going away, and nobody should mess with them. 3) Use the correct types for the option variables. MEMUNIT needs to be a uint64_t; UINT needs to be (I know, I know!) an int. 4) Validate the values in options_validate(); do the switch in options_act(). This way, setting the option to an invalid value on a running Tor will get backed out. --- src/or/config.c | 38 ++++++++++++++++++-------------------- src/or/or.h | 6 +++--- 2 files changed, 21 insertions(+), 23 deletions(-) diff --git a/src/or/config.c b/src/or/config.c index ced4288..28f1df0 100644 --- a/src/or/config.c +++ b/src/or/config.c @@ -369,9 +369,9 @@ static config_var_t option_vars_[] = { V(ServerDNSSearchDomains, BOOL, "0"), V(ServerDNSTestAddresses, CSV, "www.google.com,www.mit.edu,www.yahoo.com,www.slashdot.org"), - V(SchedulerLowWaterMark, MEMUNIT, "16 kB"), - V(SchedulerHighWaterMark, MEMUNIT, "32 kB"), - V(SchedulerMaxFlushCells, UINT, "16"), + V(SchedulerLowWaterMark__, MEMUNIT, "100 MB"), + V(SchedulerHighWaterMark__, MEMUNIT, "101 MB"), + V(SchedulerMaxFlushCells__, UINT, "1000"), V(ShutdownWaitLength, INTERVAL, "30 seconds"), V(SocksListenAddress, LINELIST, NULL), V(SocksPolicy, LINELIST, NULL), @@ -1539,23 +1539,10 @@ options_act(const or_options_t *old_options) } /* Set up scheduler thresholds */ - if (options->SchedulerLowWaterMark > 0 && - options->SchedulerHighWaterMark > options->SchedulerLowWaterMark) { - scheduler_set_watermarks(options->SchedulerLowWaterMark, - options->SchedulerHighWaterMark, - (options->SchedulerMaxFlushCells > 0) ? - options->SchedulerMaxFlushCells : 16); - } else { - if (options->SchedulerLowWaterMark == 0) { - log_warn(LD_GENERAL, "Bad SchedulerLowWaterMark option"); - } - - if (options->SchedulerHighWaterMark <= options->SchedulerLowWaterMark) { - log_warn(LD_GENERAL, "Bad SchedulerHighWaterMark option"); - } - - return -1; - } + scheduler_set_watermarks((uint32_t)options->SchedulerLowWaterMark__, + (uint32_t)options->SchedulerHighWaterMark__, + (options->SchedulerMaxFlushCells__ > 0) ? + options->SchedulerMaxFlushCells__ : 1000); /* Set up accounting */ if (accounting_parse_options(options, 0)<0) { @@ -2654,6 +2641,17 @@ options_validate(or_options_t *old_options, or_options_t *options, routerset_union(options->ExcludeExitNodesUnion_,options->ExcludeNodes); } + if (options->SchedulerLowWaterMark__ == 0 || + options->SchedulerLowWaterMark__ > UINT32_MAX) { + log_warn(LD_GENERAL, "Bad SchedulerLowWaterMark__ option"); + return -1; + } else if (options->SchedulerHighWaterMark__ <= + options->SchedulerLowWaterMark__ || + options->SchedulerHighWaterMark__ > UINT32_MAX) { + log_warn(LD_GENERAL, "Bad SchedulerHighWaterMark option"); + return -1; + } + if (options->NodeFamilies) { options->NodeFamilySets = smartlist_new(); for (cl = options->NodeFamilies; cl; cl = cl->next) { diff --git a/src/or/or.h b/src/or/or.h index ccb29ee..0de3745 100644 --- a/src/or/or.h +++ b/src/or/or.h @@ -4251,15 +4251,15 @@ typedef struct { /** Low-water mark for global scheduler - start sending when estimated * queued size falls below this threshold. */ - uint32_t SchedulerLowWaterMark; + uint64_t SchedulerLowWaterMark__; /** High-water mark for global scheduler - stop sending when estimated * queued size exceeds this threshold. */ - uint32_t SchedulerHighWaterMark; + uint64_t SchedulerHighWaterMark__; /** Flush size for global scheduler - flush this many cells at a time * when sending. */ - unsigned int SchedulerMaxFlushCells; + int SchedulerMaxFlushCells__; } or_options_t; /** Persistent state for an onion router, as saved to disk. */

1 0

[tor/master] Add scheduler/loop unit test
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 41cf9f6260d70de8b07740c89fd5273b4f073c95 Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Feb 4 13:59:53 2014 -0800 Add scheduler/loop unit test --- src/test/test_scheduler.c | 303 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 303 insertions(+) diff --git a/src/test/test_scheduler.c b/src/test/test_scheduler.c index 650d4f1..79fc453 100644 --- a/src/test/test_scheduler.c +++ b/src/test/test_scheduler.c @@ -44,11 +44,17 @@ static const circuitmux_policy_t *mock_cgp_val_2 = NULL; static int scheduler_compare_channels_mock_ctr = 0; static int scheduler_run_mock_ctr = 0; +static void channel_flush_some_cells_mock_free_all(void); +static void channel_flush_some_cells_mock_set(channel_t *chan, + ssize_t num_cells); + /* Setup for mock event stuff */ static void mock_event_free_all(void); static void mock_event_init(void); /* Mocks used by scheduler tests */ +static ssize_t channel_flush_some_cells_mock(channel_t *chan, + ssize_t num_cells); static int circuitmux_compare_muxes_mock(circuitmux_t *cmux_1, circuitmux_t *cmux_2); static const circuitmux_policy_t * circuitmux_get_policy_mock( @@ -62,6 +68,7 @@ static struct event_base * tor_libevent_get_base_mock(void); static void test_scheduler_channel_states(void *arg); static void test_scheduler_compare_channels(void *arg); static void test_scheduler_initfree(void *arg); +static void test_scheduler_loop(void *arg); static void test_scheduler_queue_heuristic(void *arg); /* Mock event init/free */ @@ -123,6 +130,120 @@ mock_event_init(void) /* Mocks */ +typedef struct { + const channel_t *chan; + ssize_t cells; +} flush_mock_channel_t; + +static smartlist_t *chans_for_flush_mock = NULL; + +static void +channel_flush_some_cells_mock_free_all(void) +{ + if (chans_for_flush_mock) { + SMARTLIST_FOREACH_BEGIN(chans_for_flush_mock, + flush_mock_channel_t *, + flush_mock_ch) { + SMARTLIST_DEL_CURRENT(chans_for_flush_mock, flush_mock_ch); + tor_free(flush_mock_ch); + } SMARTLIST_FOREACH_END(flush_mock_ch); + + smartlist_free(chans_for_flush_mock); + chans_for_flush_mock = NULL; + } +} + +static void +channel_flush_some_cells_mock_set(channel_t *chan, ssize_t num_cells) +{ + flush_mock_channel_t *flush_mock_ch = NULL; + + if (!chan) return; + if (num_cells <= 0) return; + + if (!chans_for_flush_mock) { + chans_for_flush_mock = smartlist_new(); + } + + SMARTLIST_FOREACH_BEGIN(chans_for_flush_mock, + flush_mock_channel_t *, + flush_mock_ch) { + if (flush_mock_ch != NULL && flush_mock_ch->chan != NULL) { + if (flush_mock_ch->chan == chan) { + /* Found it */ + flush_mock_ch->cells = num_cells; + break; + } + } else { + /* That shouldn't be there... */ + SMARTLIST_DEL_CURRENT(chans_for_flush_mock, flush_mock_ch); + tor_free(flush_mock_ch); + } + } SMARTLIST_FOREACH_END(flush_mock_ch); + + if (!flush_mock_ch) { + /* The loop didn't find it */ + flush_mock_ch = tor_malloc_zero(sizeof(*flush_mock_ch)); + flush_mock_ch->chan = chan; + flush_mock_ch->cells = num_cells; + smartlist_add(chans_for_flush_mock, flush_mock_ch); + } +} + +static ssize_t +channel_flush_some_cells_mock(channel_t *chan, ssize_t num_cells) +{ + ssize_t flushed = 0, max; + char unlimited = 0; + flush_mock_channel_t *found = NULL; + + test_assert(chan != NULL); + if (chan) { + if (num_cells < 0) { + num_cells = 0; + unlimited = 1; + } + + /* Check if we have it */ + if (chans_for_flush_mock != NULL) { + SMARTLIST_FOREACH_BEGIN(chans_for_flush_mock, + flush_mock_channel_t *, + flush_mock_ch) { + if (flush_mock_ch != NULL && flush_mock_ch->chan != NULL) { + if (flush_mock_ch->chan == chan) { + /* Found it */ + found = flush_mock_ch; + break; + } + } else { + /* That shouldn't be there... */ + SMARTLIST_DEL_CURRENT(chans_for_flush_mock, flush_mock_ch); + tor_free(flush_mock_ch); + } + } SMARTLIST_FOREACH_END(flush_mock_ch); + + if (found) { + /* We found one */ + if (found->cells < 0) found->cells = 0; + + if (unlimited) max = found->cells; + else max = MIN(found->cells, num_cells); + + flushed += max; + found->cells -= max; + + if (found->cells <= 0) { + smartlist_remove(chans_for_flush_mock, found); + tor_free(found); + } + } + } + } + + done: + return flushed; +} + static int circuitmux_compare_muxes_mock(circuitmux_t *cmux_1, circuitmux_t *cmux_2) @@ -415,6 +536,187 @@ test_scheduler_initfree(void *arg) } static void +test_scheduler_loop(void *arg) +{ + channel_t *ch1 = NULL, *ch2 = NULL; + + (void)arg; + + /* Set up libevent and scheduler */ + + mock_event_init(); + MOCK(tor_libevent_get_base, tor_libevent_get_base_mock); + scheduler_init(); + /* + * Install the compare channels mock so we can test + * scheduler_touch_channel(). + */ + MOCK(scheduler_compare_channels, scheduler_compare_channels_mock); + /* + * Disable scheduler_run so we can just check the state transitions + * without having to make everything it might call work too. + */ + MOCK(scheduler_run, scheduler_run_noop_mock); + + test_eq(smartlist_len(channels_pending), 0); + + /* Set up a fake channel */ + ch1 = new_fake_channel(); + test_assert(ch1); + + /* Start it off in OPENING */ + ch1->state = CHANNEL_STATE_OPENING; + /* We'll need a cmux */ + ch1->cmux = circuitmux_alloc(); + /* Try to register it */ + channel_register(ch1); + test_assert(ch1->registered); + /* Finish opening it */ + channel_change_state(ch1, CHANNEL_STATE_OPEN); + + /* It should start off in SCHED_CHAN_IDLE */ + test_eq(ch1->scheduler_state, SCHED_CHAN_IDLE); + + /* Now get another one */ + ch2 = new_fake_channel(); + test_assert(ch2); + ch2->state = CHANNEL_STATE_OPENING; + ch2->cmux = circuitmux_alloc(); + channel_register(ch2); + test_assert(ch2->registered); + /* + * Don't open ch2; then channel_num_cells_writeable() will return + * zero and we'll get coverage of that exception case in scheduler_run() + */ + + test_eq(ch1->state, CHANNEL_STATE_OPEN); + test_eq(ch2->state, CHANNEL_STATE_OPENING); + + /* Send it to SCHED_CHAN_WAITING_TO_WRITE */ + scheduler_channel_has_waiting_cells(ch1); + test_eq(ch1->scheduler_state, SCHED_CHAN_WAITING_TO_WRITE); + + /* This should send it to SCHED_CHAN_PENDING */ + scheduler_channel_wants_writes(ch1); + test_eq(ch1->scheduler_state, SCHED_CHAN_PENDING); + test_eq(smartlist_len(channels_pending), 1); + + /* Now send ch2 to SCHED_CHAN_WAITING_FOR_CELLS */ + scheduler_channel_wants_writes(ch2); + test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + + /* Drop ch2 back to idle */ + scheduler_channel_doesnt_want_writes(ch2); + test_eq(ch2->scheduler_state, SCHED_CHAN_IDLE); + + /* ...and back to SCHED_CHAN_WAITING_FOR_CELLS */ + scheduler_channel_wants_writes(ch2); + test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + + /* ...and this should kick ch2 into SCHED_CHAN_PENDING */ + scheduler_channel_has_waiting_cells(ch2); + test_eq(ch2->scheduler_state, SCHED_CHAN_PENDING); + test_eq(smartlist_len(channels_pending), 2); + + /* + * Now we've got two pending channels and need to fire off + * scheduler_run(); first, unmock it. + */ + + UNMOCK(scheduler_run); + + scheduler_run(); + + /* Now re-mock it */ + MOCK(scheduler_run, scheduler_run_noop_mock); + + /* + * Assert that they're still in the states we left and aren't still + * pending + */ + test_eq(ch1->state, CHANNEL_STATE_OPEN); + test_eq(ch2->state, CHANNEL_STATE_OPENING); + test_assert(ch1->scheduler_state != SCHED_CHAN_PENDING); + test_assert(ch2->scheduler_state != SCHED_CHAN_PENDING); + test_eq(smartlist_len(channels_pending), 0); + + /* Now, finish opening ch2, and get both back to pending */ + channel_change_state(ch2, CHANNEL_STATE_OPEN); + scheduler_channel_wants_writes(ch1); + scheduler_channel_wants_writes(ch2); + scheduler_channel_has_waiting_cells(ch1); + scheduler_channel_has_waiting_cells(ch2); + test_eq(ch1->state, CHANNEL_STATE_OPEN); + test_eq(ch2->state, CHANNEL_STATE_OPEN); + test_eq(ch1->scheduler_state, SCHED_CHAN_PENDING); + test_eq(ch2->scheduler_state, SCHED_CHAN_PENDING); + test_eq(smartlist_len(channels_pending), 2); + + /* Now, set up the channel_flush_some_cells() mock */ + MOCK(channel_flush_some_cells, channel_flush_some_cells_mock); + /* + * 16 cells on ch1 means it'll completely drain into the 32 cells + * fakechan's num_cells_writeable() returns. + */ + channel_flush_some_cells_mock_set(ch1, 16); + /* + * This one should get sent back to pending, since num_cells_writeable() + * will still return non-zero. + */ + channel_flush_some_cells_mock_set(ch2, 48); + + /* + * And re-run the scheduler_run() loop with non-zero returns from + * channel_flush_some_cells() this time. + */ + UNMOCK(scheduler_run); + + scheduler_run(); + + /* Now re-mock it */ + MOCK(scheduler_run, scheduler_run_noop_mock); + + /* + * ch1 should have gone to SCHED_CHAN_WAITING_FOR_CELLS, with 16 flushed + * and 32 writeable. + */ + test_eq(ch1->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + /* + * ...ch2 should also have gone to SCHED_CHAN_WAITING_FOR_CELLS, with + * channel_more_to_flush() returning false and channel_num_cells_writeable() + * > 0/ + */ + test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + + /* Close */ + channel_mark_for_close(ch1); + test_eq(ch1->state, CHANNEL_STATE_CLOSING); + channel_mark_for_close(ch2); + test_eq(ch2->state, CHANNEL_STATE_CLOSING); + channel_closed(ch1); + test_eq(ch1->state, CHANNEL_STATE_CLOSED); + ch1 = NULL; + channel_closed(ch2); + test_eq(ch2->state, CHANNEL_STATE_CLOSED); + ch2 = NULL; + + /* Shut things down */ + channel_flush_some_cells_mock_free_all(); + channel_free_all(); + scheduler_free_all(); + mock_event_free_all(); + + done: + tor_free(ch1); + tor_free(ch2); + + UNMOCK(channel_flush_some_cells); + UNMOCK(scheduler_compare_channels); + UNMOCK(scheduler_run); + UNMOCK(tor_libevent_get_base); +} + +static void test_scheduler_queue_heuristic(void *arg) { time_t now = approx_time(); @@ -453,6 +755,7 @@ struct testcase_t scheduler_tests[] = { { "compare_channels", test_scheduler_compare_channels, TT_FORK, NULL, NULL }, { "initfree", test_scheduler_initfree, TT_FORK, NULL, NULL }, + { "loop", test_scheduler_loop, TT_FORK, NULL, NULL }, { "queue_heuristic", test_scheduler_queue_heuristic, TT_FORK, NULL, NULL }, END_OF_TESTCASES

1 0

[tor/master] Update test_relay.c for recent test suite changes and --enable-mempools support
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 4d20c427b4874a3cb97e4567e4ae54830c5a79be Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Sep 23 07:22:26 2014 -0700 Update test_relay.c for recent test suite changes and --enable-mempools support --- src/test/test_relay.c | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/src/test/test_relay.c b/src/test/test_relay.c index 6b9cb33..6907597 100644 --- a/src/test/test_relay.c +++ b/src/test/test_relay.c @@ -61,14 +61,16 @@ test_relay_append_cell_to_circuit_queue(void *arg) (void)arg; /* We'll need the cell pool for append_cell_to_circuit_queue() to work */ +#ifdef ENABLE_MEMPOOLS init_cell_pool(); +#endif /* ENABLE_MEMPOOLS */ /* Make fake channels to be nchan and pchan for the circuit */ nchan = new_fake_channel(); - test_assert(nchan); + tt_assert(nchan); pchan = new_fake_channel(); - test_assert(pchan); + tt_assert(pchan); /* We'll need chans with working cmuxes */ nchan->cmux = circuitmux_alloc(); @@ -76,7 +78,7 @@ test_relay_append_cell_to_circuit_queue(void *arg) /* Make a fake orcirc */ orcirc = new_fake_orcirc(nchan, pchan); - test_assert(orcirc); + tt_assert(orcirc); /* Make a cell */ cell = tor_malloc_zero(sizeof(cell_t)); @@ -90,14 +92,14 @@ test_relay_append_cell_to_circuit_queue(void *arg) append_cell_to_circuit_queue(TO_CIRCUIT(orcirc), nchan, cell, CELL_DIRECTION_OUT, 0); new_count = get_mock_scheduler_has_waiting_cells_count(); - test_eq(new_count, old_count + 1); + tt_int_op(new_count, ==, old_count + 1); /* Now try the reverse direction */ old_count = get_mock_scheduler_has_waiting_cells_count(); append_cell_to_circuit_queue(TO_CIRCUIT(orcirc), pchan, cell, CELL_DIRECTION_IN, 0); new_count = get_mock_scheduler_has_waiting_cells_count(); - test_eq(new_count, old_count + 1); + tt_int_op(new_count, ==, old_count + 1); UNMOCK(scheduler_channel_has_waiting_cells); @@ -117,7 +119,9 @@ test_relay_append_cell_to_circuit_queue(void *arg) tor_free(nchan); if (pchan && pchan->cmux) circuitmux_free(pchan->cmux); tor_free(pchan); +#ifdef ENABLE_MEMPOOLS free_cell_pool(); +#endif /* ENABLE_MEMPOOLS */ return; }

1 0