SystemVerilog assertions catch a bug at the exact clock cycle and the exact signal where it happens, which is precisely what a scoreboard checking a transaction long after the fact can't do. This chapter has looked at generating and injecting stimulus at the SoC level; this article looks at the other half of the picture - where assertions actually live once the DUT is an entire chip, and what changes about how they get used.

7 min read | Intermediate Level

What You'll Learn

  • The three places assertions actually live in an SoC-level environment, and where each one comes from
  • What makes a block-level assertion reusable at the SoC level without rewriting it
  • What a genuinely new, SoC-specific assertion looks like, as distinct from a reused one
  • Why assertion density is a real performance tradeoff at this scale, and how teams manage it

Assertions Don't Get Reinvented at SoC Level - They Get Sourced

This article assumes familiarity with SVA syntax and the basics of assertion-based checking; chipverify.com's own Assertion Based Verification page is a good reference if any of that needs a refresher. What's specific to the SoC level isn't the language - it's where the assertions actually come from. Almost none of them get written fresh against the full-chip DUT. Instead, an SoC-level environment ends up with assertions from three distinct sources, each doing a different job.

Three Places Assertions Actually Live

  • Reused block-level checkers. Every IP block typically ships with its own bundled assertions, checking things like FSM legality, one-hot signals, and internal protocol timing. These ride along automatically once the block is instantiated in the full chip - nothing about them changes at integration, because they check properties entirely local to that block's own logic.
  • Reused interface-level protocol checkers. The same protocol checkers bundled with a block-level UVC - the ones that verify a bus interface never violates its own handshake rules - get reused at the SoC level the same way the UVC itself does: instantiated in passive mode, watching the real interface, checking the same protocol-legality properties they always checked, just against a real DUT-to-DUT connection instead of a DUT-to-testbench one.
  • New, SoC-specific cross-block assertions. A small number of assertions genuinely have to be written new, because they check a property that only exists once multiple blocks are connected - a request issued on one interface has to produce a completion on a different interface within some bounded number of cycles, or an interrupt asserted by a peripheral has to result in the interrupt controller reporting it pending within a fixed latency. Nothing at the block level could have checked this, because the property spans blocks that don't coexist in any single block's own testbench.

The first two categories dominate by sheer volume - a chip with dozens of blocks inherits thousands of assertions just by virtue of instantiating them - while the third category is usually a short, deliberately curated list, because each one has to be hand-written and hand-verified against the actual integration.

Three places SoC assertions live: block-level checkers that ride along inside each IP, interface protocol checkers reused in passive mode on real connections, and a few new cross-block assertions such as a request on one interface completing on another within a bound

What Makes a Block-Level Assertion Reusable

A checker written to be reusable across integration levels avoids hardcoding its own clock, reset, or hierarchy path, inferring them instead from wherever it happens to be instantiated or bound - which is exactly what lets the same checker module work unmodified whether it's sitting inside a block-level testbench or riding along inside a full SoC. The bind construct is what makes this practical in the first place: a checker gets attached to a target module or instance from outside that module's own source, so the same verified checker logic applies at SoC level without touching the RTL it's checking, and without needing a copy compiled specifically for the integration context.


// Bound to the RTL from outside its source - the checker doesn't need
// its own copy of clk/rst_n hardcoded, it infers them from the bind target
bind axi_slave_if axi_protocol_checker u_axi_chk (
  .clk    (aclk),
  .rst_n  (aresetn),
  .valid  (avalid),
  .ready  (aready)
);

Writing a Genuinely New Cross-Block Assertion

A cross-block assertion is usually a simple temporal property, not a heavyweight scoreboard - it checks that something happens within a bounded time of something else, using signals from two blocks that would never appear together in any single block's own checker.


// Interrupt-to-controller latency: an SoC-specific property spanning
// a peripheral's interrupt line and the interrupt controller's pending bit -
// neither block's own testbench could check this on its own
property irq_reaches_controller;
  @(posedge clk) disable iff (!rst_n)
  $rose(periph_irq) |-> ##[1:8] intc_pending[PERIPH_IRQ_ID];
endproperty

assert property (irq_reaches_controller)
  else `uvm_error("SOC_IRQ", "Peripheral IRQ did not reach controller in time")

Formal connectivity checks - confirming every port on the address map actually reaches its intended destination - are a related but separate SoC-level use of assertions, covered earlier in this series alongside address decode verification. The distinction there is exhaustive structural checking rather than a bounded-time behavioral property like the one above.

The Performance Tradeoff

Assertion density is not free. A full-chip simulation that inherits every block-level and interface-level assertion by default can see a meaningful simulation slowdown, purely from the volume of properties being evaluated every cycle across dozens of blocks at once. Teams typically respond by being deliberate about what stays enabled where: the full assertion set runs in targeted, block-focused regressions and in formal verification, where exhaustive checking is the point, while a full-chip regression run selectively disables assertions that are redundant with what a lower-level regression already exercises exhaustively, keeping only the checks that add real value at this specific level of integration.

Common Mistakes

Disabling assertions broadly for simulation performance without checking what's being lost.

Turning off entire categories of assertions to speed up a regression can silently remove the exact local, cycle-accurate detection that makes assertions valuable over a scoreboard in the first place. Disable deliberately, one redundant category at a time, not as a blanket performance fix.

Writing a new SoC-level assertion as a full scoreboard instead of a simple temporal property.

Most genuinely new cross-block assertions are bounded-time or ordering properties between a small number of signals. Reaching for a complex checker with its own state machine is usually a sign the property belongs in a scoreboard instead, not in an assertion.

Assuming block-level assertions automatically cover the properties that only exist once blocks are connected.

A block's own bundled assertions only know about that block's own internal signals. Any property that spans two blocks - a cross-block latency, an ordering requirement between two interfaces - has to be written specifically for the integration; it doesn't appear for free just because both blocks individually pass their own checks.

Summary

In this article, you learned:

  • SoC-level assertions come from three sources: reused block-level checkers, reused interface-level protocol checkers, and a small set of genuinely new cross-block assertions
  • A reusable checker infers its clock, reset, and hierarchy from its instantiation context rather than hardcoding them, and bind is what lets it attach to the RTL from outside the RTL's own source
  • A new cross-block assertion checks a property that spans multiple blocks - like a bounded-time latency between an event on one interface and a response on another - that no single block's own testbench could ever have checked
  • Assertion density has a real simulation performance cost at full-chip scale, so teams selectively disable assertions that are redundant with lower-level regressions rather than running everything by default
  • Formal connectivity checking is a related but distinct SoC-level use of assertions, aimed at exhaustive structural coverage rather than bounded-time behavioral properties
Did you find what you were looking for?

Quiz

Test Your Knowledge

1 of 5 Score: 0 / 5