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
    • Self-Checking Testbenches
    • Where to Check
    • Assertions as Local Checkers
    • Scoreboards
    • How Precise a Reference Model?
    • Ordering and Timing in Checks
    • End-of-Test Checks
    • False Passes
    • Checking Performance
    • Hunting the Zoo with Checkers
    • Drills: Checking
  • 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

‹First Principles of Verification Strategy
  1. Topics
  2. First Principles of Verification Strategy
  3. Part 5: Checking

Part 5 · Checking · All levels

Part 5: Checking

How do we know the output is right? Choose between local assertions and end-to-end scoreboards for a given rule.

  • 11topics
  • 11lessons
On this page

    Part 5 answers: How do we know the output is right?

    Where Part 5 sits among the sixteen questions of the course.

    Stimulus without checking is a demonstration. Checking decides, for every output, whether it is right: locally, with assertions at the place a rule applies, or end to end, with a scoreboard comparing outputs against a reference model.

    This part covers self-checking testbenches, where to check, assertions, scoreboards, how precise a reference model must be, checking reordered and dropped outputs, end-of-test checks, checking performance, and the quiet failure every DV engineer must guard against: a checker that checks nothing.

    After this part you can

    • Choose between local assertions and end-to-end scoreboards for a given rule.

    • Build checks that catch lost, duplicated and reordered outputs.

    • Prove that a checker actually works.

    Warm-up: three questions from Part 4

    Answer each in your head before opening it. If two or more feel shaky, revisit Part 4: Stimulus first.

    Check yourself Why does uniform random rarely hit rare corners?

    If a corner has probability p per trial, hitting it once takes about 1/p trials on average; for small p that is far beyond any regression.

    Check yourself What does a constraint model?

    The legal environment of the design: what the real neighbours may send.

    Check yourself A test fails once in 1,000 seeds. What does that tell you?

    Something real and rare is wrong, in the design or the testbench; the seed reproduces it, and the failure rate says roughly how rare the triggering condition is.

    Lessons

    #

    Lesson

    Level

    Status

    5.1

    Self-Checking Testbenches

    F · Foundation

    Ready

    5.2

    Where to Check

    W · Working

    Ready

    5.3

    Assertions as Local Checkers

    W · Working

    Ready

    5.4

    Scoreboards

    W · Working

    Ready

    5.5

    How Precise a Reference Model?

    S · Senior

    Ready

    5.6

    Ordering and Timing in Checks

    S · Senior

    Ready

    5.7

    End-of-Test Checks

    W · Working

    Ready

    5.8

    False Passes

    S · Senior

    Ready

    5.9

    Checking Performance

    S · Senior

    Ready

    5.10

    Hunting the Zoo with Checkers

    S · Senior

    Ready

    —

    Drills and checkpoint

    all levels

    Ready

    Every lesson in this part is ready. Work through them in order: each one sets up the problem the next one solves.

    Tip

    DCRouter in this part. Steps 6 and 7: assertions and a scoreboard for DCRouter; which zoo bugs now fail. DCRouter is the small router you verify across the course, with 24 planted bugs; see Meet DCRouter.

    Where other courses go deeper

    This course teaches the decisions behind verification. These lessons teach the tools and syntax that carry them out, so this part links to them instead of repeating them.

    • SystemVerilog course: SVA

    • UVM course: Checking

    • Protocols course: Ordering-Aware Scoreboards

    Related topics

    • Course hub

    • Previous: Part 4 · Stimulus

    • Next: Part 6 · Coverage

    PreviousNext: Self-Checking Testbenches

    Up next

    Up nextSelf-Checking Testbenches

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • How to Use This Course
    • Reading Paths
    • Concept Map