TCP中RTT和RTO的计算方法
计算RTT以及RTO的代码比较简单，我们先来看原理，首先相关的rfc有两篇分别是rfc793以及rfc6298，而相关的paper有一篇，那就是Van Jacobson和Michael J. Karels的 Congestion Avoidance and Control这篇paper，这篇1988年的paper中描述的RTT计算方法，就是我们当前所使用的计算方法，可能有的操作系统有一点修改，不过基本的东西都一样。
首先RTT是什么，RTT简单来说，就是我发送一个数据包，然后对端回一个ack，那么当我接到ack之后，就能计算出从我发送出包到接到过了多久，这个时间就是RTT。RTT的计算是很简单的，就是一个时间差。
而RTO呢，RTO也就是tcp在发送一个数据包之后，会启动一个重传定时器，而RTO就是这个定时器的重传时间，那么这个时候，就有问题了，由于RTO是指的这次发送当前数据包所预估超时时间,那么RTO就需要一个很好的统计方法，来更好的预测这次的超时时间。
我们所能想到的最简单的方法，那就是取平均数，比如第一次RTT是500毫秒，第二次是800毫秒，那么第三次发送的时候，RTO就应该是650毫秒。其实经典的RTO计算方法和取平均有点类似，只不过因子不太一样，取平均的话，也就是老的RTO和新的RTT都是占50%的权重，而在经典的RTO计算中就有些变化了。
来看经典的RTT计算方法,这个计算方法是在RFC793中提出的，计算方法是这样子的：
|
1
2
|
SRTT = ( ALPHA * SRTT ) + ((1-ALPHA) * RTT)
RTO = min[UBOUND,max[LBOUND,(BETA*SRTT)]]
|
其中ALPHA是一个scala因子，一般来说建议ALPHA是0.8和0.9.UBOUND就是RTO的最大值，LBOUND是RTO的最小值，BETA也是一个因子，建议是1.3-2.0。
这里可以看到在经典的RTO计算方法中会有一个很大的问题，就是当RTT对RTO的影响太小了，也就是说经典的RTO计算方法在RTT变化比较大的网络中，会表现的非常不好的。
于是在1988年，大神Van jacobson和Michael J. Karels的 Congestion Avoidance and Control这篇paper中，描述了一种新的计算方法，这里对于rtt的采样，多添加了一个因素，那就是均差(mean deviation)，而这里并不是传统意义上的均差，使用的平均数其实就是我们在经典方法中的srtt。 计算方法是这样子的：
|
1
2
3
|
Err ≡ m−a
a←a+gErr
v ← v+g(|Err|−v)
|
其中m就是当前最新的RTT，然后 a就是经典方法中的的SRTT，然后v就是均差，而Err顾名思义，就是我们预测的RTT的错误偏差。
可是这里有个问题，那就是由于因子g的存在，那么就有可能出现浮点数，因此我们只需要做个变化，让g=1/2^n,那么上面的的等式就变为下面这个了
|
1
2
|
2^na ← 2^na+Err
2^nv ← 2^nv+(|Err|−v)
|
假设g=1/8,也就是n为3，并且sa为2^n*a,sv为2^n*v,那么对应的c伪码就如下，：
|
1
2
3
4
5
6
7
8
9
|
/∗ update Average estimator ∗/
m −= (sa >> 3);
sa += m;
/∗ update Deviation estimator ∗/
if
(m < 0)
m = −m;
m −= (sv >> 2);
sv += m;
rto = (sa >> 3) + sv;
|
然后我们再来看rfc6298中对RTO计算的描述，这个rfc基本上就和Van jacobson和Michael J. Karels所描述的计算方法一致。其中第一次RTO的计算方法是这样子的：
|
1
2
3
|
SRTT <- R
RTTVAR <- R/2
RTO <- SRTT + max (G, K*RTTVAR)
|
后续的RTO计算是这样子的:
|
1
2
3
|
RTTVAR <- (1 - beta) * RTTVAR + beta * |SRTT - R'|
SRTT <- (1 - alpha) * SRTT + alpha * R'
RTO <- SRTT + max (G, 4*RTTVAR)
|
可以看到和上面的公式有差别，这里RTTVAR就是上面的v，而SRTT就是上面的a。
其实这个公式和jacobson的公式是一样的，只需要对公式做个变化。比如
|
1
|
SRTT <- (1 - alpha) * SRTT + alpha * R'
|
这个公式我们可以这样子来：
|
1
|
SRTT <- SRTT - SRTT*alpha + alpha*R` => SRTT <- SRTT + alpha*(R` - SRTT)
|
于是我们可以看到这个公式就和上面的公式a是相同的了。
最后我们来看linux下的实现，linux的实现和jacobson所描述的伪码基本一致，这里beta因子是1/4,而alpha因子是1/8.
linux下对应的计算是在tcp_rtt_estimator这个函数中，这个函数的第二个参数，就是当前最新的rtt值。linux的实现多了两个东西，分别是mdev和medev_max, 其中mdev就是上面计算方法中的RTTVAR，而mdev_max则就是每次均差的最大值(linux最小是50毫秒).而在linux中RTTVAR也就等于mdev_max.
这里要注意一个东西，那就是RTT的计算是每次都会做的，而对于RTO来说是和数据段相关的，也就是说每次发送的时候估计rtt，然后当估算RTT时发送的段收到ack，之后就应该进行下一次估算了(也就是一个RTT过去了),也就是需要调节对应的rttvar，并且重新初始化一些值.
|
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
|
u32 srtt;
/* smoothed round trip time << 3 */
u32 mdev;
/* medium deviation */
u32 mdev_max;
/* maximal mdev for the last rtt period */
u32 rttvar;
/* smoothed mdev_max */
u32 rtt_seq;
/* sequence number to update rttvar */
static
void
tcp_rtt_estimator(
struct
sock *sk,
const
__u32 mrtt)
{
struct
tcp_sock *tp = tcp_sk(sk);
long
m = mrtt;
/* RTT */
/* The following amusing code comes from Jacobson's
* article in SIGCOMM '88. Note that rtt and mdev
* are scaled versions of rtt and mean deviation.
* This is designed to be as fast as possible
* m stands for "measurement".
*
* On a 1990 paper the rto value is changed to:
* RTO = rtt + 4 * mdev
*
* Funny. This algorithm seems to be very broken.
* These formulae increase RTO, when it should be decreased, increase
* too slowly, when it should be increased quickly, decrease too quickly
* etc. I guess in BSD RTO takes ONE value, so that it is absolutely
* does not matter how to _calculate_ it. Seems, it was trap
* that VJ failed to avoid. 8)
*/
if
(m == 0)
m = 1;
if
(tp->srtt != 0) {
//开始更新a也就是srtt.可以看到因子为1/8.
m -= (tp->srtt >> 3);
/* m is now error in rtt est */
tp->srtt += m;
/* rtt = 7/8 rtt + 1/8 new */
//开始更新mean deviation.
if
(m < 0) {
m = -m;
/* m is now abs(error) */
m -= (tp->mdev >> 2);
/* similar update on mdev */
/* This is similar to one of Eifel findings.
* Eifel blocks mdev updates when rtt decreases.
* This solution is a bit different: we use finer gain
* for mdev in this case (alpha*beta).
* Like Eifel it also prevents growth of rto,
* but also it limits too fast rto decreases,
* happening in pure Eifel.
*/
if
(m > 0)
m >>= 3;
}
else
{
m -= (tp->mdev >> 2);
/* similar update on mdev */
}
tp->mdev += m;
/* mdev = 3/4 mdev + 1/4 new */
//找到最大值付给rttvar
if
(tp->mdev > tp->mdev_max) {
tp->mdev_max = tp->mdev;
if
(tp->mdev_max > tp->rttvar)
tp->rttvar = tp->mdev_max;
}
//本次RTT的估算结束
if
(after(tp->snd_una, tp->rtt_seq)) {
//调节rttvar
if
(tp->mdev_max < tp->rttvar)
tp->rttvar -= (tp->rttvar - tp->mdev_max) >> 2;
tp->rtt_seq = tp->snd_nxt;
//设置最小值
tp->mdev_max = tcp_rto_min(sk);
}
}
else
{
//第一次进来的情况
/* no previous measure. */
tp->srtt = m << 3;
/* take the measured time to be rtt */
tp->mdev = m << 1;
/* make sure rto = 3*rtt */
tp->mdev_max = tp->rttvar = max(tp->mdev, tcp_rto_min(sk));
tp->rtt_seq = tp->snd_nxt;
}
}
|
最后来看一下RTO的计算，RTO的计算在__tcp_set_rto中，这个计算它是严格遵守rfc6298中的描述。
|
1
2
3
4
|
static
inline
u32 __tcp_set_rto(
const
struct
tcp_sock *tp)
{
return
(tp->srtt >> 3) + tp->rttvar;
}
|