This chapter moves from generating and checking stimulus to closing on it: what "done" actually means once the DUT is an entire chip.
Coverage at the SoC level isn't a bigger version of coverage at the block level - it measures fundamentally different things, because the questions worth asking are different. This article covers what a coverage model built for full-chip scale should actually target.
11 min read | Intermediate Level
What You'll Learn
- Why scaling a block-level coverage model up to SoC size produces mostly noise
- The specific things an SoC-level coverage model should actually measure
- Why scenario and cross-core coverage generally have to be hand-built rather than generated for free
- Why closing coverage at this scale usually needs a directed, not purely random, approach
Why Block-Level Coverage Doesn't Just Scale Up
A block-level covergroup typically crosses a handful of fields from a single transaction type - an address range against a burst length against a handful of control bits - because that's the entire legal input space for one interface, and every cross in it corresponds to something a directed engineer would reasonably want tested.
Extend that same instinct to the SoC level and the cross-product explodes: cross every master's address space against every slave's, against every QoS value, against every outstanding-transaction depth, and the covergroup produces bins numbering in the hundreds of thousands. Most of those bins describe combinations nobody asked to verify, some don't correspond to anything the design can even do, and the ones that do matter get buried in the noise of everything that doesn't.
An SoC-level coverage model has to be built by asking what's actually worth knowing, not by mechanically crossing every available signal.
What an SoC-Level Coverage Model Actually Targets
- Reachability and access coverage. For every master, which slaves and memory regions did it actually reach, and did every legal path defined by the address map and decode logic get exercised at least once? A large-scale interconnect coverage model built this way, tracking a reachability matrix of allowed master-to-slave paths, can easily run into hundreds of cover items and well over a hundred thousand bins on a chip with many masters and slaves - a scale that's only manageable because every bin maps directly to a specific, meaningful legal path from the address map, not an arbitrary cross.
- Scenario coverage. Which scenarios from the virtual-sequence library actually ran, in which combinations - tracking that the DMA-transfer scenario and the interrupt-storm scenario have both run concurrently, for instance, not just that each ran on its own at some point. This is generally the hardest category to get for free: most stimulus-generation frameworks are still weak at natively tracking which sequence of actions actually executed and in what temporal relationship to each other, so teams typically sample this by hand - a simple covergroup fed by an enum recording which scenario the virtual sequencer just selected, crossed against whatever else was running concurrently.
- Cross-core and multi-core interaction coverage. Which pairs of cores contended for the same lock, the same shared memory region, or the same peripheral, and at what kind of timing offset - directly measuring whether the multi-core stress testing covered earlier in this series actually landed on real contention, rather than assuming it did because the test ran.
- Configuration coverage. Which combinations of IP and system configuration - clock ratios, power states, peripheral settings - were actually exercised, since a bug that only appears at one particular configuration is invisible to a coverage model that never tracked configuration as a coverage axis in the first place.
- Arbitration and QoS coverage. At each point of contention in the interconnect, which quality-of-service values were actually driven, and which masters actually won arbitration against which others - a category of coverage that only exists once multiple masters are contending for the same resource at the same time, which no single master's own testbench could ever produce.
// Scenario coverage sampled explicitly, since the virtual sequencer's
// scenario selection isn't tracked as coverage on its own
covergroup scenario_cg with function sample(scenario_id_t active[$]);
option.per_instance = 1;
cp_scenario: coverpoint active[0] {
bins dma_transfer = {SCEN_DMA_TRANSFER};
bins irq_storm = {SCEN_IRQ_STORM};
bins coherency_test = {SCEN_COHERENCY_LITMUS};
}
// Cross with a second concurrently-active scenario, capturing
// combinations the virtual sequencer allowed to overlap
cp_concurrent: coverpoint (active.size() > 1) ? active[1] : SCEN_NONE;
cx_overlap: cross cp_scenario, cp_concurrent;
endgroup
Formal, PSS-based scenario generation faces the same gap: current tooling is generally strong at generating a legal sequence of actions but weak at expressing coverage goals over the temporal relationships between them, which is exactly why this category tends to end up as a hand-built covergroup fed by the environment rather than something the stimulus-generation layer reports automatically.
Code Coverage's Smaller Role at This Scale
Code coverage - statement, branch, and expression coverage against the RTL itself - still runs at the SoC level, but it stops being the primary closure metric the way it often is at the block level. See chipverify.com's Code Coverage page for the underlying metrics if a refresher is useful.
At full-chip scale, code coverage is mainly valuable for catching a narrower, integration-specific problem: RTL that's structurally unreachable because of how blocks were wired together or configured at the SoC level - a tie-off that permanently disables a code path, a configuration register whose reset value makes an entire branch dead, a mode that's wired unreachable by the way two blocks were connected.
Functional coverage, not code coverage, is what actually answers whether the scenarios, configurations, and interactions that matter got exercised.
Coverage from the Software Side
A meaningful slice of SoC-level coverage doesn't come from the SystemVerilog testbench at all - it comes from what the embedded C tests actually exercised on the processor side. Whether every interrupt source was actually taken and its handler entered, whether every interrupt priority level got exercised (including a higher-priority interrupt preempting a lower-priority handler already in progress), and whether every documented error-recovery code path in the software stack was actually reached are all coverage questions that only the software side can answer, since none of that state is visible as a signal-level covergroup could track it.
This is usually collected as a much simpler, mostly boolean coverage model - did this ISR run, did this recovery path execute - written into a shared memory location or control register the SystemVerilog side polls and folds into the same coverage database as everything else, rather than a full cross-coverage model in its own right.
Merging Coverage Across Many Regressions
An SoC's full coverage picture never comes from one regression run. Block-level regressions, SoC-level simulation, emulation, and sometimes formal all contribute their own share of functional and code coverage, often from different tools entirely.
The Unified Coverage Interoperability Standard (UCIS) exists specifically to make this practical: it defines a common format and API for coverage data so results from different simulators, formal tools, and emulation platforms can be merged into one database instead of being compared by hand, combining coverage across multiple runs over time, across different sections of the design, and across genuinely different tool types.
Coverage closure sign-off at the SoC level is almost always a question about this merged view, not about any single regression's own report - a scenario covered once in a block-level regression and never again at the SoC level still counts as covered in the merged database, which is exactly the point.
Closing Coverage at This Scale
With hundreds of thousands of meaningful bins instead of a few hundred, closing coverage by simply running more constrained-random regression and hoping the remaining holes fall out by chance becomes impractical - the CPU time needed to randomly stumble into the last few percent of a coverage model this large can dwarf the time spent on everything before it.
Some teams address this with coverage-guided regression tools that analyze which bins are still open, identify which of them are actually reachable together versus mutually exclusive, and generate new randomization seeds specifically steered toward the remaining gaps rather than resampling the same well-covered space - reported reductions in regression CPU time of several times over compared to undirected re-runs are common with this approach, precisely because most of a large regression's runtime is normally spent re-covering bins that closed long ago.
Common Mistakes
Building the SoC-level coverage model by copying a block-level covergroup structure and scaling it up.
Mechanically crossing every available signal produces a coverage model dominated by meaningless bins. Start from what's actually worth knowing at this level - reachability, scenarios, configuration, contention - not from what fields happen to be available to cross.
Treating a high overall coverage percentage as proof of closure without checking category by category.
A high aggregate number can hide a scenario-coverage or cross-core-coverage category that's still mostly empty, especially since those categories tend to be smaller and easier to lose inside a large reachability-coverage total.
Only measuring coverage on legal stimulus and ignoring whether negative tests actually hit their targets.
A negative test that injects a fault but never confirms the specific error path was reached leaves that category of coverage completely blind, even though the test itself reports as passing.
Summary
In this article, you learned:
- Scaling a block-level coverage model's crossing approach up to SoC size produces mostly meaningless bins instead of a bigger, still-useful coverage model
- Reachability/access coverage, scenario coverage, cross-core interaction coverage, configuration coverage, and arbitration/QoS coverage are the categories that actually matter at full-chip scale
- Scenario and cross-core coverage generally have to be sampled explicitly by the environment, since most stimulus-generation frameworks don't natively track temporal relationships between actions as coverage
- A reachability-style coverage model can reach hundreds of thousands of bins and still be meaningful, because every bin maps to a specific legal path rather than an arbitrary cross
- Closing coverage at this scale typically needs a directed, gap-aware regression strategy rather than relying on undirected constrained-random runs to find the remaining holes by chance
- Code coverage still runs at the SoC level but mainly catches RTL made unreachable by integration wiring or configuration, rather than serving as the primary closure metric
- A meaningful slice of coverage - interrupt handling, priority preemption, software error-recovery paths - can only be measured from the embedded C test side, not from a signal-level covergroup
- Coverage closure sign-off is almost always a question about a merged view across many regressions and tools, which is exactly the problem the UCIS standard exists to solve