Fact-checked by Grok 2 weeks ago

Automatic repeat request

Automatic repeat request (ARQ) is an error-control method employed in data transmission protocols to ensure reliable delivery over unreliable or noisy channels by automatically detecting errors or losses in transmitted packets and requesting their retransmission from the sender.^[1] This technique operates at the link layer, using acknowledgments (ACKs) from the receiver to confirm successful receipt and negative acknowledgments (NAKs) or timeouts to trigger retransmissions, thereby minimizing data loss without requiring end-to-end intervention.^[2] ARQ is fundamental to link-layer standards such as High-Level Data Link Control (HDLC), while similar mechanisms are integral to transport-layer protocols like Transmission Control Protocol (TCP) for enhancing reliability in error-prone environments.^[1] The core mechanism of ARQ involves breaking data into smaller frames or packets, appending error-detection codes such as cyclic redundancy checks (CRC), and utilizing a feedback channel for the receiver to inform the sender of the transmission status.^[2] Upon detecting an error via integrity checks, the receiver discards the faulty packet and signals for retransmission, which the sender performs from its buffer until an acknowledgment is received or a maximum retry limit is reached.^[3] This process provides higher reliability than forward error correction (FEC) alone, especially in scenarios with variable error rates, though it introduces latency due to the round-trip time for feedback.^[1] ARQ protocols are categorized into types such as stop-and-wait, go-back-N, and selective repeat, based on retransmission strategies that balance efficiency and complexity.^[2]^[3] These schemes have been surveyed and refined since the early 1970s, influencing link-layer designs in IEEE 802 standards and IETF recommendations.^[3]

Fundamentals

Definition and Purpose

Automatic repeat request (ARQ) is an error-control method used in data communication protocols to ensure the reliable transmission of information over potentially unreliable channels. In this protocol, the sender transmits data packets, and the receiver inspects them for errors using detection mechanisms; if an error is detected, the receiver notifies the sender via feedback to request retransmission of the affected packet.^[4] This automatic process distinguishes ARQ from simpler discard-based error handling, as it actively recovers lost or corrupted data without manual intervention.^[2] The primary purpose of ARQ is to provide reliable data delivery in environments prone to transmission errors, such as wireless or noisy links, by combining error detection with selective retransmission. By leveraging feedback, ARQ corrects errors on-demand, minimizing the impact of channel imperfections while adapting to varying error rates.^[5] This approach enhances overall system efficiency compared to uncorrected transmission, where errors could propagate and degrade higher-layer performance.^[4] Key components of an ARQ system include the sender, which originates and retransmits packets; the receiver, which verifies integrity and generates feedback; the forward channel for data flow; and the reverse channel for acknowledgments (ACKs) confirming successful receipt or negative acknowledgments (NAKs) indicating errors. The basic operation follows a sequential cycle: the sender transmits a packet, the receiver performs error detection and responds with ACK or NAK, and the sender retransmits only if necessary, continuing until acknowledgment is received or a retry limit is exceeded.^[2] This feedback-driven loop ensures error recovery without assuming a perfect channel.^[4] In contrast to forward error correction (FEC), which embeds redundant information in the initial transmission to enable receiver-side error repair without feedback, ARQ depends on retransmissions triggered by receiver notifications and avoids upfront bandwidth overhead for redundancy.^[4] ARQ principles are employed in protocols like TCP within the TCP/IP suite to maintain end-to-end reliability.^[4]

Historical Development

