TCP flow control (rwnd), sequence wrap-around time & window scaling

1. In the 20-byte TCP header, how many bits wide is the Window Size field, and what is the largest integer it can represent directly?
   Stuck? Peek at 4.3.2 TCP 3-way handshake, connection termination & state machine

   • 3-way handshake: SYN(seq=x) → SYN+ACK(seq=y, ack=x+1) → ACK(seq=x+1, ack=y+1).
   • Seq consumption: SYN = +1, FIN = +1, Pure ACK = 0, Data(L) = +L (full connection advances by D + 2).
   • Teardown states: Active closer goes FIN-WAIT-1 → FIN-WAIT-2 → TIME-WAIT (2·MSL) → CLOSED; Passive closer goes CLOSE-WAIT (half-close) → LAST-ACK → CLOSED.

   Read lesson 4.3.2

2. How many distinct byte sequence numbers exist in TCP’s 32-bit Sequence Number field?
   Stuck? Peek at 4.2.2 Sliding window protocols, pipelining & k-bit sequence numbers

   • Sliding-window utilisation: η = min(1, N / (1 + 2a)); full utilisation at N = ⌈1 + 2a⌉.
   • k-bit sequence space: 0 .. 2ᵏ − 1 (2ᵏ numbers); universal bound: Ws + Wr ≤ 2ᵏ.

   Read lesson 4.2.2

3. What is the Bandwidth-Delay Product (in bytes) of a 1 Gbps link with RTT = 100 ms?
   Stuck? Peek at 1.3.3 RTT, bandwidth-delay product, utilisation and a = Tp/Tt

   • RTT = 2·T_p for tiny signals (add T_t / queuing if stated).
   • BDP = B × T_p bits in flight; B × RTT before any reply.
   • a = T_p / T_t.
   • Send-and-wait: U = T_t/(T_t + 2T_p) = 1/(1 + 2a); throughput = U·B.
   • To keep the link busy: about 1 + 2a units in flight.

   Read lesson 1.3.3

What happens if a fast server sends data at 1 Gbps to a smartphone whose application reads data slowly from its receive buffer? Without feedback, the smartphone's memory buffer would overflow in milliseconds!

TCP Flow Control solves this: in every ACK segment, the receiver advertises its current free buffer space in the 16-bit Receive Window (rwnd) field. In this lesson we also solve two famous GATE numericals: how fast do 32-bit sequence numbers wrap around, and how does Window Scaling break past the 64 KB limit?

Suppose the receiver's buffer fills up completely, so it sends an ACK with rwnd = 0 (stopping the sender). Later, the receiving app reads data and the receiver sends a pure ACK with rwnd = 4000 — but remember from 4.3.2 that pure ACKs are not acknowledged, and suppose that rwnd = 4000 ACK is lost on the link! Why don't both sides wait for each other forever in a permanent deadlock?

Because when a TCP sender receives rwnd = 0, it starts a Persist Timer! Whenever the persist timer expires, the sender transmits a tiny 1-byte Zero-Window Probe segment, forcing the receiver to reply with an ACK carrying its current rwnd!

Receiver Buffer & the Advertised Window (rwnd)

Suppose the receiver allocates a receive buffer of size RcvBuffer bytes. At any instant, some bytes have arrived from the network and are sitting in the buffer waiting for the receiving application to read them:

Zero Window & Persist Timer: When rwnd = 0, the sender stops normal transmission and runs a Persist Timer, periodically sending a 1-byte Zero-Window Probe so a lost non-zero window update never causes deadlock.

32-Bit Sequence Number Wrap-Around Time

Because the TCP Sequence Number field is 32 bits, there are 2³² = 4,294,967,296 bytes before sequence numbers wrap back to 0. If a sender transmits continuously at data rate B bits/second (which is B / 8 bytes/second):

To prevent an old delayed segment from colliding with a new segment of the same sequence number after wrap-around, T_wrap must be strictly greater than the Maximum Segment Lifetime (MSL) (or TCP must add the 32-bit PAWS — Protection Against Wrapped Sequence numbers — timestamp option on multi-Gbps links).

The 64 KB Window Limit & TCP Window Scaling Option

The TCP header's Window Size field is only 16 bits, so the largest window it can advertise directly is 2¹⁶ − 1 = 65,535 bytes (≈ 64 KB). On a 1 Gbps link with RTT = 100 ms, the Bandwidth-Delay Product is 12.5 MB — a 64 KB window would cap link utilisation at 64 KB / 12.5 MB ≈ 0.5%!

