TCP拥塞控制及BBR原理分析

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了TCP拥塞控制及BBR原理分析相关的知识,希望对你有一定的参考价值。

参考技术A

导语:TCP拥塞控制不仅仅是网络层的概念,可以将其归属于控制论的范畴。在TCP的演进过程中,出现了很多优秀的思想和算法,以实现网络传输过程中,在公平竞争性的前提下,尽可能地利用带宽资源。本文介绍TCP发展过程中出现的几种拥塞控制算法,并着重介绍BBR的原理。

TCP拥塞控制不仅仅是网络层的概念,可以将其归属于控制论的范畴。在TCP的演进过程中,出现了很多优秀的思想和算法,以实现网络传输过程中,在公平竞争性的前提下,尽可能地利用带宽资源。

公平性是在发生拥塞时各源端(或同一源端建立的不同TCP连接或UDP数据报)能公平地共享同一网络资源(如带宽、缓存等)。处于相同级别的源端应该得到相同数量的网络资源。产生公平性的根本原因在于拥塞发生必然导致数据包丢失,而数据包丢失会导致各数据流之间为争抢有限的网络资源发生竞争,争抢能力弱的数据流将受到更多损害。因此,没有拥塞,也就没有公平性问题。

TCP层上的公平性问题表现在两方面:

(1)面向连接的TCP和无连接的UDP在拥塞发生时对拥塞指示的不同反应和处理,导致对网络资源的不公平使用问题。在拥塞发生时,有拥塞控制机制的TCP会按拥塞控制步骤进入拥塞避免阶段,从而主动减小发送到网络的数据量。但对无连接的数据报UDP,由于没有端到端的拥塞控制机制,即使网络出现了拥塞,也不会减少向网络发送的数据量。结果遵守拥塞控制的TCP数据流得到的网络资源越来越少,没有拥塞控制的UDP则会得到越来越多的网络资源。

(2)TCP连接之间也存在公平性问题。产生问题的原因在于使用了不同的拥塞控制算法,一些TCP在拥塞前使用了大窗口尺寸,或者它们的RTT较小,或者数据包比其他TCP大,这样它们也会多占带宽。

拥塞控制主要包括四个过程:1)慢启动;2)拥塞避免;3)拥塞发生;4)快速恢复。

RTT :数据包从发出去到收到对它的ack的来回时间,采用平滑方式计算RTT

RTO :重传超时。简单的如RTO=n*RTT, n=3(或其他RTO计算方法)

SACK :TCP Option携带多组ACK信息

FR :Fast Retransmission,收到3个dup ack后,即可认为发生了丢包。不需要等待RTO超时即可重传丢失的包。

ER :Early Retransmission,无法产生足够的dupack和没有新的数据包可以发送进入网络的情况下,减少触发FR的dup ack数量,以达到触发FR的目的。

TLP :如果发生了尾丢包,由于尾包后面没有更多的数据包,也就没有办法触发任何的dupack。实际上,Google统计超过70%的RTO是尾丢包导致没有任何dup

ack 。TLP算法是通过发送一个loss probe包,来产生足够的SACK/FACK的信息以触发RF。

Pacing :控制发送速率,防止bursting

流控 :Flow control站在单条TCP连接的维度,目的是让发送方发包的速度,不超过接收方收包的能力。所以流控解决的问题是,如何在接收方可承受的范围内,让单条 TCP 连接的速度最大化。通过滑动窗口机制实现。

拥塞控制 :Congestion control站在整个互联网的维度,让网络里所有TCP连接最大化共享网络通道的同时,尽可能的少出现网络拥塞现象,让网络世界里的每一个参与者既公平又高效。

cwnd :发送窗口,拥塞窗口;在拥塞控制过程中窗口大小值变化。

rwnd :接收窗口,通知发送者能够发送的数据大小。

sliding window :滑动窗口,只是一种抽象机制概念;在发送请求及收到ack的过程中滑动。

历史上出现的各种TCP拥塞控制算法,其本质是针对拥塞控制的四个过程做策略调整。按照算法依据的因素,可以简单的分为以下类型:

因为Reno等算法是后续算法的基础,这里详细的描述下Reno算法的过程。

(1)慢热启动算法 – Slow Start

(2)拥塞避免算法 – Congestion Avoidance
当cwnd >= ssthresh时,就会进入“拥塞避免算法”。算法如下:

(3)拥塞状态算法 – Fast Retransmit
Tahoe是等RTO超时,FR是在收到3个duplicate ACK时就开启重传,而不用等到RTO超时。拥塞发生时:

(4)快速恢复 – Fast Recovery