The roots of automatic repeat request (ARQ) protocols trace back to the mid-20th century, emerging from efforts to ensure reliable data transmission amid noise and errors in early electronic communication systems. Initial concepts drew from telegraphy practices, where manual retransmissions addressed garbled messages, evolving into automated mechanisms in the 1940s and 1950s as computing advanced. Claude Shannon's seminal 1948 work on information theory provided the theoretical foundation, demonstrating that error-free communication over noisy channels was possible through redundancy and feedback principles, which later influenced practical ARQ implementations for robust data delivery.^[6] In the 1960s, ARQ mechanisms gained formalization during the development of early packet-switching networks, particularly through U.S. Department of Defense-funded projects. Paul Baran's 1964 RAND Corporation reports on distributed communications networks introduced packet switching with built-in error detection and retransmission strategies to maintain reliability in potentially disrupted environments, laying groundwork for ARQ in decentralized systems. Stop-and-wait ARQ variants appeared in initial ARPANET designs around 1968-1969, where senders awaited acknowledgments before proceeding, addressing the challenges of variable delays in nascent packet networks.^[7] The 1970s and 1980s marked significant advancements in ARQ protocols, integrating them into standardized communication frameworks. Vint Cerf and Robert Kahn's 1974 proposal for the Transmission Control Protocol (TCP) incorporated ARQ through sequence numbering, acknowledgments, and timeouts for retransmission, enabling reliable end-to-end data transfer across heterogeneous networks. The International Telecommunication Union (ITU-T) standardized X.25 in 1976, employing ARQ-based error recovery in its Link Access Procedure (LAP) for packet-switched wide-area networks. By 1979, High-Level Data Link Control (HDLC), ratified by the International Organization for Standardization (ISO), formalized go-back-N and selective repeat ARQ options, enhancing efficiency in synchronous data links.^[8]^[9]^[10] ARQ's evolution continued into modern wireless standards, adapting to higher mobility and interference. The IEEE 802.11 standard for wireless local area networks, released in 1997, incorporated ARQ at the medium access control (MAC) layer to handle frame errors via acknowledgments and retransmissions, supporting reliable Wi-Fi connectivity. In cellular communications, the 3rd Generation Partnership Project (3GPP) introduced hybrid ARQ (HARQ) in Long-Term Evolution (LTE) specifications finalized in 2008, combining forward error correction with retransmissions for improved throughput in broadband mobile networks.^[11]^[12]

Protocol Types

Stop-and-Wait ARQ

Stop-and-Wait ARQ is the most basic automatic repeat request protocol, in which the sender transmits a single data frame or packet and then halts transmission until it receives a positive acknowledgment (ACK) from the receiver confirming successful receipt, or a negative acknowledgment (NAK) indicating an error. If neither is received within a predefined timeout period—typically set to account for propagation delays and processing—the sender assumes the frame was lost or corrupted and retransmits it. This mechanism ensures reliable delivery over potentially erroneous channels by combining error detection with selective retransmission of only the problematic frame.^[1] The operational sequence begins with the sender encapsulating data into a frame, appending error-detection information such as a checksum, and transmitting it over the channel while simultaneously starting a retransmission timer. Upon receipt, the receiver verifies the frame's integrity; if valid, it discards any duplicates using sequence numbers (typically 0 or 1) and sends an ACK back to the sender. If invalid or if no frame arrives within an expected window, the receiver sends a NAK or simply times out, prompting the sender to retransmit upon timer expiration or NAK arrival. This stop-and-wait cycle repeats for each frame, maintaining strict sequencing and flow control without buffering multiple outstanding frames.^[1]^[13] A primary advantage of Stop-and-Wait ARQ lies in its simplicity, requiring minimal buffering (only one frame at a time) and low computational overhead, which makes it suitable for resource-constrained devices and channels with low bit error rates where retransmissions are infrequent. It is particularly effective in half-duplex environments, as the forward data path and reverse acknowledgment path can operate alternately without complex synchronization.^[1]^[13] However, the protocol suffers from significant inefficiencies on high-bandwidth or high-latency links, as the sender remains idle during the round-trip time for acknowledgments, leading to underutilization of the channel and increased end-to-end delay—especially pronounced in scenarios like satellite communications where propagation delays are substantial.^[1]^[13] The throughput of Stop-and-Wait ARQ, which measures the effective data rate as a fraction of the channel capacity, is derived considering both propagation delays and error probabilities. In an error-free scenario, the time to successfully transmit one frame includes the frame transmission time t_f plus the round-trip propagation time $2 t_p (from sender to receiver and back for the ACK). Thus, the efficiency \eta is the ratio of useful transmission time to total cycle time:

\eta = \frac{t_f}{t_f + 2 t_p} = \frac{1}{1 + 2a}