Putting it together

• TCP flow control protects the receiver’s buffer by advertising free space rwnd in every ACK; a Persist Timer prevents deadlock when rwnd = 0.
• The 32-bit byte sequence number wraps around in (2³² × 8) / B seconds (34.36 s at 1 Gbps).
• The Window Scale option shifts the 16-bit window field left by up to 14 bits (× 2ˢ), expanding max rwnd from 64 KB to ~1 GiB.

• Bytes vs Bits in Wrap-Around Time! Each TCP sequence number counts 1 byte = 8 bits, so the total bits in one cycle is 2³² × 8 = 2³⁵ bits (students who forget the × 8 get 4.29 seconds instead of 34.36 seconds!).
• Window Scale option can ONLY be sent in SYN segments! The scale shift S is fixed during the 3-way handshake and cannot be changed mid-connection.

T_wrap = 2³² × 8 / B (34.36 s at 1 Gbps); rwnd = free buffer; Persist Timer pokes a Zero Window!

We now know how TCP numbers bytes, sets up connections, and controls flow with rwnd. Next question (4.3.4): How does a TCP sender know how many milliseconds to set its retransmission timeout (RTO) timer for when internet round-trip times fluctuate wildly?

1. NAT

   A TCP connection transfers data continuously at a rate of 2 Gbps (2 × 10⁹ bits/sec). How many seconds (rounded to 2 decimal places) does it take for the 32-bit TCP sequence number space to wrap around?

   Write your answer before opening the key.

2. NAT

   A TCP receiver has a total receive buffer of 64,000 bytes. Currently 14,000 bytes of unread data are sitting in the buffer. If the connection uses NO window scaling (S = 0), what value does the receiver place in the 16-bit Window Size field of its next ACK?

   Write your answer before opening the key.

3. MCQ

   What is the purpose of the TCP Persist Timer?

   1. To measure the round-trip time of every segment.
   2. To close a connection after 2 × MSL in the TIME-WAIT state.
   3. To periodically send a 1-byte Zero-Window Probe when the receiver has advertised rwnd = 0, preventing deadlock if a subsequent non-zero window update ACK is lost.
   4. To double the transmission rate every RTT.
4. NAT

   During the 3-way handshake, a TCP receiver advertises a Window Scale shift count of S = 3. Later, it sends an ACK with the 16-bit Window Size field set to 10,000. What is the actual receive window size (rwnd) in bytes?

   Write your answer before opening the key.

• Flow control: rwnd = RcvBuffer − (LastByteRcvd − LastByteRead); sender keeps BytesInFlight ≤ rwnd.
• Zero window (`rwnd = 0`): sender runs Persist Timer and sends 1-byte Zero-Window Probes.
• Wrap-around time: T_wrap = (2³² × 8) / B seconds (34.36 s at 1 Gbps).
• Window scaling: True rwnd = HeaderWindow × 2ˢ (S ≤ 14, negotiated in SYN).

• rwnd (advertised receive window)
• TCP flow control
• zero window
• persist timer and zero-window probe
• wrap-around time = 2³²·8 / B
• window scaling (shift ≤ 14)

1. Formula for TCP 32-bit sequence number wrap-around time at link rate B bits/sec?
   Reveal answer

   T_wrap = (2³² × 8) / B seconds (≈ 34.36 seconds at 1 Gbps).
2. What does a TCP sender do when it receives rwnd = 0?
   Reveal answer

   It pauses normal data transmission and starts the Persist Timer, sending 1-byte Zero-Window Probes when the timer expires.
3. If the TCP Window Size field is W and the Window Scale option shift is S, what is the true rwnd?
   Reveal answer

   W × 2ˢ bytes (where S ≤ 14 is negotiated in the SYN handshake).

• 1 Gbps Wrap-Around Benchmark: Memorise T_wrap(1 Gbps) = 34.36 s! Then for any rate X Gbps, just divide: T_wrap = 34.36 / X seconds (and for Y Mbps, 34,360 / Y seconds)! — solving any GATE wrap-around time question in 5 seconds without computing 2³⁵.
• Max Flow-Control Throughput: Throughput_max = min(B, (rwnd in bits) / RTT). — questions giving rwnd and RTT and asking for throughput.