TCP中RTT的测量和RTO的计算 以及 接收缓存大小的动态调整

RTT测量

https://www.cnblogs.com/codestack/p/11919697.html

在发送端有两种RTT的测量方法，但是因为TCP流控制是在接收端进行的，

所以接收端也需要有测量RTT的方法。

/* Receiver "autotuning" code.
 *
 * The algorithm for RTT estimation w/o timestamps is based on
 * Dynamic Right-Sizing (DRS) by Wu Feng and Mike Fisk of LANL.
 * <http://public.lanl.gov/radiant/pubs.html#DRS>
 *
 * More detail on this code can be found at
 * <http://staff.psc.edu/jheffner/>,
 * though this reference is out of date.  A new paper
 * is pending.
 
 不管是没有使用时间戳选项的RTT采样，还是使用时间戳选项的RTT采样，都是获得一个RTT样本。
 
 之后还需要对获得的RTT样本进行处理，以得到最终的RTT。
 对于没有使用时间戳选项的RTT测量方法，不进行微调。因为用此种方法获得的RTT采样值已经偏高而且收敛

很慢。直接选择最小RTT样本作为最终的RTT测量值。

对于使用时间戳选项的RTT测量方法，进行微调，新样本占最终RTT的1/8，即rtt = 7/8 old + 1/8 new。
 
 */
static void tcp_rcv_rtt_update(struct tcp_sock *tp, u32 sample, int win_dep)
{
    u32 new_sample = tp->rcv_rtt_est.rtt_us;
    long m = sample;

    if (m == 0)
        m = 1;/* 时延最小为1ms*、*/

    if (new_sample != 0) { /* 不是第一次获得样本*/
        /* If we sample in larger samples in the non-timestamp
         * case, we could grossly overestimate the RTT especially
         * with chatty applications or bulk transfer apps which
         * are stalled on filesystem I/O.
         *
         * Also, since we are only going for a minimum in the
         * non-timestamp case, we do not smooth things out
         * else with timestamps disabled convergence takes too
         * long. /* 对RTT采样进行微调，新的RTT样本只占最终RTT的1/8 *
         */
        if (!win_dep) {//需要对采样进行微调
            m -= (new_sample >> 3);
            new_sample += m;
        } else { /* 不对RTT采样进行微调，直接取最小值，原因可见上面那段注释*/
            m <<= 3; 
            if (m < new_sample)
                new_sample = m;
        }
    } else {
        /* No previous measure. 第一次获得样本*//注意，Linux内核为了避免浮点运算，RTT采样都是按8倍存储的*/
        new_sample = m << 3;//注意，Linux内核为了避免浮点运算，RTT采样都是按8倍存储的
    }

    tp->rcv_rtt_est.rtt_us = new_sample;/* 更新RTT*/
}
/*
此函数的原理：我们知道发送端不可能在一个RTT期间发送大于一个通告窗口的数据量。
那么接收端可以把接收一个确认窗口的数据量(rcv_wnd)所用的时间作为RTT。接收端收到一个数据段，
然后发送确认(确认号为rcv_nxt，通告窗口为rcv_wnd)，开始计时，RTT就是收到序号为rcv_nxt + rcv_wnd的数据段所用的时间。
很显然，这种假设并不准确，测量所得的RTT会偏大一些。所以这种方法只有当没有采用时间戳选项时才使用，
而内核默认是采用时间戳选项的(tcp_timestamps为1)。
下面是一段对此方法的评价：
If the sender is being throttled by the network, this estimate will be valid. However, if the sending application did nothave any data to send, 
the measured time could be much larger than the actual round-trip time. Thus this measurementacts only as an upper-bound on the round-trip time.
————————————————


*/
static inline void tcp_rcv_rtt_measure(struct tcp_sock *tp)
{
    u32 delta_us;
    /* 第一次接收到数据时，需要对相关变量初始化*/

    if (tp->rcv_rtt_est.time.v64 == 0)
        goto new_measure;
     /* 收到指定的序列号后，才能获取一个RTT测量样本*/
    if (before(tp->rcv_nxt, tp->rcv_rtt_est.seq))
        return;
     /* RTT的样本：jiffies - tp->rcv_rtt_est.time */
    delta_us = skb_mstamp_us_delta(&tp->tcp_mstamp, &tp->rcv_rtt_est.time);
    tcp_rcv_rtt_update(tp, delta_us, 1);

new_measure:
    tp->rcv_rtt_est.seq = tp->rcv_nxt + tp->rcv_wnd;
    tp->rcv_rtt_est.time = tp->tcp_mstamp;
}
/*但是在流量小的时候，通过时间戳采样得到的RTT的值会偏大，此时就会采用

没有时间戳时的RTT测量方法。*/
static inline void tcp_rcv_rtt_measure_ts(struct sock *sk,
                      const struct sk_buff *skb)
{
    struct tcp_sock *tp = tcp_sk(sk);
    if (tp->rx_opt.rcv_tsecr &&/* 启用了Timestamps选项，并且流量稳定*/
        (TCP_SKB_CB(skb)->end_seq -
         TCP_SKB_CB(skb)->seq >= inet_csk(sk)->icsk_ack.rcv_mss))
            /* RTT = 当前时间 - 回显时间*/
        tcp_rcv_rtt_update(tp,
                   jiffies_to_usecs(tcp_time_stamp -
                            tp->rx_opt.rcv_tsecr),
                   0);
}

调整接收缓存

数据从TCP接收缓存复制到用户空间之后，会调用tcp_rcv_space_adjust()来调整TCP接收缓存和接收窗口上限的大小

