Transport Layer Protocol Practice Questions

In Congestion Avoidance (cwnd ≥ ssthresh), cwnd increases by 1 MSS per RTT - linear (additive) growth. Implementation: for each ACK received, cwnd += MSS × (MSS/cwnd). Since approximately cwnd/MSS ACKs arrive per RTT, total increase per RTT = (cwnd/MSS) × (MSS²/cwnd) = MSS - one MSS per RTT. This linear growth implements the AIMD (Additive Increase, Multiplicative Decrease) strategy: cautiously probe for more bandwidth after the slow start phase.

Nagle's algorithm addresses the inefficiency of sending many small packets (e.g., 1-byte payloads with 40-byte headers) when the application generates data slowly. It coalesces small outgoing messages until an ACK is received or a full segment is ready. Silly Window Syndrome at the receiver is solved by Clark's solution.

When rwnd = 0, the sender must stop transmitting. However, if the receiver later frees buffer space and sends an updated window advertisement (rwnd > 0) that gets lost, the sender would block forever waiting. TCP prevents this deadlock using window probing: when rwnd = 0, the sender starts a persist timer. When it fires, the sender sends a 1-byte probe segment. The receiver acknowledges this probe with its current rwnd value - if rwnd > 0, the sender can resume. This probing continues until the window opens, preventing permanent deadlock.

Transmission time T = frame size / bandwidth = 1000 bits / 1,000,000 bps = 1 ms. Propagation delay D = 270 ms. a = D/T = 270/1 = 270. Minimum window size for 100% utilization: W ≥ 1 + 2a = 1 + 2×270 = 541. With W = 541 frames, the sender can transmit continuously while waiting for the first ACK to return (round trip = 2D = 540 ms = 540 frames worth of data). Minimum window size = 541.

For a sliding window protocol: let a = propagation delay / transmission time = D/T. Without windowing (stop-and-wait): Utilization = 1/(1+2a). With window size W: Utilization = W/(1+2a) if W < 1+2a (window too small to fill the pipe), or Utilization = 1 if W ≥ 1+2a (window large enough). Equivalently: Utilization = min(1, W×T/(T+2D)) = min(1, WT/(T+2D)). Options A and D express equivalent forms. The minimum window size to achieve full utilization: W ≥ 1 + 2a = (T + 2D)/T.

Stop-and-wait flow control sends one frame and waits for acknowledgment before sending the next. Though simple, it is inefficient for high bandwidth-delay product networks.

The TIME_WAIT state (typically $2 \times MSL$ duration) ensures that any delayed or duplicate segments from the previous connection incarnation do not appear in a new connection that might reuse the same socket pair (source IP, source port, destination IP, destination port). It also handles the case where the final ACK is lost, as the passive closer will retransmit FIN segments.

For Go-Back-N, the maximum sender window size is $2^n - 1$ where $n$ is the number of bits in the sequence number. If the window were $2^n$, the sender could send packets with sequence numbers wrapping around completely, making it impossible for the receiver to distinguish between new transmissions and retransmissions. For Selective Repeat, the limit is $2^{n-1}$.

SR window size is limited to 2^(n-1) to prevent ambiguity. Consider n=2 bits (sequence numbers 0,1,2,3) with W=3: sender sends frames 0,1,2. Receiver ACKs all three. Sender slides window to send 3,0,1. If all ACKs are lost, the receiver is now expecting frames 3,0,1 but could receive retransmissions of old frames 0,1,2 - it cannot distinguish old frame 0 from new frame 0. With W ≤ 2^(n-1) = 2: sender window (0,1) and receiver window (2,3) never overlap in sequence space, preventing ambiguity. GBN allows W ≤ 2^n - 1 because the receiver doesn't buffer out-of-order frames.

For Go-Back-N, the sender window size must be at most $2^n - 1$ to correctly distinguish new frames from retransmitted ones. Selective Repeat requires the window $\leq 2^{n-1}$.

AIMD stands for Additive Increase, Multiplicative Decrease. Additive Increase: during Congestion Avoidance, cwnd grows by +1 MSS per RTT (linear/additive growth). Multiplicative Decrease: upon detecting congestion (packet loss), cwnd is multiplied by a factor less than 1 - in TCP Reno, cwnd is halved (multiplied by 0.5) on three duplicate ACKs, or reset to 1 MSS on timeout. AIMD is proven to converge to fair sharing of network bandwidth among competing flows and to operate near full link utilization.

UDP total length field includes the $8$-byte UDP header plus the payload. Therefore, application data = total length - header size = $10000 - 8 = 9992$ bytes.

Flow control is an end-to-end mechanism between sender and receiver: the receiver advertises its available buffer space (receive window, rwnd) in TCP headers, and the sender limits its unacknowledged data to rwnd. This prevents buffer overflow at the receiver. Congestion control is a network-aware mechanism: the sender limits its sending rate based on perceived network congestion (packet loss, delay) to prevent overwhelming routers/links in the network path. TCP combines both: the sender's effective window = min(rwnd, cwnd) where cwnd is the congestion window.

Fast Retransmit: when the receiver gets an out-of-order segment, it immediately sends a duplicate ACK for the last in-order byte received. If the sender receives 3 duplicate ACKs for the same sequence number, it infers that the next expected segment was lost (rather than just delayed). The sender immediately retransmits that segment without waiting for the retransmission timer to expire (which could take seconds). Fast Retransmit reduces recovery time compared to waiting for timeout, and is followed by Fast Recovery (in TCP Reno) rather than Slow Start.

UDP has no connection setup (connectionless), its header is fixed at $8$ bytes, and it supports multiplexing/demultiplexing allowing multiple applications to communicate. UDP does NOT guarantee in-order delivery or even delivery at all-that is a TCP characteristic.

During Slow Start, TCP increases cwnd by $1$ MSS for every ACK received. Since one RTT typically elicits ACKs for all segments sent in that window, the cwnd approximately doubles every RTT, resulting in exponential growth. Linear increase ($1$ MSS per RTT) occurs during Congestion Avoidance.

AIMD fairness proof using the efficiency-fairness plane: consider two flows with throughputs x₁ and x₂. The equal bandwidth line is x₁=x₂ and the full utilization line is x₁+x₂=capacity. Additive Increase: both flows move in direction (+1,+1) - parallel to equal bandwidth line, moving toward full utilization. Multiplicative Decrease: both flows scale by 0.5 - move toward origin along the line from origin through current point. The combination of these moves drives the operating point toward the intersection of equal bandwidth and full utilization lines, achieving both fairness and efficiency.