TCP Reno test 12

Test Description:

This test show how the behavior of Reno TCP with multiple packet drops.

Expected output:

When the first packet is dropped, a fast retransmission is performed. Unlike TCP Tahoe, TCP Reno moves the snd_nxt pointer to its previous position before fast retransmission, which causes negative effective window when the new ACK is received. TCP Reno has to wait for a timeout to recover from the multiple loss.

Test Topology:

 Server ................Router..................Client

        8Mbs 5ms
 5(0)------------------0(1)        800kbs 100ms
                            0(0)-----------------7(0)
 6(0)------------------0(2)
        8Mbs 5ms

SSF Test Configuration File: f16.dml

send window = receive window = 50 packets

SSF Tcpdump File:

f16.tcpdump
f16serv1.tcpdump
f16serv2.tcpdump

Figure 1: sequence plot for tcpdump at Router Zoom in for figure 1

Figure 2. sequence plot, RTT plot and cwnd plot for tcpdump at Server 1

Zoom in for Figure 2

(EPS file for Figure 2)

Figure 3. sequence plot, RTT plot and cwnd plot for tcpdump at Server 2

(EPS file for Figure 3)

NS Test with the same parameters

NS tcpdump trace file: f16.tr

Trace Analysis:

The output is consistent with expected output.

Top connection analysis (server 1):

The first fast retransmission/fast recovery:

From Figure 1 plot 1, we can see that after 3 duplicate ACKs the first lost packet is retransmitted.
As seen in Figure 2 plot 3, according to fast recovery algorithm the ssthresh is set to 22 packets, and cwnd is set to 25 packets.
During the fast recovery 5 more new packets are sent before a new data ACK comes.

The second fast retransmission/fast recovery:

After the first packet is resent, new ACK comes and is followed by 3 duplicate ACKs, and the second lost packet is retransmitted.
According to Figure 2 plot 3, ssthresh is set to 11 packets, cwnd is set to 14 packets.
No new packet is sent during fast recovery because cwnd isn't large enough:
- According to the send window management algorithm (see SSF TCP implementation), the usable window is:
```
D = snd_una + snd_wnd - snd_nxt
```
  In SSF TCP a new packet can be sent only when D >= MSS, implying:
```
min(cwnd, rwnd) - (snd_nxt - snd_una) >= MSS 
```
- In this test TCP Reno is used. From Figure 2 plot 3, we can see after fast retransmission:
```
  min(cwnd, rwnd) = 14 MSS
snd_nxt - snd.una = 48 MSS
```
- From Figure 1 plot 1 we can see that no packet is sent during this fast recovery.

New ACK received for the second lost packet:
- no new packet can be sent because the usable window D < 0:
```
  cwnd = ssthresh = 11 MSS
  min(cwnd, rwnd) = 11 MSS,
snd_nxt - snd.una = 46 MSS.
 
```
- From Figure 1 plot 1 we can see that indeed no packet is sent after this ACK.
Timeout and retransmission:
- After the timeout cwnd is 1 MSS, ssthresh is set to 5 MSS (5 * 960 bytes as shown in Figure 2 plot 3 ). One packet is retransmitted.
New ACK received and slow start:
- From Figure 2 plot 3, we can see after fast retransmission:
```
  min(cwnd, rwnd) = 2 MSS
snd_nxt - snd.una = 0
```
- 2 packets can be sent. Both of them are retransmitted packets.
The following new ACK:

The same thing happens, snd_nxt = snd_una each time, cwnd increases by 1 MSS untill reach ssthresh