Reno算法以其简单、有效和鲁棒性,应用最广泛。该算法所包含的慢启动、拥塞避免和快速重传、快速恢复机制,是现有的众多算法的基础。从Reno运行机制中很容易看出,为了维持一个动态平衡,必须周期性地产生一定量的丢失,再加上AIMD机制--减少快,增长慢,尤其是在大窗口环境下,由于一个数据报的丢失所带来的窗口缩小要花费很长的时间来恢复,这样,带宽利用率不可能很高且随着网络的链路带宽不断提升,这种弊端将越来越明显。另外,丢包并不一定是网络拥塞,可能是网络常态,但是基于丢包的拥塞控制并不能区分。

vegas通过对RTT的非常重的监控来计算一个基准RTT。然后通过这个基准RTT来估计当前的网络实际带宽,如果实际带宽比我们的期望的带宽要小或是要多的活,那么就开始线性地减少或增加cwnd的大小。

中间路由器缓存数据导致RTT变大,认为发生拥塞;RTT不公平性,当不同的数据流对网络瓶颈带宽进行竞争时,具有较小RTT的TCP数据流的拥塞窗口增加速率将会快于具有大RTT的TCP数据流,从而将会占有更多的网络带宽资源。

在发送端做带宽估计,当探测到丢包时,根据带宽值来设置拥塞窗口、慢启动阈值。 那么,这个算法是怎么测量带宽的?每个RTT时间,会测量一次带宽,测量带宽的公式很简单,就是这段RTT内成功被ACK了多少字节。Westwood会根据RTT变化来判断丢包是否是网络拥塞造成的,还是网络常态的丢包。如果时延变化不明显,就认为是非网络拥塞,此时cwnd减少的比较小。

BIC-TCP是Linux 2.6.18默认拥塞控制算法,依赖丢包条件触发。BIC-TCP认为TCP拥塞窗口调整的本质就是找到最适合当前网络的一个发送窗口,为了找到这个窗口值,TCP采取的方式是(拥塞避免阶段)每RTT加1,缓慢上升,丢包时下降一半,接着再来慢慢上升。BIC-TCP的提出者们看穿了事情的本质,其实这就是一个搜索的过程,而TCP的搜索方式类似于逐个遍历搜索方法,可以认为这个值是在1和一个比较大的数(large_window)之间,既然在这个区间内需要搜索一个最佳值,那么显然最好的方式就是二分搜索思想。

BIC-TCP就是基于这样一个二分思想的:当出现丢包的时候,说明最佳窗口值应该比这个值小,那么BIC就把此时的cwnd设置为max_win,把乘法减小后的值设置为min_win,然后BIC就开始在这两者之间执行二分思想--每次跳到max_win和min_win的中点。

BIC也具备RTT的不公平性。RTT小的连接,窗口调整发生的速度越快,因此可能更快的抢占带宽。

CUBIC在设计上简化了BIC-TCP的窗口调整算法,在BIC-TCP的窗口调整中会出现一个凹和凸(这里的凹和凸指的是数学意义上的凹和凸,凹函数/凸函数)的增长曲线,CUBIC使用了一个三次函数(即一个立方函数),在三次函数曲线中同样存在一个凹和凸的部分,该曲线形状和BIC-TCP的曲线图十分相似,于是该部分取代BIC-TCP的增长曲线。另外,CUBIC中最关键的点在于它的窗口增长函数仅仅取决于连续的两次拥塞事件的时间间隔值,从而窗口增长完全独立于网络的时延RTT,使得连接之间保持良好的RRTT公平性。

来看下具体细节:当某次拥塞事件发生时,Wmax设置为此时发生拥塞时的窗口值,然后把窗口进行乘法减小,乘法减小因子设为β,当从快速恢复阶段退出然后进入到拥塞避免阶段,此时CUBIC的窗口增长开始按照“凹”式增长曲线进行增长,该过程一直持续直到窗口再次增长到Wmax,紧接着,该函数转入“凸”式增长阶段。该方式的增长可以使得窗口一直维持在Wmax附近,从而可以达到网络带宽的高利用率和协议本身的稳定性。

CUBIC窗口的增长函数:W(t) = C * (t-K)3 + Wmax, 其中C和β为常量。

t为当前时间距上一次窗口减小的时间差,而K就代表该函数从W增长到Wmax的时间周期。

通俗一点讲,假如我们知道了Wmax,那么CUBIC的核心思想就是需要在连续两次拥塞期间执行完上面的三次函数增长曲线

