commit 52cadff0d60e393d7b75001aee304cdc1ab79c6b Author: Nick Mathewson <nickm@torproject.org> Date: Thu Apr 11 11:43:40 2013 -0400 Rename all fields which measure bw in kb to end with _kb --- src/or/dirserv.c | 179 +++++++++++++++++++++++++------------------------ src/or/dirserv.h | 4 +- src/or/dirvote.c | 42 ++++++------ src/or/dirvote.h | 2 +- src/or/or.h | 6 +- src/or/routerlist.c | 4 +- src/or/routerparse.c | 35 +++++----- src/test/test_dir.c | 104 +++++++++++++++--------------- 8 files changed, 191 insertions(+), 185 deletions(-) diff --git a/src/or/dirserv.c b/src/or/dirserv.c index 80dc15b..bf47506 100644 --- a/src/or/dirserv.c +++ b/src/or/dirserv.c @@ -92,8 +92,8 @@ static const signed_descriptor_t *get_signed_descriptor_by_fp( time_t publish_cutoff); static was_router_added_t dirserv_add_extrainfo(extrainfo_t *ei, const char **msg); -static uint32_t dirserv_get_bandwidth_for_router(const routerinfo_t *ri); -static uint32_t dirserv_get_credible_bandwidth(const routerinfo_t *ri); +static uint32_t dirserv_get_bandwidth_for_router_kb(const routerinfo_t *ri); +static uint32_t dirserv_get_credible_bandwidth_kb(const routerinfo_t *ri); /************** Fingerprint handling code ************/ @@ -1776,17 +1776,17 @@ static double guard_wfu = 0.0; * many seconds. */ static long guard_tk = 0; /** Any router with a bandwidth at least this high is "Fast" */ -static uint32_t fast_bandwidth = 0; +static uint32_t fast_bandwidth_kb = 0; /** If exits can be guards, then all guards must have a bandwidth this * high. */ -static uint32_t guard_bandwidth_including_exits = 0; +static uint32_t guard_bandwidth_including_exits_kb = 0; /** If exits can't be guards, then all guards must have a bandwidth this * high. */ -static uint32_t guard_bandwidth_excluding_exits = 0; +static uint32_t guard_bandwidth_excluding_exits_kb = 0; /** Total bandwidth of all the routers we're considering. */ -static uint64_t total_bandwidth = 0; +static uint64_t total_bandwidth_kb = 0; /** Total bandwidth of all the exit routers we're considering. */ -static uint64_t total_exit_bandwidth = 0; +static uint64_t total_exit_bandwidth_kb = 0; /** Helper: estimate the uptime of a router given its stated uptime and the * amount of time since it last stated its stated uptime. */ @@ -1830,8 +1830,8 @@ dirserv_thinks_router_is_unreliable(time_t now, } } if (need_capacity) { - uint32_t bw = dirserv_get_credible_bandwidth(router); - if (bw < fast_bandwidth) + uint32_t bw_kb = dirserv_get_credible_bandwidth_kb(router); + if (bw_kb < fast_bandwidth_kb) return 1; } return 0; @@ -1879,7 +1879,7 @@ dirserv_thinks_router_is_hs_dir(const routerinfo_t *router, /** Don't consider routers with less bandwidth than this when computing * thresholds. */ -#define ABSOLUTE_MIN_BW_VALUE_TO_CONSIDER 4 +#define ABSOLUTE_MIN_BW_VALUE_TO_CONSIDER_KB 4 /** Helper for dirserv_compute_performance_thresholds(): Decide whether to * include a router in our calculations, and return true iff we should; the @@ -1894,16 +1894,16 @@ router_counts_toward_thresholds(const node_t *node, time_t now, /* Have measured bw? */ int have_mbw = dirserv_has_measured_bw(node->ri->cache_info.identity_digest); - uint64_t min_bw = ABSOLUTE_MIN_BW_VALUE_TO_CONSIDER; + uint64_t min_bw_kb = ABSOLUTE_MIN_BW_VALUE_TO_CONSIDER_KB; const or_options_t *options = get_options(); if (options->TestingTorNetwork) { - min_bw = (int64_t)options->TestingMinExitFlagThreshold; + min_bw_kb = (int64_t)options->TestingMinExitFlagThreshold / 1000; } return node->ri && router_is_active(node->ri, node, now) && !digestmap_get(omit_as_sybil, node->ri->cache_info.identity_digest) && - (dirserv_get_credible_bandwidth(node->ri) >= min_bw) && + (dirserv_get_credible_bandwidth_kb(node->ri) >= min_bw_kb) && (have_mbw || !require_mbw); } @@ -1920,7 +1920,7 @@ dirserv_compute_performance_thresholds(routerlist_t *rl, digestmap_t *omit_as_sybil) { int n_active, n_active_nonexit, n_familiar; - uint32_t *uptimes, *bandwidths, *bandwidths_excluding_exits; + uint32_t *uptimes, *bandwidths_kb, *bandwidths_excluding_exits_kb; long *tks; double *mtbfs, *wfus; time_t now = time(NULL); @@ -1934,13 +1934,13 @@ dirserv_compute_performance_thresholds(routerlist_t *rl, /* initialize these all here, in case there are no routers */ stable_uptime = 0; stable_mtbf = 0; - fast_bandwidth = 0; - guard_bandwidth_including_exits = 0; - guard_bandwidth_excluding_exits = 0; + fast_bandwidth_kb = 0; + guard_bandwidth_including_exits_kb = 0; + guard_bandwidth_excluding_exits_kb = 0; guard_tk = 0; guard_wfu = 0; - total_bandwidth = 0; - total_exit_bandwidth = 0; + total_bandwidth_kb = 0; + total_exit_bandwidth_kb = 0; /* Initialize arrays that will hold values for each router. We'll * sort them and use that to compute thresholds. */ @@ -1948,9 +1948,9 @@ dirserv_compute_performance_thresholds(routerlist_t *rl, /* Uptime for every active router. */ uptimes = tor_malloc(sizeof(uint32_t)*smartlist_len(rl->routers)); /* Bandwidth for every active router. */ - bandwidths = tor_malloc(sizeof(uint32_t)*smartlist_len(rl->routers)); + bandwidths_kb = tor_malloc(sizeof(uint32_t)*smartlist_len(rl->routers)); /* Bandwidth for every active non-exit router. */ - bandwidths_excluding_exits = + bandwidths_excluding_exits_kb = tor_malloc(sizeof(uint32_t)*smartlist_len(rl->routers)); /* Weighted mean time between failure for each active router. */ mtbfs = tor_malloc(sizeof(double)*smartlist_len(rl->routers)); @@ -1967,18 +1967,18 @@ dirserv_compute_performance_thresholds(routerlist_t *rl, require_mbw)) { routerinfo_t *ri = node->ri; const char *id = ri->cache_info.identity_digest; - uint32_t bw; + uint32_t bw_kb; node->is_exit = (!router_exit_policy_rejects_all(ri) && exit_policy_is_general_exit(ri->exit_policy)); uptimes[n_active] = (uint32_t)real_uptime(ri, now); mtbfs[n_active] = rep_hist_get_stability(id, now); tks [n_active] = rep_hist_get_weighted_time_known(id, now); - bandwidths[n_active] = bw = dirserv_get_credible_bandwidth(ri); - total_bandwidth += bw; + bandwidths_kb[n_active] = bw_kb = dirserv_get_credible_bandwidth_kb(ri); + total_bandwidth_kb += bw_kb; if (node->is_exit && !node->is_bad_exit) { - total_exit_bandwidth += bw; + total_exit_bandwidth_kb += bw_kb; } else { - bandwidths_excluding_exits[n_active_nonexit] = bw; + bandwidths_excluding_exits_kb[n_active_nonexit] = bw_kb; ++n_active_nonexit; } ++n_active; @@ -1992,11 +1992,11 @@ dirserv_compute_performance_thresholds(routerlist_t *rl, /* The median mtbf is stable, if we have enough mtbf info */ stable_mtbf = median_double(mtbfs, n_active); /* The 12.5th percentile bandwidth is fast. */ - fast_bandwidth = find_nth_uint32(bandwidths, n_active, n_active/8); + fast_bandwidth_kb = find_nth_uint32(bandwidths_kb, n_active, n_active/8); /* (Now bandwidths is sorted.) */ - if (fast_bandwidth < ROUTER_REQUIRED_MIN_BANDWIDTH/(2 * 1000)) - fast_bandwidth = bandwidths[n_active/4]; - guard_bandwidth_including_exits = bandwidths[(n_active-1)/2]; + if (fast_bandwidth_kb < ROUTER_REQUIRED_MIN_BANDWIDTH/(2 * 1000)) + fast_bandwidth_kb = bandwidths_kb[n_active/4]; + guard_bandwidth_including_exits_kb = bandwidths_kb[(n_active-1)/2]; guard_tk = find_nth_long(tks, n_active, n_active/8); } @@ -2006,26 +2006,29 @@ dirserv_compute_performance_thresholds(routerlist_t *rl, { /* We can vote on a parameter for the minimum and maximum. */ #define ABSOLUTE_MIN_VALUE_FOR_FAST_FLAG 4 - int32_t min_fast, max_fast; + int32_t min_fast_kb, max_fast_kb, min_fast, max_fast; min_fast = networkstatus_get_param(NULL, "FastFlagMinThreshold", ABSOLUTE_MIN_VALUE_FOR_FAST_FLAG, ABSOLUTE_MIN_VALUE_FOR_FAST_FLAG, INT32_MAX); if (options->TestingTorNetwork) { - min_fast = (int32_t)options->TestingMinFastFlagThreshold/1000; + min_fast = (int32_t)options->TestingMinFastFlagThreshold; } max_fast = networkstatus_get_param(NULL, "FastFlagMaxThreshold", INT32_MAX, min_fast, INT32_MAX); - if (fast_bandwidth < (uint32_t)min_fast) - fast_bandwidth = min_fast; - if (fast_bandwidth > (uint32_t)max_fast) - fast_bandwidth = max_fast; + min_fast_kb = min_fast / 1000; + max_fast_kb = max_fast / 1000; + + if (fast_bandwidth_kb < (uint32_t)min_fast_kb) + fast_bandwidth_kb = min_fast_kb; + if (fast_bandwidth_kb > (uint32_t)max_fast_kb) + fast_bandwidth_kb = max_fast_kb; } /* Protect sufficiently fast nodes from being pushed out of the set * of Fast nodes. */ if (options->AuthDirFastGuarantee && - fast_bandwidth > options->AuthDirFastGuarantee/1000) - fast_bandwidth = (uint32_t)options->AuthDirFastGuarantee/1000; + fast_bandwidth_kb > options->AuthDirFastGuarantee/1000) + fast_bandwidth_kb = (uint32_t)options->AuthDirFastGuarantee/1000; /* Now that we have a time-known that 7/8 routers are known longer than, * fill wfus with the wfu of every such "familiar" router. */ @@ -2050,8 +2053,8 @@ dirserv_compute_performance_thresholds(routerlist_t *rl, enough_mtbf_info = rep_hist_have_measured_enough_stability(); if (n_active_nonexit) { - guard_bandwidth_excluding_exits = - median_uint32(bandwidths_excluding_exits, n_active_nonexit); + guard_bandwidth_excluding_exits_kb = + median_uint32(bandwidths_excluding_exits_kb, n_active_nonexit); } log_info(LD_DIRSERV, @@ -2062,24 +2065,24 @@ dirserv_compute_performance_thresholds(routerlist_t *rl, "We%s have enough stability data.", (unsigned long)stable_uptime, (unsigned long)stable_mtbf, - (unsigned long)fast_bandwidth, + (unsigned long)fast_bandwidth_kb, guard_wfu*100, (unsigned long)guard_tk, - (unsigned long)guard_bandwidth_including_exits, - (unsigned long)guard_bandwidth_excluding_exits, + (unsigned long)guard_bandwidth_including_exits_kb, + (unsigned long)guard_bandwidth_excluding_exits_kb, enough_mtbf_info ? "" : " don't "); tor_free(uptimes); tor_free(mtbfs); - tor_free(bandwidths); - tor_free(bandwidths_excluding_exits); + tor_free(bandwidths_kb); + tor_free(bandwidths_excluding_exits_kb); tor_free(tks); tor_free(wfus); } /** Measured bandwidth cache entry */ typedef struct mbw_cache_entry_s { - long mbw; + long mbw_kb; time_t as_of; } mbw_cache_entry_t; @@ -2106,13 +2109,13 @@ dirserv_cache_measured_bw(const measured_bw_line_t *parsed_line, if (e) { /* Check that we really are newer, and update */ if (as_of > e->as_of) { - e->mbw = parsed_line->bw; + e->mbw_kb = parsed_line->bw_kb; e->as_of = as_of; } } else { /* We'll have to insert a new entry */ e = tor_malloc(sizeof(*e)); - e->mbw = parsed_line->bw; + e->mbw_kb = parsed_line->bw_kb; e->as_of = as_of; digestmap_set(mbw_cache, parsed_line->node_id, e); } @@ -2163,8 +2166,8 @@ dirserv_get_measured_bw_cache_size(void) * we found it. The bw_out and as_of_out pointers receive the cached * bandwidth value and the time it was cached if not NULL. */ int -dirserv_query_measured_bw_cache(const char *node_id, long *bw_out, - time_t *as_of_out) +dirserv_query_measured_bw_cache_kb(const char *node_id, long *bw_kb_out, + time_t *as_of_out) { mbw_cache_entry_t *v = NULL; int rv = 0; @@ -2174,7 +2177,7 @@ dirserv_query_measured_bw_cache(const char *node_id, long *bw_out, if (v) { /* Found something */ rv = 1; - if (bw_out) *bw_out = v->mbw; + if (bw_kb_out) *bw_kb_out = v->mbw_kb; if (as_of_out) *as_of_out = v->as_of; } } @@ -2186,22 +2189,22 @@ dirserv_query_measured_bw_cache(const char *node_id, long *bw_out, int dirserv_has_measured_bw(const char *node_id) { - return dirserv_query_measured_bw_cache(node_id, NULL, NULL); + return dirserv_query_measured_bw_cache_kb(node_id, NULL, NULL); } /** Get the best estimate of a router's bandwidth for dirauth purposes, * preferring measured to advertised values if available. */ static uint32_t -dirserv_get_bandwidth_for_router(const routerinfo_t *ri) +dirserv_get_bandwidth_for_router_kb(const routerinfo_t *ri) { - uint32_t bw = 0; + uint32_t bw_kb = 0; /* * Yeah, measured bandwidths in measured_bw_line_t are (implicitly * signed) longs and the ones router_get_advertised_bandwidth() returns * are uint32_t. */ - long mbw = 0; + long mbw_kb = 0; if (ri) { /* @@ -2209,17 +2212,17 @@ dirserv_get_bandwidth_for_router(const routerinfo_t *ri) * as_of_out here, on the theory that a stale measured bandwidth is still * better to trust than an advertised one. */ - if (dirserv_query_measured_bw_cache(ri->cache_info.identity_digest, - &mbw, NULL)) { + if (dirserv_query_measured_bw_cache_kb(ri->cache_info.identity_digest, + &mbw_kb, NULL)) { /* Got one! */ - bw = (uint32_t)mbw; + bw_kb = (uint32_t)mbw_kb; } else { /* If not, fall back to advertised */ - bw = router_get_advertised_bandwidth(ri) / 1000; + bw_kb = router_get_advertised_bandwidth(ri) / 1000; } } - return bw; + return bw_kb; } /** Look through the routerlist, and using the measured bandwidth cache count @@ -2248,30 +2251,30 @@ dirserv_count_measured_bws(routerlist_t *rl) * bandwidths, we don't want to ever give flags to unmeasured routers, so * return 0. */ static uint32_t -dirserv_get_credible_bandwidth(const routerinfo_t *ri) +dirserv_get_credible_bandwidth_kb(const routerinfo_t *ri) { int threshold; - uint32_t bw = 0; - long mbw; + uint32_t bw_kb = 0; + long mbw_kb; tor_assert(ri); /* Check if we have a measured bandwidth, and check the threshold if not */ - if (!(dirserv_query_measured_bw_cache(ri->cache_info.identity_digest, - &mbw, NULL))) { + if (!(dirserv_query_measured_bw_cache_kb(ri->cache_info.identity_digest, + &mbw_kb, NULL))) { threshold = get_options()->MinMeasuredBWsForAuthToIgnoreAdvertised; if (routers_with_measured_bw > threshold) { /* Return zero for unmeasured bandwidth if we are above threshold */ - bw = 0; + bw_kb = 0; } else { /* Return an advertised bandwidth otherwise */ - bw = router_get_advertised_bandwidth_capped(ri) / 1000; + bw_kb = router_get_advertised_bandwidth_capped(ri) / 1000; } } else { /* We have the measured bandwidth in mbw */ - bw = (uint32_t)mbw; + bw_kb = (uint32_t)mbw_kb; } - return bw; + return bw_kb; } /** Give a statement of our current performance thresholds for inclusion @@ -2288,11 +2291,11 @@ dirserv_get_flag_thresholds_line(void) "enough-mtbf=%d", (unsigned long)stable_uptime, (unsigned long)stable_mtbf, - (unsigned long)fast_bandwidth, + (unsigned long)fast_bandwidth_kb*1000, guard_wfu*100, (unsigned long)guard_tk, - (unsigned long)guard_bandwidth_including_exits, - (unsigned long)guard_bandwidth_excluding_exits, + (unsigned long)guard_bandwidth_including_exits_kb*1000, + (unsigned long)guard_bandwidth_excluding_exits_kb*1000, enough_mtbf_info ? 1 : 0); return result; @@ -2426,7 +2429,7 @@ routerstatus_format_entry(char *buf, size_t buf_len, if (format != NS_V2) { const routerinfo_t* desc = router_get_by_id_digest(rs->identity_digest); - uint32_t bw; + uint32_t bw_kb; if (format != NS_CONTROL_PORT) { /* Blow up more or less nicely if we didn't get anything or not the @@ -2471,13 +2474,13 @@ routerstatus_format_entry(char *buf, size_t buf_len, } if (format == NS_CONTROL_PORT && rs->has_bandwidth) { - bw = rs->bandwidth; + bw_kb = rs->bandwidth_kb; } else { tor_assert(desc); - bw = router_get_advertised_bandwidth_capped(desc) / 1000; + bw_kb = router_get_advertised_bandwidth_capped(desc) / 1000; } r = tor_snprintf(cp, buf_len - (cp-buf), - "w Bandwidth=%d\n", bw); + "w Bandwidth=%d\n", bw_kb); if (r<0) { log_warn(LD_BUG, "Not enough space in buffer."); @@ -2487,7 +2490,7 @@ routerstatus_format_entry(char *buf, size_t buf_len, if (format == NS_V3_VOTE && vrs && vrs->has_measured_bw) { *--cp = '\0'; /* Kill "\n" */ r = tor_snprintf(cp, buf_len - (cp-buf), - " Measured=%d\n", vrs->measured_bw); + " Measured=%d\n", vrs->measured_bw_kb); if (r<0) { log_warn(LD_BUG, "Not enough space in buffer for weight line."); return -1; @@ -2521,7 +2524,7 @@ compare_routerinfo_by_ip_and_bw_(const void **a, const void **b) { routerinfo_t *first = *(routerinfo_t **)a, *second = *(routerinfo_t **)b; int first_is_auth, second_is_auth; - uint32_t bw_first, bw_second; + uint32_t bw_kb_first, bw_kb_second; const node_t *node_first, *node_second; int first_is_running, second_is_running; @@ -2556,12 +2559,12 @@ compare_routerinfo_by_ip_and_bw_(const void **a, const void **b) else if (!first_is_running && second_is_running) return 1; - bw_first = dirserv_get_bandwidth_for_router(first); - bw_second = dirserv_get_bandwidth_for_router(second); + bw_kb_first = dirserv_get_bandwidth_for_router_kb(first); + bw_kb_second = dirserv_get_bandwidth_for_router_kb(second); - if (bw_first > bw_second) + if (bw_kb_first > bw_kb_second) return -1; - else if (bw_first < bw_second) + else if (bw_kb_first < bw_kb_second) return 1; /* They're equal! Compare by identity digest, so there's a @@ -2697,7 +2700,7 @@ set_routerstatus_from_routerinfo(routerstatus_t *rs, int listbaddirs, int vote_on_hsdirs) { const or_options_t *options = get_options(); - uint32_t routerbw = dirserv_get_credible_bandwidth(ri); + uint32_t routerbw_kb = dirserv_get_credible_bandwidth_kb(ri); memset(rs, 0, sizeof(routerstatus_t)); @@ -2724,9 +2727,9 @@ set_routerstatus_from_routerinfo(routerstatus_t *rs, if (node->is_fast && ((options->AuthDirGuardBWGuarantee && - routerbw >= options->AuthDirGuardBWGuarantee/1000) || - routerbw >= MIN(guard_bandwidth_including_exits, - guard_bandwidth_excluding_exits)) && + routerbw_kb >= options->AuthDirGuardBWGuarantee/1000) || + routerbw_kb >= MIN(guard_bandwidth_including_exits_kb, + guard_bandwidth_excluding_exits_kb)) && is_router_version_good_for_possible_guard(ri->platform)) { long tk = rep_hist_get_weighted_time_known( node->identity, now); @@ -2821,7 +2824,7 @@ measured_bw_line_parse(measured_bw_line_t *out, const char *orig_line) } cp+=strlen("bw="); - out->bw = tor_parse_long(cp, 0, 0, LONG_MAX, &parse_ok, &endptr); + out->bw_kb = tor_parse_long(cp, 0, 0, LONG_MAX, &parse_ok, &endptr); if (!parse_ok || (*endptr && !TOR_ISSPACE(*endptr))) { log_warn(LD_DIRSERV, "Invalid bandwidth in bandwidth file line: %s", escaped(orig_line)); @@ -2879,7 +2882,7 @@ measured_bw_line_apply(measured_bw_line_t *parsed_line, if (rs) { rs->has_measured_bw = 1; - rs->measured_bw = (uint32_t)parsed_line->bw; + rs->measured_bw_kb = (uint32_t)parsed_line->bw_kb; } else { log_info(LD_DIRSERV, "Node ID %s not found in routerstatus list", parsed_line->node_hex); diff --git a/src/or/dirserv.h b/src/or/dirserv.h index a84ae96..d6eb4ab 100644 --- a/src/or/dirserv.h +++ b/src/or/dirserv.h @@ -151,8 +151,8 @@ void dirserv_cache_measured_bw(const measured_bw_line_t *parsed_line, void dirserv_clear_measured_bw_cache(void); void dirserv_expire_measured_bw_cache(time_t now); int dirserv_get_measured_bw_cache_size(void); -int dirserv_query_measured_bw_cache(const char *node_id, long *bw_out, - time_t *as_of_out); +int dirserv_query_measured_bw_cache_kb(const char *node_id, long *bw_out, + time_t *as_of_out); int dirserv_has_measured_bw(const char *node_id); #endif diff --git a/src/or/dirvote.c b/src/or/dirvote.c index 7043cef..417721d 100644 --- a/src/or/dirvote.c +++ b/src/or/dirvote.c @@ -1388,7 +1388,7 @@ networkstatus_compute_consensus(smartlist_t *votes, char *client_versions = NULL, *server_versions = NULL; smartlist_t *flags; const char *flavor_name; - uint32_t max_unmeasured_bw = DEFAULT_MAX_UNMEASURED_BW; + uint32_t max_unmeasured_bw_kb = DEFAULT_MAX_UNMEASURED_BW_KB; int64_t G=0, M=0, E=0, D=0, T=0; /* For bandwidth weights */ const routerstatus_format_type_t rs_format = flavor == FLAV_NS ? NS_V3_CONSENSUS : NS_V3_CONSENSUS_MICRODESC; @@ -1600,12 +1600,12 @@ networkstatus_compute_consensus(smartlist_t *votes, int ok = 0; char *eq = strchr(max_unmeasured_param, '='); if (eq) { - max_unmeasured_bw = (uint32_t) + max_unmeasured_bw_kb = (uint32_t) tor_parse_ulong(eq+1, 10, 1, UINT32_MAX, &ok, NULL); if (!ok) { log_warn(LD_DIR, "Bad element '%s' in max unmeasured bw param", escaped(max_unmeasured_param)); - max_unmeasured_bw = DEFAULT_MAX_UNMEASURED_BW; + max_unmeasured_bw_kb = DEFAULT_MAX_UNMEASURED_BW_KB; } } } @@ -1622,9 +1622,10 @@ networkstatus_compute_consensus(smartlist_t *votes, smartlist_t *chosen_flags = smartlist_new(); smartlist_t *versions = smartlist_new(); smartlist_t *exitsummaries = smartlist_new(); - uint32_t *bandwidths = tor_malloc(sizeof(uint32_t) * smartlist_len(votes)); - uint32_t *measured_bws = tor_malloc(sizeof(uint32_t) * - smartlist_len(votes)); + uint32_t *bandwidths_kb = tor_malloc(sizeof(uint32_t) * + smartlist_len(votes)); + uint32_t *measured_bws_kb = tor_malloc(sizeof(uint32_t) * + smartlist_len(votes)); int num_bandwidths; int num_mbws; @@ -1804,10 +1805,10 @@ networkstatus_compute_consensus(smartlist_t *votes, /* count bandwidths */ if (rs->has_measured_bw) - measured_bws[num_mbws++] = rs->measured_bw; + measured_bws_kb[num_mbws++] = rs->measured_bw_kb; if (rs->status.has_bandwidth) - bandwidths[num_bandwidths++] = rs->status.bandwidth; + bandwidths_kb[num_bandwidths++] = rs->status.bandwidth_kb; } SMARTLIST_FOREACH_END(v); /* We don't include this router at all unless more than half of @@ -1898,16 +1899,16 @@ networkstatus_compute_consensus(smartlist_t *votes, if (consensus_method >= 6 && num_mbws > 2) { rs_out.has_bandwidth = 1; rs_out.bw_is_unmeasured = 0; - rs_out.bandwidth = median_uint32(measured_bws, num_mbws); + rs_out.bandwidth_kb = median_uint32(measured_bws_kb, num_mbws); } else if (consensus_method >= 5 && num_bandwidths > 0) { rs_out.has_bandwidth = 1; rs_out.bw_is_unmeasured = 1; - rs_out.bandwidth = median_uint32(bandwidths, num_bandwidths); + rs_out.bandwidth_kb = median_uint32(bandwidths_kb, num_bandwidths); if (consensus_method >= MIN_METHOD_TO_CLIP_UNMEASURED_BW && n_authorities_measuring_bandwidth > 2) { /* Cap non-measured bandwidths. */ - if (rs_out.bandwidth > max_unmeasured_bw) { - rs_out.bandwidth = max_unmeasured_bw; + if (rs_out.bandwidth_kb > max_unmeasured_bw_kb) { + rs_out.bandwidth_kb = max_unmeasured_bw_kb; } } } @@ -1919,15 +1920,15 @@ networkstatus_compute_consensus(smartlist_t *votes, if (consensus_method >= MIN_METHOD_FOR_BW_WEIGHTS) { if (rs_out.has_bandwidth) { - T += rs_out.bandwidth; + T += rs_out.bandwidth_kb; if (is_exit && is_guard) - D += rs_out.bandwidth; + D += rs_out.bandwidth_kb; else if (is_exit) - E += rs_out.bandwidth; + E += rs_out.bandwidth_kb; else if (is_guard) - G += rs_out.bandwidth; + G += rs_out.bandwidth_kb; else - M += rs_out.bandwidth; + M += rs_out.bandwidth_kb; } else { log_warn(LD_BUG, "Missing consensus bandwidth for router %s", rs_out.nickname); @@ -2053,7 +2054,8 @@ networkstatus_compute_consensus(smartlist_t *votes, if (rs_out.has_bandwidth) { int unmeasured = rs_out.bw_is_unmeasured && consensus_method >= MIN_METHOD_TO_CLIP_UNMEASURED_BW; - smartlist_add_asprintf(chunks, "w Bandwidth=%d%s\n", rs_out.bandwidth, + smartlist_add_asprintf(chunks, "w Bandwidth=%d%s\n", + rs_out.bandwidth_kb, unmeasured?" Unmeasured=1":""); } @@ -2080,8 +2082,8 @@ networkstatus_compute_consensus(smartlist_t *votes, smartlist_free(chosen_flags); smartlist_free(versions); smartlist_free(exitsummaries); - tor_free(bandwidths); - tor_free(measured_bws); + tor_free(bandwidths_kb); + tor_free(measured_bws_kb); } if (consensus_method >= MIN_METHOD_FOR_FOOTER) { diff --git a/src/or/dirvote.h b/src/or/dirvote.h index 8d036d6..b236452 100644 --- a/src/or/dirvote.h +++ b/src/or/dirvote.h @@ -61,7 +61,7 @@ /** Default bandwidth to clip unmeasured bandwidths to using method >= * MIN_METHOD_TO_CLIP_UNMEASURED_BW */ -#define DEFAULT_MAX_UNMEASURED_BW 20 +#define DEFAULT_MAX_UNMEASURED_BW_KB 20 void dirvote_free_all(void); diff --git a/src/or/or.h b/src/or/or.h index ece2bc7..4a95347 100644 --- a/src/or/or.h +++ b/src/or/or.h @@ -2096,7 +2096,7 @@ typedef struct routerstatus_t { unsigned int bw_is_unmeasured:1; /**< This is a consensus entry, with * the Unmeasured flag set. */ - uint32_t bandwidth; /**< Bandwidth (capacity) of the router as reported in + uint32_t bandwidth_kb; /**< Bandwidth (capacity) of the router as reported in * the vote/consensus, in kilobytes/sec. */ char *exitsummary; /**< exit policy summary - * XXX weasel: this probably should not stay a string. */ @@ -2342,7 +2342,7 @@ typedef struct vote_routerstatus_t { char *version; /**< The version that the authority says this router is * running. */ unsigned int has_measured_bw:1; /**< The vote had a measured bw */ - uint32_t measured_bw; /**< Measured bandwidth (capacity) of the router */ + uint32_t measured_bw_kb; /**< Measured bandwidth (capacity) of the router */ /** The hash or hashes that the authority claims this microdesc has. */ vote_microdesc_hash_t *microdesc; } vote_routerstatus_t; @@ -4478,7 +4478,7 @@ typedef enum { typedef struct measured_bw_line_t { char node_id[DIGEST_LEN]; char node_hex[MAX_HEX_NICKNAME_LEN+1]; - long int bw; + long int bw_kb; } measured_bw_line_t; #endif diff --git a/src/or/routerlist.c b/src/or/routerlist.c index 0c978e9..6ed168e 100644 --- a/src/or/routerlist.c +++ b/src/or/routerlist.c @@ -1793,7 +1793,7 @@ compute_weighted_bandwidths(const smartlist_t *sl, "old router selection algorithm."); return -1; } - this_bw = kb_to_bytes(node->rs->bandwidth); + this_bw = kb_to_bytes(node->rs->bandwidth_kb); } else if (node->ri) { /* bridge or other descriptor not in our consensus */ this_bw = bridge_get_advertised_bandwidth_bounded(node->ri); @@ -1944,7 +1944,7 @@ smartlist_choose_node_by_bandwidth(const smartlist_t *sl, is_guard = node->is_possible_guard; if (node->rs) { if (node->rs->has_bandwidth) { - this_bw = kb_to_bytes(node->rs->bandwidth); + this_bw = kb_to_bytes(node->rs->bandwidth_kb); } else { /* guess */ is_known = 0; } diff --git a/src/or/routerparse.c b/src/or/routerparse.c index f8edb84..0eadcc9 100644 --- a/src/or/routerparse.c +++ b/src/or/routerparse.c @@ -1966,9 +1966,10 @@ routerstatus_parse_entry_from_string(memarea_t *area, for (i=0; i < tok->n_args; ++i) { if (!strcmpstart(tok->args[i], "Bandwidth=")) { int ok; - rs->bandwidth = (uint32_t)tor_parse_ulong(strchr(tok->args[i], '=')+1, - 10, 0, UINT32_MAX, - &ok, NULL); + rs->bandwidth_kb = + (uint32_t)tor_parse_ulong(strchr(tok->args[i], '=')+1, + 10, 0, UINT32_MAX, + &ok, NULL); if (!ok) { log_warn(LD_DIR, "Invalid Bandwidth %s", escaped(tok->args[i])); goto err; @@ -1976,7 +1977,7 @@ routerstatus_parse_entry_from_string(memarea_t *area, rs->has_bandwidth = 1; } else if (!strcmpstart(tok->args[i], "Measured=") && vote_rs) { int ok; - vote_rs->measured_bw = + vote_rs->measured_bw_kb = (uint32_t)tor_parse_ulong(strchr(tok->args[i], '=')+1, 10, 0, UINT32_MAX, &ok, NULL); if (!ok) { @@ -2351,23 +2352,23 @@ networkstatus_verify_bw_weights(networkstatus_t *ns, int consensus_method) is_exit = rs->is_exit; } if (rs->has_bandwidth) { - T += rs->bandwidth; + T += rs->bandwidth_kb; if (is_exit && rs->is_possible_guard) { - D += rs->bandwidth; - Gtotal += Wgd*rs->bandwidth; - Mtotal += Wmd*rs->bandwidth; - Etotal += Wed*rs->bandwidth; + D += rs->bandwidth_kb; + Gtotal += Wgd*rs->bandwidth_kb; + Mtotal += Wmd*rs->bandwidth_kb; + Etotal += Wed*rs->bandwidth_kb; } else if (is_exit) { - E += rs->bandwidth; - Mtotal += Wme*rs->bandwidth; - Etotal += Wee*rs->bandwidth; + E += rs->bandwidth_kb; + Mtotal += Wme*rs->bandwidth_kb; + Etotal += Wee*rs->bandwidth_kb; } else if (rs->is_possible_guard) { - G += rs->bandwidth; - Gtotal += Wgg*rs->bandwidth; - Mtotal += Wmg*rs->bandwidth; + G += rs->bandwidth_kb; + Gtotal += Wgg*rs->bandwidth_kb; + Mtotal += Wmg*rs->bandwidth_kb; } else { - M += rs->bandwidth; - Mtotal += Wmm*rs->bandwidth; + M += rs->bandwidth_kb; + Mtotal += Wmm*rs->bandwidth_kb; } } else { log_warn(LD_BUG, "Missing consensus bandwidth for router %s", diff --git a/src/test/test_dir.c b/src/test/test_dir.c index 606dfe5..849bb9e 100644 --- a/src/test/test_dir.c +++ b/src/test/test_dir.c @@ -508,7 +508,7 @@ test_dir_split_fps(void *testdata) } static void -test_dir_measured_bw(void) +test_dir_measured_bw_kb(void) { measured_bw_line_t mbwl; int i; @@ -564,7 +564,7 @@ test_dir_measured_bw(void) for (i = 0; strcmp(lines_pass[i], "end"); i++) { //fprintf(stderr, "Testing: %s %d\n", lines_pass[i], TOR_ISSPACE('\n')); test_assert(measured_bw_line_parse(&mbwl, lines_pass[i]) == 0); - test_assert(mbwl.bw == 1024); + test_assert(mbwl.bw_kb == 1024); test_assert(strcmp(mbwl.node_hex, "557365204145532d32353620696e73746561642e") == 0); } @@ -577,7 +577,7 @@ test_dir_measured_bw(void) /** Do the measured bandwidth cache unit test */ static void -test_dir_measured_bw_cache(void) +test_dir_measured_bw_kb_cache(void) { /* Initial fake time_t for testing */ time_t curr = MBWC_INIT_TIME; @@ -595,23 +595,23 @@ test_dir_measured_bw_cache(void) * the node_hex field. */ memset(mbwl[0].node_id, 0x01, DIGEST_LEN); - mbwl[0].bw = 20; + mbwl[0].bw_kb = 20; memset(mbwl[1].node_id, 0x02, DIGEST_LEN); - mbwl[1].bw = 40; + mbwl[1].bw_kb = 40; memset(mbwl[2].node_id, 0x03, DIGEST_LEN); - mbwl[2].bw = 80; + mbwl[2].bw_kb = 80; /* Try caching something */ dirserv_cache_measured_bw(&(mbwl[0]), curr); test_eq(dirserv_get_measured_bw_cache_size(), 1); /* Okay, let's see if we can retrieve it */ - test_assert(dirserv_query_measured_bw_cache(mbwl[0].node_id, &bw, &as_of)); + test_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,&bw, &as_of)); test_eq(bw, 20); test_eq(as_of, MBWC_INIT_TIME); /* Try retrieving it without some outputs */ - test_assert(dirserv_query_measured_bw_cache(mbwl[0].node_id, NULL, NULL)); - test_assert(dirserv_query_measured_bw_cache(mbwl[0].node_id, &bw, NULL)); + test_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,NULL, NULL)); + test_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,&bw, NULL)); test_eq(bw, 20); - test_assert(dirserv_query_measured_bw_cache(mbwl[0].node_id, NULL, &as_of)); + test_assert(dirserv_query_measured_bw_cache_kb(mbwl[0].node_id,NULL, &as_of)); test_eq(as_of, MBWC_INIT_TIME); /* Now expire it */ curr += MAX_MEASUREMENT_AGE + 1; @@ -619,7 +619,7 @@ test_dir_measured_bw_cache(void) /* Check that the cache is empty */ test_eq(dirserv_get_measured_bw_cache_size(), 0); /* Check that we can't retrieve it */ - test_assert(!dirserv_query_measured_bw_cache(mbwl[0].node_id, NULL, NULL)); + test_assert(!dirserv_query_measured_bw_cache_kb(mbwl[0].node_id, NULL, NULL)); /* Try caching a few things now */ dirserv_cache_measured_bw(&(mbwl[0]), curr); test_eq(dirserv_get_measured_bw_cache_size(), 1); @@ -829,8 +829,8 @@ generate_ri_from_rs(const vote_routerstatus_t *vrs) * router_get_advertised_bandwidth_capped() of routerlist.c and * routerstatus_format_entry() of dirserv.c. */ - r->bandwidthrate = rs->bandwidth * 1000; - r->bandwidthcapacity = rs->bandwidth * 1000; + r->bandwidthrate = rs->bandwidth_kb * 1000; + r->bandwidthcapacity = rs->bandwidth_kb * 1000; } return r; } @@ -952,7 +952,7 @@ vote_tweaks_for_v3ns(networkstatus_t *v, int voter, time_t now) if (voter == 1) { measured_bw_line_t mbw; memset(mbw.node_id, 33, sizeof(mbw.node_id)); - mbw.bw = 1024; + mbw.bw_kb = 1024; test_assert(measured_bw_line_apply(&mbw, v->routerstatus_list) == 1); } else if (voter == 2 || voter == 3) { @@ -1048,7 +1048,7 @@ test_vrs_for_v3ns(vote_routerstatus_t *vrs, int voter, time_t now) (voter == 1 || voter == 2)) { /* Check the measured bandwidth bits */ test_assert(vrs->has_measured_bw && - vrs->measured_bw == 1024); + vrs->measured_bw_kb == 1024); } else { /* * Didn't expect this, but the old unit test only checked some of them, @@ -1779,12 +1779,12 @@ test_dir_random_weighted(void *testdata) ; } -/* Function pointers for test_dir_clip_unmeasured_bw() */ +/* Function pointers for test_dir_clip_unmeasured_bw_kb() */ static uint32_t alternate_clip_bw = 0; /** - * Generate a routerstatus for clip_unmeasured_bw test; based on the + * Generate a routerstatus for clip_unmeasured_bw_kb test; based on the * v3_networkstatus ones. */ static vote_routerstatus_t * @@ -1793,8 +1793,8 @@ gen_routerstatus_for_umbw(int idx, time_t now) vote_routerstatus_t *vrs = NULL; routerstatus_t *rs; tor_addr_t addr_ipv6; - uint32_t max_unmeasured_bw = (alternate_clip_bw > 0) ? - alternate_clip_bw : DEFAULT_MAX_UNMEASURED_BW; + uint32_t max_unmeasured_bw_kb = (alternate_clip_bw > 0) ? + alternate_clip_bw : DEFAULT_MAX_UNMEASURED_BW_KB; switch (idx) { case 0: @@ -1818,7 +1818,7 @@ gen_routerstatus_for_umbw(int idx, time_t now) */ vrs->has_measured_bw = 1; rs->has_bandwidth = 1; - vrs->measured_bw = rs->bandwidth = max_unmeasured_bw / 2; + vrs->measured_bw_kb = rs->bandwidth_kb = max_unmeasured_bw_kb / 2; break; case 1: /* Generate the second routerstatus. */ @@ -1844,7 +1844,7 @@ gen_routerstatus_for_umbw(int idx, time_t now) */ vrs->has_measured_bw = 1; rs->has_bandwidth = 1; - vrs->measured_bw = rs->bandwidth = 2 * max_unmeasured_bw; + vrs->measured_bw_kb = rs->bandwidth_kb = 2 * max_unmeasured_bw_kb; break; case 2: /* Generate the third routerstatus. */ @@ -1868,8 +1868,8 @@ gen_routerstatus_for_umbw(int idx, time_t now) */ vrs->has_measured_bw = 0; rs->has_bandwidth = 1; - vrs->measured_bw = 0; - rs->bandwidth = 2 * max_unmeasured_bw; + vrs->measured_bw_kb = 0; + rs->bandwidth_kb = 2 * max_unmeasured_bw_kb; break; case 3: /* Generate a fourth routerstatus that is not running. */ @@ -1892,8 +1892,8 @@ gen_routerstatus_for_umbw(int idx, time_t now) */ vrs->has_measured_bw = 0; rs->has_bandwidth = 1; - vrs->measured_bw = 0; - rs->bandwidth = max_unmeasured_bw / 2; + vrs->measured_bw_kb = 0; + rs->bandwidth_kb = max_unmeasured_bw_kb / 2; break; case 4: /* No more for this test; return NULL */ @@ -1922,7 +1922,7 @@ vote_tweaks_for_umbw(networkstatus_t *v, int voter, time_t now) test_assert(v->supported_methods); smartlist_clear(v->supported_methods); - /* Method 17 is MIN_METHOD_TO_CLIP_UNMEASURED_BW */ + /* Method 17 is MIN_METHOD_TO_CLIP_UNMEASURED_BW_KB */ smartlist_split_string(v->supported_methods, "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17", NULL, 0, -1); @@ -1948,8 +1948,8 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now) { routerstatus_t *rs; tor_addr_t addr_ipv6; - uint32_t max_unmeasured_bw = (alternate_clip_bw > 0) ? - alternate_clip_bw : DEFAULT_MAX_UNMEASURED_BW; + uint32_t max_unmeasured_bw_kb = (alternate_clip_bw > 0) ? + alternate_clip_bw : DEFAULT_MAX_UNMEASURED_BW_KB; (void)voter; test_assert(vrs); @@ -1978,8 +1978,8 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now) test_eq(rs->dir_port, 8000); test_assert(rs->has_bandwidth); test_assert(vrs->has_measured_bw); - test_eq(rs->bandwidth, max_unmeasured_bw / 2); - test_eq(vrs->measured_bw, max_unmeasured_bw / 2); + test_eq(rs->bandwidth_kb, max_unmeasured_bw_kb / 2); + test_eq(vrs->measured_bw_kb, max_unmeasured_bw_kb / 2); } else if (tor_memeq(rs->identity_digest, "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5" "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5", @@ -2005,8 +2005,8 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now) test_eq(rs->ipv6_orport, 4711); test_assert(rs->has_bandwidth); test_assert(vrs->has_measured_bw); - test_eq(rs->bandwidth, max_unmeasured_bw * 2); - test_eq(vrs->measured_bw, max_unmeasured_bw * 2); + test_eq(rs->bandwidth_kb, max_unmeasured_bw_kb * 2); + test_eq(vrs->measured_bw_kb, max_unmeasured_bw_kb * 2); } else if (tor_memeq(rs->identity_digest, "\x33\x33\x33\x33\x33\x33\x33\x33\x33\x33" "\x33\x33\x33\x33\x33\x33\x33\x33\x33\x33", @@ -2018,8 +2018,8 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now) */ test_assert(rs->has_bandwidth); test_assert(!(vrs->has_measured_bw)); - test_eq(rs->bandwidth, max_unmeasured_bw * 2); - test_eq(vrs->measured_bw, 0); + test_eq(rs->bandwidth_kb, max_unmeasured_bw_kb * 2); + test_eq(vrs->measured_bw_kb, 0); } else if (tor_memeq(rs->identity_digest, "\x34\x34\x34\x34\x34\x34\x34\x34\x34\x34" "\x34\x34\x34\x34\x34\x34\x34\x34\x34\x34", @@ -2030,8 +2030,8 @@ test_vrs_for_umbw(vote_routerstatus_t *vrs, int voter, time_t now) */ test_assert(rs->has_bandwidth); test_assert(!(vrs->has_measured_bw)); - test_eq(rs->bandwidth, max_unmeasured_bw / 2); - test_eq(vrs->measured_bw, 0); + test_eq(rs->bandwidth_kb, max_unmeasured_bw_kb / 2); + test_eq(vrs->measured_bw_kb, 0); } else { test_assert(0); } @@ -2050,7 +2050,7 @@ test_consensus_for_umbw(networkstatus_t *con, time_t now) test_assert(con); test_assert(!con->cert); - /* test_assert(con->consensus_method >= MIN_METHOD_TO_CLIP_UNMEASURED_BW); */ + /* test_assert(con->consensus_method >= MIN_METHOD_TO_CLIP_UNMEASURED_BW_KB); */ test_assert(con->consensus_method >= 16); test_eq(4, smartlist_len(con->routerstatus_list)); /* There should be four listed routers; all voters saw the same in this */ @@ -2066,8 +2066,8 @@ static void test_routerstatus_for_umbw(routerstatus_t *rs, time_t now) { tor_addr_t addr_ipv6; - uint32_t max_unmeasured_bw = (alternate_clip_bw > 0) ? - alternate_clip_bw : DEFAULT_MAX_UNMEASURED_BW; + uint32_t max_unmeasured_bw_kb = (alternate_clip_bw > 0) ? + alternate_clip_bw : DEFAULT_MAX_UNMEASURED_BW_KB; test_assert(rs); @@ -2093,7 +2093,7 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now) test_assert(!rs->is_named); /* This one should have measured bandwidth below the clip cutoff */ test_assert(rs->has_bandwidth); - test_eq(rs->bandwidth, max_unmeasured_bw / 2); + test_eq(rs->bandwidth_kb, max_unmeasured_bw_kb / 2); test_assert(!(rs->bw_is_unmeasured)); } else if (tor_memeq(rs->identity_digest, "\x5\x5\x5\x5\x5\x5\x5\x5\x5\x5" @@ -2124,7 +2124,7 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now) test_assert(!rs->is_named); /* This one should have measured bandwidth above the clip cutoff */ test_assert(rs->has_bandwidth); - test_eq(rs->bandwidth, max_unmeasured_bw * 2); + test_eq(rs->bandwidth_kb, max_unmeasured_bw_kb * 2); test_assert(!(rs->bw_is_unmeasured)); } else if (tor_memeq(rs->identity_digest, "\x33\x33\x33\x33\x33\x33\x33\x33\x33\x33" @@ -2135,7 +2135,7 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now) * and so should be clipped */ test_assert(rs->has_bandwidth); - test_eq(rs->bandwidth, max_unmeasured_bw); + test_eq(rs->bandwidth_kb, max_unmeasured_bw_kb); test_assert(rs->bw_is_unmeasured); } else if (tor_memeq(rs->identity_digest, "\x34\x34\x34\x34\x34\x34\x34\x34\x34\x34" @@ -2146,7 +2146,7 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now) * and so should not be clipped */ test_assert(rs->has_bandwidth); - test_eq(rs->bandwidth, max_unmeasured_bw / 2); + test_eq(rs->bandwidth_kb, max_unmeasured_bw_kb / 2); test_assert(rs->bw_is_unmeasured); } else { /* Weren't expecting this... */ @@ -2164,7 +2164,7 @@ test_routerstatus_for_umbw(routerstatus_t *rs, time_t now) */ static void -test_dir_clip_unmeasured_bw(void) +test_dir_clip_unmeasured_bw_kb(void) { /* Run the test with the default clip bandwidth */ alternate_clip_bw = 0; @@ -2176,20 +2176,20 @@ test_dir_clip_unmeasured_bw(void) } /** - * This version of test_dir_clip_unmeasured_bw() uses a non-default choice of + * This version of test_dir_clip_unmeasured_bw_kb() uses a non-default choice of * clip bandwidth. */ static void -test_dir_clip_unmeasured_bw_alt(void) +test_dir_clip_unmeasured_bw_kb_alt(void) { /* * Try a different one; this value is chosen so that the below-the-cutoff * unmeasured nodes the test uses, at alternate_clip_bw / 2, will be above - * DEFAULT_MAX_UNMEASURED_BW and if the consensus incorrectly uses that + * DEFAULT_MAX_UNMEASURED_BW_KB and if the consensus incorrectly uses that * cutoff it will fail the test. */ - alternate_clip_bw = 3 * DEFAULT_MAX_UNMEASURED_BW; + alternate_clip_bw = 3 * DEFAULT_MAX_UNMEASURED_BW_KB; test_a_networkstatus(gen_routerstatus_for_umbw, vote_tweaks_for_umbw, test_vrs_for_umbw, @@ -2209,14 +2209,14 @@ struct testcase_t dir_tests[] = { DIR_LEGACY(versions), DIR_LEGACY(fp_pairs), DIR(split_fps), - DIR_LEGACY(measured_bw), + DIR_LEGACY(measured_bw_kb), DIR_LEGACY(param_voting), DIR_LEGACY(v3_networkstatus), DIR(random_weighted), DIR(scale_bw), - DIR_LEGACY(clip_unmeasured_bw), - DIR_LEGACY(clip_unmeasured_bw_alt), - DIR_LEGACY(measured_bw_cache), + DIR_LEGACY(clip_unmeasured_bw_kb), + DIR_LEGACY(clip_unmeasured_bw_kb_alt), + DIR_LEGACY(measured_bw_kb_cache), END_OF_TESTCASES };