where a = \frac{t_p}{t_f} is the normalized propagation delay factor, representing the bandwidth-delay product impact. To incorporate errors, assume each frame has an independent error probability P_e, requiring on average \frac{1}{1 - P_e} transmissions per successful delivery (since the probability of success is $1 - P_e). The expected cycle time scales by this factor, yielding the full throughput formula:

\eta = \frac{1 - P_e}{1 + 2a}

This derivation assumes negligible ACK transmission time and processing delays, ACKs are error-free or protected separately, and errors lead to retransmission without cumulative effects. The formula highlights how errors reduce throughput linearly while delays amplify idleness, limiting applicability to low-a and low-P_e channels.^[14]^[15] An illustrative example of Stop-and-Wait ARQ in practice is its use in early modem-based file transfer protocols like XMODEM, developed in the late 1970s for bulletin board systems, where the sender would transmit fixed-size blocks (128 bytes) over dial-up telephone lines and wait for ACK/NAK before the next, ensuring reliability despite noisy analog connections.^[16]

Go-Back-N ARQ

Go-Back-N ARQ is an extension of basic ARQ protocols that employs a sliding window mechanism to improve efficiency by allowing the sender to transmit up to N unacknowledged frames before awaiting confirmation. The receiver operates with a single-frame buffer and sends cumulative acknowledgments (ACKs), each specifying the sequence number of the next expected frame in order, thereby acknowledging all prior correctly received frames. This approach enables pipelined transmission, where multiple frames are outstanding on the channel simultaneously.^[17] In operation, the sender assigns sequence numbers to frames using modulo-M arithmetic, where M is determined by the number of bits k allocated for sequencing (e.g., numbers cycling from 0 to M-1). The sender advances its window as ACKs arrive, sliding it forward to allow new transmissions. The receiver accepts only in-order frames; upon detecting an error (via checksum failure) or an out-of-sequence frame, it discards the erroneous frame and any subsequent ones, without buffering them, and continues sending ACKs for the last correctly received frame. If the sender experiences a timeout for any unacknowledged frame or receives a negative acknowledgment (NAK), it performs a "go-back" by retransmitting all frames from the point of the lost or errored frame onward, resetting the window accordingly.^[18] To prevent ambiguity in distinguishing new frames from retransmissions, the maximum window size is constrained by the sequence number space: N \leq 2^k - 1, where k is the number of bits used for sequence numbers. For instance, with 3-bit sequence numbers (k=3), N \leq 7, ensuring the sender does not wrap around the sequence space before resolving all potential ACKs. This limitation arises because the receiver cannot differentiate between a new frame with a repeated sequence number and a retransmission if the window exceeds half the sequence space.^[18] Go-Back-N ARQ offers improved efficiency over stop-and-wait protocols on channels with high bandwidth-delay products, as it minimizes idle time by keeping the link utilized with multiple in-flight frames, achieving throughput closer to the channel capacity under low error rates. However, it inefficiently retransmits correctly received frames following an error, wasting bandwidth and reducing overall performance in noisy environments where errors are frequent.^[17] An example of Go-Back-N ARQ implementation is in the High-Level Data Link Control (HDLC) protocol, standardized for bit-oriented synchronous data transmission over point-to-point links, where the sender window size defaults to 7 (for 3-bit sequence numbers) or optionally extends to 127 (for 7-bit sequence numbers) to balance efficiency and ambiguity avoidance.^[19]

Selective Repeat ARQ

