ARQ, short for Automatic Repeat Request, is an error-control method used in data communications where the receiver detects errors in received data and asks the sender to retransmit anything that arrived corrupted or went missing. It’s one of the foundational techniques that makes reliable communication possible over imperfect channels, used in everything from Wi-Fi to cellular networks to the internet’s core protocols like TCP/IP.
How ARQ Works
The basic idea behind ARQ is straightforward. A sender transmits a chunk of data (called a frame or packet) to a receiver. Before sending, the sender attaches a small piece of error-checking information, typically generated using a method called a cyclic redundancy check (CRC). The receiver performs the same mathematical check on the data it receives. If the numbers match, the data arrived intact. If they don’t, something went wrong during transmission.
When the receiver confirms a packet arrived correctly, it sends back a positive acknowledgment (ACK). When it detects an error, or when no response comes back within a set time period (a timeout), the sender retransmits that packet. This loop of send, check, acknowledge, and potentially resend continues until every packet is successfully delivered. Sequence numbers attached to each packet let both sides keep track of which specific packets have been received and which still need retransmission.
The Three Main Types of ARQ
There are three primary ARQ protocols, each handling retransmission differently. They represent a trade-off between simplicity and efficiency.
Stop-and-Wait
This is the simplest approach. The sender transmits one packet, then waits for an acknowledgment before sending the next one. If the acknowledgment doesn’t arrive within the timeout window, the sender retransmits. It’s easy to implement but inefficient when the round-trip time between sender and receiver is large compared to how long it takes to transmit a single packet. The sender spends most of its time sitting idle, waiting for confirmation, rather than pushing data through the channel.
Go-Back-N
Go-Back-N improves on stop-and-wait by letting the sender transmit multiple packets in a row without waiting for individual acknowledgments. The sender maintains a “window” of up to N packets that can be in flight at once. The receiver, however, only accepts packets in strict sequential order. If packet 5 out of a batch of 10 arrives with an error, the receiver discards packets 6 through 10, even if they arrived perfectly. When the sender’s timer expires, it “goes back” to the first unacknowledged packet and resends everything from that point forward.
This is more efficient than stop-and-wait because the channel stays busy, but it wastes bandwidth when errors occur. Every packet sent after the corrupted one gets thrown away and retransmitted regardless of whether those packets were fine. The window size is also constrained by the sequence number field: with n bits available for sequence numbers, the maximum window size is 2^n minus 1.
Selective Repeat
Selective Repeat is the most efficient of the three. Like Go-Back-N, the sender can have multiple packets in flight. The key difference is that the receiver accepts and buffers out-of-order packets that arrive correctly, rather than discarding them. When an error is detected, the receiver sends a negative acknowledgment (NAK) for just that specific packet. The sender then retransmits only the corrupted packet and continues sending new ones.
This avoids the wasted retransmissions of Go-Back-N, but it comes at a cost: the receiver needs more memory to buffer out-of-order packets, more sequence number bits are required, and the implementation is more complex. The receiver must also reorder packets before passing them up to the application, since they may arrive out of sequence.
Efficiency and Window Size
The efficiency of any ARQ protocol depends heavily on two factors: the error rate of the channel and the relationship between the transmission time and the round-trip time. The round-trip time includes the time to transmit the packet, the propagation delay in both directions, processing time, and the time for the acknowledgment to travel back.
For stop-and-wait, the channel sits idle during the entire round trip after each packet. If the round-trip time is 10 times longer than the packet transmission time, the channel is only being used about 10% of the time, even with no errors at all. Sliding window protocols like Go-Back-N and Selective Repeat solve this by keeping the pipe full. The window size needs to be large enough to cover the bandwidth-delay product, which is essentially the number of packets that fit “in the pipe” between sender and receiver at any given moment. If the window is too small, the sender still ends up waiting.
For Go-Back-N with a sufficiently large window, the channel efficiency works out to (1 minus the packet error rate) divided by (1 plus the number of in-flight packets times the error rate). As error rates climb, Go-Back-N’s efficiency drops sharply because each error triggers a burst of retransmissions. Selective Repeat handles high-error environments better since only the damaged packets need resending.
Hybrid ARQ in Modern Networks
Standard ARQ throws away a failed packet entirely and starts fresh with each retransmission. Hybrid ARQ, or HARQ, takes a smarter approach: it saves the information from failed transmission attempts and combines it with subsequent retransmissions to improve the chances of successful decoding. This is the dominant method in modern cellular networks, including 4G LTE and 5G.
The most common form, called HARQ with Incremental Redundancy, works by initially sending data encoded with a lightweight error-correction code. If decoding fails, the sender transmits additional redundancy information rather than a complete copy. The receiver combines all received versions to reconstruct the original data. This is more bandwidth-efficient than pure ARQ because each retransmission adds new useful information rather than repeating the same bits. In practice, the system generates a set number of “redundancy versions” that are sent one after another until decoding succeeds or the attempts are exhausted.
Where ARQ Is Used
ARQ operates at multiple layers of networking. At the data link layer, protocols like IEEE 802.11 (Wi-Fi) use ARQ to ensure frames are delivered reliably over wireless connections, where interference and signal fading make errors common. At the transport layer, TCP uses a variant of ARQ with sequence numbers, acknowledgments, and timeouts to guarantee reliable delivery of data across the internet, even though the underlying network (IP) offers no such guarantees on its own.
The protocol’s flexibility is part of why it’s so widespread. Simple devices with limited memory can implement stop-and-wait. High-throughput systems can use Selective Repeat or Hybrid ARQ to maximize channel usage. The core principle remains the same across all of them: detect errors, request retransmission, and don’t move forward until the data is right.