Sliding Window Protocol (Go-Back-N) — A Comprehensive Explanation

Sliding window protocols are a family of data link / transport mechanisms that allow a sender to keep multiple frames “in flight” without waiting for an acknowledgment (ACK) for every single frame. Sliding window protocol works by maintaining a sending window (what frames may be sent) and a receiving window (what frames are allowed to be accepted). In Go-Back-N (GBN) ARQ, if an error is detected (e.g., via CRC or timeout), the receiver generally uses cumulative ACKs and the sender retransmits from the last unacknowledged frame, not only the lost one. Go-Back-N ARQ.

Key intuition:

• The sender can transmit up to $N$ frames without being “forbidden” by the window limit.
• ACKs are cumulative: receiving frame $k$ implies all frames $\le k$ were received correctly.
• When a frame error occurs, the receiver discards later frames, and the sender “goes back” to resend everything from the missing frame.

Core components you must know

1. Sequence number: lets receiver order frames and detect duplicates/loss.
2. Cumulative ACK: receiver ACKs the highest in-order frame.
3. Retransmission (timeout/error): in GBN, sender retransmits from the missing frame.
4. Window size W: bounds pipeline depth and determines efficiency.

GBN requires the sender to keep a buffer of transmitted frames (at least from the oldest unacknowledged one) until they are cumulatively ACKed.

The GBN sliding window: what each side does

Sender (GBN):

• Maintains a sending window of size $W$.
• Sends frames with sequence numbers within the window.
• Starts/uses a timer for the oldest unacknowledged frame.
• On timeout, retransmits all frames starting from the oldest unacknowledged frame (“go back N”).
• Advances the window when cumulative ACKs arrive.

Receiver (GBN):

• Expects frames in order.
• If frame $i$ is correct and equals the next expected sequence number, deliver it to the upper layer and ACK cumulatively (ACK for $i$).
• If frame $i$ is corrupt or not the expected one, discard it and ACK the last correctly received in-order frame (ACK for $i-1$).
  This is why the sender must retransmit from the missing frame: receiver will not “buffer ahead” for later frames in basic GBN.

Concrete timeline example (with sequence numbers)

Assume:

• Window size $W=4$
• Sender has frames with sequence numbers $0,1,2,3,4,5,\dots$
• Receiver expects in-order frames starting at $0$

Example event

1. Sender transmits frames $0,1,2,3$.
2. Frame $1$ arrives corrupted.
3. Receiver discards frame $1$ and also discards $2,3$ if they arrive out of order (basic GBN).
4. Receiver sends cumulative ACK for the last good in-order frame: ACK for $0$.
5. Sender sees that ACK does not advance beyond frame $0$ and/or a timeout occurs.
6. Sender retransmits starting from frame $1$: frames $1,2,3$ (and possibly more within window constraints).

This captures the distinctive property of GBN: after a loss/error at frame $i$, the sender retransmits from $i$ onward, potentially wasting bandwidth.

[Warning]{type="warning", title="Efficiency cost in GBN", content="GBN can retransmit frames that were received correctly but discarded at the receiver due to an earlier error. This increases overhead under high error rates."}

Choosing window size: performance intuition

Let:

• $W$ = sender window size (max outstanding frames)
• Larger $W$ increases the pipeline, potentially improving throughput when errors are rare.
• But with higher error probability, GBN wastes more transmissions because errors cause retransmission of multiple frames.

A simplified qualitative throughput tradeoff often used in networking courses is:

• More pipelining (larger $W$) helps in low-loss conditions.
• Higher loss/error rates reduce effective throughput because retransmissions (from the missing frame) consume bandwidth.

[CalloutBlock]{type="tip", title="Exam-ready takeaway", content="To explain GBN: emphasize cumulative ACKs + receiver discards out-of-order frames + sender retransmits from the oldest unacknowledged frame after timeout/error."}