Selective Repeat ARQ is a highly efficient automatic repeat request protocol that retransmits only the frames identified as erroneous, while the receiver buffers correctly received out-of-order frames to maintain sequence integrity upon delivery to higher layers. Unlike simpler ARQ variants, it employs individual acknowledgments for each frame, enabling the sender to proceed with new transmissions without halting for cumulative confirmations. This approach minimizes redundant data transfer, particularly in channels with sporadic errors.^[19] The protocol operates using a sliding window mechanism where the sender transmits up to a predefined window size of numbered frames. Upon receipt, the receiver inspects each frame: correctly received frames prompt a selective acknowledgment (SACK) specifying the frame's sequence number, while errored frames elicit a negative acknowledgment (NAK). The receiver stores valid out-of-order frames in a buffer until all preceding frames arrive, at which point it reassembles and forwards the complete sequence. The sender, upon receiving a NAK or experiencing a timeout for an unacknowledged frame, retransmits solely that frame, advancing the window as positive ACKs arrive. This selective process ensures continuous flow while isolating error recovery.^[19] To prevent ambiguity between new frames and potential duplicates from retransmissions, Selective Repeat ARQ requires a sequence number space at least twice the maximum window size. For a k-bit sequence number field, this limits the window to at most $2^{k-1} frames, ensuring the receiver can uniquely identify frames within the current window without overlap from prior cycles.^[19] The primary advantages of Selective Repeat ARQ include optimal bandwidth utilization through minimal retransmissions—only errored frames are resent—and superior performance in high-latency or error-prone environments compared to protocols that discard entire blocks. However, these benefits come with increased implementation complexity, as both sender and receiver must maintain buffers for out-of-order frames and track individual ACK/NAK states, demanding more memory and processing resources.^[19] The efficiency \eta of Selective Repeat ARQ is \eta = 1 - P_e, where P_e is the frame error rate, assuming a sufficiently large window size to cover the bandwidth-delay product and error-free acknowledgments. This formula indicates near-channel-capacity performance in low-error conditions by minimizing redundant transmissions.^[19] An practical example of Selective Repeat principles in action is the TCP protocol's Selective Acknowledgment (SACK) option, introduced in RFC 2018, which permits receivers to report multiple non-contiguous blocks of successfully received data. This allows TCP senders to retransmit only missing segments, reducing recovery time from multiple losses without invoking full window reductions.^[20]

Operational Mechanisms

Error Detection Methods

In Automatic Repeat reQuest (ARQ) protocols, error detection plays a pivotal role by identifying transmission errors in received data frames, which precedes the generation of feedback signals to initiate retransmissions.^[3] These detection methods are typically appended to the data frames as redundant check information, enabling the receiver to verify integrity without correcting errors.^[3] One common method is the checksum, a simple arithmetic technique that computes the one's complement sum of 16-bit words from the data and appends the result modulo $2^{16} to detect inconsistencies.^[21] For instance, the Internet checksum used in IPv4 headers sums all 16-bit segments and takes the one's complement of the result, providing basic protection against single-bit and some multi-bit errors in ARQ-enabled networks.^[21] Cyclic Redundancy Check (CRC) offers more robust detection through polynomial division in GF(2), particularly effective for burst errors up to the degree of the generator polynomial.^[22] The CRC-32 variant, employing a 32-bit polynomial such as x^{32} + x^{26} + x^{23} + x^{22} + x^{16} + x^{12} + x^{11} + x^{10} + x^{8} + x^{7} + x^{5} + x^{4} + x^{2} + x + 1, is a standard in protocols like Ethernet for ARQ error verification.^[23] Parity bits provide a rudimentary approach by adding a single bit to ensure an even or odd number of 1s in the data word, capable of detecting single-bit errors but ineffective against even-numbered errors or bursts.^[24] Their use in ARQ is limited due to low detection capability, often serving as a lightweight option in simple systems. Modern lightweight hash-based methods, such as the Fletcher-32 checksum, compute two running sums modulo 65535 over 16-bit blocks to produce a 32-bit value, balancing efficiency and detection strength as an alternative to CRC in resource-constrained ARQ implementations.^[25] These methods detect various error patterns, including single-bit flips, burst errors (for CRC, all bursts shorter than the polynomial degree), and random multi-bit errors, with extremely low undetected error probabilities—on the order of $2^{-n} for an n-bit check where undetected errors are negligible in practice.^[3] For CRC computation, consider a message M(x) of degree k and generator polynomial G(x) of degree n. The transmitter forms M(x) \cdot x^n, performs modulo-2 division by G(x) to obtain remainder R(x), and transmits T(x) = M(x) \cdot x^n + R(x). The receiver divides T(x) by G(x); a zero remainder confirms no errors.

