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
    • Intent and the Oracle
    • From Prose to Rules
    • Reference Models
    • Tables and Executable Specifications
    • Specification Review and Ambiguity
    • Requirements Traceability
    • What Not to Check
    • Drills: Specifications as Checkable Rules
  • 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 2: Specifications as Checkable Rules
  1. Topics
  2. First Principles of Verification Strategy
  3. Part 2: Specifications as Checkable Rules
  4. Specification Review and Ambiguity

Part 2 · Specifications as Checkable Rules · Senior (S)

Specification Review and Ambiguity

A specification review led by the people who must verify it finds bugs before any RTL exists. The questions a verifier asks of every requirement (reset, limits, errors, simultaneous events, modes), a worked review of a draft DCRouter section, and what to do while an answer is pending.

On this page

    Note

    Level: Senior (S) · Answers: What exactly are we checking against?

    Before this: Specification Bugs, From Prose to Rules

    The cheapest bug a verification engineer will ever find is one found in a meeting, in a document, before a line of RTL exists. Fixing it costs an edit to a paragraph. The same disagreement found in simulation costs debug time and RTL changes; found in silicon, a respin. Yet many teams start verification only when the RTL is ready, and read the specification only to write tests.

    How should a verifier review a specification, and what questions find the gaps?

    The obvious answer, and why it breaks

    The obvious review reads the document for errors: typos, wrong numbers, contradictions. That finds the easy problems. The expensive ones are silences: the document says nothing about what happens at reset, at a limit, on an error, or when two events coincide. Silence reads as "nothing special happens", and each reader fills it differently. A verifier's review is a hunt for silences.

    The idea: ask every requirement the same questions

    Question

    Typical silence it exposes

    What happens at reset, and in the first cycles after it?

    Reset values, start-up order, what may be sent before initialisation

    What happens at each limit (full, empty, maximum, zero)?

    Off-by-one boundaries, saturation versus wrap

    What happens on an error, and who is told?

    Error responses, counters, recovery

    What if two events happen in the same cycle?

    Priorities between simultaneous updates

    Does it hold in every mode and configuration?

    Behaviour when features are disabled

    How soon, exactly?

    Latency, ordering, "eventually"

    How would I check it?

    Anything that cannot become an assertion or model prediction

    A worked review: a draft DCRouter section

    Suppose an early draft of DCRouter's error section read as follows. The questions a verifier would file are listed under it.

    Diagram
    Draft:  "Packets with a bad CRC are flagged with out_err and counted in ERR_CNT.
             Software can clear the counters."
    
    Q1  Flagged on which flit? The tail only, or every flit of the packet?
    Q2  Counted per input or per output? (One counter per port, but which port?)
    Q3  What happens when a counter reaches its maximum: saturate or wrap?
    Q4  Does clearing one counter clear the others?
    Q5  Is a header with len = 0 a CRC error, another kind of error, or legal?
    Q6  Is the packet still forwarded when its CRC is bad, or dropped?
    Q7  Is out_err set for high-priority packets exactly as for low-priority ones?

    Every question became part of DCRouter's final rules R5, R8 and R9, and five of them match Bug Zoo bugs: what is counted, and where (Q2, BUG_14 counts port 2's good packets), saturation (Q3, BUG_15), independent clearing (Q4, BUG_19), length 0 (Q5, BUG_4) and priority (Q7, BUG_13). Each silence in the draft was a place a real bug could hide.

    While an answer is pending

    • File it, with an owner and a date: a question in a hallway is forgotten; a filed one is answered.

    • Choose the strictest reasonable reading for checks in the meantime, and mark the check as provisional.

    • Do not let the RTL answer it: "whatever the design does" is not a specification.

    • Track open questions as risk: unanswered questions at sign-off are part of residual risk (Part 14).

    How real teams run specification reviews

    Practice

    Purpose

    Verification sign-off on the specification before RTL

    Gaps are found when they cost a paragraph

    A question list per specification section

    Every silence is asked about systematically

    Questions tracked like bugs

    Owners, answers and versions are recorded

    What breaks

    A project (illustrative) started verification only after RTL freeze. The first week of writing checks produced 47 questions about the specification; 12 led to RTL changes, two of them in blocks already integrated. A review at the specification stage would have asked the same questions when the answers cost nothing to implement.

    Why this matters

    Senior lens. Start verification at the specification. A verifier's first deliverable is a list of precise questions, not tests, and the number of questions answered before RTL starts is one of the best predictors of a calm project. Silences in a specification are not neutral; they are bugs that have not chosen their form yet.

    Interview

    Asked: "What do you do with an ambiguous requirement?"

    Weak answer: Ask the designer what the RTL does and check that.

    Strong answer: File it as a specification question with an owner, and get a written answer from whoever owns the spec, not from the RTL, because "whatever the design does" isn't a specification. While waiting, I write the check against the strictest reasonable reading and mark it provisional. I find these early by reviewing every requirement with the same questions: reset, limits, errors, simultaneous events, modes, timing, and how I'd check it. Open questions at sign-off are part of residual risk.

    Follow-ups: (1) Why not use the designer's interpretation? (2) Which question finds the most gaps?

    Check yourself A requirement says "the counter is cleared by software". List three questions a verifier should ask.

    Any three of: cleared by a write of any value or a specific one? Does clearing one counter clear others? What if hardware increments it in the same cycle as the clear? What is read back immediately after? Can it be cleared in every mode?

    Check yourself Why is "check whatever the RTL does" a bad answer to an ambiguity?

    It turns the design into its own specification, so any bug in that behaviour becomes the expected result and can never fail.

    Key takeaways

    • Specification review by verifiers finds bugs when they cost an edit to a paragraph.

    • Ask every requirement about reset, limits, errors, simultaneous events, modes, timing and how to check it.

    • File every question, check the strictest reading meanwhile, and never let the RTL answer it.

    Keep going

    Next: Lesson 2.6, Requirements Traceability. From requirement to check to coverage to result.

    Related topics

    • Part 2 overview: Specifications as Checkable Rules

    Previous

    29 / 160

    Next: Requirements Traceability

    Up next

    Up nextRequirements Traceability

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Intent and the Oracle
    • From Prose to Rules
    • Reference Models