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

  • Start Here4
  • UVM Foundations14
  • UVM Phases & Simulation Lifecycle26
  • Factory & Configuration15
  • Transaction-Level Modeling (TLM)13
  • UVM Sequences & Stimulus21
  • UVM Agents & Protocol VIP21
  • Environment & Test Classes11
  • Checking & Coverage in UVM21
  • UVM Register Abstraction Layer (RAL)22
  • Advanced UVM in Practice13
  • Debug & Regression10
  • Coding Practice47
  • Verification in Industry Practice10
  • Senior Prep: Architecture, Leadership and Interviews32
    • Verification Architecture and Planning
    • UVM with SVA and Formal
      • Where Assertions Live
      • Assertion Control from the Test
      • Cover Properties and Coverage Closure
      • Reusing Properties in Formal
      • Reporting Assertion Failures through uvm_report
    • Leadership and Senior Judgment
    • Interview Bank
Loading lesson

‹Senior Prep: Architecture, Leadership and Interviews
  1. Topics
  2. UVM Verification
  3. Senior Prep: Architecture, Leadership and Interviews
  4. UVM with SVA and Formal

Part 13 · Senior Prep · Intermediate

UVM with SVA and Formal

Assertions inside a UVM bench: where each rule lives, how tests control it, how covers reach closure, how formal reuses the file, and how failures reach the verdict.

  • 5topics
  • 5lessons
On this page

    A UVM bench stimulates with classes and judges with classes, but some rules are about cycles and internal state that no monitor sees. Those rules are assertions, and a senior engineer is expected to answer the integration questions around them: which rules go in a checker and which in the scoreboard, how a test switches one rule off without silencing the rest, how cover hits reach the closure report, how the same file serves a formal tool, and how a failure ends up in the verdict.

    What you will be able to do

    • Place each DMA rule in its right home (bound checker, interface, monitor or scoreboard) and defend the choice.

    • Switch one rule off for one test and one instance, from class code, and know where $assertoff stops working.

    • Bring cover-property hits into the UVM report and the plan, and catch vacuous passes.

    • Keep one property file usable by both the UVM bench and a formal tool, and replay a counterexample as a UVM test.

    • Route assertion failures into the UVM verdict, waivers and quit count, and keep one root cause from flooding the log.

    The picture: one checker, five integration questions

    Flowchart: a bound rule checker with five branches, one per lesson: placement, test control, cover closure, formal reuse and failure reporting.
    Every lesson works on the same scratch checker bound into the DMA: two assertions, three covers and one knob.

    Lessons in order

    #

    Lesson

    The question it answers

    1

    Where Assertions Live

    The fault campaign missed DONE stuck at 1 and TLAST stuck at 0. Where does each missing check belong?

    2

    Assertion Control from the Test

    A test breaks one rule on purpose. What is the narrowest switch, and why does $assertoff from a class not work?

    3

    Cover Properties and Coverage Closure

    How do cover hits reach the plan, and when is a passing assertion vacuous?

    4

    Reusing Properties in Formal

    What changes when the same file goes to a formal tool, and what comes back?

    5

    Reporting Assertion Failures through uvm_report

    One stuck flag gave 57 errors. How should assertion failures enter the verdict?

    Note

    The mechanisms are built in the industry section: Formal Alongside Simulation proves the DMA's register rules with an open-source formal flow, and Assertion VIP and bind builds a real APB protocol checker and catches a broken driver with it. Read those first if bind, assume or a counterexample are new to you; these lessons assume them.

    Start with: Where Assertions Live.

    Related topics

    • Up: Senior Prep

    • Beyond Simulation

    PreviousNext: Where Assertions Live

    Up next

    Up nextWhere Assertions Live

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Verification Architecture and Planning
    • Leadership and Senior Judgment
    • Interview Bank