Differential D8253 Diff 21399 sys/netinet/cc/cc_cubic.c

Changeset View

Standalone View

sys/netinet/cc/cc_cubic.c

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines	struct cubic {
/* Minimum observed rtt in ticks. */		/* Minimum observed rtt in ticks. */
int min_rtt_ticks;		int min_rtt_ticks;
/* Mean observed rtt between congestion epochs. */		/* Mean observed rtt between congestion epochs. */
int mean_rtt_ticks;		int mean_rtt_ticks;
/* ACKs since last congestion event. */		/* ACKs since last congestion event. */
int epoch_ack_count;		int epoch_ack_count;
/* Time of last congestion event in ticks. */		/* Time of last congestion event in ticks. */
int t_last_cong;		int t_last_cong;
		/* Time of last congestion event in ticks for previous event. */
		int t_last_cong_prev;
};		};

static MALLOC_DEFINE(M_CUBIC, "cubic data",		static MALLOC_DEFINE(M_CUBIC, "cubic data",
"Per connection data required for the CUBIC congestion control algorithm");		"Per connection data required for the CUBIC congestion control algorithm");

		SYSCTL_NODE(_net_inet_tcp_cc, OID_AUTO, cubic, CTLFLAG_RW, NULL,
		"cubic congestion control related settings");

		static int fast_convergence = 1;
		SYSCTL_INT(_net_inet_tcp_cc_cubic, OID_AUTO, fast_convergence, CTLFLAG_RWTUN,
		&fast_convergence, 0, "Enable fast convergence");

struct cc_algo cubic_cc_algo = {		struct cc_algo cubic_cc_algo = {
.name = "cubic",		.name = "cubic",
.ack_received = cubic_ack_received,		.ack_received = cubic_ack_received,
.cb_destroy = cubic_cb_destroy,		.cb_destroy = cubic_cb_destroy,
.cb_init = cubic_cb_init,		.cb_init = cubic_cb_init,
.cong_signal = cubic_cong_signal,		.cong_signal = cubic_cong_signal,
.conn_init = cubic_conn_init,		.conn_init = cubic_conn_init,
.mod_init = cubic_mod_init,		.mod_init = cubic_mod_init,
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines	cubic_cong_signal(struct cc_var *ccv, uint32_t type)
mss = CCV(ccv, t_maxseg);		mss = CCV(ccv, t_maxseg);

switch (type) {		switch (type) {
case CC_NDUPACK:		case CC_NDUPACK:
if (!IN_FASTRECOVERY(CCV(ccv, t_flags))) {		if (!IN_FASTRECOVERY(CCV(ccv, t_flags))) {
if (!IN_CONGRECOVERY(CCV(ccv, t_flags))) {		if (!IN_CONGRECOVERY(CCV(ccv, t_flags))) {
cubic_ssthresh_update(ccv);		cubic_ssthresh_update(ccv);
cubic_data->num_cong_events++;		cubic_data->num_cong_events++;
cubic_data->prev_max_cwnd = cubic_data->max_cwnd;
cubic_data->max_cwnd = win;		cubic_data->max_cwnd = win;
CCV(ccv, snd_cwnd) = CCV(ccv, snd_ssthresh);		CCV(ccv, snd_cwnd) = CCV(ccv, snd_ssthresh);
}		}
ENTER_RECOVERY(CCV(ccv, t_flags));		ENTER_RECOVERY(CCV(ccv, t_flags));
}		}
break;		break;

case CC_ECN:		case CC_ECN:
if (!IN_CONGRECOVERY(CCV(ccv, t_flags))) {		if (!IN_CONGRECOVERY(CCV(ccv, t_flags))) {
cubic_ssthresh_update(ccv);		cubic_ssthresh_update(ccv);
cubic_data->num_cong_events++;		cubic_data->num_cong_events++;
cubic_data->prev_max_cwnd = cubic_data->max_cwnd;
cubic_data->max_cwnd = win;		cubic_data->max_cwnd = win;
cubic_data->t_last_cong = ticks;		cubic_data->t_last_cong = ticks;
		/*
		* cubic_ssthresh_update(ccv) sets ssthresh to cwnd
		* scaled by beta so this assignment is equivalent
		*/
CCV(ccv, snd_cwnd) = CCV(ccv, snd_ssthresh);		CCV(ccv, snd_cwnd) = CCV(ccv, snd_ssthresh);
ENTER_CONGRECOVERY(CCV(ccv, t_flags));		ENTER_CONGRECOVERY(CCV(ccv, t_flags));
}		}
break;		break;

case CC_RTO:		case CC_RTO:
/*		/*
* Grab the current time and record it so we know when the		* Grab the current time and record it so we know when the
* most recent congestion event was. Only record it when the		* most recent congestion event was. Only record it when the
* timeout has fired more than once, as there is a reasonable		* timeout has fired more than once, as there is a reasonable
* chance the first one is a false alarm and may not indicate		* chance the first one is a false alarm and may not indicate
* congestion.		* congestion.
*/		*/
if (CCV(ccv, t_rxtshift) >= 2) {		if (CCV(ccv, t_rxtshift) == 1)
cubic_data->num_cong_events++;		cubic_data->t_last_cong_prev = cubic_data->t_last_cong;
cubic_data->t_last_cong = ticks;
cubic_ssthresh_update(ccv);		cubic_ssthresh_update(ccv);
		cubic_data->num_cong_events++;
cubic_data->max_cwnd = win;		cubic_data->max_cwnd = win;
		cubic_data->t_last_cong = ticks;
CCV(ccv, snd_cwnd) = mss;		CCV(ccv, snd_cwnd) = mss;
}
break;		break;
		case CC_RTO_ERR:
		cubic_data->num_cong_events--;
		cubic_data->t_last_cong = cubic_data->t_last_cong_prev;
		cubic_data->max_cwnd = max(cubic_data->max_cwnd,
		cubic_data->prev_max_cwnd);
		break;
}		}
}		}

