OneNoughtOne
0/240
Loading content...
Read aloud is unavailable in this browser.
In the early days of telecommunications, the dominant paradigm was circuit switching—a model that established dedicated, end-to-end paths for each communication session. While effective for continuous voice traffic, circuit switching fundamentally underutilized network resources when applied to the bursty nature of data communication.
The breakthrough came with packet switching, a revolutionary approach that fragments data into discrete units called packets, routes each independently through a shared network infrastructure, and reassembles them at the destination. At the heart of packet switching lies a deceptively simple technique: store-and-forward switching.
This page provides an exhaustive examination of store-and-forward switching—the mechanism that enables modern internetworking. We will explore its fundamental principles, operational mechanics, performance characteristics, and the engineering tradeoffs that make it the cornerstone of virtually all data networks today.
By completing this page, you will: (1) Understand the precise operational mechanics of store-and-forward switching, (2) Calculate store-and-forward delay with mathematical precision, (3) Analyze the advantages and limitations of this approach, (4) Compare store-and-forward with alternative switching techniques, and (5) Apply this knowledge to real-world network design decisions.
Store-and-forward switching is a data transmission technique where an intermediate network device (switch, router, or node) must receive an entire packet before it can begin forwarding that packet to the next hop. This contrasts sharply with techniques like cut-through switching, where forwarding can begin as soon as the destination address is read.
Store-and-forward switching operates through three distinct phases:
Store Phase: The entire packet is received bit-by-bit and stored in the device's buffer memory. The device must wait until the complete packet arrives, including all headers, payload, and trailer (typically containing error-detection codes).
Process Phase: Once the complete packet is buffered, the device performs essential operations:
Forward Phase: The device transmits the packet on the selected output link, bit-by-bit, to the next hop (another switch/router or the final destination).
The requirement to store the complete packet before forwarding serves several critical purposes:
Store-and-forward predates digital computer networks. The concept originated in telegraph and postal systems where messages were received at relay stations, stored temporarily, and forwarded to the next station. Paul Baran's seminal 1964 RAND report on distributed communication networks formalized this approach for data networks, directly influencing the design of ARPANET—the precursor to the modern Internet.
Understanding the delay characteristics of store-and-forward switching is essential for network design and performance analysis. Let us develop a rigorous mathematical framework for calculating end-to-end delay.
The total delay experienced by a packet traversing a store-and-forward network consists of four components at each hop:
1. Transmission Delay (d_trans)
The time required to push all bits of the packet onto the link. This is a function of packet size and link bandwidth:
$$d_{trans} = \frac{L}{R}$$
Where:
2. Propagation Delay (d_prop)
The time for a bit to travel from sender to receiver across the physical medium:
$$d_{prop} = \frac{d}{s}$$
Where:
3. Processing Delay (d_proc)
The time required for the switch/router to examine header fields, perform error checking, and determine the output interface. Typically microseconds in modern hardware.
4. Queuing Delay (d_queue)
The time a packet waits in the output buffer before transmission. Highly variable, depending on traffic intensity.
The key characteristic of store-and-forward is that a packet incurs a FULL transmission delay at EVERY hop. Unlike cut-through switching (where forwarding can begin after receiving just the header), store-and-forward requires the entire packet to be received before any forwarding begins. This accumulates into significant latency across multiple hops.
Consider a packet traversing N links (N-1 intermediate switches) from source to destination:
$$D_{total} = N \cdot d_{trans} + \sum_{i=1}^{N} d_{prop,i} + \sum_{i=1}^{N-1} d_{proc,i} + \sum_{i=1}^{N-1} d_{queue,i}$$
Simplifying for identical links and assuming negligible processing delay:
$$D_{total} = N \cdot \frac{L}{R} + N \cdot d_{prop} + D_{queue}$$
Problem: Calculate the end-to-end delay for a 1500-byte packet traversing 3 links (source → switch1 → switch2 → destination). Each link is 100 km with a transmission rate of 100 Mbps. Assume negligible processing and queuing delays.
Solution:
Convert packet size: L = 1500 bytes × 8 = 12,000 bits
Calculate transmission delay per hop: $$d_{trans} = \frac{12,000 \text{ bits}}{100 \times 10^6 \text{ bps}} = 0.12 \text{ ms} = 120 \text{ μs}$$
Calculate propagation delay per hop: $$d_{prop} = \frac{100 \times 10^3 \text{ m}}{2 \times 10^8 \text{ m/s}} = 0.5 \text{ ms} = 500 \text{ μs}$$
Total delay with N = 3 links: $$D_{total} = 3 \times 0.12 + 3 \times 0.5 = 0.36 + 1.5 = 1.86 \text{ ms}$$
Notice that the packet incurs three full transmission delays—one at the source and one at each of the two intermediate switches. This is the store-and-forward penalty.
| Component | Per-Hop Value | Number of Occurrences | Total Contribution |
|---|---|---|---|
| Transmission Delay | 120 μs | 3 (each hop) | 360 μs |
| Propagation Delay | 500 μs | 3 (each link) | 1500 μs |
| Processing Delay | ~1-10 μs | 2 (each switch) | ~2-20 μs |
| Queuing Delay | Variable | 2 (each switch) | Variable |
| Total (minimum) | — | — | ~1.86 ms |
Store-and-forward switching is implemented across various network devices, each with specific architectural considerations. Understanding these implementations is crucial for network engineering.
Modern Ethernet switches primarily operate in store-and-forward mode, though many also support cut-through as a configurable option.
Buffer Architecture:
Input Buffering: Packets are stored in memory associated with the input port. Simple but can suffer from head-of-line (HOL) blocking—where a packet destined for an idle output is stuck behind a packet destined for a busy output.
Output Buffering: Packets are stored in memory associated with the output port. Eliminates HOL blocking but requires memory bandwidth of N×R (where N is port count and R is port speed)—a significant engineering challenge.
Shared Memory: A single large buffer pool shared across all ports. Most efficient memory utilization with statistical multiplexing benefits. Used in most enterprise-class switches.
Virtual Output Queueing (VOQ): Each input port maintains separate queues for each output port. Eliminates HOL blocking without the memory bandwidth demands of pure output buffering. Common in high-performance data center switches.
Error Handling:
When a frame's CRC check fails, the switch discards the frame silently. It does not generate any error notification to the sender—that responsibility belongs to higher-layer protocols (TCP, application-level acknowledgments). This follows the end-to-end principle: complex error recovery is handled by endpoints, not intermediate nodes.
Routers implement store-and-forward at the packet level, with additional processing for Layer 3 operations:
Additional Router Processing:
Buffer Management in Routers:
Router buffers must be carefully sized. The traditional rule of thumb (from Villamizar and Song, 1994) suggests:
$$B = RTT \times C$$
Where B is buffer size, RTT is the average round-trip time of flows, and C is link capacity. However, recent research (Appenzeller et al., 2004) suggests that with many flows, this can be reduced to:
$$B = \frac{RTT \times C}{\sqrt{N}}$$
Where N is the number of flows. This has significant implications for router ASIC design.
Excessive buffering causes 'buffer bloat'—a phenomenon where large buffers absorb traffic bursts but introduce hundreds of milliseconds of queuing delay. This degrades interactive applications (VoIP, gaming, video conferencing) and confuses TCP's congestion control algorithms. Modern networks use Active Queue Management (AQM) techniques like CoDel and PIE to manage buffer occupancy intelligently.
Store-and-forward switching has become the dominant paradigm in data networks for compelling technical reasons. Let us examine its advantages in depth.
| Scenario | Store-and-Forward | Cut-Through |
|---|---|---|
| Corrupted frame received | Detected via FCS, frame discarded locally | Partially forwarded before error detected |
| Runt frame (too short) | Detected, discarded | May be forwarded partially |
| Giant frame (too long) | Detected, discarded | Forwarded until buffer overflow |
| Collision fragment | Identified and dropped | May propagate error |
| Network-wide error impact | Errors contained locally | Errors may cascade |
Beyond technical merits, store-and-forward provides operational benefits:
Debugging and Troubleshooting: Since packets are fully received before forwarding, switches can log complete packet information for debugging. Many switches offer port mirroring (SPAN) capabilities that rely on store-and-forward buffering.
Traffic Analysis: Network monitoring tools (NetFlow, sFlow, IPFIX) sample packets at switches. Complete packet availability enables comprehensive traffic analysis without missing data in truncated packets.
Regulatory Compliance: In environments requiring lawful intercept or data retention, store-and-forward ensures complete capture capability.
Predictable Behavior: The deterministic nature of store-and-forward (receive-process-forward) simplifies network modeling, capacity planning, and SLA guarantees compared to the variable-latency behavior of cut-through switches adapting between modes.
All IP routers operate in store-and-forward mode—there is no cut-through alternative. The reason: routers must decrement TTL and recompute the IP header checksum (IPv4), potentially fragment packets, and perform longest-prefix-match routing. These operations require access to header fields that arrive throughout the packet, making cut-through impossible at Layer 3.
No engineering solution is without tradeoffs. Store-and-forward switching has inherent limitations that influence network design decisions.
To quantify the latency penalty, consider a 1500-byte Ethernet frame:
| Link Speed | Store-and-Forward Delay | Cut-Through Delay* | Difference |
|---|---|---|---|
| 10 Mbps | 1200 μs (1.2 ms) | ~50 μs | 1150 μs |
| 100 Mbps | 120 μs | ~5 μs | 115 μs |
| 1 Gbps | 12 μs | ~0.5 μs | 11.5 μs |
| 10 Gbps | 1.2 μs | ~0.05 μs | 1.15 μs |
| 100 Gbps | 0.12 μs | ~0.005 μs | 0.115 μs |
*Cut-through delay assumes forwarding begins after destination MAC address (first 14 bytes) is received.
Key Insight: At higher speeds, the absolute latency difference shrinks. At 100 Gbps, the store-and-forward penalty is merely 115 nanoseconds—often negligible compared to propagation and queuing delays.
Store-and-forward latency is most significant in:
For typical enterprise and consumer applications, the latency difference is imperceptible.
Many modern switches support 'adaptive' or 'error-free cut-through' mode. The switch operates in cut-through mode under normal conditions but automatically transitions to store-and-forward when error rates exceed a threshold. This provides low latency when conditions are good and error protection when needed.
Despite the availability of cut-through alternatives, store-and-forward remains the dominant switching paradigm across most network contexts. Let's examine its application in contemporary network architectures.
Modern data center networks operate at 25/100/400 Gbps speeds with leaf-spine topologies minimizing hop counts. In these environments:
In WAN contexts (enterprise WANs, ISP networks, internet backbone):
OpenFlow-based SDN implementations are inherently store-and-forward:
Store-and-forward switching is so fundamental that it's easy to overlook. Every email you send, every web page you load, every video you stream traverses dozens of store-and-forward devices. The entire Internet is built on this simple principle: receive completely, validate, then forward. This reliability-focused approach has enabled the network to scale from a few dozen nodes in 1969 to billions of devices today.
We have conducted an exhaustive examination of store-and-forward switching—the foundational mechanism underlying packet-switched networks. Let us consolidate the key concepts:
What's Next:
With store-and-forward mechanics established, we turn to a fundamental question: how are packets routed through the network? The next page explores the datagram approach—the connectionless, per-packet routing paradigm that characterizes the Internet Protocol (IP) and contrasts sharply with the connection-oriented virtual circuit approach.
You have mastered the store-and-forward switching paradigm—the foundation of packet-switched networks. You can now calculate switching delays, analyze buffer architectures, and explain why this seemingly simple technique underpins the entire Internet. Next, we'll explore how datagrams find their way through networks without pre-established paths.