SystemVerilog Coverage Options

A covergroup's raw bin hits are only half the story. Coverage options control how that raw hit data actually turns into a reported percentage — how many hits a bin needs before it counts as covered, what target counts as "done," and how much one covergroup's score should count when it's combined with others into a single project-wide number.

13 min read | Intermediate Level

What You'll Learn

• The difference in scope between option and type_option
• How at_least changes exactly how many hits a bin needs before it counts as covered
• How goal lets a covergroup report 100% before every one of its bins has actually been hit
• How weight controls how much a covergroup contributes when combined into an aggregate coverage score
• What auto_bin_max, per_instance, and comment each control

option vs type_option

Both are set the same way — option.name = value; or type_option.name = value; inside a covergroup — but they apply to different things. option controls settings for one specific covergroup instance (or acts as that instance's own default). type_option controls settings for the covergroup type as a whole, shared identically across every instance of it, and can't be overridden per instance.

at_least: How Many Hits Count as Covered

By default, a single hit is enough for a bin to count as covered. at_least raises that threshold:

covergroup cg @(posedge clk);
  cp_addr: coverpoint addr {
    option.at_least = 3;   // a bin needs 3 hits before it counts as covered
    bins low  = {[0:63]};
    bins high = {[64:127]};
  }
endgroup

If addr falls in the low range only twice during a test, that bin is not counted as covered yet — at_least requires 3 hits, and only 2 have happened. It takes a third hit before the bin flips to covered and starts contributing to the reported percentage.

goal: A More Achievable Target

goal sets what percentage of actual bin hits gets reported as "100% done" for that covergroup:

covergroup cg @(posedge clk);
  option.goal = 80;   // reported as fully covered once 80% of bins are hit

  cp_mode: coverpoint mode {
    bins b[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};   // 10 explicit bins
  }
endgroup

If 8 of the 10 mode bins are actually hit — 80% of them — this covergroup reports 100% coverage, since it met the goal that was set. The other 2 bins are still genuinely unhit; the goal just means reaching them isn't required for this covergroup to be considered complete.

weight: Contribution to a Combined Score

When several covergroups are combined into one overall project coverage number, weight controls how much each one counts in that combination — a plain average by default, or a weighted one if set:

covergroup cg1 @(posedge clk);
  option.weight = 5;   // counts 5x as much in a combined score
  ...
endgroup

covergroup cg2 @(posedge clk);
  option.weight = 1;   // default weight
  ...
endgroup

If cg1 is at 100% and cg2 is at 0%, a plain average would report 50% combined. With cg1 weighted 5 times as heavily as cg2, the combined score instead becomes (5×100 + 1×0) / (5+1) = 83.3% — cg1's score dominates the combined result, in proportion to its weight.

auto_bin_max, per_instance, and comment

Three more commonly-used options, each simpler than the ones above:

• option.auto_bin_max = N; — caps how many bins are automatically created for a coverpoint that doesn't explicitly define its own bins. The default is 64; a coverpoint covering a wide value range without explicit bins gets split into up to this many automatically-sized bins.
• option.per_instance = 1; — by default, coverage from multiple instances of the same covergroup (for example, one inside a class that gets constructed many times) is combined into a single aggregate result. Setting this reports each instance's own coverage separately instead, which matters when it's important to know whether every individual instance was exercised, not just the group as a whole.
• option.comment = "..."; — a plain documentation string attached to the coverage report, with no effect on the calculated percentage at all.

Common Beginner Mistakes