\begin{align*} &\text{Transmitted frame: } T(x) = M(x) \cdot x^n + R(x) \\ &\text{Where } R(x) \text{ is the remainder of } \frac{M(x) \cdot x^n}{G(x)} \\ &\text{Receiver check: } T(x) \mod G(x) = 0 \text{ (error-free)} \end{align*}

^[26]

Acknowledgment and Retransmission Processes

In Automatic Repeat Request (ARQ) protocols, acknowledgments serve as feedback mechanisms to confirm data reception or indicate errors, enabling the sender to decide on retransmissions. Positive acknowledgments (ACKs) are sent by the receiver upon successful receipt of a data unit, signaling the sender to proceed with the next transmission. Some ARQ protocols use negative acknowledgments (NAKs) to notify the sender of detected errors in the received data, prompting retransmission of the affected unit; others rely on the absence of ACKs and timeouts. These acknowledgment types can be cumulative, where an ACK confirms all data units up to a specified sequence number, or selective, which explicitly identifies only the successfully received units while implying others need retransmission.^[3]^[27] Timing mechanisms in ARQ ensure timely retransmissions by incorporating retransmission timers based on estimated round-trip time (RTT). The timer starts upon sending a data unit and expires if no ACK arrives within the calculated interval, triggering a retransmission; this interval is often derived from smoothed RTT measurements to adapt to network variability. For handling duplicates—arising from delayed or lost ACKs—sequence numbers are assigned to data units, allowing the receiver to discard redundant transmissions and send cumulative ACKs to advance the sender's window. Exponential backoff may adjust the timer on repeated timeouts to mitigate congestion.^[3]^[28] Retransmission policies dictate the response to feedback: upon receiving a NAK, the sender immediately retransmits the erroneous unit, while timeouts lead to delayed retransmissions of unacknowledged units. In cumulative schemes, an error may prompt retransmission of the errored unit and all subsequent units in the window; selective policies limit retransmissions to only the erroneous units for efficiency. Flow control integrates with these policies through window adjustments based on ACKs, where the receiver advertises its buffer capacity to prevent overflow and regulate sender throughput.^[3]^[28] To optimize bandwidth in bidirectional links, ARQ employs piggybacking, where ACKs or NAKs are embedded in reverse-direction data packets rather than sent as standalone control messages, reducing protocol overhead without delaying feedback. This technique is particularly effective in full-duplex environments, combining reliability signaling with ongoing data exchange. ARQ mechanisms rely briefly on prior error detection outcomes to generate appropriate ACKs or NAKs.^[3] A representative example is the Transmission Control Protocol (TCP), which implements ARQ-like reliability through its three-way handshake for initial sequence number synchronization: the client sends a SYN segment with its initial sequence number, the server responds with SYN-ACK confirming the client's number and providing its own, and the client finalizes with an ACK of the server's number. Subsequent data transfers use cumulative ACKs and RTT-based timers for retransmissions, with sequence numbers handling duplicates and window scaling for flow control.^[28]

Applications and Performance

Use in Communication Protocols

