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

  • How to Use This Course
  • Reading Path
  • CDC/RDC Glossary
  • CDC/RDC Metrics Reference
  • CDC/RDC Interview Prep
  • CDC/RDC Signoff Cheatsheet
  • Clock Domains and Failure Modes8
  • Metastability and Synchronizers16
  • CDC Protocols and Handshakes16
    • Pulse Synchronizers
    • Handshake Protocols Across Domains
    • Async FIFO CDC
      • Gray Pointers in Signoff
      • Full and Empty
      • Depth Sizing
      • FIFO Reset and Tool Checks
    • CDC Protocol Verification
  • Reconvergence and Gray Coding16
  • Reset Domain Crossing16
  • Architecture and Design Rules16
  • CDC Signoff Methodology24
  • RDC Signoff16
  • Debug and Case Studies11
  • CDC and RDC Interview Prep30
  • Capstone: Sign Off a Multi-clock Peripheral4
Loading lesson

‹Async FIFO CDC
  1. Topics
  2. CDC & RDC
  3. CDC Protocols and Handshakes
  4. Async FIFO CDC
  5. FIFO Reset and Tool Checks

Part 3 · CDC Protocols and Handshakes · All levels

FIFO Reset and Tool Checks

Resetting both sides together, what the pointer synchronisers need, and how tools see the memory.

On this page

    Why it matters

    A FIFO holds distributed state: a write pointer in one domain, a read pointer in another, and flags derived from both. Resetting only one side leaves the pointers disagreeing about occupancy forever, and the FIFO then overflows or underflows on data that is perfectly well behaved. Reset is consequently part of the CDC review, not somebody else's problem.

    Resetting both sides

    1. Reset each side with its own properly synchronised reset, so each domain releases cleanly on its own clock.

    2. Assert both resets from the same source at the same time, so both pointers clear to zero together.

    3. Hold reset until each side has seen several clock edges, and long enough for the pointer synchronisers to flush stale values (at least the synchroniser depth in cycles of the slower clock after the pointers reach zero).

    4. Forbid writes while the write reset is asserted and reads while the read reset is asserted.

    5. After reset the FIFO reads empty and not full; confirm both flags, not just one.

    What the pointer synchronisers need

    The synchroniser flops themselves take the reset of their own receiving domain, matching the domain they clock with. A synchroniser whose flops reset with the far domain releases at the wrong time and can present a half-reset pointer to live logic. Where the simulation model of the synchroniser has no reset, the testbench holds both domain resets long enough to flush unknowns before traffic starts.

    How tools treat the memory array crossing

    In generic terms, the memory array is the one part of the FIFO that does not cross through synchronisers: write addresses and write data stay in the write domain, read addresses and read data stay in the read domain, and the array itself is a dual-clock structure. Structural checks therefore expect the array to be recognised as a memory rather than as a bundle of crossings, with the two clock associations documented; anything else (a single-clocked array, or data paths leaking between domains around the array) is reported for review. Reset-domain analysis covers the FIFO too, since its resets span two domains.

    Common mistakes

    Common pitfall

    A watchdog or power controller that resets one domain while the FIFO holds live data. Any reset event touching one side must reset or drain the FIFO as a whole; a half-reset FIFO is corrupt by construction, and no sequence of reads repairs it.

    Interview

    Answer the one-sided-reset question quantitatively: if the write pointer held 40 and the read pointer resets to 0, the FIFO believes it holds 40 entries it does not have. Then say how you prevent it: common reset source, both sides together.

    Check yourself After a reset that only reached the read side, empty reads 0. Is the FIFO usable?

    No: the write pointer still holds its old value, so occupancy is garbage and full/empty are meaningless. Reset both sides together before any traffic.

    Related topics

    • Full and empty

    • RTL: Asynchronous FIFO

    • RTL: Reset domain crossing

    Previous

    42 / 179

    Next: CDC Protocol Verification

    Up next

    Up nextCDC Protocol Verification

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Gray Pointers in Signoff
    • Full and Empty