BBR通过实时计算带宽和最小RTT来决定发送速率pacing rate和窗口大小cwnd。完全摒弃丢包作为拥塞控制的直接反馈因素。

传统的拥塞控制算法是计算cwnd值来规定当前可以发送多少数据,但是并不关注以什么样的速度发送数据。如果简单而粗暴地将窗口大小(send.cwnd、recv.cwnd的最小值)数据全部突发出去,这往往会造成路由器的排队,在深队列的情况下,会测量出rtt剧烈地抖动。bbr在计算cwnd的同时,还计算了一个与之适配的pacing rate,该pacing rate规定cwnd指示的一窗数据的数据包之间,以多大的时间间隔发送出去。

我们知道,网络工作的最优点是在物理链路延迟状态下,以最大速率传输数据。传统的拥塞控制算法思想是根据数据传输及ACK来确定RTT,但是这个RTT并不是物理链路延时,可能包含了路由器缓存耗时,也可能是拥塞状态下的耗时。传统的带宽计算也是在不断的试探逼近最优发送窗口,并在RTT或者统计周期内计算带宽。这种情况下,RTT并不是真正的物理链路延迟,带宽也有可能是在有路由缓存或丢包状况下计算得到,那么必然得到的不是精准的值。

BBR摒弃了丢包和实时RTT作为拥塞控制因素。引入BDP管道容量来衡量链路传输水平。BBR追求的是在链路最小RTT(物理链路延迟)的状态下,找到最大带宽。

首先我们认为网络最优点是可以达到的。下面描述RTT及收包速率与数据包投递速率的关系。

图中上半部分的过程可以描述为:随着数据包投递速率增加,如果没有超过最优带宽,则RTT不会变化,此时的RTT是物理链路延迟。随着投递速率继续增加,这时中间路由节点可能出现需要缓存数据包的情况,这会导致RTT变大。如果投递速率继续增加,超过路由缓存能力,则可能出现丢包。

图中下半部分的过程可以描述为:随着数据包投递速率增加,如果没有超过最优带宽,则发送方确认接收端收到的数据速率增加。随着投递速率继续增加,因为数据包缓存在中间路由,这些包并不能及时得到ACK,因此发送方得到的ACK速率,即发送发确认接收方收到数据的速率会维持不变。如果投递速率继续增加,超过路由缓存能力,则可能出现丢包。

1)应答了多少数据,记为delivered;
2)应答1)中的delivered这么多数据所用的时间,记为interval_us。
将上述二者相除,就能得到带宽:bw = delivered/interval_us;该计算方法不关注数据包ack及顺序,是纯粹的标量。

我们可以根据图示很容易算出从Delivered为7时的数据包被确认到X被确认为止,一共有12-7=5个数据包被确认,即这段时间网络上清空了5个数据包。我们便很容易算出带宽值了。

当10s内没有发现最小RTTProp时,就要进入ProbeRTT状态。在ProbeRTT状态,仅发4MSS/RTT(接近停止发送),从而排空链路上的数据包,测量真实的RTTProp。这里带来的一个问题是,在一个RTT时间内以4MSS速率发送可能会造成抖动,特别是长RTT场景。具体的参考willko文章《GBN手札-BBR实时大数据传输之痛》。

我对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: [plain] view plain copy 在CODE上查看代码片派生到我的代码片 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改成了下面的样子: [plain] view plain copy 在CODE上查看代码片派生到我的代码片 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: [plain] view plain copy 在CODE上查看代码片派生到我的代码片 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: [plain] view plain copy 在CODE上查看代码片派生到我的代码片 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: [plain] view plain copy 在CODE上查看代码片派生到我的代码片 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: [plain] view plain copy 在CODE上查看代码片派生到我的代码片 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代码:

[plain] view plain copy 在CODE上查看代码片派生到我的代码片 #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;    www.sratchina.com  易购娱乐 www.boyuanyl.cn      switch (ev) {      case CA_EVENT_CWND_RESTART:          gradients = ca->gradients;          if (gradients)              memset(gradients, 0, window * sizeof(gradients[0]));          memset(ca, 0, sizeof www.chuangshi88.cn(*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-www.sbsbo.cn>rtt;          ca->rtt.v64 =www.sbsbo.cc 0;          break;      default:          break;      }  }    static void tcp_cdg_init(struct www.linkenzc.cn sock *sk)  {      struct cdg *ca = www.linlenyl.cn 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"); 

以上是关于TCP拥塞控制及BBR原理分析的主要内容,如果未能解决你的问题,请参考以下文章

Linux打开TCP BBR拥塞控制算法

BBR拥塞控制算法

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

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

新式拥塞控制漫谈

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