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
  • Reconvergence and Gray Coding16
  • Reset Domain Crossing16
  • Architecture and Design Rules16
  • CDC Signoff Methodology24
  • RDC Signoff16
  • Debug and Case Studies11
    • Reading a CDC Report
    • Classic Bug Anatomy
      • Lost Pulse Bug
      • Torn Bus Bug
      • FIFO Pointer Bug
      • Reset Release Bug
    • Case Studies
  • CDC and RDC Interview Prep30
  • Capstone: Sign Off a Multi-clock Peripheral4
Loading lesson

‹Classic Bug Anatomy
  1. Topics
  2. CDC & RDC
  3. Debug and Case Studies
  4. Classic Bug Anatomy
  5. Torn Bus Bug

Part 9 · Debug and Case Studies · Advanced

Torn Bus Bug

Impossible values on a crossed bus: how tearing looks in debug data, the finding behind it, and the guard that closes it.

On this page

    The symptom is data nobody sent: a control register reads a value the source never wrote, or a state machine takes a transition its inputs cannot explain, once in thousands of runs. In a waveform the signature is a destination word that matches neither the old nor the new source value for exactly the synchroniser latency, then settles to the new value. In a log it is a single impossible sample surrounded by correct ones.

    What the mechanism is

    The tearing mechanism itself is taught in the bus-tearing lesson of the metastability section, with its own simulated waveform: bits of one word arriving through independent synchronisers mix old and new values whenever several bits change together. This lesson adds only the debug angle, so read that lesson first and return here with the picture in mind.

    Recognising it in the lab

    Observation

    Points to tearing when

    Points elsewhere when

    An impossible intermediate value

    It lasts exactly the synchroniser depth, then corrects itself.

    It persists: that is a logic bug, not a crossing.

    Which transitions tear

    Single-bit steps are free of tearing (the settling rules still apply); multi-bit steps tear.

    Single-bit steps corrupt too: suspect the synchroniser structure itself.

    Failure rate versus traffic

    Rises with transition rate on the bus.

    Constant per boot regardless of traffic: suspect reset or initialisation.

    The finding that would have caught it

    Structural analysis reports the multi-bit bus crossing without a protocol, the same class the violation-classes lesson lists. The debug question for the report is always whether the finding was absent or was waived: absent means a setup hole such as a missing clock, while waived as quasi-static without qualification evidence means the waiver process failed, not the analysis.

    Fix and regression guard

    Fix it with the pattern that fits the value type: Gray code for stepping counters, a handshake or load pulse for arbitrary words, a FIFO for streams. The guard is structural first and directed second: a standing check that no multi-bit bus crosses without a recognised protocol, plus a directed test that steps the bus through its worst multi-bit transitions, such as 0111 to 1000, with skew in the model. A thousand random crossings prove nothing; the all-bits-change transition is the one that tears.

    Common pitfall

    Matching layout delays between the bits narrows the vulnerable span but never removes it, and the residual must be re-proven after every route change. Accept skew matching as hardening, never as the safety argument or the waiver.

    Check yourself A lab trace shows the destination reading a value the source never sent for exactly two destination cycles after a bus step, then the correct value. Tearing or logic bug?

    Tearing: the duration matches the synchroniser depth and it self-corrects. A logic bug would persist or repeat deterministically.

    Check yourself The report never flagged the bus, yet it tears. What are the two candidate explanations?

    Either the analysis never saw the crossing because of a setup hole, or it flagged it and the finding was waived without evidence. Check the setup and the waiver log in that order.

    Related topics

    • Bus Tearing

    • Safe Patterns Overview

    • Lost Pulse Bug

    Previous

    140 / 179

    Next: FIFO Pointer Bug

    Up next

    Up nextFIFO Pointer Bug

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Reset Release Bug