Automatic Repeat Request (ARQ) is integral to the TCP/IP suite, where the Transmission Control Protocol (TCP) implements ARQ mechanisms through sequence numbers for ordering, acknowledgments (ACKs) to confirm receipt, and retransmissions for lost or corrupted segments, ensuring reliable end-to-end delivery over unreliable IP networks.^[28] This approach, specified in the foundational TCP document from 1981, operates as a go-back-N variant, retransmitting all outstanding segments upon timeout or duplicate ACKs to handle errors without higher-layer intervention.^[28] At the link layer, protocols such as High-Level Data Link Control (HDLC) employ go-back-N ARQ to manage frame retransmissions in synchronous environments, using sequence numbers and supervisory frames for error recovery in point-to-multipoint scenarios.^[29] Similarly, the Point-to-Point Protocol (PPP), which leverages HDLC-like framing for encapsulation, incorporates ARQ through its Link Control Protocol (LCP) options for negotiated error detection and optional retransmission capabilities over serial links.^[16] In wireless personal area networks, Bluetooth adopts selective repeat ARQ at the baseband layer for asynchronous connection-less (ACL) links, allowing individual packet retransmissions based on negative acknowledgments (NAKs) to optimize throughput in interference-prone short-range communications, as defined in its core specifications since the early 2000s. Wireless local area networks utilize hybrid ARQ in IEEE 802.11 (Wi-Fi) standards, combining forward error correction (FEC) in the physical layer with ARQ retransmissions at the MAC layer via block acknowledgments, enabling efficient recovery from packet losses in contention-based environments. For cellular networks, Long-Term Evolution (LTE) and 5G New Radio (NR) employ Hybrid ARQ (HARQ), which integrates ARQ with incremental redundancy FEC; upon decoding failure, receivers request retransmissions that provide additional parity bits for soft combining, significantly improving spectral efficiency in high-mobility scenarios as outlined in 3GPP technical specifications. In satellite communications, ARQ is applied alongside DVB-S2 standards to mitigate errors over long-delay links, where adaptive coding and modulation (ACM) pairs with higher-layer ARQ protocols to request retransmissions for uncorrectable frames, enhancing reliability in hybrid satellite-terrestrial systems without relying solely on FEC due to propagation delays.^[30] Emerging Internet of Things (IoT) protocols like Zigbee incorporate lightweight ARQ variants based on IEEE 802.15.4, using optional per-frame acknowledgments and up to three retransmission attempts with exponential backoff to balance low power consumption and reliability in mesh topologies for sensor networks. A notable case study is ARQ in Voice over IP (VoIP) over UDP, where the Real-time Transport Protocol (RTP) adds reliability through application-layer mechanisms like negative acknowledgments (NACKs) and selective retransmissions as per RTP extensions, avoiding TCP's full overhead while correcting critical packet losses to maintain conversational quality without excessive latency.

Efficiency and Limitations

The throughput efficiency of Automatic Repeat Request (ARQ) protocols is influenced by factors such as the channel error rate P_e, propagation delay, and window size, which determine how effectively the available bandwidth is utilized for successful data transmission. In general, efficiency decreases as P_e increases because more retransmissions are required, reducing the proportion of useful data relative to total transmissions. For instance, in the stop-and-wait variant, the efficiency can be approximated as \eta = \frac{1 - P_e}{1 + 2a}, where a = \frac{t_p}{t_f} is the ratio of one-way propagation delay t_p to frame transmission time t_f, assuming negligible acknowledgment time; this highlights how higher delays (larger a) or error rates degrade performance by idling the sender during round-trip times. Larger window sizes in protocols like go-back-N or selective repeat mitigate delay impacts up to the bandwidth-delay product limit, allowing pipelined transmission to approach full channel utilization in low-error scenarios.^[31] Latency in ARQ systems arises from the inherent round-trip time (RTT) for acknowledgments plus additional delays from retransmissions, leading to end-to-end delays that scale with the average number of transmission attempts per frame. The average number of attempts is \frac{1}{1 - P_e}, so total latency per frame is approximately t_f + \text{RTT} \times \frac{1}{1 - P_e}, which becomes prohibitive in high-latency environments like satellite links where frequent errors amplify waiting periods. This added delay contrasts with forward error correction (FEC), which avoids retransmissions but incurs constant overhead.^[31] Key limitations of ARQ include the bandwidth overhead from frequent acknowledgments (ACKs), which consume channel resources even on error-free links—typically 1-5% of capacity depending on frame size—and vulnerability to errors in the feedback channel, potentially triggering unnecessary retransmissions or frame losses if negative ACKs (NAKs) are corrupted. In scenarios with perfect forward channels but noisy reverse links, this can halve effective throughput by causing duplicate transmissions. Additionally, ARQ performs poorly in asymmetric channels or broadcast settings lacking reliable feedback.^[32] Compared to FEC, ARQ offers superior efficiency in low-error-rate environments (e.g., P_e < 10^{-3}) by transmitting only uncoded data initially and retransmitting selectively, achieving near-100% utilization when errors are rare, whereas FEC imposes a fixed redundancy penalty of 20-50% regardless of conditions. However, in high-error channels (P_e > 10^{-2}), ARQ's repeated attempts lead to excessive latency and reduced throughput due to cumulative retransmissions, making FEC preferable for its ability to correct errors in a single pass without feedback dependency. Hybrid ARQ-FEC schemes balance these trade-offs by combining incremental redundancy with retransmissions.^[32] To address these limitations, adaptive ARQ strategies dynamically switch operational modes based on estimated channel quality, such as transitioning from go-back-N to selective repeat in poor conditions or adjusting window sizes via feedback on error rates, thereby maintaining higher throughput (up to 20-30% improvement) across varying P_e. For example, in a channel with 1% error rate (P_e = 0.01) and 100 ms RTT where frame transmission time equals RTT (i.e., a = 0.5), stop-and-wait efficiency drops to approximately 50% due to idling and one expected retransmission per 100 frames.^[33]

