Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutContactPrivacyTerms
Skip to lesson

Course contents

  • RTL Foundations36
  • Combinational Design25
  • Sequential Design27
  • FSM & Control27
  • Timing & Clocking39
  • Reset & CDC34
    • Reset Architecture
    • Metastability and Synchronisation
    • Asynchronous FIFO
      • Why an Async FIFO Is the Standard
      • Pointers and Gray Conversion
      • Full, Empty and the Complete Design
      • Almost Full and Almost Empty
      • Reset and Initialisation
      • Verification and CDC Closure
      • Sizing a FIFO, End to End
    • CDC Protocols
    • Reset Domain Crossing
    • CDC Verification
  • Memory & Buses57
  • Advanced RTL28
  • Senior & Interview76
  • Glossary and Notation
Loading lesson

‹Asynchronous FIFO
  1. Topics
  2. RTL Design
  3. Reset & CDC
  4. Asynchronous FIFO
  5. Why an Async FIFO Is the Standard

Part 6 · Reset & CDC · Intermediate

Why an Async FIFO Is the Standard

Why FIFOs carry multi-bit streams across clocks, and their throughput, latency and area cost.

On this page

    Why this matters

    A handshake moves one word per round trip, and per-bit synchronisers corrupt a bus. An async FIFO moves up to one word per cycle of the slower clock, because the data waits in memory and only Gray pointers cross.

    After this lesson you can: explain why an async FIFO is the standard stream crossing, state its latency and flag costs, and say why its depth needs a bound for the real workload.

    The multi-bit stream problem

    A stream of data words cannot cross with bit-wise synchronisers (see the bus lesson). A handshake works but moves one word per round trip, costing several cycles of both clocks.

    An asynchronous FIFO moves up to one word per cycle of the slower clock. Data never crosses a synchroniser: it waits in memory until the pointers mark it valid.

    Method

    Throughput

    Latency

    Area

    Use for

    2FF per bit

    n/a (unsafe for related bits)

    –

    tiny

    Independent single bits only

    Handshake with stable data

    1 word per round trip (about 9 source cycles per word in the lesson's testbench; depends on the two clock ratios)

    Medium

    Small

    Control and configuration, low rates

    Gray pointer for a counter

    1 value per sample

    2 to 3 cycles

    Tiny

    Counters and pointers

    Asynchronous FIFO

    Up to 1 word per slower clock

    A few cycles

    Memory + pointers

    Streams and bursts, rate matching

    Words moved in 18 source cycles with a 10 ns source and a 7.13 ns destination: about 2 by the handshake against up to 18 by an async FIFO

    Read each row along the same 18 source cycles; one box is one word delivered.

    • The handshake spends about 9 source cycles on each word: request across, acknowledge back, then both return to zero.

    • The FIFO overlaps those crossings. With both sides ready, it delivers one word per cycle of the slower clock, here the 10 ns source.

    • The FIFO pays for that with memory and two pointer synchronisers, so the handshake is still the right choice for rare configuration writes.

    Benefits

    • Safe multi-bit transfer: data sits in memory; only single-bit-changing pointers cross.

    • Rate matching and bursts: it absorbs short mismatches between the producer and consumer rates.

    • Clean interface: winc/wfull on one side, rinc/rempty on the other, both simple synchronous handshakes.

    • Reusable: the structure is the same for any data width and any power-of-two depth of 2 or more.

    Costs

    • Latency: a word written becomes visible to the reader only after its write pointer crosses (2 or 3 read-clock cycles).

    • Depth: it must be deep enough to cover the worst burst imbalance plus the pointer crossing delay.

    • Pessimistic flags: full and empty are decided from stale information, so the FIFO can report full or empty a few entries early.

    Common mistakes

    Tip

    B × max(0, 1 − f_r / f_w) is only a continuous-service, steady-rate burst approximation, starting empty. It is not a worst-case depth rule. Use the actual fastest producer and slowest consumer clocks, initial occupancy, start phase, consumer pauses and maximum writes still in flight after backpressure. Pointer visibility latency is measured in receiving-clock cycles; convert it to time and then to blocked service or arrivals, rather than adding a universal 2 to 4 entries.

    For an explicit workload envelope, bound Q(t) = Q0 + A(t) − C(t), where A counts accepted arrivals and C counts reads that can actually occur (including startup/empty visibility and consumer pauses). Choose power-of-two depth at least the largest Q over every allowed phase/pause trace, including post-warning writes. If sizing from offered arrivals, either guarantee enough capacity for all offers or explicitly budget stalls. Full always gates acceptance; almost-full reserves capacity for a producer that cannot stop immediately.

    Illustrative trace (not a measured run)

    Occupancy bound

    Q0=8, 100 arrivals at 200 MHz; 100 MHz consumer continuously available

    Steady-rate increase 50; phase/visibility can reduce service below 50 reads

    First 100 ns of the 500 ns burst has no consumer service; minimum service in remaining 400 ns is 40 reads

    8 + 100 − 40 = 68; depth 64 is insufficient

    After the warning, at most 6 more arrivals with no guaranteed reads

    Reserve at least 6 slots at the warning; include these arrivals in A if outside the original burst

    Common pitfall

    An async FIFO moves data, but it does not magically make rates match. If the producer is permanently faster than the consumer, the FIFO fills and the producer must stall via wfull. Provide backpressure; don't assume the FIFO will never be full.

    Check yourself Starting empty, with continuous 100 MHz consumer service and a 100-word 200 MHz burst, what depth does the steady-rate approximation give, ignoring phase and crossing latency?

    100 × max(0, 1 − 100/200) = 50 words, so 64 is the next power-of-two depth. Prefill, pauses, start phase and reaction latency require a separate worst-case bound.

    Remember

    • Data never crosses a synchroniser. It waits in memory until the pointers mark it valid.

    • Costs: 2 or 3 read-clock cycles before a word is visible, and full and empty flags that report a few entries early.

    • B × max(0, 1 − f_r / f_w) is a steady-rate burst estimate, not a worst-case depth rule.

    Rule of thumb: a FIFO absorbs bursts; it does not match rates, so the producer must still stall on wfull.

    How this was checked

    The occupancy trace in the sizing table is illustrative; it is not a measured run.

    Keep going

    • Practice: Design an asynchronous FIFO with CDC handling

    • Practice: High-throughput CDC with an asynchronous FIFO

    • Interview: run a mock interview on this topic

    Related topics

    • Pointers and Gray conversion

    • Sizing a FIFO, end to end

    Previous

    165 / 350

    Next: Pointers and Gray Conversion

    Up next

    Up nextPointers and Gray Conversion

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Full, Empty and the Complete Design
    • Almost Full and Almost Empty
    • Reset and Initialisation