static void		static void
cubic_conn_init(struct cc_var *ccv)		cubic_conn_init(struct cc_var *ccv)
{		{
struct cubic *cubic_data;		struct cubic *cubic_data;

▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Lines

/*		/*
* Update the ssthresh in the event of congestion.		* Update the ssthresh in the event of congestion.
*/		*/
static void		static void
cubic_ssthresh_update(struct cc_var *ccv)		cubic_ssthresh_update(struct cc_var *ccv)
{		{
struct cubic *cubic_data;		struct cubic *cubic_data;
		u_long snd_ssthresh, snd_cwnd;

cubic_data = ccv->cc_data;		cubic_data = ccv->cc_data;

/*		/*
* On the first congestion event, set ssthresh to cwnd * 0.5, on		* 3.5. Multiplicative decrease
* subsequent congestion events, set it to cwnd * beta.		*
		* When a packet loss occurs, CUBIC reduces its window size by a factor
		* of beta. Parameter beta_cubic SHOULD be set to 0.7.
		*
		* W_max = cwnd; // save window size before reduction
		* cwnd = cwnd * beta_cubic; // window reduction
*/		*/
if (cubic_data->num_cong_events == 0)		snd_ssthresh = (CCV(ccv, snd_cwnd) * CUBIC_BETA) >> CUBIC_SHIFT;
		rscheffUnsubmitted Not Done Inline Actions need a typecast to (uint64_t) here for very large cwnd rscheff: need a typecast to (uint64_t) here for very large cwnd
CCV(ccv, snd_ssthresh) = CCV(ccv, snd_cwnd) >> 1;		CCV(ccv, snd_ssthresh) = max(snd_ssthresh, 2*CCV(ccv, t_maxseg));

		/*
		* 3.6. Fast convergence
		*
		* To improve the convergence speed of CUBIC, we add a heuristic in the
		* protocol. When a new flow joins the network, existing flows in the
		* network need to give up their bandwidth shares to allow the flow some
		* room for growth if the existing flows have been using all the
		* bandwidth of the network. To increase this release of bandwidth by
		* existing flows, the following mechanism called fast convergence
		* SHOULD be implemented.
		*
		* With fast convergence, when a loss event occurs, before a window
		* reduction of congestion window, a flow remembers the last value of
		* W_max before it updates W_max for the current loss event. Let us
		* call the last value of W_max to be W_last_max.
		*
		* if (W_max < W_last_max){ // check downward trend
		* W_last_max = W_max; // remember the last W_max
		* W_max = W_max*(1+beta_cubic)/2; // further reduce W_max
		* } else { // check upward trend
		* W_last_max = W_max // remember the last W_max
		* }
		*/
		snd_cwnd = CCV(ccv, snd_cwnd);

		if (snd_cwnd < cubic_data->prev_max_cwnd && fast_convergence)
		cubic_data->prev_max_cwnd = (snd_cwnd *
		(CUBIC_SCALE + CUBIC_BETA)) / (2 * CUBIC_SCALE);
		rscheffUnsubmitted Not Done Inline Actions Why introduce CUBIC_SCALE for a single use here, instead of (1<<CUBIC_SCALE)? Also, this code doesn't seem to match the comment? rscheff: Why introduce CUBIC_SCALE for a single use here, instead of (1<<CUBIC_SCALE)? Also, this code…
else		else
CCV(ccv, snd_ssthresh) = ((u_long)CCV(ccv, snd_cwnd) *		cubic_data->prev_max_cwnd = snd_cwnd;
CUBIC_BETA) >> CUBIC_SHIFT;
}		}


DECLARE_CC_MODULE(cubic, &cubic_cc_algo);		DECLARE_CC_MODULE(cubic, &cubic_cc_algo);