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
    • CDC Protocols
    • Reset Domain Crossing
    • CDC Verification
      • Rules
      • Simulation
      • Assertion Patterns
      • FIFO Tests
      • Signoff
      • Reading a CDC Report
      • A CDC Mini Project
  • Memory & Buses57
  • Advanced RTL28
  • Senior & Interview76
  • Glossary and Notation
Loading lesson

‹Reset & CDC
  1. Topics
  2. RTL Design
  3. Reset & CDC
  4. CDC Verification

Part 6 · Reset & CDC · Intermediate

CDC Verification

Structural, simulation, assertion and signoff checks that prove a CDC crossing is safe.

  • 7topics
  • 7lessons

Topics in this section

  1. 1Rules1 lesson
  2. 2Simulation1 lesson
  3. 3Assertion Patterns1 lesson
  4. 4FIFO Tests1 lesson
  5. 5Signoff1 lesson
  6. 6Reading a CDC Report1 lesson
  7. 7A CDC Mini Project1 lesson
On this page

    No single check proves a crossing safe. Structural analysis, hostile simulation, protocol assertions and implementation constraints each cover one layer.

    The four CDC verification layers, from structure at the bottom to implementation at the top, each with one bug that only it catches

    Read the stack from the bottom. A crossing can pass every layer below and still fail the next one: a correctly built synchroniser says nothing about whether the handshake on top of it holds req until ack.

    Layer

    Question

    Tool

    Structural

    Is every crossing a synchroniser, handshake, Gray pointer or FIFO?

    CDC analysis tool, lint

    Functional

    Does the protocol work with random phases, ratios and resets?

    Simulation with metastability-aware models

    Protocol

    Does req stay up until ack? Is data stable? Is Gray one bit per step?

    SVA assertions (simulation or formal)

    Implementation

    Are skew and delay bounds on the crossing paths met?

    STA with CDC constraints

    Lessons in this topic

    7 lessons, about 45 min

    1. 1RulesYou can read a CDC report (violations, cautions, info), decide between a fix and a waiver, and state what a clean report does not prove.5 min
    2. 2SimulationYou can build a hostile CDC simulation with unrelated periods, offsets, jitter and perturbation models, and judge it by window hits per crossing.4 min
    3. 3Assertion PatternsYou can write the four CDC protocol properties (request holds, data stable, ack needs request, Gray one bit) and bind each to the right clock.5 min
    4. 4FIFO TestsYou can build a handshake-only FIFO scoreboard, state its interface contract, and add coverage, assertions, reset scenarios and mutations for an async FIFO.5 min
    5. 5SignoffYou can fill in a CDC signoff table, allocate a FIT budget across crossings, and trace a late finding to the check that would have caught it.5 min
    6. 6Reading a CDC ReportYou can sort CDC findings into classes, confirm each one in the RTL, choose the standard fix, and write a waiver whose evidence would catch the bug it waives.10 min
    7. 7A CDC Mini ProjectYou can build a two-clock block from a synchroniser, a handshake, an async FIFO and per-domain resets, list every crossing with its scheme, and prove it with a hostile test and mutants.11 min

    Interview

    A strong answer to “how do you verify CDC?” names all four layers and gives one concrete example for each, including what a mutation (injected bug) showed.

    Check yourself A design passes all simulations with two exact-ratio clocks. Why is that weak evidence for CDC?

    With commensurate clocks the relative phase takes only a few values, so the metastability window may never be hit. Random phases, ratios and jitter are needed (the simulation lesson measures this).

    Revision sheet

    The whole topic on one page, taken from each lesson's Remember box. Read it before an interview, or print it.

    Rules

    • A violation needs a fix or a justified waiver. A caution needs review. A missing info entry means the tool did not see the intended structure.

    • A waiver carries a reason, an owner and a review date, under version control.

    • Logic in front of a synchroniser can glitch on the sampling edge, so register in the source domain first.

    Rule of thumb: name synchroniser modules consistently, so the tool knows the approved ones and custom structures stand out.

    Simulation

    • Zero window hits on a crossing is inconclusive, not a pass. Change the ratio, offset or jitter and run longer.

    • Hostile timing has seven ingredients: unrelated periods, random offsets, jitter, perturbation models, random resets, long runs and hit coverage.

    • Plain RTL simulation does not model analog metastability. Hits show exposure to the model's window, not a failure probability.

    Assertion Patterns

    • Bind the Gray one-bit check to the registered source pointer and source clock, once for each FIFO direction.

    • A slow destination can skip Gray values: 000 to 011 is a legal two-bit change there. Never apply the one-step check to destination samples.

    • Stay in the simple SVA subset (implication, $past, $stable, $rose, fixed delays) so the checks run in every assertion-capable flow.

    FIFO Tests

    • r_data must be the word consumed at that edge (show-ahead). A registered-read FIFO needs a latency-aware checker.

    • Check the queue size against the depth as well as the data, or overflow goes unseen.

    • After one dropped word, every later read mismatches, so a real bench may stop at the first error.

    Rule of thumb: a test that cannot fail on a known-bad FIFO is not a CDC test.

    Signoff

    • FIT = 10^9 / MTBF hours. Sum every crossing, including each synchroniser bit, against the allocation.

    • Window-hit counts cannot supply reliability parameters. Use characterised cells, PVT and the implemented settling time.

    • Keep the signoff table in the repository and update it each release.

    Rule of thumb: classify, use the matching structure, constrain, check structurally, simulate hostile, and prove the tests catch injected bugs.

    Reading a CDC Report

    • A per-bit synchroniser is wrong whenever bits change on the same edge, whether they form one bus or rejoin later (reconvergence).

    • A counter crosses as registered Gray code; data crosses by handshake or async FIFO; related flags are consolidated to one bit first.

    • Only quasi-static values are waived, and the waiver names the write condition, the assertion that checks it and what voids it.

    Rule of thumb: fix by class, and waive only what an assertion keeps proving.

    A CDC Mini Project

    • List every signal that crosses the boundary and give each one a scheme: a level synchroniser, a handshake, Gray pointers or a FIFO.

    • Data held under a protocol needs a max-delay constraint, not a synchroniser; per-bit synchronisers on it can make it worse.

    • A passing run counts only with its numbers: several seeds, window hits on every crossing, and each mutant shown to fail.

    Rule of thumb: no crossing without a scheme, no seed count of one, no pass without window hits.

    Practise it

    • Practice question: Waveform debug of a CDC glitch causing metastability

    • Practice question: Inline RTL checkers: X/Z detection and handshake liveness

    • Practice question: CDC FIFO read data mismatch from clock misalignment

    • Code lab: Gray code sync bus

    • Code lab: CDC handshake

    • Interview: run a mock interview on this topic

    PreviousNext: Rules

    Up next

    Up nextRules

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Reset Architecture
    • Metastability and Synchronisation
    • Asynchronous FIFO