我对TCP CDG拥塞控制算法的改进和优化
来源:互联网 发布:wamp配置php环境变量 编辑:程序博客网 时间:2024/05/01 22:35
其实这不是我的优化,我是借用了BBR之力。
借了什么力呢?这是我一再强调的,BBR最大的共享不是为Linux贡献了一个TCP拥塞控制算法(它同时在也BSD上被实现...),而是它重构了Linux TCP的实现!借助BBR对Linux TCP实现的重构,很多之前做不到的事情,现在可以做到了。
简而言之,BBR算法对Linux TCP实现的重构中,将以下三件事完全分离:
1.重传哪些包;
2.传输多少包;
3.实际传输。
拥塞控制算法侧重解决上述第2点问题。
-----------------------------------
CDG必须要拥塞窗口的背后默默维护一个”自己的窗口“,称为shadow_wnd,该窗口只受”实际拥塞情况“的影响,而不受”Linux TCP拥塞状态机“的影响。所以说,即便在丢包重传的Recovery时期,也必须动态维护这个shadow_wnd,使其按照Reno方式增长(或者按照CUBIC方式,随便什么方式都可以)。
然则这在BBR之前的Linux 4.8版本之前的内核中是无法做到的。因为tcp_congestion_ops机构体中没有一个回调函数是在Recovery阶段可以被调用的到的,而你所能控制的拥塞算法只能通过tcp_congestion_ops结构体的回调来实现。
BBR将以下的逻辑引入到了Linux:
只要实现了cong_control回调,那就就不会再调用标准的PRR算法和拥塞避免tcp_cong_avoid函数,无论在任何阶段,均调用cong_control回调。因此,我的方法是,在Recovery或者Loss状态调用cong_control回调即可!在该回调中维护CDG的shadow窗口。
这谈何容易!BBR引入的逻辑非常粗糙,只要实现了cong_control,该函数就无条件返回。事实上正确的做法是cong_control回调有个返回值,当满足一定条件时返回,否则继续下面的逻辑。但是BBR并没有引入这些。
-----------------------------------
但是,我将其引入了。
请看,我将tcp_input.c中的tcp_cong_control改成了下面的样子:
-----------------------------------
以下的代码只是我对标准Linux 4.3内核CDG算法的differ,想理解代码细节的,请先阅读标准CDG代码,我虽然是个传说中有求必应的人,但那只是传说...请注意,我的目标内核是3.10内核,在我移植CDG之前,我已经移植了BBR,所以说,你最好以4.9内核为准,然而这样一来,又会对3.10内核的一些接口表示费解..这里不就不多解释了,我要说的是,想彻底逃离学院派,就必须把所有这些代码都搞清楚!不然的话,首先,你根本什么都看不懂,其次,即便你有想法,你也做不来。完整的代码我会附在本文最后。
以下是patch中几个重要函数的说明:
1.CDG的cong_control回调函数cdg_main:
2.状态设置回调函数cdg_state:
3.UNDO函数tcp_cdg_undo_cwnd:
4.RTT梯度计算函数tcp_cdg_grad:
我首先盲测了一下原生的CDG,Oh NO!太垃圾,比CUBIC好,高丢包率下竟然与Westwood相当,在所有这一切中,BBR始终是另类,遥不可及,在我看了Paper之后,迅速自己实现了一版,感谢BBR对Linux TCP的重构!我承认我自己只懂Reno,BIC,CUBIC,Vegas,BBR这几种算法,其它HTCP,Westwood这些我并没有详细分析过,但是无论我怎么测,我发现我的CDG(应该是我改过的CDG),一直跟BBR接近。
CDG是什么?CDG实际上就是传统基于丢包的算法加上了一个抗噪声机制,本来基于丢包的算法就是以不断填充缓存为手段,直到填满缓存发生丢包进行减窗,然而有的时候并非拥塞的原因也会发生丢包,此时按照算法来看依然会减窗,这就大大降低了带宽的利用率。加上了这个CDG的RTT梯度抗噪声机制后,网络带宽的利用率大大提高了。然而可能会加重拥塞,所以CDG内置了backoff算法,这里就不赘述了。
-----------------------------------
借了什么力呢?这是我一再强调的,BBR最大的共享不是为Linux贡献了一个TCP拥塞控制算法(它同时在也BSD上被实现...),而是它重构了Linux TCP的实现!借助BBR对Linux TCP实现的重构,很多之前做不到的事情,现在可以做到了。
简而言之,BBR算法对Linux TCP实现的重构中,将以下三件事完全分离:
1.重传哪些包;
2.传输多少包;
3.实际传输。
拥塞控制算法侧重解决上述第2点问题。
-----------------------------------
CDG必须要拥塞窗口的背后默默维护一个”自己的窗口“,称为shadow_wnd,该窗口只受”实际拥塞情况“的影响,而不受”Linux TCP拥塞状态机“的影响。所以说,即便在丢包重传的Recovery时期,也必须动态维护这个shadow_wnd,使其按照Reno方式增长(或者按照CUBIC方式,随便什么方式都可以)。
然则这在BBR之前的Linux 4.8版本之前的内核中是无法做到的。因为tcp_congestion_ops机构体中没有一个回调函数是在Recovery阶段可以被调用的到的,而你所能控制的拥塞算法只能通过tcp_congestion_ops结构体的回调来实现。
BBR将以下的逻辑引入到了Linux:
static void tcp_cong_control(struct sock *sk, u32 ack, u32 acked_sacked, int flag, const struct rate_sample *rs){ const struct inet_connection_sock *icsk = inet_csk(sk); if (icsk->icsk_ca_ops->cong_control) { icsk->icsk_ca_ops->cong_control(sk, rs); return; } if (tcp_in_cwnd_reduction(sk)) { /* Reduce cwnd if state mandates */ tcp_cwnd_reduction(sk, acked_sacked, flag); } else if (tcp_may_raise_cwnd(sk, flag)) { /* Advance cwnd if state allows */ tcp_cong_avoid(sk, ack, acked_sacked); } tcp_update_pacing_rate(sk);}
只要实现了cong_control回调,那就就不会再调用标准的PRR算法和拥塞避免tcp_cong_avoid函数,无论在任何阶段,均调用cong_control回调。因此,我的方法是,在Recovery或者Loss状态调用cong_control回调即可!在该回调中维护CDG的shadow窗口。
这谈何容易!BBR引入的逻辑非常粗糙,只要实现了cong_control,该函数就无条件返回。事实上正确的做法是cong_control回调有个返回值,当满足一定条件时返回,否则继续下面的逻辑。但是BBR并没有引入这些。
-----------------------------------
但是,我将其引入了。
请看,我将tcp_input.c中的tcp_cong_control改成了下面的样子:
static void tcp_cong_control(struct sock *sk, u32 ack, u32 prior_in_flight, u32 acked_sacked, int flag, const struct rate_sample *rs){ const struct inet_connection_sock *icsk = inet_csk(sk);#ifdef BBR if (icsk->icsk_ca_ops->cong_control) { icsk->icsk_ca_ops->cong_control(sk, rs);#ifdef CDG // 以下是我添加的判断,新增了rs的flag字段,一旦置位就继续而不返回。 if (!(rs->flag & CDG_CONT)) return;#endif }#endif if (tcp_in_cwnd_reduction(sk)) { /* Reduce cwnd if state mandates */ tcp_cwnd_reduction(sk, acked_sacked, 1); } else if (tcp_may_raise_cwnd(sk, flag)) { /* Advance cwnd if state allows */ tcp_cong_avoid(sk, ack, prior_in_flight); } tcp_update_pacing_rate(sk);}我添加了个判断。其实我的目的很简单,就是在Recovery状态下也能调用到CDG的逻辑,就这么简单个逻辑在不懂的人眼里显得如此高大上,在懂的人眼里显得如此傻逼...不管怎样,我做了。
-----------------------------------
以下的代码只是我对标准Linux 4.3内核CDG算法的differ,想理解代码细节的,请先阅读标准CDG代码,我虽然是个传说中有求必应的人,但那只是传说...请注意,我的目标内核是3.10内核,在我移植CDG之前,我已经移植了BBR,所以说,你最好以4.9内核为准,然而这样一来,又会对3.10内核的一些接口表示费解..这里不就不多解释了,我要说的是,想彻底逃离学院派,就必须把所有这些代码都搞清楚!不然的话,首先,你根本什么都看不懂,其次,即便你有想法,你也做不来。完整的代码我会附在本文最后。
以下是patch中几个重要函数的说明:
1.CDG的cong_control回调函数cdg_main:
static void cdg_main(struct sock *sk, struct rate_sample *rs){ struct inet_connection_sock *icsk = inet_csk(sk); struct tcp_sock *tp = tcp_sk(sk); struct cdg *ca = inet_csk_ca(sk); if (!shadow_grow) { rs->flag |= CDG_CONT; return; } if (icsk->icsk_ca_state != TCP_CA_Open) { // 在重传阶段,依然要采集rtt,因为链路不问包类型,重传包也会影响网络可用容量。 if (rs->rtt_us) { // 感谢BBR增加了rs结构体,从中可以取rtt_us ca->rtt.min = min_not_zero(ca->rtt.min, (s32)rs->rtt_us); ca->rtt.max = max(ca->rtt.max, (s32)rs->rtt_us); } if (ca->state == CDG_NONFULL && use_tolerance) { if (!shadow_fast && (ca->ack_sack_cnt < 0 || ca->ack_sack_cnt == 0) && ca->rtt.v64) { s32 grad = 0; if (ca->rtt_prev.v64) grad = tcp_cdg_grad(ca); ca->rtt_prev = ca->rtt; ca->ack_sack_cnt = tcp_packets_in_flight(tp); ca->rtt.v64 = 0; } ca->ack_sack_cnt -= rs->acked_sacked; if (ca->state == CDG_NONFULL || shadow_fast) { // 如果链路未完全拥塞,那么shadow窗口便默默地帮助实际窗口占据空间,等到快速恢复结束,便可以由实际窗口可用。 tcp_cong_avoid_ai_shadow(sk, ca->shadow_wnd, rs->acked_sacked); tp->snd_cwnd = ca->shadow_wnd; } rs->flag |= CDG_CONT; } } else { // 为了让执行流继续,增加CDG_CONT标志。 rs->flag |= CDG_CONT; }}
2.状态设置回调函数cdg_state:
static void cdg_state(struct sock *sk, u8 new_state){ struct cdg *ca = inet_csk_ca(sk); struct tcp_sock *tp = tcp_sk(sk); if (!recovery_restore) return; if (new_state == TCP_CA_Open) // 进入Open状态时,直接接管shadow窗口,这里可能会有突发问题。 tp->snd_cwnd = max(max(tp->snd_cwnd, ca->shadow_wnd), 2U); if (new_state == TCP_CA_Loss) { // 进入Loss状态,判断是否是噪声丢包 if (ca->state == CDG_NONFULL && use_tolerance) { // 如果是噪声丢包,那么便恢复窗口。 tp->snd_cwnd = ca->shadow_wnd; printk("#### cwnd:%u \n", tp->snd_cwnd); if (loss_push) // 如果是噪声丢包,那么在窗口内继续发送数据。 tcp_push_pending_frames(sk); } // 如果是拥塞丢包,那么执行原有流程。 }}
3.UNDO函数tcp_cdg_undo_cwnd:
static u32 tcp_cdg_undo_cwnd(struct sock *sk){ struct cdg *ca = inet_csk_ca(sk); struct tcp_sock *tp = tcp_sk(sk); // undo到shadow窗口 return max3(2U, ca->shadow_wnd, max(tp->snd_cwnd, ca->undo_cwnd));}
4.RTT梯度计算函数tcp_cdg_grad:
static s32 tcp_cdg_grad(struct cdg *ca){ // rtt在pkts_acked回调和cong_control中被采样值更新 s32 gmin = ca->rtt.min - ca->rtt_prev.min; s32 gmax = ca->rtt.max - ca->rtt_prev.max; s32 grad; if (ca->gradients) { ca->gsum.min += gmin - ca->gradients[ca->tail].min; ca->gsum.max += gmax - ca->gradients[ca->tail].max; ca->gradients[ca->tail].min = gmin; ca->gradients[ca->tail].max = gmax; ca->tail = (ca->tail + 1) & (window - 1); gmin = ca->gsum.min; gmax = ca->gsum.max; } ...... /* Backoff was effectual: */ if (gmin <= -32 || gmax <= -32) ca->backoff_cnt = 0; if (use_tolerance) { /* Reduce small variations to zero: */ gmin = DIV_ROUND_CLOSEST(gmin, 64); gmax = DIV_ROUND_CLOSEST(gmax, 64); // 注意看上一篇文章CDG模型图示的边沿触发条件。 if (gmin > 0 && gmax <= 0) ca->state = CDG_FULL; else if ((gmin > 0 && gmax > 0) || gmax < 0) ca->state = CDG_NONFULL; } return grad;}
我首先盲测了一下原生的CDG,Oh NO!太垃圾,比CUBIC好,高丢包率下竟然与Westwood相当,在所有这一切中,BBR始终是另类,遥不可及,在我看了Paper之后,迅速自己实现了一版,感谢BBR对Linux TCP的重构!我承认我自己只懂Reno,BIC,CUBIC,Vegas,BBR这几种算法,其它HTCP,Westwood这些我并没有详细分析过,但是无论我怎么测,我发现我的CDG(应该是我改过的CDG),一直跟BBR接近。
CDG是什么?CDG实际上就是传统基于丢包的算法加上了一个抗噪声机制,本来基于丢包的算法就是以不断填充缓存为手段,直到填满缓存发生丢包进行减窗,然而有的时候并非拥塞的原因也会发生丢包,此时按照算法来看依然会减窗,这就大大降低了带宽的利用率。加上了这个CDG的RTT梯度抗噪声机制后,网络带宽的利用率大大提高了。然而可能会加重拥塞,所以CDG内置了backoff算法,这里就不赘述了。
-----------------------------------
tcp_cdg.c代码:
#include <linux/kernel.h>#include <linux/random.h>#include <linux/module.h>#include <net/tcp.h>#define HYSTART_ACK_TRAIN1#define HYSTART_DELAY2static int window __read_mostly = 8;static unsigned int backoff_beta __read_mostly = 0.7071 * 1024; /* sqrt 0.5 */static unsigned int backoff_factor __read_mostly = 42;static unsigned int hystart_detect __read_mostly = 3;static unsigned int use_ineff __read_mostly = 5;static unsigned int use_shadow __read_mostly = 1;static unsigned int backoff __read_mostly = 0;static unsigned int use_tolerance __read_mostly = 1;static unsigned int shadow_fast __read_mostly = 1;static unsigned int shadow_grow __read_mostly = 1;static unsigned int recovery_restore __read_mostly = 1;static unsigned int loss_push __read_mostly = 1;module_param(window, int, 0444);MODULE_PARM_DESC(window, "gradient window size (power of two <= 256)");module_param(backoff_beta, uint, 0644);MODULE_PARM_DESC(backoff_beta, "backoff beta (0-1024)");module_param(backoff_factor, uint, 0644);MODULE_PARM_DESC(backoff_factor, "backoff probability scale factor");module_param(hystart_detect, uint, 0644);MODULE_PARM_DESC(hystart_detect, "use Hybrid Slow start " "(0: disabled, 1: ACK train, 2: delay threshold, 3: both)");module_param(use_ineff, uint, 0644);MODULE_PARM_DESC(use_ineff, "use ineffectual backoff detection (threshold)");module_param(use_shadow, uint, 0644);MODULE_PARM_DESC(use_shadow, "use shadow window heuristic");module_param(backoff, uint, 0644);MODULE_PARM_DESC(backoff, "back");module_param(use_tolerance, uint, 0644);MODULE_PARM_DESC(use_tolerance, "use loss tolerance heuristic");module_param(shadow_fast, uint, 0644);MODULE_PARM_DESC(shadow_fast, "back");module_param(shadow_grow, uint, 0644);MODULE_PARM_DESC(shadow_grow, "back");module_param(recovery_restore, uint, 0644);MODULE_PARM_DESC(recovery_restore, "back");module_param(loss_push, uint, 0644);MODULE_PARM_DESC(loss_push, "back");struct cdg_minmax {union {struct {s32 min;s32 max;};u64 v64;};};enum cdg_state {CDG_UNKNOWN = 0,CDG_NONFULL = 1,CDG_FULL = 2,CDG_BACKOFF = 3,};struct cdg {struct cdg_minmax rtt;struct cdg_minmax rtt_prev;struct cdg_minmax *gradients;struct cdg_minmax gsum;bool gfilled;u8 tail;u8 state;u8 delack;u32 rtt_seq;u32 undo_cwnd;u32 shadow_wnd;u32 snd_cwnd_cnt;u16 backoff_cnt;u16 sample_cnt;s32 delay_min;s32 ack_sack_cnt;u32 last_ack;u32 round_start;};/** * nexp_u32 - negative base-e exponential * @ux: x in units of micro * * Returns exp(ux * -1e-6) * U32_MAX. */static u32 __pure nexp_u32(u32 ux){static const u16 v[] = {/* exp(-x)*65536-1 for x = 0, 0.000256, 0.000512, ... */65535,65518, 65501, 65468, 65401, 65267, 65001, 64470, 63422,61378, 57484, 50423, 38795, 22965, 8047, 987, 14,};u32 msb = ux >> 8;u32 res;int i;/* Cut off when ux >= 2^24 (actual result is <= 222/U32_MAX). */if (msb > U16_MAX)return 0;/* Scale first eight bits linearly: */res = U32_MAX - (ux & 0xff) * (U32_MAX / 1000000);/* Obtain e^(x + y + ...) by computing e^x * e^y * ...: */for (i = 1; msb; i++, msb >>= 1) {u32 y = v[i & -(msb & 1)] + U32_C(1);res = ((u64)res * y) >> 16;}return res;}/* Based on the HyStart algorithm (by Ha et al.) that is implemented in * tcp_cubic. Differences/experimental changes: * o Using Hayes' delayed ACK filter. * o Using a usec clock for the ACK train. * o Reset ACK train when application limited. * o Invoked at any cwnd (i.e. also when cwnd < 16). * o Invoked only when cwnd < ssthresh (i.e. not when cwnd == ssthresh). */static void tcp_cdg_hystart_update(struct sock *sk){struct cdg *ca = inet_csk_ca(sk);struct tcp_sock *tp = tcp_sk(sk);ca->delay_min = min_not_zero(ca->delay_min, ca->rtt.min);if (ca->delay_min == 0)return;if (hystart_detect & HYSTART_ACK_TRAIN) {u32 now_us = div_u64(local_clock(), NSEC_PER_USEC);if (ca->last_ack == 0 || !tcp_is_cwnd_limited(sk, tcp_packets_in_flight(tp))) {ca->last_ack = now_us;ca->round_start = now_us;} else if (before(now_us, ca->last_ack + 3000)) {u32 base_owd = max(ca->delay_min / 2U, 125U);ca->last_ack = now_us;if (after(now_us, ca->round_start + base_owd)) {tp->snd_ssthresh = tp->snd_cwnd;return;}}}if (hystart_detect & HYSTART_DELAY) {if (ca->sample_cnt < 8) {ca->sample_cnt++;} else {s32 thresh = max(ca->delay_min + ca->delay_min / 8U, 125U);if (ca->rtt.min > thresh) {tp->snd_ssthresh = tp->snd_cwnd;}}}}static s32 tcp_cdg_grad(struct cdg *ca){s32 gmin = ca->rtt.min - ca->rtt_prev.min;s32 gmax = ca->rtt.max - ca->rtt_prev.max;s32 grad;if (ca->gradients) {ca->gsum.min += gmin - ca->gradients[ca->tail].min;ca->gsum.max += gmax - ca->gradients[ca->tail].max;ca->gradients[ca->tail].min = gmin;ca->gradients[ca->tail].max = gmax;ca->tail = (ca->tail + 1) & (window - 1);gmin = ca->gsum.min;gmax = ca->gsum.max;}/* We keep sums to ignore gradients during cwnd reductions; * the paper's smoothed gradients otherwise simplify to: * (rtt_latest - rtt_oldest) / window. * * We also drop division by window here. */grad = gmin > 0 ? gmin : gmax;/* Extrapolate missing values in gradient window: */if (!ca->gfilled) {if (!ca->gradients && window > 1)grad *= window; /* Memory allocation failed. */else if (ca->tail == 0)ca->gfilled = true;elsegrad = (grad * window) / (int)ca->tail;}/* Backoff was effectual: */if (gmin <= -32 || gmax <= -32)ca->backoff_cnt = 0;if (use_tolerance) {/* Reduce small variations to zero: */gmin = DIV_ROUND_CLOSEST(gmin, 64);gmax = DIV_ROUND_CLOSEST(gmax, 64);if (gmin > 0 && gmax <= 0)ca->state = CDG_FULL;else if ((gmin > 0 && gmax > 0) || gmax < 0)ca->state = CDG_NONFULL;}return grad;}void tcp_enter_cwr_1(struct sock *sk){struct tcp_sock *tp = tcp_sk(sk);tp->prior_ssthresh = 0;if (inet_csk(sk)->icsk_ca_state < TCP_CA_CWR) {tp->undo_marker = 0;tp->high_seq = tp->snd_nxt;tp->tlp_high_seq = 0;tp->snd_cwnd_cnt = 0;tp->prior_cwnd = tp->snd_cwnd;tp->prr_delivered = 0;tp->prr_out = 0;tp->snd_ssthresh = inet_csk(sk)->icsk_ca_ops->ssthresh(sk);if (tp->ecn_flags & TCP_ECN_OK)tp->ecn_flags |= TCP_ECN_QUEUE_CWR;tcp_set_ca_state(sk, TCP_CA_CWR);}}static bool tcp_cdg_backoff(struct sock *sk, u32 grad){struct cdg *ca = inet_csk_ca(sk);struct tcp_sock *tp = tcp_sk(sk);if (prandom_u32() <= nexp_u32(grad * backoff_factor))return false;if (use_ineff) {ca->backoff_cnt++;if (ca->backoff_cnt > use_ineff)return false;}ca->shadow_wnd = max(ca->shadow_wnd, tp->snd_cwnd);ca->state = CDG_BACKOFF;tcp_enter_cwr_1(sk);return true;}void tcp_cong_avoid_ai_shadow(struct sock *sk, u32 w, u32 acked){struct tcp_sock *tp = tcp_sk(sk);struct cdg *ca = inet_csk_ca(sk);if (ca->snd_cwnd_cnt >= w) {ca->snd_cwnd_cnt = 0;ca->shadow_wnd ++;}ca->snd_cwnd_cnt += acked;if (ca->snd_cwnd_cnt >= w) {u32 delta = ca->snd_cwnd_cnt / w;ca->snd_cwnd_cnt -= delta * w;ca->shadow_wnd += delta;}ca->shadow_wnd = min(ca->shadow_wnd, tp->snd_cwnd_clamp);}/* Not called in CWR or Recovery state. */static void tcp_cdg_cong_avoid(struct sock *sk, u32 ack, u32 acked){struct cdg *ca = inet_csk_ca(sk);struct tcp_sock *tp = tcp_sk(sk);u32 prior_snd_cwnd;u32 incr;if (tp->snd_cwnd <= tp->snd_ssthresh && hystart_detect)tcp_cdg_hystart_update(sk);if (after(ack, ca->rtt_seq) && ca->rtt.v64) {s32 grad = 0;if (ca->rtt_prev.v64)grad = tcp_cdg_grad(ca);ca->rtt_seq = tp->snd_nxt;ca->rtt_prev = ca->rtt;ca->rtt.v64 = 0;ca->last_ack = 0;ca->sample_cnt = 0;if (backoff && grad > 0 && tcp_cdg_backoff(sk, grad))return;}if (!tcp_is_cwnd_limited(sk, tcp_packets_in_flight(tp))) {ca->shadow_wnd = min(ca->shadow_wnd, tp->snd_cwnd);return;}prior_snd_cwnd = tp->snd_cwnd;tcp_reno_cong_avoid(sk, ack, acked);incr = tp->snd_cwnd - prior_snd_cwnd;ca->shadow_wnd = max(ca->shadow_wnd, ca->shadow_wnd + incr);}static void tcp_cdg_acked(struct sock *sk, u32 num_acked, s32 rtt_us){struct cdg *ca = inet_csk_ca(sk);struct tcp_sock *tp = tcp_sk(sk);if (rtt_us <= 0)return;/* A heuristic for filtering delayed ACKs, adapted from: * D.A. Hayes. "Timing enhancements to the FreeBSD kernel to support * delay and rate based TCP mechanisms." TR 100219A. CAIA, 2010. */if (tp->sacked_out == 0) {if (num_acked == 1 && ca->delack) {/* A delayed ACK is only used for the minimum if it is * provenly lower than an existing non-zero minimum. */ca->rtt.min = min(ca->rtt.min, rtt_us);ca->delack--;return;} else if (num_acked > 1 && ca->delack < 5) {ca->delack++;}}ca->rtt.min = min_not_zero(ca->rtt.min, rtt_us);ca->rtt.max = max(ca->rtt.max, rtt_us);}static u32 tcp_cdg_ssthresh(struct sock *sk){struct cdg *ca = inet_csk_ca(sk);struct tcp_sock *tp = tcp_sk(sk);ca->undo_cwnd = tp->snd_cwnd;ca->snd_cwnd_cnt = 0;ca->ack_sack_cnt = tcp_packets_in_flight(tp);if (ca->state == CDG_BACKOFF)return max(2U, (tp->snd_cwnd * min(1024U, backoff_beta)) >> 10);if (ca->state == CDG_NONFULL && use_tolerance)return tp->snd_cwnd;ca->shadow_wnd = max(min(ca->shadow_wnd >> 1, tp->snd_cwnd), 2U);if (use_shadow)return max3(2U, ca->shadow_wnd, tp->snd_cwnd >> 1);return max(2U, tp->snd_cwnd >> 1);}static u32 tcp_cdg_undo_cwnd(struct sock *sk){struct cdg *ca = inet_csk_ca(sk);struct tcp_sock *tp = tcp_sk(sk);return max3(2U, ca->shadow_wnd, max(tp->snd_cwnd, ca->undo_cwnd));}static void tcp_cdg_cwnd_event(struct sock *sk, const enum tcp_ca_event ev){struct cdg *ca = inet_csk_ca(sk);struct tcp_sock *tp = tcp_sk(sk);struct cdg_minmax *gradients;switch (ev) {case CA_EVENT_CWND_RESTART:gradients = ca->gradients;if (gradients)memset(gradients, 0, window * sizeof(gradients[0]));memset(ca, 0, sizeof(*ca));ca->gradients = gradients;ca->rtt_seq = tp->snd_nxt;ca->shadow_wnd = tp->snd_cwnd;break;case CA_EVENT_COMPLETE_CWR:ca->state = CDG_UNKNOWN;ca->rtt_seq = tp->snd_nxt;ca->rtt_prev = ca->rtt;ca->rtt.v64 = 0;break;default:break;}}static void tcp_cdg_init(struct sock *sk){struct cdg *ca = inet_csk_ca(sk);struct tcp_sock *tp = tcp_sk(sk);/* We silently fall back to window = 1 if allocation fails. */if (window > 1)ca->gradients = kcalloc(window, sizeof(ca->gradients[0]),GFP_NOWAIT | __GFP_NOWARN);ca->rtt_seq = tp->snd_nxt;ca->shadow_wnd = tp->snd_cwnd;ca->ack_sack_cnt = 0;}static void tcp_cdg_release(struct sock *sk){struct cdg *ca = inet_csk_ca(sk);kfree(ca->gradients);}static void cdg_main(struct sock *sk, struct rate_sample *rs){struct inet_connection_sock *icsk = inet_csk(sk);struct tcp_sock *tp = tcp_sk(sk);struct cdg *ca = inet_csk_ca(sk);if (!shadow_grow) {rs->flag |= CDG_CONT;return;}if (icsk->icsk_ca_state != TCP_CA_Open) {if (rs->rtt_us) {ca->rtt.min = min_not_zero(ca->rtt.min, (s32)rs->rtt_us);ca->rtt.max = max(ca->rtt.max, (s32)rs->rtt_us);}if (ca->state == CDG_NONFULL && use_tolerance) {if (!shadow_fast && (ca->ack_sack_cnt < 0 || ca->ack_sack_cnt == 0) && ca->rtt.v64) {s32 grad = 0;if (ca->rtt_prev.v64)grad = tcp_cdg_grad(ca);ca->rtt_prev = ca->rtt;ca->ack_sack_cnt = tcp_packets_in_flight(tp);ca->rtt.v64 = 0;}ca->ack_sack_cnt -= rs->acked_sacked;if (ca->state == CDG_NONFULL || shadow_fast) {tcp_cong_avoid_ai_shadow(sk, ca->shadow_wnd, rs->acked_sacked);tp->snd_cwnd = ca->shadow_wnd;}rs->flag |= CDG_CONT;}} else {rs->flag |= CDG_CONT;}}static void cdg_state(struct sock *sk, u8 new_state){struct cdg *ca = inet_csk_ca(sk);struct tcp_sock *tp = tcp_sk(sk);if (!recovery_restore)return;if (new_state == TCP_CA_Open)tp->snd_cwnd = max(max(tp->snd_cwnd, ca->shadow_wnd), 2U);if (new_state == TCP_CA_Loss) {if (ca->state == CDG_NONFULL && use_tolerance) {tp->snd_cwnd = ca->shadow_wnd;if (loss_push)tcp_push_pending_frames(sk);} }}struct tcp_congestion_ops tcp_cdg __read_mostly = {.cong_avoid = tcp_cdg_cong_avoid,.cong_control= cdg_main,.set_state = cdg_state,.cwnd_event = tcp_cdg_cwnd_event,.pkts_acked = tcp_cdg_acked,.undo_cwnd = tcp_cdg_undo_cwnd,.ssthresh = tcp_cdg_ssthresh,.release = tcp_cdg_release,.init = tcp_cdg_init,.owner = THIS_MODULE,.name = "cdg",};static int __init tcp_cdg_register(void){if (backoff_beta > 1024 || window < 1 || window > 256)return -ERANGE;if (!is_power_of_2(window))return -EINVAL;BUILD_BUG_ON(sizeof(struct cdg) > ICSK_CA_PRIV_SIZE);tcp_register_congestion_control(&tcp_cdg);return 0;}static void __exit tcp_cdg_unregister(void){tcp_unregister_congestion_control(&tcp_cdg);}module_init(tcp_cdg_register);module_exit(tcp_cdg_unregister);MODULE_AUTHOR("...");MODULE_LICENSE("GPL");MODULE_DESCRIPTION("TCP CDG");
1 0
- 我对TCP CDG拥塞控制算法的改进和优化
- 基于RTT梯度的TCP CDG拥塞控制算法
- 网络拥塞控制(四) TCP拥塞控制的其他算法
- TCP拥塞控制算法
- TCP拥塞控制算法
- TCP拥塞控制算法
- tcp拥塞控制算法
- TCP的流量控制和拥塞控制
- TCP的流量控制和拥塞控制
- TCP的流量控制和拥塞控制
- TCP的流量控制和拥塞控制
- TCP的流量控制和拥塞控制
- TCP的流量控制和拥塞控制
- TCP的流量控制和拥塞控制
- TCP的流量控制和拥塞控制
- TCP的流量控制和拥塞控制
- TCP的流量控制和拥塞控制
- TCP的流量控制和拥塞控制
- 我的第一个博客
- 多线程——java实现多线程的方式
- (写给新手)javase各种代码块的概念和用处
- Android样式的开发:Property Animation篇
- 第十五周oj训练—— 将字符串格式化后输出(串)(2284)
- 我对TCP CDG拥塞控制算法的改进和优化
- boost:asio网络库初学之echo服务器客户端实现
- 手动跟踪程序和重绘箭头
- Hadoop权威指南+MR+Hive+HBase+Flume+ES+Lucene电子书下载
- Intellij IDEA同时打开多个项目
- JAVA连接SQL Server数据库
- C++输入(2):文件读取
- several methods for uploading files to server
- Codeforces Round #225 (Div. 1)-C. Propagating tree(线段树)