/*
 * This function should be called every time data is copied to user space.
 * It calculates the appropriate TCP receive buffer space.
 tp->rcvq_space.space表示当前接收缓存的大小（只包括应用层数据，单位为字节）。
 sk->sk_rcvbuf表示当前接收缓存的大小（包括应用层数据、TCP协议头、sk_buff和skb_shared_info结构，

tcp_adv_win_scale微调，单位为字节）
 */
void tcp_rcv_space_adjust(struct sock *sk)
{
    struct tcp_sock *tp = tcp_sk(sk);
    int time;
    int copied;
    /*计算上次调整到现在的时间*/ 

    time = skb_mstamp_us_delta(&tp->tcp_mstamp, &tp->rcvq_space.time);
    /* 调整至少每隔一个RTT才进行一次，RTT的作用在这里?
    //注意，Linux内核为了避免浮点运算，RTT采样都是按8倍存储的
    或者没哟计算出接收方rtt?/
    if (time < (tp->rcv_rtt_est.rtt_us >> 3) || tp->rcv_rtt_est.rtt_us == 0)
        return;

    /* Number of bytes copied to user in last RTT */
    /* 一个RTT内接收方应用程序接收并复制到用户空间的数据量*/  
    copied = tp->copied_seq - tp->rcvq_space.seq;
    if (copied <= tp->rcvq_space.space) /* 如果这次的space比上次的 小*/  
        goto new_measure;

    /* A bit of theory :
     * copied = bytes received in previous RTT, our base window
     * To cope with packet losses, we need a 2x factor
     * To cope with slow start, and sender growing its cwin by 100 %
     * every RTT, we need a 4x factor, because the ACK we are sending
     * now is for the next RTT, not the current one :
     * <prev RTT . ><current RTT .. ><next RTT .... >
     */
        /* 如果这次的space比上次的 大   */
    /* 启用自动调节接收缓冲区大小，并且接收缓冲区没有上锁*/

    if (sysctl_tcp_moderate_rcvbuf &&
        !(sk->sk_userlocks & SOCK_RCVBUF_LOCK)) {
        int rcvwin, rcvmem, rcvbuf;

        /* minimal window to cope with packet losses, assuming
         * steady state. Add some cushion because of small variations.
         */
        rcvwin = (copied << 1) + 16 * tp->advmss;

        /* If rate increased by 25%,
         *    assume slow start, rcvwin = 3 * copied
         * If rate increased by 50%,
         *    assume sender can use 2x growth, rcvwin = 4 * copied
         */
        if (copied >=
            tp->rcvq_space.space + (tp->rcvq_space.space >> 2)) {
            if (copied >=
                tp->rcvq_space.space + (tp->rcvq_space.space >> 1))
                rcvwin <<= 1;
            else
                rcvwin += (rcvwin >> 1);
        }
        /* 一个数据包耗费的总内存包括： 
                       * 应用层数据：tp->advmss， 
                       * 协议头：MAX_TCP_HEADER， 
                       * sk_buff结构， 
                       * skb_shared_info结构。 
                       */  

        rcvmem = SKB_TRUESIZE(tp->advmss + MAX_TCP_HEADER);
        while (tcp_win_from_space(rcvmem) < tp->advmss)
            rcvmem += 128; // 为啥微调是128
        /*不能超过允许的最大接收缓冲区大小*/

        rcvbuf = min(rcvwin / tp->advmss * rcvmem, sysctl_tcp_rmem[2]);
        if (rcvbuf > sk->sk_rcvbuf) {
            sk->sk_rcvbuf = rcvbuf;/* 调整接收缓冲区的大小*/

            /* Make the window clamp follow along.  */
            tp->window_clamp = rcvwin;/*调整接收窗口的上限*/
        }
    }
    tp->rcvq_space.space = copied;//更新接收方窗口上限

new_measure:
    tp->rcvq_space.seq = tp->copied_seq;
    tp->rcvq_space.time = tp->tcp_mstamp;
}

sk->sk_rcvbuf：分配给连接的接收使用的buf大小（size of receive buffer in bytes）。通常将数据拷贝给用户后会根据历史接收情况重新计算sk_rcvbuf（具体参见tcp_rcv_space_adjust）。
sk->sk_rmem_alloc：接收已经使用的buf大小。(接收到报文会相应增加，将数据交给用户后会相应减少)
tp->window_clamp：连接窗口的上限（Maximal window to advertise）。通常是通过历史接收情况估算出当前需要通告的最优窗口（具体参见tcp_rcv_space_adjust）。rcv_ssthresh动态调整最终会趋向于这个值。
tp->rcv_ssthresh：当前允许通告的最大窗口（Current window clamp）。窗口的选择大多时候都由rcv_ssthresh决定，而rcv_ssthresh是会动态调整的。而rcv_ssthresh调整的上限就是tp->window_clamp

RTT的测量有两种方法：

1. TCP Timestamp选项

   在发送数据包时，在tcp头部选项中携带时间，接收端收到数据包发送ACK时，将该时间带回

   RTT=当前时间 - 数据包中Timestamp选项的回显时间

2. skb中的skb_mstamp成员

   发送数据时将时间保存在skb->skb_mstamp中，当收到ack时，则

   RTT=当前时间 - skb->skb_mstamp

   由于该方法无法区分重传包和原始数据包，所以只能对未重传过的数据包计算RTT

 

发送方每接收到一个ACK，都会调用tcp_ack()来处理。
tcp_ack()中会调用tcp_clean_rtx_queue()来删除重传队列中已经被确认的数据段。
在tcp_clean_rtx_queue()中：
如果ACK确认了重传的数据包，则seq_rtt = -1；
否则，seq_rtt = now - scb->when；
然后调用tcp_ack_update_rtt(sk, flag, seq_rtt)来更新RTT和RTO

https://tools.ietf.org/html/rfc6298