Switching Modes
Switching Modes
A network switch's basic job — read a frame, look up its destination, forward it to the right port — can actually be carried out in more than one way. The point at which a switch decides to start forwarding a frame, relative to how much of that frame it has actually received, is called its switching mode. The mode a switch uses has a direct, practical effect on a network's latency, throughput, and error handling.
This lesson covers:
- How a switch forwards frames, in brief
- The three major switching modes: Store-and-Forward, Cut-Through, and Fragment-Free
- How to choose between them
A Quick Recap: How a Switch Forwards Frames
A network switch connects multiple devices within a Local Area Network (LAN). Unlike a hub, which copies incoming data to every port, a switch forwards data intelligently, using a table of MAC (Media Access Control) addresses built from the frames it has already seen — a table commonly called the CAM table (Content Addressable Memory table).
When a frame arrives, the switch:
- Reads the frame's destination MAC address.
- Looks that address up in the CAM table.
- If found, forwards the frame out the corresponding port only.
- If not found, floods the frame out every port except the one it arrived on.
What differs between switching modes is when, during this process, the switch is willing to start sending the frame out the destination port — which is the subject of the rest of this lesson.
Why Switching Modes Matter
- Efficient data delivery — a switch sends data only to the intended device rather than flooding the whole network, saving bandwidth and reducing congestion.
- Reduced collisions — modern switches support full-duplex communication, letting a device send and receive simultaneously, which removes most of the collisions a half-duplex, shared-media network would suffer.
- Improved performance — intelligently managed traffic effectively expands available bandwidth, the same way turning a two-lane road into a six-lane highway lets more traffic move without delay.
Exactly how much of that performance gain you get — and how much error protection you keep — depends on which switching mode is in use.
The Three Major Switching Modes
| Mode | Waits for | Error checking | Latency |
|---|---|---|---|
| Store-and-Forward | The entire frame | Full (CRC/FCS) | Highest |
| Cut-Through | Just the destination MAC address | None | Lowest |
| Fragment-Free | The first 64 bytes | Partial (collision fragments only) | In between |
1. Store-and-Forward Switching
Definition. The switch receives the entire frame, stores it in buffer memory, checks it for errors, and only then forwards it — or discards it if it's damaged.
How it works
- Receive the entire frame — the switch waits until the full frame has arrived.
- Store the frame — it's placed into the switch's buffer memory.
- Check for errors — the switch performs a CRC (Cyclic Redundancy Check) using the frame's Frame Check Sequence (FCS).
- Forward or discard — if no error is found, the frame is forwarded; if an error is found, it's discarded on the spot.
Real-world analogy. A courier service verifies the address, checks for damage, and confirms the package is complete before dispatching it — not after. Store-and-forward switching applies that same "check first, then send" discipline to every frame.
Advantages
- High reliability — only error-free frames are ever forwarded.
- Better security — corrupted frames never reach their destination.
- Collision protection — damaged or collided frames are caught and discarded.
- Well suited to large, enterprise-grade networks that prioritize stability.
Disadvantages
- Higher latency — the switch must wait for the entire frame before forwarding any of it.
- Requires more buffer memory, since full frames must be temporarily stored.
2. Cut-Through Switching
Definition. The switch starts forwarding a frame as soon as it has read the destination MAC address — without waiting for the rest of the frame to arrive.
How it works
- Receive initial bytes — right after the frame's preamble, the switch reads the destination MAC address.
- Look up the CAM table — the destination address is checked against the switching table.
- Start forwarding immediately — the switch begins transmitting the frame out the destination port right away, with no waiting.
Real-world analogy. A receptionist who, the moment a visitor says whose office they want, immediately points them there — without checking whether the visitor's story is actually correct. It's fast, but it trusts information that hasn't been fully verified yet.
Advantages
- Extremely low latency — frames start moving almost immediately.
- Fastest possible data transmission among the three modes.
- Well suited to applications that are highly latency-sensitive.
Disadvantages
- No error checking at all — corrupted frames can be forwarded.
- Lower reliability — invalid data can reach its destination.
- Collision fragments (damaged frames caused by two devices transmitting at once) can pass straight through, since the switch never inspects the rest of the frame.
Common use cases: high-performance data centers, low-latency trading systems, real-time communication networks — environments where shaving off every microsecond of delay outweighs the cost of occasionally forwarding a bad frame.
3. Fragment-Free Switching
Definition. A hybrid approach that keeps most of cut-through's speed while adding limited error checking. Instead of forwarding the instant the destination address is read, the switch waits until it has received the frame's first 64 bytes.
Why 64 bytes specifically? In Ethernet networks, collisions — when two devices transmit at the same time — almost always corrupt data within the first 64 bytes of a frame. A frame damaged by a collision ("a runt" or "collision fragment") is reliably smaller than 64 bytes. By checking just that much of the frame, a switch can catch the great majority of collision-damaged frames without paying the full latency cost of waiting for the entire thing.
How it works
- Receive the first 64 bytes — the switch buffers just this much of the frame.
- Check for collision fragments — if the frame is shorter than 64 bytes (a telltale sign of a collision), it's discarded.
- Forward the frame — if no problem is found in those 64 bytes, the switch forwards the frame immediately, exactly as cut-through switching would.
Real-world analogy. Airport security doing a quick screening rather than a full, exhaustive inspection — most obvious problems are caught quickly, while passenger flow stays fast.
Advantages
- Faster than store-and-forward, since it doesn't wait for the whole frame.
- Better error detection than pure cut-through, since it catches collision fragments.
- A reasonable middle ground between speed and reliability.
Disadvantages
- Error detection is still incomplete — it does not perform a full CRC check.
- Corruption occurring after the first 64 bytes can go completely undetected.
Which Switching Mode Should You Use?
| Choose... | When... |
|---|---|
| Store-and-Forward | Reliability is critical, error-free transmission is required, or you're running a large enterprise network where stability matters more than shaving off microseconds. |
| Cut-Through | Speed is the top priority, latency must be minimized, and the application can tolerate occasional minor errors. |
| Fragment-Free | You want a balance between speed and reliability under moderate network traffic. |
Common Mistakes
- Assuming "faster" always means "better." Cut-through switching minimizes latency but can forward corrupted frames; for applications where data integrity matters more than microseconds (file transfers, for example), store-and-forward is usually the safer default.
- Forgetting that store-and-forward is the default on most modern switches. Many enterprise switches use store-and-forward because buffer memory and processing power are cheap today, making the latency cost largely negligible compared to the reliability gained.
- Overestimating fragment-free's error protection. It only guards against collision-related corruption in the first 64 bytes — it is not a substitute for full CRC checking when end-to-end data integrity truly matters.