TCP congestion window simulator

Set the initial congestion window (usually 1 segment in exercises), the initial slow-start threshold, the number of rounds, and the rounds at whose end a loss is detected, for example "12 dup, 19 timeout". A round is one round trip, in which the sender transmits a full window. The chart shades slow start, the table lists cwnd, ssthresh and the segment numbers sent in every round, and you can ask which round sends a given segment.

• Switch between Tahoe and Reno to see the difference a triple duplicate ACK makes.
• Hover a row of the table for the reason the window changed.
• "Copy answer" gives the table and the phase intervals as text; "Copy link" saves the exercise.

A TCP sender may have at most the smaller of two windows unacknowledged: the receiver's advertised window, which protects the receiver, and the congestion window (cwnd), which protects the network. The sender has no direct signal of how much the path can carry, so it probes: it raises cwnd while data gets through and cuts it when a loss suggests a queue somewhere has overflowed.

The rule at the heart of it is additive increase, multiplicative decrease (AIMD): grow by a constant amount per round trip, halve on loss. Chiu and Jain showed in 1989 that this combination drives flows sharing a link towards a fair and efficient share.

In slow start, cwnd increases by one segment for every segment acknowledged, so it doubles each round trip: 1, 2, 4, 8 and so on. Despite the name this is fast, exponential growth, and it ends when cwnd reaches the slow-start threshold (ssthresh). From there, congestion avoidance adds about one segment per round trip. The threshold remembers roughly where trouble started last time: it is set to half the window whenever a loss is detected.

A sender learns of a loss in two ways. A retransmission timeout means nothing has come back for a long time, a sign of heavy congestion. Three duplicate ACKs mean later segments are arriving while one is missing, so the network is still delivering.

• TCP Tahoe treats both the same: ssthresh = cwnd / 2, cwnd = 1, slow start again.
• TCP Reno does the same after a timeout. After three duplicate ACKs it retransmits at once (fast retransmit), sets ssthresh = cwnd / 2 and continues from there in congestion avoidance (fast recovery), instead of collapsing to one segment.

With a loss detected by duplicate ACKs every 10 rounds over 60 rounds, starting from ssthresh 32, Tahoe's window fell to 1 after each loss and it sent 659 segments; Reno's never fell below 9 and it sent 1,036.

Exercises model TCP round by round, and they simplify in different ways. Check which your course uses:

• Reaching ssthresh in slow start. If doubling would pass ssthresh, some solutions stop at ssthresh and others double past it before switching to linear growth.
• The window after three duplicate ACKs. RFC 5681's fast recovery sets cwnd to ssthresh + 3 segments while recovering and back to ssthresh afterwards; round-level exercises show either value.
• The floor on ssthresh. RFC 5681 sets ssthresh to at least two segments; small textbook examples often ignore it.
• Which round the loss is in. Here a loss "in round n" is detected at the end of round n, so round n + 1 already has the new window.

Reno grows by one segment per round trip, which is far too slow on fast, long paths: refilling a large window after a halving takes thousands of round trips. CUBIC, standardised in RFC 9438 and the default in Linux and Windows, grows the window as a cubic function of the time since the last loss, W(t) = C(t − K)³ + W_max with C = 0.4, reducing it to 0.7 W_max on a loss. It returns to the previous maximum after K = ∛(W_max · 0.3 / 0.4) seconds, whatever the round trip:

In October 1986 the early Internet suffered the first of a series of congestion collapses, during which, Van Jacobson reported, throughput between Lawrence Berkeley Laboratory and UC Berkeley fell from 32 kbit/s to 40 bit/s. Jacobson and Michael Karels's 1988 paper "Congestion Avoidance and Control" introduced slow start, congestion avoidance and better retransmit timers, shipped in 4.3BSD Tahoe; fast recovery followed in 4.3BSD Reno. The algorithms were standardised as RFC 2001 in 1997 and are now RFC 5681.