BIC算法
当发生丢包的时候，当前窗口为W-max, 减小窗口后的大小为W， BIC算法就是根据这个原理在(W, W-max]区间内做二分搜索
当接近于W-max时曲线应该更平滑，当离W-max较远的时候，曲线可以更加陡峭
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32static void bictcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
{
struct tcp_sock *tp = tcp_sk(sk);
struct bictcp *ca = inet_csk_ca(sk);
if (!tcp_is_cwnd_limited(sk))
return;
if (tcp_in_slow_start(tp))
tcp_slow_start(tp, acked);
else {
bictcp_update(ca, tp->snd_cwnd);// 计算ca->cnt, 表示增加一个cwnd需要的ack数量
tcp_cong_avoid_ai(tp, ca->cnt, 1); // 根据ca->cnt计算snd_cwnd
}
}
void tcp_cong_avoid_ai(struct tcp_sock *tp, u32 w, u32 acked)
{
/* If credits accumulated at a higher w, apply them gently now. */
if (tp->snd_cwnd_cnt >= w) {
tp->snd_cwnd_cnt = 0;
tp->snd_cwnd++;
}
tp->snd_cwnd_cnt += acked;
if (tp->snd_cwnd_cnt >= w) {
u32 delta = tp->snd_cwnd_cnt / w;
tp->snd_cwnd_cnt -= delta * w;
tp->snd_cwnd += delta;
}
tp->snd_cwnd = min(tp->snd_cwnd, tp->snd_cwnd_clamp);
}
bictcp_recalc_ssthresh计算慢启动阈值
在snd_cwnd > low_window(14)的时候， 引入beta/BICTCP_BETA_SCALE (819/1024), 不至于下降的过快
并记录当前拥塞时的last_max_cwnd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21static u32 bictcp_recalc_ssthresh(struct sock *sk)
{
const struct tcp_sock *tp = tcp_sk(sk);
struct bictcp *ca = inet_csk_ca(sk);
ca->epoch_start = 0;/* end of epoch */
/* Wmax and fast convergence */
if (tp->snd_cwnd < ca->last_max_cwnd && fast_convergence)
ca->last_max_cwnd = (tp->snd_cwnd * (BICTCP_BETA_SCALE + beta))
/ (2 * BICTCP_BETA_SCALE);
else
ca->last_max_cwnd = tp->snd_cwnd;
ca->loss_cwnd = tp->snd_cwnd;
if (tp->snd_cwnd <= low_window)
return max(tp->snd_cwnd >> 1U, 2U);
else
return max((tp->snd_cwnd * beta) / BICTCP_BETA_SCALE, 2U);
}
bictcp_acked
计算ca->delayed_ack，表示每收到一个ack，平均确认的packet数量，这里通过ACK_RATIO_SHIFT做了加权计算
1
2
3
4
5
6
7
8
9
10
11
12//ratio = (15*ratio + sample) / 16
static void bictcp_acked(struct sock *sk, const struct ack_sample *sample)
{
const struct inet_connection_sock *icsk = inet_csk(sk);
if (icsk->icsk_ca_state == TCP_CA_Open) {
struct bictcp *ca = inet_csk_ca(sk);
ca->delayed_ack += sample->pkts_acked -
(ca->delayed_ack >> ACK_RATIO_SHIFT);
}
}
bictcp_update计算ca->cnt
max_increment：一个rtt时间内最大增加的cwnd数量，默认16
BICTCP_B: 增加到last_max_cwnd需要的rtt数，默认4
smooth_part： 在非常逼近last_max_cwnd的时候，减慢cwnd增加的速度，默认20
当cwnd < last_max_cwnd的时候，需要根据差距选择合适的逼近方式
当last_max_cwnd - cwnd > BICTCP_Bmax_increment(416)时，ca->cnt=cwnd / max_increment线性增加，一个rtt最大增加max_increment
当last_max_cwnd - cwnd <= BICTCP_B(4)时，说明差距较小，需要缓慢逼近last_max_cwnd，5个rtt后cwnd+1
当last_max_cwnd - cwnd 在(BICTCP_B, BICTCP_B*max_increment]区间时，BICTCP_B个rtt时间后，达到last_max_cwnd
当cwnd >= last_max_cwnd时
当cwnd - ca->last_max_cwnd < BICTCP_B, 说明只超过last_max_cwnd一点，继续谨慎增加，ca->cnt = (cwnd * smooth_part) / BICTCP_B， 5个rtt+1
当cwnd - ca->last_max_cwnd 在[BICTCP_B,max_increment*(BICTCP_B-1))区间时，一个rtt后增加(cwnd - ca->last_max_cwnd)/(BICTCP_B-1) 个cwnd, 这里随着rtt内cwnd的增加，又会增大增长速率
当cwnd - ca->last_max_cwnd >= max_increment*(BICTCP_B-1)时，说明上一个last_max_cwnd已经没有参考意义，开始线性增加，一个rtt增加max_increment
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56static inline void bictcp_update(struct bictcp *ca, u32 cwnd)
{
if (ca->last_cwnd == cwnd &&
(s32)(tcp_time_stamp - ca->last_time) <= HZ / 32)
return;
ca->last_cwnd = cwnd;
ca->last_time = tcp_time_stamp;
if (ca->epoch_start == 0) /* record the beginning of an epoch */
ca->epoch_start = tcp_time_stamp;
/* start off normal */
if (cwnd <= low_window) {
ca->cnt = cwnd;
return;
}
/* binary increase */
if (cwnd < ca->last_max_cwnd) {
__u32dist = (ca->last_max_cwnd - cwnd)
/ BICTCP_B;
if (dist > max_increment)
/* linear increase */
ca->cnt = cwnd / max_increment;
else if (dist <= 1U)
/* binary search increase */
ca->cnt = (cwnd * smooth_part) / BICTCP_B;
else
/* binary search increase */
ca->cnt = cwnd / dist;
} else {
/* slow start AMD linear increase */
if (cwnd < ca->last_max_cwnd + BICTCP_B)
/* slow start */
ca->cnt = (cwnd * smooth_part) / BICTCP_B;
else if (cwnd < ca->last_max_cwnd + max_increment*(BICTCP_B-1))
/* slow start */
ca->cnt = (cwnd * (BICTCP_B-1))
/ (cwnd - ca->last_max_cwnd);
else
/* linear increase */
ca->cnt = cwnd / max_increment;
}
/* if in slow start or link utilization is very low */
if (ca->last_max_cwnd == 0) {
if (ca->cnt > 20) /* increase cwnd 5% per RTT */
ca->cnt = 20;
}
ca->cnt = (ca->cnt << ACK_RATIO_SHIFT) / ca->delayed_ack;
if (ca->cnt == 0)/* cannot be zero */
ca->cnt = 1;
}
最后通过除以delayed_ack，来考虑延时ack的情况，来计算需要的ack包的数量
bictcp_state
在TCP_CA_Loss状态的回掉中，会调用bictcp_state来reset ca
其中包括了last_max_cwnd被设置为0
这是不就说每次丢包后，cwnd=1，bic算法都要重新开始？ 那bic算法还有什么意义呢？
当然不是。
TCP_CA_Loss是当被超时定时器超时的时候，调用tcp_enter_loss,在其中被设置
而内核的丢包检测有:超时丢包检测,快速丢包检测以及rack之类的丢包检测
举例来说，一下子发了20个包，前16个中任何一个丢掉，几乎都会收到3个重复ack(进入recovery)，就不会超时, 如果尾部丢包还有tlp， 并且rack进一步减少了超时情况
还需要的说明的是，当丢包时会保存ssthresh，通过ssthresh来记录当前cwnd信息，下一次可以慢启动快速达到该阈值
bic算法总结bic算法在超过ssthresh后有max_increment限制，只能线性增加
对于两个rtt不同的tcp连接， 因为max_increment的控制，导致两个连接达到相同速率的不公平性
cubic算法
很容易看到bic的cwnd／时间坐标轴是在超时丢包点是凸到凹类似三次方的曲线，可以拟合到三次方程中
W(t) = C*(t-K)^3 + W_max (Eq. 1)
where C is a CUBIC parameter, t is the elapsed time from the last
window reduction,and K is the time period that the above function
takes to increase W to W_max when there is no further loss event and
is calculated by using the following equation:
K = cubic_root(W_max*beta/C) (Eq. 2)
where beta is the multiplication decrease factor.
相同rtt流的公平
RTT相同的两个流，如果一个连接的W-max较大，则乘法减小后beta*W-max就减少的更多，并且W_max较大的流K较大，则会导致W_max较大的流增加的缓慢，从而导致两个流收敛到同一个cwnd
不同rtt流的公平
因为丢包后，都是根据流逝时间t来计算的
有相对较快的增长速度
也就是三次方系数C， C又决定了K的大小，C越大，K越小，增长到W-max的速度就越快
cubic参数 & bictcp_update1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38beta_scale = 8*(BICTCP_BETA_SCALE+beta) / 3/ (BICTCP_BETA_SCALE - beta);
cube_rtt_scale = (bic_scale * 10);/* 1024*c/rtt */
cube_factor = 1ull << (10+3*BICTCP_HZ); /* 2^40 */
do_div(cube_factor, bic_scale * 10);
static inline void bictcp_update(struct bictcp *ca, u32 cwnd, u32 acked)
{
//...
ca->bic_K = cubic_root(cube_factor * (ca->last_max_cwnd - cwnd));
//...
t = (s32)(tcp_time_stamp - ca->epoch_start);
t += msecs_to_jiffies(ca->delay_min >> 3);
/* change the unit from HZ to bictcp_HZ */
t <<= BICTCP_HZ;
do_div(t, HZ);
if (t < ca->bic_K)/* t - K */
offs = ca->bic_K - t;
else
offs = t - ca->bic_K;
/* c/rtt * (t-K)^3 */
delta = (cube_rtt_scale * offs * offs * offs) >> (10+3*BICTCP_HZ);
if (t < ca->bic_K) /* below origin*/
bic_target = ca->bic_origin_point - delta;
else /* above origin*/
bic_target = ca->bic_origin_point + delta;
/* cubic function - calc bictcp_cnt*/
if (bic_target > cwnd) {
ca->cnt = cwnd / (bic_target - cwnd);
} else {
ca->cnt = 100 * cwnd; /* very small increment*/
}
...
}
beta & BICTCP_BETA_SCALE
由bictcp_recalc_ssthresh函数的返回结果知道
paper中的beta这里是beta / BICTCP_BETA_SCALE， beta默认为717， BICTCP_BETA_SCALE为1024
因此丢包后cubic窗口减小0.7的倍数
beta_scale & tcp_friendliness
因为cubic实时计算调整cwnd值，因此比传统的AIMD算法更加友好， 尤其是对于RTT较小的连接来说，都需要经过K时间才能到达W-max
在论文中提到，为了和AIMD算法的per RTT内有相同的增长率,窗口增加的大小至少为$W_{tcp}$
$$W_{tcp} = W_{max}\beta + 3\frac{1-\beta}{1+\beta}\frac{t}{RTT}$$
因此开启tcp_friendiness实际上意味着有更好的增长率，而非因为更友好而更加保守
bic_scale & cube_rtt_scale
bic_scale就是paper中三次方系数C的1024倍缩放值
cube_rtt_scale是在bic_scale/RTT, 这里rtt=100ms=0.1s
cube_factor & bic_K & BICTCP_HZ
通过bic_K和paper中的公式对比，可以知道cube_factor就是1/(C/RTT)
而实际上因为bic_scale放大了1024倍，并且计算K的时候要开三次方，放大10^(3*BICTCP_HZ)就是让K放大BICTCP_HZ
BICTCP_HZ这个值决定了K的时间精度
最后通过BIC类似的方式更新ca->cnt
cubic hystart
cubic hystart提供了一种在RTT很小或者快速收到连续ack的时候，退出slowstart的检测机制
因为新建连接并不丢包的时候, K=0, 曲线增长率很大，启用hystart可以快速到达W-max值
调整Cubic参数
fast_convergence = 0 开启后快速收敛，丢包后略小的W-max，可以关闭
tcp_friendliness = 1 默认参数，始终开启， 开启后实际上保证了per RTT内的增长率
beta=717 可以设置的更大(beta/1024)控制丢包后的窗口大小，早期值为819
BICTCP_HZ=10 对于HZ>=1000可以适当调整这个值，来让K有高的精度, 影响不大
hystart = 1 保持默认开启，快速退出慢启动，使用三次方增长曲线
bic_scale = 41 系数C的1024倍，C越大K越小，可以适当增大这个数值
其他:
代码中cube_rtt_scale和cube_factor使用了RTT=100ms来计算，可以适当减小这个数值
更小的RTT意味着
cube_rtt_scale更大，更高的增长率系数C
cube_factor更小， 更小的K值
参考资料
281
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
