Sliding Window Protocol at the Data Link Layer: How Reliable Frame Delivery Works

At the data link layer, a sliding window protocol is an ARQ technique that enables pipelined transmission of multiple frames while still providing reliable delivery despite loss/corruption. The sender transmits up to a bounded number of frames that are not yet acknowledged (the “sender window”), and the receiver acknowledges received frames to allow the sender to advance the window. This increases utilization when the round-trip time is large compared to transmission time, compared with stop-and-wait.

A common family of sliding window ARQ protocols includes:

• Go-Back-N (GBN)
• Selective Repeat (SR)

Both require sequence numbers in frame headers and timeouts for retransmission.

Core concepts: windowing, sequence numbers, and reliable delivery

Sliding window protocols generalize stop-and-wait by allowing multiple frames “in flight” before acknowledgments return. The number of unacknowledged frames the sender may have outstanding is its maximum sender window size; similarly, the receiver may have a receiver window size depending on the variant.

1) Sequence numbers prevent duplicates and enable ordering

The sender tags each frame with a consecutive sequence number so the receiver can detect missing frames and (in SR) buffer out-of-order frames. With sliding windows, more than 1-bit sequence numbers may be needed because multiple frames can be outstanding concurrently.

2) ACK behavior is protocol-dependent

• In GBN, the receiver primarily supports in-order delivery (receiver effectively behaves like size 1) and uses cumulative acknowledgments; a single loss triggers retransmission of multiple frames. 2
• In SR, the receiver can accept out-of-order frames within its window, buffer them, and acknowledge frames individually; only lost/corrupt frames are retransmitted. 2

3) Timeouts and retransmission complete reliability

Like stop-and-wait, sliding window ARQ uses timeout mechanisms; if acknowledgments don’t arrive, the sender retransmits according to the protocol’s rules. 2

Step-by-step: how a sliding window protocol works at the data link layer

A sliding window protocol can be understood as a loop with five interacting components:

1. Sender window (bounded pipelining)
2. Receiver window (accept/buffer policy)
3. ACK generation (cumulative vs individual)
4. Sender timers (retransmission triggers)
5. Window advancement (base moves forward as ACKs arrive)

General workflow (works for both GBN and SR)

Sliding window protocol operation:

• Sender:

  • Maintains a window of sequence numbers for frames that can be sent but not yet acknowledged.
  • Sends frames whose sequence numbers fall within the window.
  • Starts/restarts timers for unacknowledged frames.
  • Advances the send window base when ACKs arrive.

• Receiver:

  • Maintains the next expected sequence number (plus buffering capacity in SR).
  • Checks integrity (e.g., checksum) and sequence number validity.
  • Sends ACKs per its variant rules.

These ideas are consistent with standard sliding window ARQ explanations used in reliable data transfer discussions.

Go-Back-N (GBN) sliding window at the data link layer

In Go-Back-N, the sender can transmit up to $N$ frames without waiting for each one’s ACK, but the receiver behaves like it expects frames in order (receiver window size effectively $1$).

GBN receiver rule (in-order only)

• If the receiver gets the expected frame correctly, it sends an ACK for that frame (and typically implies earlier frames were received correctly).
• If a frame is lost/corrupt, the receiver discards subsequent out-of-order frames (since the protocol is effectively in-order) and keeps/returns ACK information that allows the sender to retransmit from the missing point. 2

GBN retransmission rule (cumulative trigger)

When the sender detects that the ACK didn’t arrive (via timeout or NACK/implicit negative response), it retransmits the missing frame and all frames that followed it within the window, which is why GBN is “go back $N$.” 2

Selective Repeat (SR) sliding window at the data link layer

In Selective Repeat, the sender still transmits multiple frames within its window, but the receiver can accept out-of-order frames and buffer them. Each correctly received frame is acknowledged individually. 2

SR receiver rule (buffer + independent ACK)

• If a frame is received correctly and its sequence number lies within the receiver window, the receiver buffers it (if out-of-order).
• The receiver sends an ACK specific to that sequence number.
• Delivery to the upper layer occurs in-order by using a “receive base” pointer and releasing buffered frames once the missing earlier frames arrive. 2

SR retransmission rule (only what’s missing)

When a timeout occurs for a particular frame $n$ (whose ACK hasn’t been received), the sender retransmits only that frame, not the entire tail of the window. 2

Why sliding window improves efficiency (and when it doesn’t)

The efficiency improvement comes from pipelining: the sender can keep transmitting while waiting for ACKs. Standard descriptions of sliding window ARQ emphasize that this avoids idle time when round-trip time is large relative to packet transmission time.

However, retransmission overhead depends on the error pattern:

• GBN can retransmit many frames after a single loss because it sends the “rest of the window” again. 2
• SR reduces wasted retransmissions by retransmitting only the missing/corrupt frames, but it requires more receiver buffering and more complex sequence/ACK management. 2