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 Paths
  • Concept Map
  • Meet DCRouter
  • Glossary
  • Part 0: What Verification Is8
  • Part 1: What Can Go Wrong11
    • A Taxonomy of Bugs
    • Specification Bugs
    • Corner Cases and Boundaries
    • Concurrency and Races
    • Integration and Interface Bugs
    • Configuration and Mode Bugs
    • Performance Bugs
    • Reset, Clock and Power Bugs
    • Where Bugs Hide
    • Classifying the Bug Zoo
    • Drills: What Can Go Wrong
  • Part 2: Specifications as Checkable Rules8
  • Part 3: Observability and Controllability7
  • Part 4: Stimulus11
  • Part 5: Checking11
  • Part 6: Coverage10
  • Part 7: Formal and Simulation10
  • Part 8: Verification Levels and Reuse8
  • Part 9: Planning and Risk9
  • Part 10: Emulation and Prototyping8
  • Part 11: Post-Silicon Validation8
  • Part 12: Bug Economics8
  • Part 13: Debug7
  • Part 14: Sign-Off7
  • Part 15: Verification in Context8
  • Part 16: Case Studies5
  • Part 17: Capstones5
  • Part 18: Interview Preparation6
Loading lesson

‹Part 1: What Can Go Wrong
  1. Topics
  2. First Principles of Verification Strategy
  3. Part 1: What Can Go Wrong
  4. Reset, Clock and Power Bugs

Part 1 · What Can Go Wrong · Senior (S)

Reset, Clock and Power Bugs

Reset values, clock-domain crossings and power states break designs in ways ordinary RTL simulation is poor at seeing: X values that look like zeros, metastability that simulation never models, power domains that simulators keep alive. What each class needs, and where it is checked.

On this page

    Note

    Level: Senior (S) · Answers: What can go wrong?

    Before this: Performance Bugs

    Three chips, three escapes (illustrative). One booted only on some boards, because a register without reset started random and the RTL simulation had quietly initialised it to zero. One corrupted data once a day, because a signal crossed between two clocks without a synchroniser, and simulation, which has no metastability, never failed. One hung after waking from sleep, because the simulator had kept a powered-down block alive and holding its state. Each was correct in RTL simulation.

    Which bugs does ordinary RTL simulation miss, and what finds them?

    The obvious answer, and why it breaks

    The obvious assumption is that a thorough RTL simulation covers reset, clocking and power along with everything else, since they are all in the RTL. But plain RTL simulation is an idealised model: registers can start as zero or X depending on the simulator and settings, every clock crossing behaves perfectly, and power is never actually removed. Each idealisation hides a whole class of real failures.

    The idea: three classes, three blind spots

    Class

    What goes wrong in silicon

    Why plain RTL simulation misses it

    What finds it

    Reset

    Wrong reset values; flops without reset start random; reset released in the wrong order

    Uninitialised state may simulate as 0 or as X that is masked by optimistic logic

    Reset-value checks, X-propagation analysis, reset-order tests

    Clock-domain crossing

    Metastability, lost or duplicated pulses, incoherent multi-bit data

    Simulation has no metastability and fixed clock ratios

    Structural CDC analysis, protocol checks on crossings, randomised clock ratios

    Power

    State lost on power-down, missing isolation, wrong retention, failed wake

    Without power-aware simulation, blocks are never powered down

    Power-aware simulation with the power intent, power-state coverage

    Where each belongs in the plan

    • Reset: read every register after reset and compare with the specification; check that no X reaches outputs; test reset in the middle of traffic and in different orders across domains.

    • Clock crossings: run structural CDC analysis on the netlist or RTL, not simulation alone; check the protocol of every handshake crossing; vary clock ratios in simulation.

    • Power: simulate with the power intent applied so domains really lose state; cover every power-state transition, including wake with work pending.

    How real teams split the work

    Class

    Primary method

    Where the detail lives

    Reset

    Register reset checks, X-propagation and formal reset analysis

    Formal and RTL courses

    Clock-domain crossing

    Structural CDC and RDC analysis plus targeted simulation

    CDC and RDC course

    Power

    Power-aware simulation, power-state coverage

    Low-power verification course

    What breaks

    DCRouter has one reset bug and three low-power bugs. The reset bug, port 3 disabled after reset (BUG_17), is visible to any test that reads CTRL or sends on port 3. The power bugs need tests that let DCRouter go idle and sleep: losing an output's lock when it sleeps mid-packet (BUG_20), failing to wake from port 3 (BUG_21), and dropping credit returns while asleep (BUG_22). A test that keeps traffic flowing never sleeps, and never sees any of them. (DCRouter has a single clock, so it has no crossing bugs; the CDC and RDC course covers those.)

    Why this matters

    Senior lens. Plain RTL simulation is a model with known idealisations: perfect clocks, no metastability, no power removal, and whatever the simulator does with uninitialised state. List those idealisations explicitly in the plan, and for each, name the method that covers what it hides. Bugs in these classes are rarely subtle; they are invisible to the wrong tool.

    Interview

    Asked: "What bugs does RTL simulation miss?"

    Weak answer: Timing bugs.

    Strong answer: Anything its idealisations hide. Reset bugs, because uninitialised flops may simulate as zero or as an X that optimistic logic masks, so I check reset values and X-propagation explicitly. Clock-domain crossing bugs, because simulation has no metastability and fixed clock ratios, so they need structural CDC analysis and protocol checks on crossings. Power bugs, because without power-aware simulation nothing is ever powered down, so state loss, isolation and wake bugs need the power intent applied. Plus anything that needs real timing or analog behaviour, which belongs to STA and silicon validation.

    Follow-ups: (1) Why isn't simulation enough for CDC? (2) What does power-aware simulation add?

    Check yourself A flop has no reset and the design works in simulation. Why might it fail on silicon?

    It powers up in a random state; the simulator may have started it at 0 or masked an X, hiding behaviour that depends on its initial value.

    Check yourself Which DCRouter bugs can a test with continuous traffic never find?

    The low-power bugs (BUG_20, BUG_21, BUG_22): DCRouter only sleeps after 8 idle cycles.

    Key takeaways

    • Plain RTL simulation idealises reset, clocks and power, hiding whole classes of bugs.

    • Reset needs value and X checks, crossings need structural CDC analysis, power needs power-aware simulation.

    • Name each idealisation in the plan and the method that covers it.

    Keep going

    Next: Lesson 1.9, Where Bugs Hide. Bugs cluster in new, complex and changed logic: spending effort where they are.

    Related topics

    • Part 1 overview: What Can Go Wrong

    • CDC and RDC course

    • Low-power verification course: Power-Aware Simulation

    Previous

    21 / 160

    Next: Where Bugs Hide

    Up next

    Up nextWhere Bugs Hide

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • A Taxonomy of Bugs
    • Specification Bugs
    • Corner Cases and Boundaries