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
  • Memory & Buses57
  • Advanced RTL28
  • Senior & Interview76
    • Low-Power RTL Hub
    • DFT and Scan Hub
    • Physical Awareness Hub
    • Waveform Debug Hub
    • STA and ECO Hub
    • RTL-to-Implementation Closure
    • DFT-Ready RTL
    • Capstone: Resilient Streaming Peripheral
    • Principal Design Review
    • Senior RTL Interview Questions & Model Answers
      • Interview: Combinational and Arithmetic
      • Interview: Sequential and Pipelines
      • Interview: FSM and Control
      • Interview: Timing and STA
      • Interview: CDC and Reset
      • Interview: Memories and Buses
      • Interview: Low-Power Design
      • Interview: Debug and ECO
        • X-propagation discipline
        • Why simulation and silicon disagree
        • Capturing an intermittent failure
        • ECO or RTL change
      • Interview: Coding and Whiteboard
  • Glossary and Notation
Loading lesson

‹Interview: Debug and ECO
  1. Topics
  2. RTL Design
  3. Senior & Interview
  4. Senior RTL Interview Questions & Model Answers
  5. Interview: Debug and ECO
  6. Capturing an intermittent failure

Part 9 · Senior · Senior

Capturing an intermittent failure

A three-phase method for intermittent failures: reproduce from a seed, trigger on first divergence, then narrow.

On this page

    Why this matters

    A failure once in fifty runs cannot be debugged by rerunning until it passes. The interviewer asks how to capture it to see if you have a method: reproduce, trigger, narrow.

    After this lesson you can: list what a full replay configuration contains, set a trigger with pre-failure history, and shrink a failing case.

    The question

    The interviewer describes a regression that fails once in fifty runs and asks how to capture it. The question tests method under uncertainty. The answer is a loop: reproduce, trigger, narrow.

    Model answer

    Reproduce with a full run manifest; if it does not fail on demand, go back and reproduce. Then trigger with a checker at the earliest divergence and pre-trigger history. Then narrow one knob at a time; if the case does not yet fit one wave window, narrow again. Finally trace causes backward and fix.
    The capture loop: reproduce until the failure is on demand, trigger at the earliest divergence, then narrow until the case fits one waveform window.

    Follow the arrows from the top. The two loops are where the time goes: each one repeats until its question answers yes.

    • The first loop ends only when the failure happens every time from the saved manifest.

    • The trigger sits once, between the loops, so every narrowing run is judged by the same checker.

    • The second loop ends when the smallest failing case fits one waveform window.

    Reproduce first. Preserve the seed and random-stream setup, plusargs, source revision and local diff, tool version/options, defines, parameter overrides, input files, memory initialization, reset/clock schedule and external responses. Record hashes for replay inputs and scheduling/parallelism options. A seed alone is not a full run configuration.

    Trigger second. Place a checker on the earliest observed divergence and retain pre-trigger history with a simulator-supported circular waveform buffer or an explicit transaction/state ring buffer. Freeze that buffer on failure and retain a bounded post-trigger tail. If only forward dumping is available, deterministic replay must enable dumping before the known failure window; enabling a dump at the failure cannot reconstruct earlier waves.

    Narrow third. Vary one knob at a time, halve the stimulus, and walk the hierarchy from the top-level mismatch down to the block. Stop when the smallest failing case fits in one wave window.

    Phase

    Goal

    Artifact kept

    Reproduce

    The same failure on demand

    Complete run manifest and immutable replay inputs

    Trigger

    The earliest observed failing cycle

    Checker plus buffered pre-trigger history or replay dump started before the window

    Narrow

    The smallest failing case

    Minimal stimulus plus hierarchy path

    Interview

    Strongest one-line answer: seed it, trigger on the first divergence, halve until small.

    Follow-ups

    • The same seed passes in rerun. What does that mean? Keep several hypotheses open: omitted configuration/input differences, changed random-stream consumption, testbench driver/observer races, DUT scheduling races, uninitialized state or external nondeterminism. Compare manifests and input traces first; with identical inputs, find the first internal divergence and inspect event ordering. A bench race can expose a DUT race, so do not assume two independent bugs or assign blame from the seed alone.

    • The failure needs overnight runs to appear. How do you shorten the loop? Constrain the randomization toward the failing neighborhood and shorten the test while keeping the trigger armed. Each halving of runtime doubles the experiments per night.

    Common wrong answers

    • “Rerun until it passes and move on.” A passing rerun without a root cause is not evidence. The bug ships with the design.

    • “Turn dumping on only after failure.” Forward dumping loses the causal history. Use a circular buffer, bounded state/transaction history, or deterministic replay with dumping enabled ahead of the known window; filter scope and time to keep it readable.

    Common pitfall

    Start with the earliest observed divergence, not only the last mismatch. Then trace its causes backward: latent corruption can precede observation, and independent failures need not share one root cause.

    Check yourself A checker fires ten thousand cycles after an earlier visible failure. What should improve?

    Add checks closer to the violated invariant and retain earlier state/transaction history. An earlier observation reduces the search, but still needs causal tracing; the trigger itself is not proof of root cause.

    Check yourself Two knobs changed between the passing and failing runs. What now?

    Change one at a time. With two moving knobs no result identifies the cause.

    Remember

    • A seed alone is not a run configuration. Record source revision, tools, defines, parameters, inputs and reset schedule.

    • Trigger on the earliest divergence and keep pre-trigger history in a circular buffer. Dumping after the failure loses causes.

    • Vary one knob at a time and halve the stimulus until the failure fits in one wave window.

    Rule of thumb: seed it, trigger on the first divergence, halve until small.

    Keep going

    • Interview: run a mock interview on this topic

    Related topics

    • Self-checking and observability

    • Useful runtime instrumentation

    Previous

    343 / 350

    Next: ECO or RTL change

    Up next

    Up nextECO or RTL change

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • X-propagation discipline