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

  • RTL Foundations36
  • Combinational Design25
  • Sequential Design27
  • FSM & Control27
  • Timing & Clocking39
  • Reset & CDC34
  • Memory & Buses57
  • Advanced RTL28
    • Parameterization and Generate Hub
    • Top-Level Integration Hub
    • Synthesis Intent Hub
    • Style and Static Checks Hub
    • Assertions in RTL Hub
      • Immediate vs concurrent assertions
      • assert, cover, and assume roles
      • Common RTL property templates
      • SVA Cheat Sheet and Bug Hunt
    • Formal Verification Basics Hub
    • Reusable SystemVerilog for RTL
  • Senior & Interview76
  • Glossary and Notation
Loading lesson

‹Advanced RTL
  1. Topics
  2. RTL Design
  3. Advanced RTL
  4. Assertions in RTL Hub

Part 8 · Advanced · Advanced

Assertions in RTL Hub

What immediate and concurrent assertions check, what cover and assume add, and the RTL properties to reuse.

  • 4topics
  • 4lessons

Topics in this section

  1. 1Immediate vs concurrent assertions1 lesson
  2. 2assert, cover, and assume roles1 lesson
  3. 3Common RTL property templates1 lesson
  4. 4SVA Cheat Sheet and Bug Hunt1 lesson
On this page

    Assertions state what must hold. Immediate checks run with procedural code, clocked checks span cycles, and cover and assume complete the sign-off story.

    Construct

    Job

    Where it runs

    assert

    Flags a violation when the design breaks a rule

    Simulation and formal

    cover

    Records that a scenario was exercised

    Simulation and formal

    assume

    Promises environment behavior to constrain a proof

    Formal (constraint); simulation checks it like an assertion on the stimulus

    Lessons in this topic

    4 lessons, about 23 min

    1. 1Immediate vs concurrent assertionsYou can choose immediate or concurrent form, write a request window with `##[1:3]`, and read the failing trace from a waveform.5 min
    2. 2assert, cover, and assume rolesYou can assign assert, cover and assume to the right questions, and cover the exact antecedent of an implication.4 min
    3. 3Common RTL property templatesYou can write the four checks on one clock and reset, and place the reset check at the first active edge.4 min
    4. 4SVA Cheat Sheet and Bug HuntYou can read the common SVA operators edge by edge, go from an assertion failure line to the cycle and the RTL line that caused it, and pair key properties with covers.10 min
    Check yourself Simulation passes and every assert holds. Why ask for cover before signing off?

    Cover the exact antecedent to see whether the obligation was exercised. A stricter response-sequence cover can miss even when requests occurred. Simulation evidence, property proof and reachability are separate results.

    Interview

    Likely question: “How do assertions fit in sign-off?” Name the property, its exact trigger and scenario covers, the proof depth or simulation scope, and reviewed assumptions. A formal proof remains evidence under its assumptions even if a separate cover search misses.

    Revision sheet

    The whole topic on one page, taken from each lesson's Remember box. Read it before an interview, or print it.

    Immediate vs concurrent assertions

    • Immediate checks the values when execution reaches it; concurrent samples on the clock and reasons across cycles.

    • req |-> ##[1:3] gnt opens a window at the request and accepts a grant on any of the next three edges.

    • Use a deferred assertion in always_comb so only settled values are checked.

    Rule of thumb: sample grants before updates, and observe registered violation flags after updates.

    assert, cover, and assume roles

    • Assert states a design obligation. Cover shows a scenario is exercised or reachable. Assume constrains the environment.

    • An implication is vacuous where its antecedent never triggers; cover the antecedent to see it.

    • Keep assumes to input rules, such as cancel never riding with a request.

    Rule of thumb: grant timing is an assert, where a violation is evidence; an assume would hide it.

    Common RTL property templates

    • Handshake, mutex, reset exit and stability are the four templates; each row names what a violation means.

    • Check reset state at the first active edge, before that edge's nonblocking assignments.

    • ##[1:3] excludes the request edge; use ##[0:3] if the interface allows same-edge service.

    Rule of thumb: a service-window check shows an opportunity was met, not that starvation cannot happen.

    SVA Cheat Sheet and Bug Hunt

    • |-> checks at the same edge, |=> at the next edge, ##[m:n] at the first match from m to n edges later.

    • A |=> failure is reported at the consequent edge; the antecedent held one edge earlier. Convert the printed time from the precision unit first.

    • Count the antecedent of every important property, and fail the test when the count is zero.

    Rule of thumb: an assertion that never triggered has checked nothing; cover its antecedent.

    Practise it

    • Mini project: a reusable FIFO IP with package, interface, assertions and a formal check

    • Code lab: Immediate assert

    • Code lab: SVA cover wrapper

    • Practice question: AXI protocol checker with coverage and assertions

    • Practice question: Inline RTL checkers: X detection, handshake liveness and bindable monitors

    • Interview: run a mock interview on this topic

    How this was checked

    The finite simulation benches in this topic were executed with Icarus Verilog 13.0 (2026-10-16): each prints PASS. They use local 1ns/1ps time units, FAIL diagnostics with $fatal(1, ...), and $finish only after PASS. The course runner also recognizes FAIL text through its log parser; standalone simulator exit status needs failing termination explicitly.

    PreviousNext: Immediate vs concurrent assertions

    Up next

    Up nextImmediate vs concurrent assertions

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Parameterization and Generate Hub
    • Top-Level Integration Hub
    • Synthesis Intent Hub