TCP-Westwood在TCP-Reno的基础上增强了窗口控制和退避处理,例如,TCPW发送端监控ACK报文的接收速率,进而估算当前连接可达到的数据发送速率(可用带宽)。当发送端检测到丢包时(超时或者3个重复ACK),发送端根据估算的发送速率设置拥塞窗口大小(cwnd)和慢启动阈值(ssthresh)。不同于TCP-Reno的窗口减半处理,TCP-Westwood避免太过保守的减低窗口操作,TCP-Westwood称此为:Faster-Recovery。与TCP-Reno相比,TCP-Westwood更适合于无线链路类的TCP连接。
在TCP-Westwood定义的Faster-Recovery阶段,当接收到ACK报文时,意味着对端接收了相应的一定数量的数据报文,将此报文数量除以所经过的时间,即可得到当前带宽的一个评估值。当接收到重复ACK报文(DUPACKs)时,同样意味着对端接收到一个乱序的数据报文,也可用于带宽评估。
尽管如此,发送端并不能确定哪一个数据报文触发了重复ACK报文,进而不能确定其对应的数据报文长度,这时使用一个平均的报文长度值,当之后接收到正常ACK报文之后,进行数量修正。
需要注意的是,在拥塞发生时,连接路径中的瓶颈点应是发生了饱和,其报文缓存已经填满,在此拥塞之前,发送端使用的带宽小于或者等于瓶颈处的可用带宽,所以,TCP-Westwood在调整窗口的时候,重新调整到可用带宽处,而不是简单的将窗口减半。
如果发送端在tk时刻接收到ACK报文,意味着对应的dk大小的数据被对端接收,使用以下公式计算带宽的一个采样值:
b k = d k t k − t k − 1 b_{k} = \frac{d_{k}}{t_{k}-t_{k-1}} bk=tk−tk−1dk
其中tk−1代表前一个ACK报文的接收时间。既然拥塞发生在低频的速率(高频的速率意味着无拥塞)超过链路容量时,我们对采样的速率应用一个低通滤波器来获得可用带宽的低频部分。这样做的也可去除延时ACK带来的速率采样噪声。
低通滤波器的选择十分重要,根据经验,使用Tustin approximation方法将一个连续低通滤波器离散化,得到如下的一个离散时间滤波器:
b ^ k = 2 τ t k − t k − 1 − 1 2 τ t k − t k − 1 + 1 b ^ k − 1 + b k + b k − 1 2 τ t k − t k − 1 + 1 (1) \tag{1}\hat{b}_{k} = \frac{\frac{2\tau }{t_{k}-t_{k-1}}-1}{\frac{2\tau }{t_{k}-t_{k-1}}+1}\hat{b}_{k-1} + \frac{b_{k}+b_{k-1}}{\frac{2\tau }{t_{k}-t_{k-1}}+1} b^k=tk−tk−12τ+1tk−tk−12τ−1b^k−1+tk−tk−12τ+1bk+bk−1(1)
其中bk ˆ为tk时刻的可用带宽的过滤之后的测量值,1/τ为滤波器的截止频率。为理解其工作,假设ACK报文保持恒定的到达间隔,即tk − tk−1 = Δk = τ /10,之后,滤波器(1)变为一个具有恒定系数的滤波器,如下所示:
b ^ k = a b ^ k − 1 + ( 1 − a ) 2 [ b k + b k − 1 ] (2) \tag{2}\hat{b}_{k} = a\hat{b}_{k-1}+\frac{\left ( 1-a \right )}{2}\left [ b_{k}+b_{k-1} \right ] b^k=ab^k−1+2(1−a)[bk+bk−1](2)
其中系数a = 0.9 ,此公式(2)表示一个新的bk ˆ值由90%的前一个值bk−1,和最近两个采样值之和的10%组成。但是,由于ACK的到达时间并不确定,其依赖于tk − tk−1的值,这就要求使用随时间可变的系数。当ACK报文间隔增加时,上一次的值bk-1所占比重应减少;反之,其所占比重应增加,这真是公式(1)所实现。
最后,公式(1)的截止频率为1/τ,这意味值所有高于1/τ的频率部分都过滤掉了。根据Nyquist采样原理,为了采样一个带宽为1/τ的信号,采样间隔需要低于或者等于τ/2。但是,ACK报文是不确定的,如当发送端空闲时,完全没有ACK报文到达,采样频率无法得到保证。因此,如果在最后一个ACK报文接收后,超过τ/m (m≥2)长时间,没有接收到新的ACK报文,滤波器将假设接收到一个虚拟的采样bk=0。如下图所示:
bk-1 bk bk+1 bk+n-1 bk+n
| | | | | |
|----------|-------|----------|--------|------------|-------> t
| | | | |
tk-1 tk tk+1 tk+n-1 tk+n
其中tk-1为最后接收到的ACK报文,tk+j表示虚拟的采样到达的时刻,tk+j+1 - tk+j = τ/m,(j ∈ [0, n-1]),对于此范围内的j值,有bk+j=0。
如果由tk时刻起,一直没有ACK报文,滤波器公式(1)将会以指数级速率趋近于零。
如前所述,DUPACKs应当包含在带宽估算中,因为其意味着报文的成功发送。所以,随后正常的ACK报文应当仅算作确认了一个报文,不应包含重复ACK确认的报文。但是,对于延时ACK,情况就有所不同。TCP-Westwood对于带宽测量提出了以下两点要求:
a. 发送端必须跟踪重复ACK的数量,直到接收了正常ACK。
b. 发送端应当可以检测到延迟ACK。
如下所以,在接收到ACK报文之后,首先需要确定其确认的报文数量(cumul_ack),如果其值为零,表明接收到重复ACK,使用变量accounted_for记录重复ACK数量,将cumul_ack设置为1,即重复ACK表示成功发送了一个报文。
如果cumul_ack大于1,表明此ACK为延迟ACK,或者为发生报文重传之后的正常ACK,此情况下,与已经使用的报文数量(accounted_for)进行比较,如果ACK确认的报文数量小于等于已经使用的报文数量,表明在接收到重复ACK时已经使用了这些报文,进行带宽估算,不应再次使用了,更新accounted_for。反之,表明之后部分报文被使用,其与部分可用,清空accounted_for记录。
最后参与带宽计算的报文数量由变量acked表示。
PROCEDURE AckedCount
cumul_ack = current_ack_seqno - last_ack_seqno;
if (cumul_ack = 0)
accounted_for=accounted_for+1;
cumul_ack=1;
endif
if (cumul_ack > 1)
if (accounted_for >= cumul_ack)
accounted_for=accounted_for-cumul_ack;
cumul_ack=1;
else if (accounted_for < cumul_ack)
cumul_ack= cumul_ack - accounted_for;
accounted_for=0;
endif
endif
last_ack_seqno=current_ack_seqno;
acked=cumul_ack;
return(acked);
END PROCEDURE
对于由重复ACK引起的快速重传,慢启动阈值ssthresh等于估算的带宽乘以最小RTT时长,除以报文长度。其中,BWE*RTTmin表示的为瓶颈链路的报文缓存为空时的BDP,此设置允许在拥塞发生之后瓶颈链路的缓存清空。
另外,如果处于拥塞避免阶段,将拥塞窗口设置为ssthresh,反之,对于慢启动阶段,不设置窗口,其仍可按照指数级增长。
if (n DUPACKs are received)
ssthresh = (BWE*RTTmin)/seg_size;
if (cwin>ssthresh) /* congestion avoid. */
cwin = ssthresh;
endif
endif
对于报文超时引发的情况,慢启动阈值的计算与上相同,这里将其最小值设置为2,将拥塞窗口设置为1。
if (coarse timeout expires)
ssthresh = (BWE*RTTmin)/seg_size;
if (ssthresh < 2)
ssthresh = 2;
endif;
cwin = 1;
endif
TCP-Westwood更新采样速率的周期不低于50ms(TCP_WESTWOOD_RTT_MIN),即最快50ms更新一次速率。初始的RTT值定义为20秒(TCP_WESTWOOD_INIT_RTT),应当是非常保守了,实际值很少有这么大。
/* TCP Westwood functions and constants */
#define TCP_WESTWOOD_RTT_MIN (HZ/20) /* 50ms */
#define TCP_WESTWOOD_INIT_RTT (20*HZ) /* maybe too conservative?! */
如下TCP-Westwood拥塞处理结构,其慢启动阈值计算函数ssthresh,和拥塞窗口计算函数cong_avoid函数,以及窗口撤销函数undo_cwnd都是使用TCP-Reno的对应函数。而TCP-Westwood实现的拥塞函数指针主要有cwnd_event、in_ack_event和pkts_acked。
static struct tcp_congestion_ops tcp_westwood __read_mostly = {
.init = tcp_westwood_init,
.ssthresh = tcp_reno_ssthresh,
.cong_avoid = tcp_reno_cong_avoid,
.undo_cwnd = tcp_reno_undo_cwnd,
.cwnd_event = tcp_westwood_event,
.in_ack_event = tcp_westwood_ack,
.get_info = tcp_westwood_info,
.pkts_acked = tcp_westwood_pkts_acked,
如下函数westwood_filter,如果当前带宽估算值为空,使用第一个带宽采样进行更新。否则,应用低通滤波器函数进行更新。即之前的带宽估算值占比为7/8,新的采样值占比为1/8。
static void westwood_filter(struct westwood *w, u32 delta)
{
/* If the filter is empty fill it with the first sample of bandwidth */
if (w->bw_ns_est == 0 && w->bw_est == 0) {
w->bw_ns_est = w->bk / delta;
w->bw_est = w->bw_ns_est;
} else {
w->bw_ns_est = westwood_do_filter(w->bw_ns_est, w->bk / delta);
w->bw_est = westwood_do_filter(w->bw_est, w->bw_ns_est);
}
}
static inline u32 westwood_do_filter(u32 a, u32 b)
{
return ((7 * a) + b) >> 3;
}
在窗口更新函数westwood_update_window中,更新带宽估算值。对于第一次进入此函数的情况,first_ack为真(初始化为1),需要同步Westwood记录的SND.UNA。之后,如果上一次带宽估算至今的时长超过Westwood记录的RTT与最小RTT(TCP_WESTWOOD_RTT_MIN=50毫秒)之间的最大值时,更新带宽估算值。参见以上函数westwood_filter。
变量bk中保存了ACK已经确认的数据量,在带宽采样完成之后,将其清空。在此之前,bk的值在函数TCP快速路径函数westwood_fast_bw中累加,在慢速路径中,使用函数tcp_westwood_ack进行累加。
static void westwood_update_window(struct sock *sk)
{
struct westwood *w = inet_csk_ca(sk);
s32 delta = tcp_jiffies32 - w->rtt_win_sx;
/* Initialize w->snd_una with the first acked sequence number in order
* to fix mismatch between tp->snd_una and w->snd_una for the first
* bandwidth sample
*/
if (w->first_ack) {
w->snd_una = tcp_sk(sk)->snd_una;
w->first_ack = 0;
}
/*
* See if a RTT-window has passed.
* Be careful since if RTT is less than
* 50ms we don't filter but we continue 'building the sample'.
* This minimum limit was chosen since an estimation on small
* time intervals is better to avoid...
* Obviously on a LAN we reasonably will always have
* right_bound = left_bound + WESTWOOD_RTT_MIN
*/
if (w->rtt && delta > max_t(u32, w->rtt, TCP_WESTWOOD_RTT_MIN)) {
westwood_filter(w, delta);
w->bk = 0;
w->rtt_win_sx = tcp_jiffies32;
如下函数westwood_fast_bw,其在TCP接收的快速路径中调用。首先使用westwood_update_window函数更新带宽估算值(时机未到,不会更新)。其次,更新确认报文统计信息(bk),更新最小RTT值(update_rtt_min)。
static inline void westwood_fast_bw(struct sock *sk)
{
const struct tcp_sock *tp = tcp_sk(sk);
struct westwood *w = inet_csk_ca(sk);
westwood_update_window(sk);
w->bk += tp->snd_una - w->snd_una;
w->snd_una = tp->snd_una;
update_rtt_min(w);
}
更新最小RTT值由如下函数update_rtt_min完成,在TCP初始化时,或者拥塞丢包发生时,需要重新设置最小RTT值(reset_rtt_min)。否则,如果当前RTT小于记录的最小RTT值,更新最小RTT值。当前RTT值在函数tcp_westwood_pkts_acked中更新。
static inline void update_rtt_min(struct westwood *w)
{
if (w->reset_rtt_min) {
w->rtt_min = w->rtt;
w->reset_rtt_min = 0;
} else
w->rtt_min = min(w->rtt, w->rtt_min);
}
在接收到ACK确认报文之后,函数tcp_westwood_pkts_acked使用最新的采样,更新Westwood记录的RTT时长。
/*
* @westwood_pkts_acked
* Called after processing group of packets.
* but all westwood needs is the last sample of srtt.
*/
static void tcp_westwood_pkts_acked(struct sock *sk, const struct ack_sample *sample)
{
struct westwood *w = inet_csk_ca(sk);
if (sample->rtt_us > 0)
w->rtt = usecs_to_jiffies(sample->rtt_us);
在ACK报文处理函数tcp_ack中调用此函数,标志CA_ACK_SLOWPATH表示当前TCP连接是否处于慢速路径中。在快速路径中(westwood_fast_bw),使用(tp->snd_una - w->snd_una)计算确认的数据量。但是在慢速路径中,由函数westwood_acked_count确定确认数据量。
static void tcp_westwood_ack(struct sock *sk, u32 ack_flags)
{
if (ack_flags & CA_ACK_SLOWPATH) {
struct westwood *w = inet_csk_ca(sk);
westwood_update_window(sk);
w->bk += westwood_acked_count(sk);
update_rtt_min(w);
return;
}
westwood_fast_bw(sk);
}
不同于快速路径,函数westwood_acked_count需要考虑延时ACK(delayed-ack)、重复ACK和部分ACK(partial-ack)的情况。对于重复ACK,确认数据量设定为MSS大小。对于部分ACK,确认数据量也是MSS大小,这里由accounted中需要减去之前重复ACK确认的数据量。
对于延迟ACK或者非部分ACK的情况,确认数据量为减去accounted的结果值。
static inline u32 westwood_acked_count(struct sock *sk)
{
const struct tcp_sock *tp = tcp_sk(sk);
struct westwood *w = inet_csk_ca(sk);
w->cumul_ack = tp->snd_una - w->snd_una;
/* If cumul_ack is 0 this is a dupack since it's not moving tp->snd_una.
*/
if (!w->cumul_ack) {
w->accounted += tp->mss_cache;
w->cumul_ack = tp->mss_cache;
}
if (w->cumul_ack > tp->mss_cache) {
/* Partial or delayed ack */
if (w->accounted >= w->cumul_ack) {
w->accounted -= w->cumul_ack;
w->cumul_ack = tp->mss_cache;
} else {
w->cumul_ack -= w->accounted;
w->accounted = 0;
}
}
w->snd_una = tp->snd_una;
return w->cumul_ack;
先来看一下核心函数tcp_westwood_bw_rttmin,窗口值由带宽估算值与最小RTT值的乘积,除以MSS生成,最小不能低于2。
static u32 tcp_westwood_bw_rttmin(const struct sock *sk)
{
const struct tcp_sock *tp = tcp_sk(sk);
const struct westwood *w = inet_csk_ca(sk);
return max_t(u32, (w->bw_est * w->rtt_min) / tp->mss_cache, 2);
}
如下函数tcp_westwood_event,在发送拥塞时,设置慢启动阈值ssthresh和拥塞窗口。
static void tcp_westwood_event(struct sock *sk, enum tcp_ca_event event)
{
struct tcp_sock *tp = tcp_sk(sk);
struct westwood *w = inet_csk_ca(sk);
switch (event) {
case CA_EVENT_COMPLETE_CWR:
tp->snd_cwnd = tp->snd_ssthresh = tcp_westwood_bw_rttmin(sk);
break;
case CA_EVENT_LOSS:
tp->snd_ssthresh = tcp_westwood_bw_rttmin(sk);
/* Update RTT_min when next ack arrives */
w->reset_rtt_min = 1;
break;
内核版本 5.0