References

[1]
RFC 3366 - Advice to link designers on link Automatic Repeat ...
This document provides advice to the designers of digital communication equipment and link-layer protocols employing link-layer Automatic Repeat reQuest (ARQ) ...
[2]
[PDF] ARQ Protocols - MIT
Automatic repeat request (ARQ). • Break large files into packets. • Check received packets for errors. • Use a feedback channel to request retransmissions.<|control11|><|separator|>
[3]
https://ieeexplore.ieee.org/document/1091865
[4]
Advice to link designers on link Automatic Repeat reQuest (ARQ)
An ARQ protocol retransmits link frames that have been corrupted during transmission across a channel.
[5]
[PDF] III. Link Layer ARQ Protocols 1 Automatic Repeat reQuest ... - MEWS
The goal of Automatic Repeat reQuest (ARQ) at the link layer is achieve reliable trans- mission between the sending and receiving link layers.
[6]
[PDF] A Mathematical Theory of Communication
In the present paper we will extend the theory to include a number of new factors, in particular the effect of noise in the channel, and the savings possible ...
[7]
On Distributed Communications: I. Introduction to ... - RAND
On Distributed Communications. I. Introduction to Distributed Communications Networks. Paul Baran. ResearchPublished 1964. Download PDF · Share on LinkedIn ...Missing: packet | Show results with:packet
[8]
[PDF] A Protocol for Packet Network Intercommunication - cs.Princeton
A protocol that supports the sharing of resources that exist in different packet switching networks is presented. The protocol provides.
[9]
Definition of X.25 | PCMag
The first international standard packet switching network developed in the early 1970s and published in 1976 by the CCITT (now ITU).
[10]
High-Level Data Link Control (HDLC) - UAL
Sep 12, 2016 · First data link protocol for WAN (1979). HDLC is a synchronous Data Link layer bit-oriented protocol developed by the International ...Missing: ARQ history
[11]
[PDF] IEEE 802.11 Wireless Local Area Network (WLAN)
Automatic repeat request (ARQ) and forward error correction (FEC) are ... 0163-6804/97/$10.00 © 1997 IEEE. 歜. IEEE Communications Magazine September ...
[12]
[PDF] Overview of the 3GPP Long Term Evolution Physical Layer
Expected in the 2008 time frame, LTE is a. 3GPP standard that provides for an uplink speed of up to 50 megabits per second (Mbps) and a downlink speed of up to ...
[13]
[PDF] Throughput Performance of Data-Communication Systems Using ...
Sep 8, 1977 · The various automatic-repeat-request (ARQ) schemes commonly considered are varia- tions of two basic ARQ error-control techniques: the stop-and- ...Missing: formula | Show results with:formula
[14]
[PDF] King Fahd University of Petroleum & Minerals Computer ...
Dec 3, 2011 · Therefore, utilization is given by. U = (1-P)/(1+2a). •. Note that for P = 0 (i.e. error free), the expression reduced to the previous result!
[15]
None
### Summary of Stop-and-Wait ARQ Section
[16]
[PDF] The Data Link Layer: Automatic Repeat Request Protocols - MIT
• They all use Go Back N ARQ with N = 7 or 127 (optional). • Older protocols (used for modems, e.g., xmodem) used stop and wait and simple checksums. SDLC ...
[17]
None
### Summary of Go-Back-N ARQ Section
[18]
[PDF] Chapter 1 - Rutgers University
One type of ARQ protocols that offer higher efficiency than Stop-and-wait is the sliding window protocol. The sender window size N is a measure of the maximum ...
[19]
[PDF] Go Back N and SRP - MIT OpenCourseWare
– HDLC/ SDLC developed by IBM for IBM SNA networks. – LAPB developed for ... • They all use Go Back N ARQ with N = 7 or 127 (optional). SDLC packet flag ...
[20]
[PDF] Analysis of Selective-Repeat ARQ via Matrix Signal-Flow Graphs
Abstract—In this paper, we present a new method to analyze the throughput and delay of the selective-repeat (SR) automatic repeat-request (ARQ) protocol.
[21]
RFC 2018 - TCP Selective Acknowledgment Options
* The SACK option SHOULD be filled out by repeating the most recently reported SACK blocks (based on first SACK blocks in previous SACK options) that are ...
[22]
RFC 1071: Computing the Internet checksum
The Internet checksum pairs adjacent octets into 16-bit integers, sums them, and takes the 1's complement of that sum.
[23]
Arithmetic coding based continuous error detection for efficient ARQ ...
Block cyclic redundancy check (CRC) codes are typically used to perform error detection in automatic repeat request (ARQ) protocols for data communications.
[24]
K. Brayer | IEEE Xplore Author Details
For that network, he designed a 32° cyclic redundancy check code, now designated as CRC-32 that became the federal and computer industry standard for error ...
[25]
Error control for data communication - ACM Digital Library
Error detection can be easily implemented with any parity-check block code. At the decoder the received information bits are re-encoded into parity checks and.
[26]
The Effectiveness of Checksums for Embedded Control Networks
A Fletcher checksum is computed with a block size j that is half the checksum size k (for example, a 32-bit Fletcher checksum is computed with a block size ...
[27]
Cyclic redundancy check - ACM Digital Library
The CRC character is also called the cyclic check sum, or simply the check sum character. To show how the CRC is generated, let the message consist of k bits, ...
[28]
Negative Acknowledgement - an overview | ScienceDirect Topics
The distinction between NAK and ACK is that ACK confirms successful receipt ... Hybrid automatic repeat request (HARQ) operation Automatic Repeat Request ...
[29]
RFC 793 - Transmission Control Protocol - IETF Datatracker
RFC 793 defines the Transmission Control Protocol (TCP), a reliable host-to-host protocol for packet-switched networks, providing reliable process-to-process ...
[30]
https://jcoms.fesb.unist.hr/pdfs/jcomss_v3n3_september2007_177-186.pdf
[31]
[PDF] Satellite-3G Hybrid Networks: Impact of ACM and ARQ on TCP ...
On the satellite air interface, we also adopt an Adaptive Coding and Modulation (ACM) scheme, which is a technique supported by DVB-S2 [11], in order to cope ...
[32]
[PDF] Performance of GBN ARQ
Ugbn = 1 − P 1+(W − 1)P . Ugbn = 1 − P 1+(m − 1)P . Thus, we cannot set m = 1 to compare with the stop and wait protocol!Missing: throughput | Show results with:throughput
[33]
Performance of truncated type-II hybrid ARQ schemes with noisy feedback over block fading channels
Insufficient relevant content. The provided URL (https://ieeexplore.ieee.org/document/870015) points to a specific IEEE document, but the content snippet provided is incomplete and does not contain substantive information about ARQ vs FEC performance, trade-offs, error rates, or SNR. Only the title and a partial URL structure are available, which is insufficient for a detailed summary.
[34]
[PDF] On Adaptive Go-Back- ARQ Protocol for Variable-Error Rate Channels
In this operation mode, the transmitter goes back blocks upon reception of an NACK. Whereas, in the “bad” channel state, the transmitter operates in an -copy ...