mirror of
https://gitlab.torproject.org/tpo/core/tor.git
synced 2024-11-10 13:13:44 +01:00
Merge branch 'bug40566' into 'main'
Remove unused congestion control and BDP algs See merge request tpo/core/tor!725
This commit is contained in:
commit
05624b5781
4
changes/ticket40566
Normal file
4
changes/ticket40566
Normal file
@ -0,0 +1,4 @@
|
||||
o Minor bugfix (congestion control):
|
||||
- Remove unused congestion control algorithms and BDP calculation
|
||||
code, now that we have settled on and fully tuned Vegas. Fixes
|
||||
bug 40566; bugfix on 0.4.7.4-alpha.
|
@ -22,8 +22,6 @@
|
||||
#include "core/or/congestion_control_st.h"
|
||||
#include "core/or/congestion_control_common.h"
|
||||
#include "core/or/congestion_control_vegas.h"
|
||||
#include "core/or/congestion_control_nola.h"
|
||||
#include "core/or/congestion_control_westwood.h"
|
||||
#include "core/or/congestion_control_st.h"
|
||||
#include "core/or/conflux.h"
|
||||
#include "core/or/conflux_util.h"
|
||||
@ -88,8 +86,7 @@
|
||||
|
||||
static bool congestion_control_update_circuit_bdp(congestion_control_t *,
|
||||
const circuit_t *,
|
||||
const crypt_path_t *,
|
||||
uint64_t, uint64_t);
|
||||
uint64_t);
|
||||
/* Number of times the RTT value was reset. For MetricsPort. */
|
||||
static uint64_t num_rtt_reset;
|
||||
|
||||
@ -216,6 +213,13 @@ congestion_control_new_consensus_params(const networkstatus_t *ns)
|
||||
CC_ALG_DFLT,
|
||||
CC_ALG_MIN,
|
||||
CC_ALG_MAX);
|
||||
if (cc_alg != CC_ALG_SENDME && cc_alg != CC_ALG_VEGAS) {
|
||||
// Does not need rate limiting because consensus updates
|
||||
// are at most 1x/hour
|
||||
log_warn(LD_BUG, "Unsupported congestion control algorithm %d",
|
||||
cc_alg);
|
||||
cc_alg = CC_ALG_DFLT;
|
||||
}
|
||||
|
||||
#define BWE_SENDME_MIN_MIN 2
|
||||
#define BWE_SENDME_MIN_MAX (20)
|
||||
@ -316,37 +320,13 @@ congestion_control_init_params(congestion_control_t *cc,
|
||||
cc->cc_alg = cc_alg;
|
||||
}
|
||||
|
||||
bdp_alg_t default_bdp_alg = 0;
|
||||
|
||||
switch (cc->cc_alg) {
|
||||
case CC_ALG_WESTWOOD:
|
||||
default_bdp_alg = WESTWOOD_BDP_ALG;
|
||||
break;
|
||||
case CC_ALG_VEGAS:
|
||||
default_bdp_alg = VEGAS_BDP_MIX_ALG;
|
||||
break;
|
||||
case CC_ALG_NOLA:
|
||||
default_bdp_alg = NOLA_BDP_ALG;
|
||||
break;
|
||||
case CC_ALG_SENDME:
|
||||
default:
|
||||
tor_fragile_assert();
|
||||
return; // No alg-specific params
|
||||
}
|
||||
|
||||
cc->bdp_alg =
|
||||
networkstatus_get_param(NULL, "cc_bdp_alg",
|
||||
default_bdp_alg,
|
||||
0,
|
||||
NUM_BDP_ALGS-1);
|
||||
|
||||
/* Algorithm-specific parameters */
|
||||
if (cc->cc_alg == CC_ALG_WESTWOOD) {
|
||||
congestion_control_westwood_set_params(cc);
|
||||
} else if (cc->cc_alg == CC_ALG_VEGAS) {
|
||||
if (cc->cc_alg == CC_ALG_VEGAS) {
|
||||
congestion_control_vegas_set_params(cc, path);
|
||||
} else if (cc->cc_alg == CC_ALG_NOLA) {
|
||||
congestion_control_nola_set_params(cc);
|
||||
} else {
|
||||
// This should not happen anymore
|
||||
log_warn(LD_BUG, "Unknown congestion control algorithm %d",
|
||||
cc->cc_alg);
|
||||
}
|
||||
}
|
||||
|
||||
@ -420,7 +400,6 @@ congestion_control_init(congestion_control_t *cc,
|
||||
cc_path_t path)
|
||||
{
|
||||
cc->sendme_pending_timestamps = smartlist_new();
|
||||
cc->sendme_arrival_timestamps = smartlist_new();
|
||||
|
||||
cc->in_slow_start = 1;
|
||||
congestion_control_init_params(cc, params, path);
|
||||
@ -451,9 +430,7 @@ congestion_control_free_(congestion_control_t *cc)
|
||||
return;
|
||||
|
||||
SMARTLIST_FOREACH(cc->sendme_pending_timestamps, uint64_t *, t, tor_free(t));
|
||||
SMARTLIST_FOREACH(cc->sendme_arrival_timestamps, uint64_t *, t, tor_free(t));
|
||||
smartlist_free(cc->sendme_pending_timestamps);
|
||||
smartlist_free(cc->sendme_arrival_timestamps);
|
||||
|
||||
tor_free(cc);
|
||||
}
|
||||
@ -470,22 +447,6 @@ enqueue_timestamp(smartlist_t *timestamps_u64, uint64_t timestamp_usec)
|
||||
smartlist_add(timestamps_u64, timestamp_ptr);
|
||||
}
|
||||
|
||||
/**
|
||||
* Peek at the head of a smartlist queue of u64 timestamps.
|
||||
*/
|
||||
static inline uint64_t
|
||||
peek_timestamp(const smartlist_t *timestamps_u64_usecs)
|
||||
{
|
||||
uint64_t *timestamp_ptr = smartlist_get(timestamps_u64_usecs, 0);
|
||||
|
||||
if (BUG(!timestamp_ptr)) {
|
||||
log_err(LD_CIRC, "Congestion control timestamp list became empty!");
|
||||
return 0;
|
||||
}
|
||||
|
||||
return *timestamp_ptr;
|
||||
}
|
||||
|
||||
/**
|
||||
* Dequeue a u64 monotime usec timestamp from the front of a
|
||||
* smartlist of pointers to 64.
|
||||
@ -689,61 +650,6 @@ congestion_control_note_cell_sent(congestion_control_t *cc,
|
||||
monotime_absolute_usec());
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if any edge connections are active.
|
||||
*
|
||||
* We need to know this so that we can stop computing BDP if the
|
||||
* edges are not sending on the circuit.
|
||||
*/
|
||||
static int
|
||||
circuit_has_active_streams(const circuit_t *circ,
|
||||
const crypt_path_t *layer_hint)
|
||||
{
|
||||
const edge_connection_t *streams;
|
||||
|
||||
if (CIRCUIT_IS_ORIGIN(circ)) {
|
||||
streams = CONST_TO_ORIGIN_CIRCUIT(circ)->p_streams;
|
||||
} else {
|
||||
streams = CONST_TO_OR_CIRCUIT(circ)->n_streams;
|
||||
}
|
||||
|
||||
/* Check linked list of streams */
|
||||
for (const edge_connection_t *conn = streams; conn != NULL;
|
||||
conn = conn->next_stream) {
|
||||
if (conn->base_.marked_for_close)
|
||||
continue;
|
||||
|
||||
if (edge_uses_cpath(conn, layer_hint)) {
|
||||
if (connection_get_inbuf_len(TO_CONN(conn)) > 0) {
|
||||
log_info(LD_CIRC, "CC: More in edge inbuf...");
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* If we did not reach EOF on this read, there's more */
|
||||
if (!TO_CONN(conn)->inbuf_reached_eof) {
|
||||
log_info(LD_CIRC, "CC: More on edge conn...");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (TO_CONN(conn)->linked_conn) {
|
||||
if (connection_get_inbuf_len(TO_CONN(conn)->linked_conn) > 0) {
|
||||
log_info(LD_CIRC, "CC: More in linked inbuf...");
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* If there is a linked conn, and *it* did not each EOF,
|
||||
* there's more */
|
||||
if (!TO_CONN(conn)->linked_conn->inbuf_reached_eof) {
|
||||
log_info(LD_CIRC, "CC: More on linked conn...");
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Upon receipt of a SENDME, pop the oldest timestamp off the timestamp
|
||||
* list, and use this to update RTT.
|
||||
@ -753,15 +659,13 @@ circuit_has_active_streams(const circuit_t *circ,
|
||||
*/
|
||||
bool
|
||||
congestion_control_update_circuit_estimates(congestion_control_t *cc,
|
||||
const circuit_t *circ,
|
||||
const crypt_path_t *layer_hint)
|
||||
const circuit_t *circ)
|
||||
{
|
||||
uint64_t now_usec = monotime_absolute_usec();
|
||||
|
||||
/* Update RTT first, then BDP. BDP needs fresh RTT */
|
||||
uint64_t curr_rtt_usec = congestion_control_update_circuit_rtt(cc, now_usec);
|
||||
return congestion_control_update_circuit_bdp(cc, circ, layer_hint, now_usec,
|
||||
curr_rtt_usec);
|
||||
return congestion_control_update_circuit_bdp(cc, circ, curr_rtt_usec);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -777,13 +681,6 @@ time_delta_should_use_heuristics(const congestion_control_t *cc)
|
||||
return true;
|
||||
}
|
||||
|
||||
/* If we managed to get enough acks to estimate a SENDME BDP, then
|
||||
* we have enough to estimate clock jumps relative to a baseline,
|
||||
* too. (This is at least 'cc_bwe_min' acks). */
|
||||
if (cc->bdp[BDP_ALG_SENDME_RATE]) {
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Not enough data to estimate clock jumps */
|
||||
return false;
|
||||
}
|
||||
@ -950,14 +847,10 @@ congestion_control_update_circuit_rtt(congestion_control_t *cc,
|
||||
static bool
|
||||
congestion_control_update_circuit_bdp(congestion_control_t *cc,
|
||||
const circuit_t *circ,
|
||||
const crypt_path_t *layer_hint,
|
||||
uint64_t now_usec,
|
||||
uint64_t curr_rtt_usec)
|
||||
{
|
||||
int chan_q = 0;
|
||||
unsigned int blocked_on_chan = 0;
|
||||
uint64_t timestamp_usec;
|
||||
uint64_t sendme_rate_bdp = 0;
|
||||
|
||||
tor_assert(cc);
|
||||
|
||||
@ -995,10 +888,7 @@ congestion_control_update_circuit_bdp(congestion_control_t *cc,
|
||||
cc->blocked_chan = 0;
|
||||
}
|
||||
|
||||
cc->bdp[BDP_ALG_CWND_RTT] = cwnd;
|
||||
cc->bdp[BDP_ALG_INFLIGHT_RTT] = cwnd;
|
||||
cc->bdp[BDP_ALG_SENDME_RATE] = cwnd;
|
||||
cc->bdp[BDP_ALG_PIECEWISE] = cwnd;
|
||||
cc->bdp = cwnd;
|
||||
|
||||
static ratelim_t dec_notice_limit = RATELIM_INIT(300);
|
||||
log_fn_ratelim(&dec_notice_limit, LOG_NOTICE, LD_CIRC,
|
||||
@ -1017,84 +907,7 @@ congestion_control_update_circuit_bdp(congestion_control_t *cc,
|
||||
* close to ewma RTT. Since all fields are u64, there is plenty of
|
||||
* room here to multiply first.
|
||||
*/
|
||||
cc->bdp[BDP_ALG_CWND_RTT] = cc->cwnd*cc->min_rtt_usec/cc->ewma_rtt_usec;
|
||||
|
||||
/*
|
||||
* If we have no pending streams, we do not have enough data to fill
|
||||
* the BDP, so preserve our old estimates but do not make any more.
|
||||
*/
|
||||
if (!blocked_on_chan && !circuit_has_active_streams(circ, layer_hint)) {
|
||||
log_info(LD_CIRC,
|
||||
"CC: Streams drained. Spare package window: %"PRIu64
|
||||
", no BDP update", cc->cwnd - cc->inflight);
|
||||
|
||||
/* Clear SENDME timestamps; they will be wrong with intermittent data */
|
||||
SMARTLIST_FOREACH(cc->sendme_arrival_timestamps, uint64_t *, t,
|
||||
tor_free(t));
|
||||
smartlist_clear(cc->sendme_arrival_timestamps);
|
||||
} else if (curr_rtt_usec && is_monotime_clock_reliable()) {
|
||||
/* Sendme-based BDP will quickly measure BDP in much less than
|
||||
* a cwnd worth of data when in use (in 2-10 SENDMEs).
|
||||
*
|
||||
* But if the link goes idle, it will be vastly lower than true BDP. Hence
|
||||
* we only compute it if we have either pending stream data, or streams
|
||||
* are still blocked on the channel queued data.
|
||||
*
|
||||
* We also do not compute it if we do not have a current RTT passed in,
|
||||
* because that means that monotime is currently stalled or just jumped.
|
||||
*/
|
||||
enqueue_timestamp(cc->sendme_arrival_timestamps, now_usec);
|
||||
|
||||
if (smartlist_len(cc->sendme_arrival_timestamps) >= bwe_sendme_min) {
|
||||
/* If we have more sendmes than fit in a cwnd, trim the list.
|
||||
* Those are not acurrately measuring throughput, if cwnd is
|
||||
* currently smaller than BDP */
|
||||
while (smartlist_len(cc->sendme_arrival_timestamps) >
|
||||
bwe_sendme_min &&
|
||||
(uint64_t)smartlist_len(cc->sendme_arrival_timestamps) >
|
||||
n_ewma_count(cc)) {
|
||||
(void)dequeue_timestamp(cc->sendme_arrival_timestamps);
|
||||
}
|
||||
int sendme_cnt = smartlist_len(cc->sendme_arrival_timestamps);
|
||||
|
||||
/* Calculate SENDME_BWE_COUNT pure average */
|
||||
timestamp_usec = peek_timestamp(cc->sendme_arrival_timestamps);
|
||||
uint64_t delta = now_usec - timestamp_usec;
|
||||
|
||||
/* In Shadow, the time delta between acks can be 0 if there is no
|
||||
* network activity between them. Only update BDP if the delta is
|
||||
* non-zero. */
|
||||
if (delta > 0) {
|
||||
/* The acked data is in sendme_cnt-1 chunks, because we are counting
|
||||
* the data that is processed by the other endpoint *between* all of
|
||||
* these sendmes. There's one less gap between the sendmes than the
|
||||
* number of sendmes. */
|
||||
uint64_t cells = (sendme_cnt-1)*cc->sendme_inc;
|
||||
|
||||
/* The bandwidth estimate is cells/delta, which when multiplied
|
||||
* by min RTT obtains the BDP. However, we multiply first to
|
||||
* avoid precision issues with the RTT being close to delta in size. */
|
||||
sendme_rate_bdp = cells*cc->min_rtt_usec/delta;
|
||||
|
||||
/* Calculate BDP_EWMA_COUNT N-EWMA */
|
||||
cc->bdp[BDP_ALG_SENDME_RATE] =
|
||||
n_count_ewma(sendme_rate_bdp, cc->bdp[BDP_ALG_SENDME_RATE],
|
||||
n_ewma_count(cc));
|
||||
}
|
||||
}
|
||||
|
||||
/* In-flight BDP will cause the cwnd to drift down when underutilized.
|
||||
* It is most useful when the local OR conn is blocked, so we only
|
||||
* compute it if we're utilized. */
|
||||
cc->bdp[BDP_ALG_INFLIGHT_RTT] =
|
||||
(cc->inflight - chan_q)*cc->min_rtt_usec/
|
||||
MAX(cc->ewma_rtt_usec, curr_rtt_usec);
|
||||
} else {
|
||||
/* We can still update inflight with just an EWMA RTT, but only
|
||||
* if there is data flowing */
|
||||
cc->bdp[BDP_ALG_INFLIGHT_RTT] =
|
||||
(cc->inflight - chan_q)*cc->min_rtt_usec/cc->ewma_rtt_usec;
|
||||
}
|
||||
cc->bdp = cc->cwnd*cc->min_rtt_usec/cc->ewma_rtt_usec;
|
||||
|
||||
/* The orconn is blocked; use smaller of inflight vs SENDME */
|
||||
if (blocked_on_chan) {
|
||||
@ -1107,13 +920,6 @@ congestion_control_update_circuit_bdp(congestion_control_t *cc,
|
||||
cc->next_cc_event = 0;
|
||||
cc->blocked_chan = 1;
|
||||
}
|
||||
|
||||
if (cc->bdp[BDP_ALG_SENDME_RATE]) {
|
||||
cc->bdp[BDP_ALG_PIECEWISE] = MIN(cc->bdp[BDP_ALG_INFLIGHT_RTT],
|
||||
cc->bdp[BDP_ALG_SENDME_RATE]);
|
||||
} else {
|
||||
cc->bdp[BDP_ALG_PIECEWISE] = cc->bdp[BDP_ALG_INFLIGHT_RTT];
|
||||
}
|
||||
} else {
|
||||
/* If we were previously blocked, emit a new congestion event
|
||||
* now that we are unblocked, to re-evaluate cwnd */
|
||||
@ -1123,19 +929,6 @@ congestion_control_update_circuit_bdp(congestion_control_t *cc,
|
||||
log_info(LD_CIRC, "CC: Streams un-blocked on circ channel. Chanq: %d",
|
||||
chan_q);
|
||||
}
|
||||
|
||||
cc->bdp[BDP_ALG_PIECEWISE] = MAX(cc->bdp[BDP_ALG_SENDME_RATE],
|
||||
cc->bdp[BDP_ALG_CWND_RTT]);
|
||||
}
|
||||
|
||||
/* We can end up with no piecewise value if we didn't have either
|
||||
* a SENDME estimate or enough data for an inflight estimate.
|
||||
* It also happens on the very first sendme, since we need two
|
||||
* to get a BDP. In these cases, use the cwnd method. */
|
||||
if (!cc->bdp[BDP_ALG_PIECEWISE]) {
|
||||
cc->bdp[BDP_ALG_PIECEWISE] = cc->bdp[BDP_ALG_CWND_RTT];
|
||||
log_info(LD_CIRC, "CC: No piecewise BDP. Using %"PRIu64,
|
||||
cc->bdp[BDP_ALG_PIECEWISE]);
|
||||
}
|
||||
|
||||
if (cc->next_cc_event == 0) {
|
||||
@ -1143,44 +936,25 @@ congestion_control_update_circuit_bdp(congestion_control_t *cc,
|
||||
log_info(LD_CIRC,
|
||||
"CC: Circuit %d "
|
||||
"SENDME RTT: %"PRIu64", %"PRIu64", %"PRIu64", %"PRIu64", "
|
||||
"BDP estimates: "
|
||||
"%"PRIu64", "
|
||||
"%"PRIu64", "
|
||||
"%"PRIu64", "
|
||||
"%"PRIu64", "
|
||||
"%"PRIu64". ",
|
||||
"BDP estimate: %"PRIu64,
|
||||
CONST_TO_ORIGIN_CIRCUIT(circ)->global_identifier,
|
||||
cc->min_rtt_usec/1000,
|
||||
curr_rtt_usec/1000,
|
||||
cc->ewma_rtt_usec/1000,
|
||||
cc->max_rtt_usec/1000,
|
||||
cc->bdp[BDP_ALG_INFLIGHT_RTT],
|
||||
cc->bdp[BDP_ALG_CWND_RTT],
|
||||
sendme_rate_bdp,
|
||||
cc->bdp[BDP_ALG_SENDME_RATE],
|
||||
cc->bdp[BDP_ALG_PIECEWISE]
|
||||
);
|
||||
cc->bdp);
|
||||
} else {
|
||||
log_info(LD_CIRC,
|
||||
"CC: Circuit %"PRIu64":%d "
|
||||
"SENDME RTT: %"PRIu64", %"PRIu64", %"PRIu64", %"PRIu64", "
|
||||
"%"PRIu64", "
|
||||
"%"PRIu64", "
|
||||
"%"PRIu64", "
|
||||
"%"PRIu64", "
|
||||
"%"PRIu64". ",
|
||||
"%"PRIu64,
|
||||
CONST_TO_OR_CIRCUIT(circ)->p_chan->global_identifier,
|
||||
CONST_TO_OR_CIRCUIT(circ)->p_circ_id,
|
||||
cc->min_rtt_usec/1000,
|
||||
curr_rtt_usec/1000,
|
||||
cc->ewma_rtt_usec/1000,
|
||||
cc->max_rtt_usec/1000,
|
||||
cc->bdp[BDP_ALG_INFLIGHT_RTT],
|
||||
cc->bdp[BDP_ALG_CWND_RTT],
|
||||
sendme_rate_bdp,
|
||||
cc->bdp[BDP_ALG_SENDME_RATE],
|
||||
cc->bdp[BDP_ALG_PIECEWISE]
|
||||
);
|
||||
cc->bdp);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1188,8 +962,7 @@ congestion_control_update_circuit_bdp(congestion_control_t *cc,
|
||||
* the curr_rtt_usec was not 0. */
|
||||
bool ret = (blocked_on_chan || curr_rtt_usec != 0);
|
||||
if (ret) {
|
||||
tor_trace(TR_SUBSYS(cc), TR_EV(bdp_update), circ, cc, curr_rtt_usec,
|
||||
sendme_rate_bdp);
|
||||
tor_trace(TR_SUBSYS(cc), TR_EV(bdp_update), circ, cc, curr_rtt_usec);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
@ -1199,27 +972,12 @@ congestion_control_update_circuit_bdp(congestion_control_t *cc,
|
||||
*/
|
||||
int
|
||||
congestion_control_dispatch_cc_alg(congestion_control_t *cc,
|
||||
circuit_t *circ,
|
||||
const crypt_path_t *layer_hint)
|
||||
circuit_t *circ)
|
||||
{
|
||||
int ret = -END_CIRC_REASON_INTERNAL;
|
||||
switch (cc->cc_alg) {
|
||||
case CC_ALG_WESTWOOD:
|
||||
ret = congestion_control_westwood_process_sendme(cc, circ, layer_hint);
|
||||
break;
|
||||
|
||||
case CC_ALG_VEGAS:
|
||||
ret = congestion_control_vegas_process_sendme(cc, circ, layer_hint);
|
||||
break;
|
||||
|
||||
case CC_ALG_NOLA:
|
||||
ret = congestion_control_nola_process_sendme(cc, circ, layer_hint);
|
||||
break;
|
||||
|
||||
case CC_ALG_SENDME:
|
||||
default:
|
||||
tor_assert(0);
|
||||
}
|
||||
tor_assert_nonfatal_once(cc->cc_alg == CC_ALG_VEGAS);
|
||||
ret = congestion_control_vegas_process_sendme(cc, circ);
|
||||
|
||||
if (cc->cwnd > cwnd_max) {
|
||||
static ratelim_t cwnd_limit = RATELIM_INIT(60);
|
||||
|
@ -46,16 +46,14 @@ congestion_control_t *congestion_control_new(
|
||||
cc_path_t path);
|
||||
|
||||
int congestion_control_dispatch_cc_alg(congestion_control_t *cc,
|
||||
circuit_t *circ,
|
||||
const crypt_path_t *layer_hint);
|
||||
circuit_t *circ);
|
||||
|
||||
void congestion_control_note_cell_sent(congestion_control_t *cc,
|
||||
const circuit_t *circ,
|
||||
const crypt_path_t *cpath);
|
||||
|
||||
bool congestion_control_update_circuit_estimates(congestion_control_t *,
|
||||
const circuit_t *,
|
||||
const crypt_path_t *);
|
||||
const circuit_t *);
|
||||
|
||||
int congestion_control_get_package_window(const circuit_t *,
|
||||
const crypt_path_t *);
|
||||
|
@ -1,139 +0,0 @@
|
||||
/* Copyright (c) 2019-2021, The Tor Project, Inc. */
|
||||
/* See LICENSE for licensing information */
|
||||
|
||||
/**
|
||||
* \file congestion_control_nola.c
|
||||
* \brief Code that implements the TOR_NOLA congestion control algorithm
|
||||
* from Proposal #324.
|
||||
*/
|
||||
|
||||
#define TOR_CONGESTION_CONTROL_NOLA_PRIVATE
|
||||
|
||||
#include "core/or/or.h"
|
||||
|
||||
#include "core/or/crypt_path.h"
|
||||
#include "core/or/or_circuit_st.h"
|
||||
#include "core/or/sendme.h"
|
||||
#include "core/or/congestion_control_st.h"
|
||||
#include "core/or/congestion_control_common.h"
|
||||
#include "core/or/congestion_control_nola.h"
|
||||
#include "core/or/circuituse.h"
|
||||
#include "core/or/circuitlist.h"
|
||||
#include "core/or/origin_circuit_st.h"
|
||||
#include "core/or/channel.h"
|
||||
#include "feature/nodelist/networkstatus.h"
|
||||
#include "feature/control/control_events.h"
|
||||
|
||||
#define NOLA_BDP_OVERSHOOT 100
|
||||
|
||||
/**
|
||||
* Cache NOLA consensus parameters.
|
||||
*/
|
||||
void
|
||||
congestion_control_nola_set_params(congestion_control_t *cc)
|
||||
{
|
||||
tor_assert(cc->cc_alg == CC_ALG_NOLA);
|
||||
|
||||
cc->nola_params.bdp_overshoot =
|
||||
networkstatus_get_param(NULL, "cc_nola_overshoot",
|
||||
NOLA_BDP_OVERSHOOT,
|
||||
0,
|
||||
1000);
|
||||
}
|
||||
|
||||
/**
|
||||
* Process a SENDME and update the congestion window according to the
|
||||
* rules specified in TOR_NOLA of Proposal #324.
|
||||
*
|
||||
* TOR_NOLA updates the congestion window to match the current
|
||||
* BDP estimate, every sendme. Because this can result in downward
|
||||
* drift, a fixed overhead is added to the BDP estimate. This will
|
||||
* cause some queuing, but ensures that the algorithm always uses
|
||||
* the full BDP.
|
||||
*
|
||||
* To handle the case where the local orconn blocks, TOR_NOLA uses
|
||||
* the 'piecewise' BDP estimate, which uses more a conservative BDP
|
||||
* estimate method when blocking occurs, but a more aggressive BDP
|
||||
* estimate when there is no local blocking. This minimizes local
|
||||
* client queues.
|
||||
*/
|
||||
int
|
||||
congestion_control_nola_process_sendme(congestion_control_t *cc,
|
||||
const circuit_t *circ,
|
||||
const crypt_path_t *layer_hint)
|
||||
{
|
||||
tor_assert(cc && cc->cc_alg == CC_ALG_NOLA);
|
||||
tor_assert(circ);
|
||||
|
||||
if (cc->next_cc_event)
|
||||
cc->next_cc_event--;
|
||||
|
||||
/* If we get a congestion event, the only thing NOLA
|
||||
* does is note this as if we exited slow-start
|
||||
* (which for NOLA just means we finished our ICW). */
|
||||
if (cc->next_cc_event == 0) {
|
||||
if (cc->in_slow_start) {
|
||||
cc->in_slow_start = 0;
|
||||
|
||||
/* We need to report that slow start has exited ASAP,
|
||||
* for sbws bandwidth measurement. */
|
||||
if (CIRCUIT_IS_ORIGIN(circ)) {
|
||||
/* We must discard const here because the event modifies fields :/ */
|
||||
control_event_circ_bandwidth_used_for_circ(
|
||||
TO_ORIGIN_CIRCUIT((circuit_t*)circ));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* If we did not successfully update BDP, we must return. Otherwise,
|
||||
* NOLA can drift downwards */
|
||||
if (!congestion_control_update_circuit_estimates(cc, circ, layer_hint)) {
|
||||
cc->inflight = cc->inflight - cc->sendme_inc;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* We overshoot the BDP by the cwnd_inc param amount, because BDP
|
||||
* may otherwise drift down. This helps us probe for more capacity.
|
||||
* But there is no sense to do it if the local channel is blocked. */
|
||||
if (cc->blocked_chan)
|
||||
cc->cwnd = cc->bdp[cc->bdp_alg];
|
||||
else
|
||||
cc->cwnd = cc->bdp[cc->bdp_alg] + cc->nola_params.bdp_overshoot;
|
||||
|
||||
/* cwnd can never fall below 1 increment */
|
||||
cc->cwnd = MAX(cc->cwnd, cc->cwnd_min);
|
||||
|
||||
if (CIRCUIT_IS_ORIGIN(circ)) {
|
||||
log_info(LD_CIRC,
|
||||
"CC TOR_NOLA: Circuit %d "
|
||||
"CWND: %"PRIu64", "
|
||||
"INFL: %"PRIu64", "
|
||||
"NCCE: %"PRIu16", "
|
||||
"SS: %d",
|
||||
CONST_TO_ORIGIN_CIRCUIT(circ)->global_identifier,
|
||||
cc->cwnd,
|
||||
cc->inflight,
|
||||
cc->next_cc_event,
|
||||
cc->in_slow_start
|
||||
);
|
||||
} else {
|
||||
log_info(LD_CIRC,
|
||||
"CC TOR_NOLA: Circuit %"PRIu64":%d "
|
||||
"CWND: %"PRIu64", "
|
||||
"INFL: %"PRIu64", "
|
||||
"NCCE: %"PRIu16", "
|
||||
"SS: %d",
|
||||
CONST_TO_OR_CIRCUIT(circ)->p_chan->global_identifier,
|
||||
CONST_TO_OR_CIRCUIT(circ)->p_circ_id,
|
||||
cc->cwnd,
|
||||
cc->inflight,
|
||||
cc->next_cc_event,
|
||||
cc->in_slow_start
|
||||
);
|
||||
}
|
||||
|
||||
/* Update inflight with ack */
|
||||
cc->inflight = cc->inflight - cc->sendme_inc;
|
||||
|
||||
return 0;
|
||||
}
|
@ -1,33 +0,0 @@
|
||||
/* Copyright (c) 2019-2021, The Tor Project, Inc. */
|
||||
/* See LICENSE for licensing information */
|
||||
|
||||
/**
|
||||
* \file congestion_control_nola.h
|
||||
* \brief Private-ish APIs for the TOR_NOLA congestion control algorithm
|
||||
**/
|
||||
|
||||
#ifndef TOR_CONGESTION_CONTROL_NOLA_H
|
||||
#define TOR_CONGESTION_CONTROL_NOLA_H
|
||||
|
||||
#include "core/or/crypt_path_st.h"
|
||||
#include "core/or/circuit_st.h"
|
||||
|
||||
/* Processing SENDME cell. */
|
||||
int congestion_control_nola_process_sendme(struct congestion_control_t *cc,
|
||||
const circuit_t *circ,
|
||||
const crypt_path_t *layer_hint);
|
||||
void congestion_control_nola_set_params(struct congestion_control_t *cc);
|
||||
|
||||
/* Private section starts. */
|
||||
#ifdef TOR_CONGESTION_CONTROL_NOLA_PRIVATE
|
||||
|
||||
/*
|
||||
* Unit tests declaractions.
|
||||
*/
|
||||
#ifdef TOR_UNIT_TESTS
|
||||
|
||||
#endif /* defined(TOR_UNIT_TESTS) */
|
||||
|
||||
#endif /* defined(TOR_CONGESTION_CONTROL_NOLA_PRIVATE) */
|
||||
|
||||
#endif /* !defined(TOR_CONGESTION_CONTROL_NOLA_H) */
|
@ -79,22 +79,6 @@ typedef enum {
|
||||
/** Total number of BDP algs in bdp_alg_t enum */
|
||||
#define NUM_BDP_ALGS (BDP_ALG_PIECEWISE+1)
|
||||
|
||||
/** Westwood algorithm parameters */
|
||||
struct westwood_params_t {
|
||||
/** Cwnd backoff multiplier upon congestion (as percent) */
|
||||
uint8_t cwnd_backoff_m;
|
||||
/** Max RTT backoff multiplier upon congestion (as percent) */
|
||||
uint8_t rtt_backoff_m;
|
||||
|
||||
/** Threshold between min and max RTT, to signal congestion (percent) */
|
||||
uint8_t rtt_thresh;
|
||||
|
||||
/**
|
||||
* If true, use minimum of BDP and backoff multiplication in backoff.
|
||||
* If false, use maximum of BDP and backoff multiplication in backoff. */
|
||||
bool min_backoff;
|
||||
};
|
||||
|
||||
/** Vegas algorithm parameters. */
|
||||
struct vegas_params_t {
|
||||
/** The slow-start cwnd cap for RFC3742 */
|
||||
@ -114,12 +98,6 @@ struct vegas_params_t {
|
||||
uint8_t bdp_mix_pct;
|
||||
};
|
||||
|
||||
/** NOLA consensus params */
|
||||
struct nola_params_t {
|
||||
/** How many cells to add to BDP estimate to obtain cwnd */
|
||||
uint16_t bdp_overshoot;
|
||||
};
|
||||
|
||||
/** Fields common to all congestion control algorithms */
|
||||
struct congestion_control_t {
|
||||
/**
|
||||
@ -128,19 +106,13 @@ struct congestion_control_t {
|
||||
* sendme_last_digests. */
|
||||
smartlist_t *sendme_pending_timestamps;
|
||||
|
||||
/**
|
||||
* Smartlist of uint64_t monotime timestamp of when sendme's arrived.
|
||||
* FIFO queue that is managed similar to sendme_last_digests.
|
||||
* Used to estimate circuitbandwidth and BDP. */
|
||||
smartlist_t *sendme_arrival_timestamps;
|
||||
|
||||
/** RTT time data for congestion control. */
|
||||
uint64_t ewma_rtt_usec;
|
||||
uint64_t min_rtt_usec;
|
||||
uint64_t max_rtt_usec;
|
||||
|
||||
/* BDP estimates by algorithm */
|
||||
uint64_t bdp[NUM_BDP_ALGS];
|
||||
/* Vegas BDP estimate */
|
||||
uint64_t bdp;
|
||||
|
||||
/** Congestion window */
|
||||
uint64_t cwnd;
|
||||
@ -203,15 +175,9 @@ struct congestion_control_t {
|
||||
* consensus parameter during circuit setup. */
|
||||
bdp_alg_t bdp_alg;
|
||||
|
||||
/** Algorithm-specific parameters. The specific struct that is used
|
||||
* depends upon the algorithm selected by the cc_alg parameter.
|
||||
* These should not be accessed anywhere other than the algorithm-specific
|
||||
* files. */
|
||||
union {
|
||||
struct westwood_params_t westwood_params;
|
||||
struct vegas_params_t vegas_params;
|
||||
struct nola_params_t nola_params;
|
||||
};
|
||||
/** Vegas-specific parameters. These should not be accessed anywhere
|
||||
* other than the congestion_control_vegas.c file. */
|
||||
struct vegas_params_t vegas_params;
|
||||
};
|
||||
|
||||
/**
|
||||
|
@ -98,7 +98,7 @@ uint64_t cc_stats_vegas_circ_exited_ss = 0;
|
||||
static inline uint64_t
|
||||
vegas_bdp(const congestion_control_t *cc)
|
||||
{
|
||||
return cc->bdp[BDP_ALG_CWND_RTT];
|
||||
return cc->bdp;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -405,8 +405,7 @@ cwnd_full_reset(const congestion_control_t *cc)
|
||||
*/
|
||||
int
|
||||
congestion_control_vegas_process_sendme(congestion_control_t *cc,
|
||||
const circuit_t *circ,
|
||||
const crypt_path_t *layer_hint)
|
||||
const circuit_t *circ)
|
||||
{
|
||||
uint64_t queue_use;
|
||||
|
||||
@ -422,7 +421,7 @@ congestion_control_vegas_process_sendme(congestion_control_t *cc,
|
||||
cc->next_cwnd_event--;
|
||||
|
||||
/* Compute BDP and RTT. If we did not update, don't run the alg */
|
||||
if (!congestion_control_update_circuit_estimates(cc, circ, layer_hint)) {
|
||||
if (!congestion_control_update_circuit_estimates(cc, circ)) {
|
||||
cc->inflight = cc->inflight - cc->sendme_inc;
|
||||
return 0;
|
||||
}
|
||||
|
@ -35,8 +35,7 @@ extern uint64_t cc_stats_vegas_circ_exited_ss;
|
||||
|
||||
/* Processing SENDME cell. */
|
||||
int congestion_control_vegas_process_sendme(struct congestion_control_t *cc,
|
||||
const circuit_t *circ,
|
||||
const crypt_path_t *layer_hint);
|
||||
const circuit_t *circ);
|
||||
void congestion_control_vegas_set_params(struct congestion_control_t *cc,
|
||||
cc_path_t path);
|
||||
|
||||
|
@ -1,241 +0,0 @@
|
||||
/* Copyright (c) 2019-2021, The Tor Project, Inc. */
|
||||
/* See LICENSE for licensing information */
|
||||
|
||||
/**
|
||||
* \file congestion_control_westwood.c
|
||||
* \brief Code that implements the TOR_WESTWOOD congestion control algorithm
|
||||
* from Proposal #324.
|
||||
*/
|
||||
|
||||
#define TOR_CONGESTION_CONTROL_WESTWOOD_PRIVATE
|
||||
|
||||
#include "core/or/or.h"
|
||||
|
||||
#include "core/or/crypt_path.h"
|
||||
#include "core/or/or_circuit_st.h"
|
||||
#include "core/or/sendme.h"
|
||||
#include "core/or/congestion_control_st.h"
|
||||
#include "core/or/congestion_control_common.h"
|
||||
#include "core/or/congestion_control_westwood.h"
|
||||
#include "core/or/circuitlist.h"
|
||||
#include "core/or/circuituse.h"
|
||||
#include "core/or/origin_circuit_st.h"
|
||||
#include "core/or/channel.h"
|
||||
#include "feature/nodelist/networkstatus.h"
|
||||
#include "feature/control/control_events.h"
|
||||
|
||||
#define USEC_ONE_MS (1000)
|
||||
|
||||
#define WESTWOOD_CWND_BACKOFF_M 75
|
||||
#define WESTWOOD_RTT_BACKOFF_M 100
|
||||
#define WESTWOOD_RTT_THRESH 33
|
||||
#define WESTWOOD_MIN_BACKOFF 0
|
||||
|
||||
/**
|
||||
* Cache westwood consensus parameters.
|
||||
*/
|
||||
void
|
||||
congestion_control_westwood_set_params(congestion_control_t *cc)
|
||||
{
|
||||
tor_assert(cc->cc_alg == CC_ALG_WESTWOOD);
|
||||
|
||||
cc->westwood_params.cwnd_backoff_m =
|
||||
networkstatus_get_param(NULL, "cc_westwood_cwnd_m",
|
||||
WESTWOOD_CWND_BACKOFF_M,
|
||||
0,
|
||||
100);
|
||||
|
||||
cc->westwood_params.rtt_backoff_m =
|
||||
networkstatus_get_param(NULL, "cc_westwood_rtt_m",
|
||||
WESTWOOD_RTT_BACKOFF_M,
|
||||
50,
|
||||
100);
|
||||
|
||||
cc->westwood_params.rtt_thresh =
|
||||
networkstatus_get_param(NULL, "cc_westwood_rtt_thresh",
|
||||
WESTWOOD_RTT_THRESH,
|
||||
0,
|
||||
100);
|
||||
|
||||
cc->westwood_params.min_backoff =
|
||||
networkstatus_get_param(NULL, "cc_westwood_min_backoff",
|
||||
WESTWOOD_MIN_BACKOFF,
|
||||
0,
|
||||
1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the RTT threshold that signals congestion.
|
||||
*
|
||||
* Computed from the threshold parameter that specifies a
|
||||
* percent between the min and max RTT observed so far.
|
||||
*/
|
||||
static inline uint64_t
|
||||
westwood_rtt_signal(const congestion_control_t *cc)
|
||||
{
|
||||
return ((100 - cc->westwood_params.rtt_thresh)*cc->min_rtt_usec +
|
||||
cc->westwood_params.rtt_thresh*(cc)->max_rtt_usec)/100;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compute a backoff to reduce the max RTT.
|
||||
*
|
||||
* This may be necessary to ensure that westwood does not have
|
||||
* a runaway condition where congestion inflates the max RTT, which
|
||||
* inflates the congestion threshold. That cannot happen with one
|
||||
* Westwood instance, but it may happen in aggregate. Hence, this is
|
||||
* a safety parameter, in case we need it.
|
||||
*/
|
||||
static inline uint64_t
|
||||
westwood_rtt_max_backoff(const congestion_control_t *cc)
|
||||
{
|
||||
return cc->min_rtt_usec +
|
||||
(cc->westwood_params.rtt_backoff_m *
|
||||
(cc->max_rtt_usec - cc->min_rtt_usec))/100;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the circuit is experiencing congestion, as per
|
||||
* TOR_WESTWOOD rules.
|
||||
*/
|
||||
static inline bool
|
||||
westwood_is_congested(const congestion_control_t *cc)
|
||||
{
|
||||
/* If the local channel is blocked, that is always congestion */
|
||||
if (cc->blocked_chan)
|
||||
return true;
|
||||
|
||||
/* If the min RTT is within 1ms of the signal, then there is not enough
|
||||
* range in RTTs to signify congestion. Treat that as not congested. */
|
||||
if (westwood_rtt_signal(cc) < cc->min_rtt_usec ||
|
||||
westwood_rtt_signal(cc) - cc->min_rtt_usec < USEC_ONE_MS)
|
||||
return false;
|
||||
|
||||
/* If the EWMA-smoothed RTT exceeds the westwood RTT threshold,
|
||||
* then it is congestion. */
|
||||
if (cc->ewma_rtt_usec > westwood_rtt_signal(cc))
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Process a SENDME and update the congestion window according to the
|
||||
* rules specified in TOR_WESTWOOD of Proposal #324.
|
||||
*
|
||||
* Essentially, this algorithm uses a threshold of 'rtt_thresh', which
|
||||
* is a midpoint between the min and max RTT. If the RTT exceeds this
|
||||
* threshold, then queue delay due to congestion is assumed to be present,
|
||||
* and the algorithm reduces the congestion window. If the RTT is below the
|
||||
* threshold, the circuit is not congested (ie: queue delay is low), and we
|
||||
* increase the congestion window.
|
||||
*
|
||||
* The congestion window is updated only once every congestion window worth of
|
||||
* packets, even if the signal persists. It is also updated whenever the
|
||||
* upstream orcon blocks, or unblocks. This minimizes local client queues.
|
||||
*/
|
||||
int
|
||||
congestion_control_westwood_process_sendme(congestion_control_t *cc,
|
||||
const circuit_t *circ,
|
||||
const crypt_path_t *layer_hint)
|
||||
{
|
||||
tor_assert(cc && cc->cc_alg == CC_ALG_WESTWOOD);
|
||||
tor_assert(circ);
|
||||
|
||||
/* Update ack counter until next congestion signal event is allowed */
|
||||
if (cc->next_cc_event)
|
||||
cc->next_cc_event--;
|
||||
|
||||
/* If we were unable to update our circuit estimates, Westwood must
|
||||
* *not* update its cwnd, otherwise it could run to infinity, or to 0.
|
||||
* Just update inflight from the sendme and return. */
|
||||
if (!congestion_control_update_circuit_estimates(cc, circ, layer_hint)) {
|
||||
cc->inflight = cc->inflight - cc->sendme_inc;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* We only update anything once per window */
|
||||
if (cc->next_cc_event == 0) {
|
||||
if (!westwood_is_congested(cc)) {
|
||||
if (cc->in_slow_start) {
|
||||
cc->cwnd = MAX(cc->cwnd + CWND_INC_SS(cc),
|
||||
cc->bdp[cc->bdp_alg]);
|
||||
} else {
|
||||
cc->cwnd = cc->cwnd + CWND_INC(cc);
|
||||
}
|
||||
} else {
|
||||
if (cc->westwood_params.min_backoff)
|
||||
cc->cwnd = MIN(cc->cwnd*cc->westwood_params.cwnd_backoff_m/100,
|
||||
cc->bdp[cc->bdp_alg]);
|
||||
else
|
||||
cc->cwnd = MAX(cc->cwnd*cc->westwood_params.cwnd_backoff_m/100,
|
||||
cc->bdp[cc->bdp_alg]);
|
||||
|
||||
cc->in_slow_start = 0;
|
||||
|
||||
// Because Westwood's congestion can runaway and boost max rtt,
|
||||
// which increases its congestion signal, we backoff the max rtt
|
||||
// too.
|
||||
cc->max_rtt_usec = westwood_rtt_max_backoff(cc);
|
||||
|
||||
log_info(LD_CIRC, "CC: TOR_WESTWOOD congestion. New max RTT: %"PRIu64,
|
||||
cc->max_rtt_usec/1000);
|
||||
|
||||
/* We need to report that slow start has exited ASAP,
|
||||
* for sbws bandwidth measurement. */
|
||||
if (CIRCUIT_IS_ORIGIN(circ)) {
|
||||
/* We must discard const here because the event modifies fields :/ */
|
||||
control_event_circ_bandwidth_used_for_circ(
|
||||
TO_ORIGIN_CIRCUIT((circuit_t*)circ));
|
||||
}
|
||||
}
|
||||
|
||||
/* cwnd can never fall below 1 increment */
|
||||
cc->cwnd = MAX(cc->cwnd, cc->cwnd_min);
|
||||
|
||||
/* Schedule next update */
|
||||
cc->next_cc_event = CWND_UPDATE_RATE(cc);
|
||||
|
||||
if (CIRCUIT_IS_ORIGIN(circ)) {
|
||||
log_info(LD_CIRC,
|
||||
"CC: TOR_WESTWOOD Circuit %d "
|
||||
"CWND: %"PRIu64", "
|
||||
"INFL: %"PRIu64", "
|
||||
"NCCE: %"PRIu16", "
|
||||
"WRTT: %"PRIu64", "
|
||||
"WSIG: %"PRIu64", "
|
||||
"SS: %d",
|
||||
CONST_TO_ORIGIN_CIRCUIT(circ)->global_identifier,
|
||||
cc->cwnd,
|
||||
cc->inflight,
|
||||
cc->next_cc_event,
|
||||
cc->ewma_rtt_usec/1000,
|
||||
westwood_rtt_signal(cc)/1000,
|
||||
cc->in_slow_start
|
||||
);
|
||||
} else {
|
||||
log_info(LD_CIRC,
|
||||
"CC: TOR_WESTWOOD Circuit %"PRIu64":%d "
|
||||
"CWND: %"PRIu64", "
|
||||
"INFL: %"PRIu64", "
|
||||
"NCCE: %"PRIu16", "
|
||||
"WRTT: %"PRIu64", "
|
||||
"WSIG: %"PRIu64", "
|
||||
"SS: %d",
|
||||
CONST_TO_OR_CIRCUIT(circ)->p_chan->global_identifier,
|
||||
CONST_TO_OR_CIRCUIT(circ)->p_circ_id,
|
||||
cc->cwnd,
|
||||
cc->inflight,
|
||||
cc->next_cc_event,
|
||||
cc->ewma_rtt_usec/1000,
|
||||
westwood_rtt_signal(cc)/1000,
|
||||
cc->in_slow_start
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/* Update inflight with ack */
|
||||
cc->inflight = cc->inflight - cc->sendme_inc;
|
||||
|
||||
return 0;
|
||||
}
|
@ -1,33 +0,0 @@
|
||||
/* Copyright (c) 2019-2021, The Tor Project, Inc. */
|
||||
/* See LICENSE for licensing information */
|
||||
|
||||
/**
|
||||
* \file congestion_control_westwood.h
|
||||
* \brief Private-ish APIs for the TOR_WESTWOOD congestion control algorithm
|
||||
**/
|
||||
|
||||
#ifndef TOR_CONGESTION_CONTROL_WESTWOOD_H
|
||||
#define TOR_CONGESTION_CONTROL_WESTWOOD_H
|
||||
|
||||
#include "core/or/crypt_path_st.h"
|
||||
#include "core/or/circuit_st.h"
|
||||
|
||||
/* Processing SENDME cell. */
|
||||
int congestion_control_westwood_process_sendme(struct congestion_control_t *cc,
|
||||
const circuit_t *circ,
|
||||
const crypt_path_t *layer_hint);
|
||||
void congestion_control_westwood_set_params(struct congestion_control_t *cc);
|
||||
|
||||
/* Private section starts. */
|
||||
#ifdef TOR_CONGESTION_CONTROL_WESTWOOD_PRIVATE
|
||||
|
||||
/*
|
||||
* Unit tests declaractions.
|
||||
*/
|
||||
#ifdef TOR_UNIT_TESTS
|
||||
|
||||
#endif /* defined(TOR_UNIT_TESTS) */
|
||||
|
||||
#endif /* defined(TOR_CONGESTION_CONTROL_WESTWOOD_PRIVATE) */
|
||||
|
||||
#endif /* !defined(TOR_CONGESTION_CONTROL_WESTWOOD_H) */
|
@ -36,8 +36,6 @@ LIBTOR_APP_A_SOURCES += \
|
||||
src/core/or/sendme.c \
|
||||
src/core/or/congestion_control_common.c \
|
||||
src/core/or/congestion_control_vegas.c \
|
||||
src/core/or/congestion_control_nola.c \
|
||||
src/core/or/congestion_control_westwood.c \
|
||||
src/core/or/congestion_control_flow.c \
|
||||
src/core/or/conflux.c \
|
||||
src/core/or/conflux_cell.c \
|
||||
@ -112,8 +110,6 @@ noinst_HEADERS += \
|
||||
src/core/or/congestion_control_flow.h \
|
||||
src/core/or/congestion_control_common.h \
|
||||
src/core/or/congestion_control_vegas.h \
|
||||
src/core/or/congestion_control_nola.h \
|
||||
src/core/or/congestion_control_westwood.h \
|
||||
src/core/or/conflux.h \
|
||||
src/core/or/conflux_cell.h \
|
||||
src/core/or/conflux_params.h \
|
||||
|
@ -142,7 +142,7 @@ TRACEPOINT_EVENT(tor_cc, flow_decide_xoff_sending,
|
||||
/* Emitted when the BDP value has been updated. */
|
||||
TRACEPOINT_EVENT(tor_cc, bdp_update,
|
||||
TP_ARGS(const circuit_t *, circ, const congestion_control_t *, cc,
|
||||
uint64_t, curr_rtt_usec, uint64_t, sendme_rate_bdp),
|
||||
uint64_t, curr_rtt_usec),
|
||||
TP_FIELDS(
|
||||
ctf_integer(uint64_t, circuit_ptr, circ)
|
||||
ctf_integer(uint32_t, n_circ_id, circ->n_circ_id)
|
||||
@ -150,11 +150,7 @@ TRACEPOINT_EVENT(tor_cc, bdp_update,
|
||||
ctf_integer(uint64_t, curr_rtt_usec, curr_rtt_usec)
|
||||
ctf_integer(uint64_t, ewma_rtt_usec, cc->ewma_rtt_usec)
|
||||
ctf_integer(uint64_t, max_rtt_usec, cc->max_rtt_usec)
|
||||
ctf_integer(uint64_t, bdp_inflight_rtt, cc->bdp[BDP_ALG_INFLIGHT_RTT])
|
||||
ctf_integer(uint64_t, bdp_cwnd_rtt, cc->bdp[BDP_ALG_CWND_RTT])
|
||||
ctf_integer(uint64_t, bdp_sendme_rate, cc->bdp[BDP_ALG_SENDME_RATE])
|
||||
ctf_integer(uint64_t, bdp_piecewise, cc->bdp[BDP_ALG_PIECEWISE])
|
||||
ctf_integer(uint64_t, sendme_rate_bdp, sendme_rate_bdp)
|
||||
ctf_integer(uint64_t, bdp_cwnd_rtt, cc->bdp)
|
||||
)
|
||||
)
|
||||
|
||||
|
@ -491,7 +491,7 @@ sendme_process_circuit_level(crypt_path_t *layer_hint,
|
||||
return sendme_process_circuit_level_impl(layer_hint, circ);
|
||||
}
|
||||
|
||||
return congestion_control_dispatch_cc_alg(cc, circ, layer_hint);
|
||||
return congestion_control_dispatch_cc_alg(cc, circ);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -128,7 +128,6 @@ circuit_establish_circuit_conflux_mock(const uint8_t *conflux_nonce,
|
||||
simulate_single_hop_extend(circ, 0);
|
||||
simulate_single_hop_extend(circ, 1);
|
||||
circ->cpath->prev->ccontrol = tor_malloc_zero(sizeof(congestion_control_t));
|
||||
circ->cpath->prev->ccontrol->sendme_arrival_timestamps = smartlist_new();
|
||||
circ->cpath->prev->ccontrol->sendme_pending_timestamps = smartlist_new();
|
||||
circ->cpath->prev->ccontrol->sendme_inc = 31;
|
||||
|
||||
@ -499,7 +498,6 @@ simulate_circuit_build(circuit_t *client_circ)
|
||||
relay_side->purpose = CIRCUIT_PURPOSE_OR;
|
||||
relay_side->n_chan = NULL; // No next hop
|
||||
relay_side->ccontrol = tor_malloc_zero(sizeof(congestion_control_t));
|
||||
relay_side->ccontrol->sendme_arrival_timestamps = smartlist_new();
|
||||
relay_side->ccontrol->sendme_pending_timestamps = smartlist_new();
|
||||
relay_side->ccontrol->sendme_inc = 31;
|
||||
smartlist_add(exit_circs, relay_side);
|
||||
|
@ -216,7 +216,7 @@ run_vegas_cwnd_test_vec(congestion_control_t *cc,
|
||||
circ->circuit_blocked_on_p_chan = vec[i].or_conn_blocked_in;
|
||||
cc->inflight = vec[i].inflight_in;
|
||||
|
||||
congestion_control_vegas_process_sendme(cc, circ, NULL);
|
||||
congestion_control_vegas_process_sendme(cc, circ);
|
||||
|
||||
/* If the or conn was blocked, ensure we updated our
|
||||
* CC state */
|
||||
|
Loading…
Reference in New Issue
Block a user