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. Gray Pointers in Signoff

Part 3 · CDC Protocols and Handshakes · All levels

Gray Pointers in Signoff

What makes the pointer crossing safe and what a structural check looks for.

On this page

    Why it matters

    The write pointer must be visible in the read domain (for empty) and the read pointer in the write domain (for full), but a multi-bit counter cannot cross bit-by-bit: skew between bits lets the destination sample a mixture of old and new values. Gray coding restricts every legal pointer step to a single-bit change, so a sample taken mid-change is at worst one step stale, never a torn value.

    What makes the crossing safe

    1. Gray-coded pointers cross the boundary; each increment flips exactly one bit, including the wrap-around step.

    2. Registered Gray values feed the synchronisers: the Gray code comes from source-domain flops, never from combinational conversion at the crossing, so the synchroniser input cannot glitch.

    3. A two-flop (or more) synchroniser per pointer bit in the receiving clock carries the Gray value across, exactly like a set of single-bit level crossings that change one at a time.

    4. Single-step discipline: the pointer advances by one per operation only. Jumps (reloads, skips) break the one-bit rule and with it the whole argument.

    What a structural check looks for

    Check

    What passes

    Typical finding when it fails

    Crossing classification

    Pointer crossings reported as synchronised Gray crossings, not plain multi-bit crossings

    Multi-bit crossing without protocol

    Synchroniser presence

    One synchroniser chain per pointer bit, no logic between the flops

    Missing or shared synchroniser, logic before the synchroniser

    Gray discipline

    Encoding recognised as Gray with single-step updates

    Counter that can jump, or binary pointer across the boundary

    Source hygiene

    Gray value driven by flops in the source domain

    Combinational conversion feeding the crossing

    Common mistakes

    Common pitfall

    A pointer that usually increments by one but occasionally reloads (frame restart, error recovery). The reload is a multi-bit jump, and the one sample that catches it mid-flight can tear. If the pointer can jump, the design needs a handshake or a reset-and-drain sequence around the jump, not just Gray code.

    Interview

    Explain the one-bit rule first, then the wrap step (Gray codes are cyclic, so the last-to-first step also flips one bit), then the registered-source requirement. The classic follow-up is the reload case above.

    Check yourself A Gray pointer goes 0101 to 0100 to 1100. How many bits change at each step?

    One bit each time (bit 0, then bit 3). The sequence respects the single-bit rule, so a sample mid-change is at most one step stale.

    Related topics

    • Full and empty

    • RTL: Asynchronous FIFO

    Previous

    39 / 179

    Next: Full and Empty

    Up next

    Up nextFull and Empty

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Depth Sizing
    • FIFO Reset and Tool Checks