The Asynchronous FIFO

When you need to move a stream of data from one clock domain to another, the asynchronous FIFO is the standard answer. It is the single most important CDC structure to understand.

The idea

A dual-clock FIFO is a small memory written by the source clock and read by the destination clock. The writer pushes data using the write clock, the reader pops data using the read clock, and the FIFO absorbs the difference in timing between them. Neither side has to know the other side timing, as long as the FIFO never overflows or underflows.

The crossing is in the pointers

The data words themselves never need synchronizing, because a word is written, then sits still in memory until it is read. The thing that actually crosses clock domains is the pointers: to know if the FIFO is full, the write side needs the read pointer, and to know if it is empty, the read side needs the write pointer.

1. The write pointer is maintained in the write clock domain.
2. The read pointer is maintained in the read clock domain.
3. Each pointer is converted to gray code and synchronized into the other domain with a two-flop synchronizer.
4. Full is computed on the write side, empty on the read side, using the synchronized pointer.

Why gray-coded pointers are essential

The pointers increment by one, so gray code applies perfectly: only one bit changes per step, so the synchronized pointer is always a valid value, never a corrupt in-between. This is the reason the whole structure works.

Full and empty, safely

• Empty is detected when the read pointer equals the synchronized write pointer.
• Full is detected when the write pointer equals the synchronized read pointer with the wrap bit inverted.
• Because each side uses a pointer synchronized from the other, full and empty are always pessimistic and safe: you may briefly think the FIFO is more full or more empty than it really is, but you will never overflow or underflow.