TCP-Westwood拥塞算法

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在调整窗口的时候，重新调整到可用带宽处，而不是简单的将窗口减半。

ACK接收速率的过滤

如果发送端在tk时刻接收到ACK报文，意味着对应的dk大小的数据被对端接收，使用以下公式计算带宽的一个采样值：

$$b_k=\frac{d_k}{t_k-t_{k-1}}$$

其中tk−1代表前一个ACK报文的接收时间。既然拥塞发生在低频的速率(高频的速率意味着无拥塞)超过链路容量时，我们对采样的速率应用一个低通滤波器来获得可用带宽的低频部分。这样做的也可去除延时ACK带来的速率采样噪声。

低通滤波器的选择十分重要，根据经验，使用Tustin approximation方法将一个连续低通滤波器离散化，得到如下的一个离散时间滤波器：

$${\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}\text{\hspace{1em}(1)}$$

其中bk ˆ为tk时刻的可用带宽的过滤之后的测量值，1/τ为滤波器的截止频率。为理解其工作，假设ACK报文保持恒定的到达间隔，即tk − tk−1 = Δk = τ /10，之后，滤波器（1）变为一个具有恒定系数的滤波器，如下所示：

$${\hat{b}}_k=a{\hat{b}}_{k-1}+\frac{\left(1-a\right)}{2}\left[b_k+b_{k-1}\right]\text{\hspace{1em}(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

TCP-Westwood窗口计算

对于由重复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初始化

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报文

在接收到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事件

在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