Most commonly refered to as a compromise between store-and-forward and cut-through switching, this method involves storing the first 64 bytes of the ethernet frame in a buffer and then forwarding it. The reasoning I find mentioned the most online goes something like:

It is because most errors occurs within the first 64 bytes of the frame

Now I have a couple of questions following this up.

  1. What kind of errors do they have in mind? There is no FCS field in the first 64 bytes. My speculation is that since cut-through suffers mostly from the problem of runt frames caused by collisions, this will check that the frame exists atleast until 64 bytes so as to prevent a late collision.

  2. If ethernet uses duplex which it mostly does in the modern world, why would there ever be a need to check for collisions? Wouldn't that eliminate the chances of runt frames from ever being produced?

  3. And finally, does fragment free by any chance relate to IPv4 fragmentation?
  • 1
    The 64byte line is to detect runts. That's all.
    – Ricky
    Jun 25, 2019 at 23:24

2 Answers 2


With cut-through switching, forwarding starts right after reception of the MAC destination address. This however may cause broken frames to be forwarded across a switch - simply because the frame integrity can only be checked when looking at the whole frame, from header to FCS.

In this context, fragment free means that a cut-through switch monitors the integrity of each frame while forwarding. When an ingress port exceeds a certain error rate the switch changes over to store-and-forward switching, limiting the overall number of forwarded, broken frames originating from malfunctioning ingress links.

It is because most errors occurs within the first 64 bytes of the frame

That isn't true. Error bits can be located anywhere within the frame. Also, there's no way to detect a damaged frame (not from collision) before receiving the trailing FCS.

64 bytes or 512 bits is the slot time for half-duplex Ethernet. Looking for continuing frames beyond that limit or a lack of collision guarantees that no runts from collisions are forwarded. In obsolete half-duplex mode those runts may be very common, so not forwarding them is a very good idea.

A late collision is a collision happening beyond that slot time, outside the normal collision window. They (used to) happen when the network exceeded Ethernet's design limits (segment length, 5-4-3 rule etc.). You can't always catch them (as they're late) and you can only detect those broken frames by failing FCS check.

If ethernet uses duplex which it mostly does in the modern world, why would there ever be a need to check for collisions?

With full duplex there can be no collisions. However, up to Fast Ethernet speed (100 Mbit/s) most devices still support half-duplex mode (HDX). A cut-through switch with a half-duplex link could theoretically forward fragments from collisions received on the half-duplex port. In practice, most cut-through switches use store-and-forward for HDX source ports (as part of the fragment-free strategy).

does fragment free by any chance relate to IPv4 fragmentation?

No. "Fragment" here refers to incomplete frames (mostly) due to collisions. IP fragmentation is an inefficient, yet necessary and legal mechanism to forward packets over a network not supporting the actual packet size (packet size > MTU).

  • While I agree with what you've written, you don't seem to mention what exactly is the integrity check performed on the 64 bytes. Are the switches checking if the bits are present or not or are they performing some kind of calculation? I know that fragment free won't do a CRC on it.
    – Weezy
    Jun 26, 2019 at 16:48
  • There is no extra integrity check for the first 64 bytes in Ethernet. On L2, there's only FCS for the whole frame, nothing else. Depending on the actual L1 PHY, there may be additional PCS level checks or FEC, but these are on line symbols or code groups. For IPv4 (L3) there's an IP header checksum that falls into the first 64 bytes, but IPv6 and other L3 protocols don't have that. Some transport-layer protocols (L4) also use header checksums but those differ as well.
    – Zac67
    Jun 26, 2019 at 17:13
  • I suppose they mean that if the link is broken, it's probably generating lots of errors and some are likely to occur in the first 64 bytes.
    – user253751
    Aug 30 at 16:32
  • @user253751 There's no way to detect a damaged frame within the first 64 bytes. That limit is designed to filter out runts.
    – Zac67
    Aug 30 at 16:58
  • @Zac67 it can be detected because the CRC is wrong - it covers all bytes including the first 64 - but not if you start forwarding before you get the CRC.
    – user253751

"fragment free" only makes sense if you have half duplex links, which means nowadays it is basically obsolete. Noone running a high-performance network today would use a half duplex link for anything important and half duplex links will almost certainly be running at a lower speed than the network backbone, so they would have to be store and forward switched anyway.

The purpose of "fragment free" switching is to prevent the switch from forwarding partial packets that result from collisions.

The ethernet physical layer doesn't just carry a sequence of data bits, it also carries framing and clocking information. Indeed "Ethernet II" frames don't even have a length field. It is up to the physical layer to tell the data link layer when frames begin and end.

SO while a receiver may not be able to detect corruption caused by random noise before the FCS has arrived, it can certainly detection collisions and aborted transmissions.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

Not the answer you're looking for? Browse other questions tagged or ask your own question.