TCP拥塞控制算法内核实现剖析(二)
内核版本:2.6.37
主要源文件:linux-2.6.37/ net/ ipv4/ tcp_bic.c
本文主要分析BIC算法实现
======================================================================================================
1. 相关结构体和参数
/* BIC TCP Parameters */ struct bictcp { u32 cnt ; /* increase cwnd by 1 after ACKs */ u32 last_max_cwnd ; /* last maximum snd_cwnd */ u32 loss_cwnd ; /* congestion window at last loss */ u32 last_cwnd ; /* the last snd_cwnd */ u32 last_time ; /* time when updated last_cwnd */ u32 epoch_start ; /* beginning of an epoch */ #define ACK_RATIO_SHIFT 4 u32 delayed_ack ; /* estimate the ratio of Packets/ACKs << 4 */ } ;
/* Scale factor beta calculation * max_cwnd = snd_cwnd * beta */ #define BICTCP_BETA_SCALE 1024 /* In binary search , * go to point (max+min) / N */ #define BICTCP_B 4 /*并不是真正的二分*/
2. 全局变量
static int fast_convergence = 1 ; /* BIC能快速的达到一个平衡值,开关*/
static int max_increment = 16 ; /* 每次增加的MSS 不能超过这个值,防止增长太过剧烈*/
static int low_window = 14 ; /* lower bound on congestion window , for TCP friendliness */
static int beta = 819 ; /* = 819 / 1024(BICTCP_BETA_SCALE) ,beta for multiplicative increase 。?*/
static int initial_ssthresh ; /* 初始的阈值 */
static int smooth_part = 20 ; /* log(B/(B*Smin))/log(B/(B-1))+B, # of RTT from Wmax-B to Wmax 。?*/
/* initial_ssthresh的初始值被设置成2^31-1=2147483647 */
bictcp结构体保存在:
struct inet_connection_sock { ... u32 icsk_ca_priv[16] ; #define ICSK_CA_PRIV_SIZE (16*sizeof(u32)) } static inline void *inet_csk_ca( const struct sock *sk ) { return (void *)inet_csk(sk)->icsk_ca_priv ; }
============================================================================================================
tcp_is_cwnd_limited的实现没弄明白
/* Slow start with delack produces 3 packets of burst , so that it is * safe "de facto". This will be default - same as the default reordering * threshold - but if reordering increases , we must be able to allow * cwnd to burst at least this much in order to not pull it back when * holes are filled. */ static __inline__ __u32 tcp_max_burst ( const struct tcp_sock *sk ) { return tp->reordering ; } /* u8 reordering ; Packets reordering metric */
/* RFC2681 Check whether we are limited by application or congestion * window . This is the inverse of cwnd check in tcp_tso_should_defer */ /* 返回0,不需要增加cwnd ; 返回1,cwnd被限制,需要增加 */ int tcp_is_cwnd_limited ( const struct sock *sk , u32 in_flight ) { const struct tcp_sock *tp = tcp_sk(sk) ; u32 left ; if( in_flight >= tp->snd_cwnd ) /* 不是规定in_flight < snd_cwnd ? */ return 1 ; left = tp->snd_cwnd - in_flight ; if( sk_can_gso(sk) && left * sysctl_tcp_tso_win_divisor < tp->snd_cwnd && left * tp->mss_cache < sk->sk_gso_max_size ) return 1 ; return left <= tcp_max_busrt( tp ) ; }
=============================================================================================================
3. bictcp拥塞避免
static void bictcp_cong_avoid ( struct sock *sk , u32 ack , u32 in_flight ) { struct tcp_sock *tp = tcp_sk(sk) ; struct bictcp *ca = inet_csk_ca(sk) ; /* 如果发送拥塞窗口不被限制,不能再增加,则返回 */ if( !tcp_is_cwnd_limited(sk , in_flight)) return ; if( tp->snd_cwnd < tp->snd_ssthresh ) tcp_slow_start( tp ) ; else { bictcp_update(ca , tp->snd_cwnd ) ; tcp_cong_avoid_ai( tp , ca->cnt ) ; } }
从以上函数可以看出,BIC的慢启动和reno相同。在拥塞避免阶段,当snd_cwnd <= low_window ,两者也采用相同方法。
只有当snd_cwnd > low_window时,BIC才开始显示出它的特性。
在include/ net / tcp.h中,
/* TCP timestamps are only 32-bits */
#define tcp_time_stamps ((__u32)(jiffies))
4. bictcp结构体的更新(BIC算法关键)
/* * Compute congestion window to use. */ static inline void bictcp_update( struct bictcp *ca , u32 cwnd ) { /* 31.25ms以内不更新ca!!!*/ 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 ) /* recording the beginning of an epoch */ ca->epoch_start = tcp_time_stamp ; /* start off normal */ if( cwnd <= low_window ) { /*为了保持友好性*/ ca->cnt = cwnd ; /*这样14个以内的ack,可使snd_cwnd++ */ return ; } /* binary increase */ if ( cwnd < ca->last_max_cwnd ) { /*上次掉包前一个snd_cwnd */ __u32 dist = (ca->last_max_cwnd - cwnd) / BICTCP_B ; /* 四分之一 */ if ( dist > max_increment ) /* linear increase */ /*dist > 16,处于线性增长阶段,每收到16个ACK,会使snd_cwnd++ */ ca->cnt = cwnd / max_increment ; else if ( dist <= 1U ) /* binary search increase */ /* dist <=1 , ca->cnt=5*cwnd,会造成snd_cwnd增长极其缓慢,即处于稳定阶段 */ ca->cnt = (cwnd * smooth_part ) / BICTCP_B ; else /* binary search increase */ /* 1 < dist <= 16 ,每收到dist个ACK,会使snd_cwnd++,故增长很快 */ ca->cnt = cwnd / dist ; } else { /* 进入max_probing阶段 */ /* cwnd < ca->last_max_cwnd + 4 */ if ( cwnd < ca->last_max_cwnd + BICTCP_B ) /* ca->cnt = 5*cwnd ; slow start */ ca->cnt = (cwnd * smooth_part ) / BICTCP_B ; else if ( cwnd < ca->last_max_cwnd + max_increment * ( BICTCP_B - 1)) /* 增长率从5/(3*cwnd)~47/(3*cwnd),snd_cwnd的增长加快*/ ca->cnt = (cwnd * (BICTCP_B - 1)) / (cwnd - ca->last_max_cwnd) ; else ca->cnt = cwnd / max_increment ;/* 增长率为16/cwnd ,更快 */ } /* if in slow start or link utilization is very low */ if ( ca->loss_cwnd == 0 ) { /* 没有发生过丢包,所以snd_cwnd增长应该快点*/ if ( ca->cnt > 20 )/* increase cwnd 5% per RTT */ ca->cnt = 20 ; } /* 相当于乘与delayed_ack的百分比,delayed得越严重,则snd_cwnd应该增加越快*/ /* 这样有无delayed对snd_cwnd的影响不大*/ ca->cnt = (ca->cnt << ACK_RATIO_SHIFT) / ca->delayed_ack ; /* ca->cnt cannot be zero */ if ( ca->cnt == 0) ca->cnt = 1 ;}
5. 小结:
从以上函数可以看出,和reno相比,BIC在拥塞避免阶段snd_cwnd增长极快。
当ca->last_max_cwnd - snd_cwnd >= 4 时,snd_cwnd最快的增长率为 1/16 。
而当ca->last_max_cwnd - snd_cwnd <4 时,增长率非常低,可以使当前的snd_cwnd维持很长一段时间,
即以最合适的snd_cwnd发送数据。
这两点使BIC在高带宽、长时延的环境下能达到较高的吞吐量。
1. 搜索阶段
(1) cwnd < last_max_cwnd - 64, 则cnt = cwnd / 16
(2) last_max_cwnd - 64 <= cwnd < last_max_cwnd -4 ,则cnt = cwnd / dist
(3) last_max_cwnd - 4 <= cwnd < last_max_cwnd ,则cnt = 5*cwnd
总体来说,snd_cwnd增长先快后慢,趋于稳定。
2. max probing阶段
(1) last_max_cwnd <= cwnd < last_max_cwnd + 4,则cnt = 5*cwnd
(2) last_max_cwnd + 4 <= cwnd < last_max_cwnd + 48 ,则cnt = 3*cwnd / (cwnd - last_max_cwnd)
(3) cwnd >= last_max_cwnd + 48 ,则cnt = cwnd / 16
总体来说,snd_cwnd的增长先慢后快,越来越快。
=======================================================================================================
来看一下初始化和重置
static inline void bictcp_reset( struct bictcp *ca ) { ca->cnt = 0 ; ca->last_max_cwnd = 0 ; ca->loss_cwnd = 0 ; ca->last_cwnd = 0 ; ca->last_time = 0 ; ca->epoch_start = 0 ; ca->delayed_ack = 2 << ACK_RATIO_SHIFT ; // 默认50%的delayed包 }
bictcp_reset在两种情况下被调用:初始化时(bictcp_init )、进入拥塞处理时(bictcp_state 状态为TCP_CA_Loss)。
static void bictcp_init( struct sock *sk ) { bictcp_reset( inet_csk_ca( sk) ) ; /* 加载模块时设置了。否则,其值 = 2^31 - 1 */ if ( initial_ssthresh ) tcp_sk(sk)->snd_ssthesh = initial_ssthresh ; }
=============================================================================================================
慢启动阈值调整
我们知道,对一个拥塞控制算法而言,有两个函数必不可少,除了上面分析过的bictcp_cong_avoid(拥塞避免),还有
bictcp_recalc_ssthresh(慢启动阈值重新计算)。RENO只是简单的把发生拥塞时的窗口除以2,而BIC则增加了一些东西。
/* * behave like Reno until low_window is reached , * then increase congestion window slowly */ static 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 * fast? 好像是更安全点吧。丢包点比上次低,说明恶化,则主动降低。 * 丢包点比上次高,则说明更好,当然采用更大的。 */ if ( tp->snd_cwnd < ca->last_max_cwnd && fast_convergence ) /* 就是last_max_cwnd = 0.9 * snd_cwnd */ ca->last_max_cwnd = (tp->snd_cwnd * (BICTCP_BETA_SCALE + beta )) / ( 2 * BICTCP_BETA_SCALE ) ; esle ca->last_max_cwnd = tp->snd_cwnd ; ca->loss_cwnd = tp->snd_cwnd ; /* snd_cwnd<=14时,同reno,保持友好性 */ if ( tp->snd_cwnd <= low_window ) return max( tp->snd_cwnd >> 1U , 2U ) ; esle /* 就是snd_ssthresh=0.8*snd_cwnd ,很大的一个数,能充分利用带宽 */ return max( tp->snd_cwnd * beta ) / BICTCP_BETA_SCALE , 2U ) ; }
bictcp_recalc_ssthresh做了两件事:重赋值last_max_cwnd、返回新的慢启动阈值。
特别值得注意的是,snd_ssthresh = 0.8 * snd_cwnd 。这个可比RENO的snd_ssthresh = 0.5 * snd_cwnd 大了很多。
所以说BIC能够更有效的利用大带宽。
=======================================================================================================
计算delayed packets ratio
/* Track delayed acknowledgement ratio using sliding window * ratio = (15*ratio + sample) / 16 * sample是此时的cnt,而本来的ratio = delayed_ack / 16 * 按如下函数计算后,现在的ratio = (15*ratio) /16 + cnt /16 * cnt = cnt - 原来的ratio */ static void bictcp_acked( struct sock *sk , u32 cnt , s32 rtt ) { const struct inet_connection_sock *icsk = inet_csk(sk) ; if ( icsk->icsk_ca_state == TCP_CA_Open ) { struct bictcp *ca = inet_csk_ca(sk) ; /* 作者似乎很注重delayed包对snd_cwnd的影响,要尽量削弱 */ cnt -= ca->delayed_ack >> ACK_RATIO_SHIFT ; ca->delayed_ack += cnt ; } }
在struct inet_connection_sock中,有__u8 icsk_ca_state,表示拥塞控制的状态。
在tcp.h中,
enum tcp_ca_state { TCP_CA_Open = 0, #define TCPF_CA_Open (1<<TCP_CA_Open) TCP_CA_Disorder = 1, #define TCPF_CA_Disorder (1<<TCP_CA_Disorder) TCP_CA_CWR = 2, #define TCPF_CA_CWR (1<<TCP_CA_CWR) TCP_CA_Recovery = 3, #define TCPF_CA_Recovery (1<<TCP_CA_Recovery) TCP_CA_Loss = 4 #define TCPF_CA_Loss (1<<TCP_CA_Loss) };
============================================================================================================
static u32 bictcp_undo_cwnd( struct sock *sk ) { const struct tcp_sock *tp = tcp_sk(sk) ; const struct bictcp *ca = inet_csk_ca(sk) ; return max( tp->snd_cwnd , ca->last_max_cwnd ) ; }
此函数在退出拥塞处理时调用,而下面的bictcp_state则是在进入拥塞处理时调用。
static void bictcp_state( struct sock *sk , u8 new_state ) { if ( new_state == TCP_CA_Loss ) bictcp_reset( inet_csk_ca(sk) ) ; }
============================================================================================================
bictcp算法结构体
static struct tcp_congestion_ops bictcp = { . init = bictcp_init , . ssthresh = bictcp_recalc_ssthresh , . cong_avoid = bictcp_cong_avoid , . set_state = bictcp_state , . undo_cwnd = bictcp_undo_cwnd , . pkts_acked = bictcp_acked , . owner = THIS_MODULE , . name = "bic" , } ;
bictcp注册函数
static int __init bictcp_register(void) { /* bic算法的参数不能太多,多于16个u32 */ BUILD_BUG_ON( sizeof( struct bictcp) ) > ICSK_CA_PRIV_SIZE ) ; return tcp_register_congestion_control( &bictcp ) ; }
OK,关于BIC的代码分析告一段落,接下来看看相关函数是在什么样的情况下,以什么顺序来调用的。
======================================================================================================
BIC函数的调用时机
1. 连接每收到一个ack,则调用tcp_ack
2. tcp_ack会调用bictcp_acked,用来更新cnt和delayed_ack(用来消除delay包的影响)
3. tcp_ack会调用bictcp_cong_avoid,这是分两种情况:
(1)snd_cwnd小于慢启动阈值,处于慢启动阶段,则调用tcp_slow_start
(2)snd_cwnd大于慢启动阈值,处于拥塞避免阶段,则调用bictcp_update来更新bictcp,再调用tcp_cong_avoid_ai
4. tcp_ack中如果检测到丢包,进入拥塞处理阶段,则调用bictcp_recalc_ssthresh来更新慢启动阈值。
5. tcp_ack中完成丢包重传后,退出拥塞处理阶段,则调用bictcp_undo_cwnd来更新snd_cwnd。
快速重传:tcp_ack中的丢包检测,即检测到连续3个重复ACK。
快速恢复:bictcp_undo_cwnd,直接把snd_cwnd更新为max(snd_cwnd,last_max_cwnd),和掉包前相差不大。
更具体的可以看看tcp_ack(net/ ipv4/ tcp_input.c)。