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
  • 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
    • Pre-Silicon and Post-Silicon
    • Validation Strategy
    • Observability in Silicon
    • Debugging Silicon Failures
    • Margins and Characterisation
    • Errata and Workarounds
    • Closing the Loop
    • Drills: Post-Silicon Validation
  • 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 11: Post-Silicon Validation
  1. Topics
  2. First Principles of Verification Strategy
  3. Part 11: Post-Silicon Validation
  4. Observability in Silicon

Part 11 · Post-Silicon Validation · Senior (S)

Observability in Silicon

In silicon, the only internal signals anyone can see are those the designers chose to make visible. Status registers and counters show summaries; trace buffers record a window of selected signals around a trigger; scan dumps freeze the whole state of the chip for offline reading. What each mechanism shows, what it costs in area, and how they combine to explain a failure.

On this page

    Note

    Level: Senior (S) · Answers: What do we do when the chip comes back?

    Before this: Validation Strategy, Observability

    Lesson 3.2 noted that DCRouter's credit counters are invisible at its pins, so a lost credit shows only as lower throughput. In simulation that was an inconvenience; a credit audit made it visible. In silicon, after hours of traffic, an output that has slowed to a crawl is exactly that symptom, and no audit can be run on the testbench's terms. Whether the cause can be seen depends entirely on what the designers put in the chip.

    How do you see inside a chip?

    The obvious answer, and why it breaks

    The obvious hope is to probe the chip like a board, or to rely on the external interfaces. Internal signals are not reachable by probes, and external behaviour is usually far removed from the cause, both in place and in time. What can be seen inside silicon is decided at design time, by the observability features built in.

    The idea: four mechanisms, from summary to snapshot

    A debug port gives the lab access to status and counters, trace buffers, scan chains and trigger logic designed into the chip.

    Mechanism

    Shows

    Cost

    Limit

    Status registers

    Current state summaries (locks, sleep, modes)

    Tiny

    Only what was chosen; only the present

    Event and performance counters

    How often things happened (errors, packets, stalls)

    Small

    Counts, not order or timing

    Trace buffers

    A recorded window of selected signals or transactions around a trigger

    Medium (memory)

    Short window, few signals, chosen in advance

    Scan dumps

    Every flip-flop's value at one moment, read out through the scan chains

    Reuses test scan; the chip stops

    One snapshot, and the clock must be stopped

    Trigger logic

    When to capture: an event, a counter value, a synthesised assertion

    Small

    Triggers must be designed or programmable

    Debug access usually rides on a standard test port such as JTAG (fact V13), which also reaches the scan chains used for manufacturing test.

    DCRouter in silicon

    Symptom

    What would show the cause

    An output slows to a crawl

    Credit counts in STATUS (if added, lesson 3.6); a trace of out_vld and out_crd

    Traffic stops on one input

    STATUS sleep and lock bits; PKT_CNT; a trace triggered on in_vld held high with in_rdy low for 1,000 cycles

    Packets arrive with out_err unexpectedly

    ERR_CNT per input; a trace of headers and tails at that output

    Everything stops

    A scan dump: FIFO pointers, locks, owners and credits all at once

    Designing observability in

    • Status for hidden state: credits, occupancy, state machines (lesson 3.6).

    • Counters for rates: errors, packets, stalls, retries.

    • Trace on key interfaces: transaction-level where possible, so the window holds more history.

    • Programmable triggers: including synthesised versions of key assertions (lesson 10.6).

    • Scan dump support: a way to stop clocks cleanly and read the state.

    How real teams build silicon observability

    Practice

    Purpose

    On-chip debug and trace infrastructure on every major interface

    Windows of history around failures

    Performance monitoring units

    Counts and rates for performance and anomaly detection

    Scan-dump flows linked to the RTL's flip-flop names

    A frozen state readable as RTL signals

    What breaks

    Lesson 11.2's cache-controller story is the typical cost of missing observability: six weeks of experiments for a cause a small trace buffer would have shown in an afternoon. The opposite failure is real too: trace buffers placed on interfaces where nothing ever goes wrong, and none on the new, risky block. Observability should follow the risk ranking (lesson 9.3).

    Why this matters

    Senior lens. Review observability with the same risk ranking as verification: status and counters everywhere, trace and triggers on the riskiest interfaces, scan dumps as the last resort. Every hidden state that simulation needed an audit to see is a candidate for a status register in silicon.

    Interview

    Asked: "How do you see inside a chip?"

    Weak answer: Probe the internal signals with an oscilloscope.

    Strong answer: Only through what was designed in. Status registers and event counters give summaries and rates; trace buffers record a window of selected signals or transactions around a programmable trigger; scan dumps stop the clock and read every flip-flop through the test scan chains for one full snapshot; all reached through a debug port such as JTAG. I'd put status and counters everywhere, trace and triggers on the riskiest interfaces, and make sure hidden state that simulation needed audits to see, like credit counts, has a status register.

    Follow-ups: (1) What does a trace buffer cost? (2) When would you use a scan dump?

    Check yourself Why is a scan dump useful for a total hang but not for a slow-down?

    A hang is a frozen state worth one snapshot; a slow-down is a history of events, which needs counters or a trace over time.

    Check yourself Which DCRouter hidden state from earlier lessons would most deserve a status register in silicon?

    The credit counts: lost credits show only as reduced throughput, and simulation needed a credit audit to see them.

    Key takeaways

    • In silicon you see only what was designed to be visible.

    • Status and counters summarise; trace buffers record windows; scan dumps snapshot everything.

    • Place observability by risk, and give hidden state status registers.

    Keep going

    Next: Lesson 11.4, Debugging Silicon Failures. From symptom to root cause with almost no visibility.

    Related topics

    • Part 11 overview: Post-Silicon Validation

    • DFT course: Scan Fundamentals

    Previous

    109 / 160

    Next: Debugging Silicon Failures

    Up next

    Up nextDebugging Silicon Failures

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Pre-Silicon and Post-Silicon
    • Margins and Characterisation
    • Errata and Workarounds