我对TCP CDG拥塞控制算法的改进和优化

其实这不是我的优化,我是借用了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:

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_TRAIN	1
#define HYSTART_DELAY		2

static 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;
		else
			grad = (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");
时间: 2024-10-19 06:25:47

我对TCP CDG拥塞控制算法的改进和优化的相关文章

基于RTT梯度的TCP CDG拥塞控制算法

在BBR之前,业内已经逐渐学会如何判断网络拥塞并且用于TCP拥塞控制了.        再次重申,我鄙视并且非常恶心TCP!        我本来想看看CDG算法究竟是个什么东西,无奈并没有发现什么资料,所以,就像BBR一样,只能由我来写,我不希望到时候再搜索CDG的资源,都是我写的了,请注意,CDG不是腾讯的CDG,而是CAIA Delay-Gradient.虽然CDG在BBR之前,但是我认为,在褪去了BBR的光环之后,CDG显得更加适合中国人.毕竟BBR的要求太TMD多了,只是很多人不晓得而

网络拥塞控制(三) TCP拥塞控制算法

为了防止网络的拥塞现象,TCP提出了一系列的拥塞控制机制.最初由V. Jacobson在1988年的论文中提出的TCP的拥塞控制由“慢启动(Slow start)”和“拥塞避免(Congestion avoidance)”组成,后来TCP Reno版本中又针对性的加入了“快速重传(Fast retransmit)”.“快速恢复(Fast Recovery)”算法,再后来在TCP NewReno中又对“快速恢复”算法进行了改进,近些年又出现了选择性应答( selective acknowledge

TCP拥塞控制算法-从BIC到CUBIC

本文旨在帮助大家理解TCP CUBIC拥塞控制算法背后的点点滴滴以及其方程式为什么就是那样子的.一直以来,很多人都觉得CUBIC算法非常复杂,涉及到复杂的天书般的"3次曲线"...然而,CUBIC并不像大家以为的那样复杂,之所以觉得复杂是因为没有理解其历史和背景. 本文就是介绍CUBIC的历史和背景的... BIC算法 BIC算法对窗口可能的最大值进行二分查找,它基于以下的事实:1.如果发生丢包的时候,窗口的大小是W1,那么要保持线路满载却不丢包,实际的窗口最大值应该在W1以下:2.如

TCP拥塞控制算法纵横谈-Illinois和YeAH

周五晚上.终于下了雨.所以也终于能够乱七八糟多写点松散的东西了... 方法论问题. 这个题目太大以至于内容和题目的关联看起来有失偏颇.只是也无所谓,既然被人以为"没有方法论"而歧视了.这里也就抛出一些伪方法论,总之,就是一些大而空的东西.我并非说方法论没实用,而是说方法论太实用了,以至于绝不能误解它.难道方法论不是从已经成功的经验中总结出来的吗?假设还没有成功的案例,那么方法论从何而生呢?So,我仅仅能从现成的东西入手了...分类学是一个贯通古今的学科.也蕴含在实在太多的方法论中,从中

Google&#39;s BBR拥塞控制算法模型解析

在进入这篇文章的正文之前,我还是先交代一下背景.1.首先,我对这次海马台风对深圳的影响非常准确,看过我朋友圈的都知道,没看过的也没必要知道,白赚了一天"在家办公"是收益,但在家办公着实效率不高,效果不好.2.我为什么可以在周五的早上连发3篇博客,一方面为了弥补因为台风造成"在家办公"导致的时间蹉跎,另一方面,我觉的以最快的速度分享最新的东西,是一种精神,符合虔诚基督徒的信仰而不是道德约束.3.上半年的时候,温州皮鞋厂老板推荐了一个会议,大致是说"迄今为止的

TCP拥塞控制算法 优缺点 适用环境 性能分析

[摘要]对多种TCP拥塞控制算法进行简要说明,指出它们的优缺点.以及它们的适用环境. [关键字]TCP拥塞控制算法 优点    缺点   适用环境公平性 公平性 公平性是在发生拥塞时各源端(或同一源端建立的不同TCP连接或UDP数据报)能公平地共享同一网络资源(如带宽.缓存等).处于相同级别的源端应该得到相同数量的网络资源.产生公平性的根本原因在于拥塞发生必然导致数据包丢失,而数据包丢失会导致各数据流之间为争抢有限的网络资源发生竞争,争抢能力弱的数据流将受到更多损害.因此,没有拥塞,也就没有公平

使用TCP时序图解释BBR拥塞控制算法的几个细节

周六,由于要赶一个月底的Deadline,因此选择了在家VPN加班,大半夜就爬起来跑用例,抓数据...自然也就没有时间写文章和外出耍了...不过利用周日的午夜时间(不要问我为什么可以连续24小时不睡觉,因为我觉得吃饭睡觉是负担),我决定把工作上的事情先放下,还是要把每周至少一文补上,这已经成了习惯.由于上周实在太忙乱,所以自然根本没有更多的时间去思考一些"与工作无关且深入"的东西,我指的与工作无关并非意味着与IT,与互联网无关,只是意味着不是目前我在做的.比如在两年前,VPN,PKI这

TCP拥塞控制算法纵横谈-BBR vs Reno/CUBIC

不管是在工作中,还是平时与技术上的朋友一起讨论关于BBR的问题,都不可避免的会面对"BBR和CUBIC之间的对比"的问题,毕竟CUBIC在Linux平台是默认的拥塞算法,已经好多年了.        现在突然有了个被宣传的神乎其神的BBR算法,如果真的有那么好,那肯定要比CUBIC好,如果真的这样,到底好在哪里呢?如果不是这样,那么问题又是什么呢?我想关于BBR好在哪里这个问题是不必回答的,因为如果在效率和公平性上秒杀了CUBIC,那基本上的结果就是换掉BBR,除了理论工作者没有人会问

让人很容易误解的TCP拥塞控制算法

正文 很多人会认为一个好的TCP拥塞控制算法会让连接加速,这种观点是错误的,恰恰相反,所有的拥塞控制算法都是为了TCP可以在贪婪的时候悬崖勒马,大多数时候,拥塞控制是降低了数据发送的速度. 我在本文中会针对近期跟业内朋友之间的聊天记录,总结出三言两语.        TCP拥塞控制的终极目标绝对不是加快数据发送的速度,这种理解非常自私且肤浅!它的终结目标是在公平占有带宽的前提下无限度提高带宽的利用率!        如果你只关注一个独立的TCP连接本身,那么你也许永远都不可能设计出什么比较好的算