A Cross That Can Never Close

Where the interviewer goes next. Open a node to practise that follow-up.

WhyWhat IfProve ItBreak ItCompare

1. A Cross That Can Never Close
2. WhyWhat Binsof and Intersect SelectL1 Junior

   Explain what binsof(c) intersect {READ} selects. Why not just name the bin?

   Reveal the Model Answer

   binsof(c) means all the bins of coverpoint c. Adding intersect {READ} keeps only the bins whose values include READ. For an enum with automatic bins, you never wrote the bin names. Selecting by value is simpler, and it survives a bin rename. When you did name a bin, as with l.long_, binsof(l.long_) picks it directly.

   Self-Check

   Tick each key point you covered in your answer.

   Key point 1 binsof(c) means all the bins of coverpoint c. Key point 2 Adding intersect {READ} keeps only the bins whose values include READ. Key point 3 For an enum with automatic bins, you never wrote the bin names. Key point 4 Selecting by value is simpler, and it survives a bin rename. Key point 5 When you did name a bin, as with l.long_, binsof(l.long_) picks it directly.

   Misconception

   "intersect means the value must equal every listed value."

   It keeps bins that share at least one value with the list. intersect {[5:8]} keeps any bin overlapping that range.

   Source IEEE 1800-2017 §19.6.1

   • Lesson C5Cross Coverage
3. CompareA Cross vs Two Guarded CoverpointsL1 JuniorL2 Mid-Level

   Compare the cross with exclusions against two coverpoints guarded by the command. What does this version print?

   module tb;
     typedef enum bit {READ, WRITE} cmd_t;
     cmd_t cmd;
     bit [3:0] len;
     covergroup cg;
       rd_len: coverpoint len iff (cmd == READ)  { bins one = {1}; bins short_ = {[2:4]}; }
       wr_len: coverpoint len iff (cmd == WRITE) { bins one = {1}; bins short_ = {[2:4]}; bins long_ = {[5:8]}; }
     endgroup
     cg cov = new();
     initial begin
       for (int i = 1; i <= 4; i++) begin cmd = READ;  len = 4'(i); cov.sample(); end
       for (int i = 1; i <= 4; i++) begin cmd = WRITE; len = 4'(i); cov.sample(); end
       $display("covergroup=%0.2f (reads complete, writes missing long)", cov.get_coverage());
     end
   endmodule
   

   Reveal the Model Answer

   It prints 83.33. The read coverpoint has only the legal read lengths, so it closes at 100%. The write coverpoint is missing long_, so it reads 66.67%, and the group averages the two. Splitting needs no exclusions, and each coverpoint reads clearly. A cross is better when many fields combine, because guarded coverpoints multiply quickly.

   RUNVerilator (coverage build) · simulator service

   Edit the code, then run it

   OutputWaves

   RunReset codeExpected: covergroup=83.33 (reads complete, writes missing long)

   Self-Check

   Tick each key point you covered in your answer.

   Key point 1 It prints 83.33. Key point 2 The read coverpoint has only the legal read lengths, so it closes at 100%. Key point 3 The write coverpoint is missing long_, so it reads 66.67%, and the group averages the two. Key point 4 Splitting needs no exclusions, and each coverpoint reads clearly. Key point 5 A cross is better when many fields combine, because guarded coverpoints multiply quickly.

   Half-Truth

   "Guarded coverpoints and a cross always give the same number."

   The covergroup averages its items, so one hole weighs differently in each model. Here a missing write bin costs 16.67 points. Compare items, not totals.

   Source IEEE 1800-2017 §19.11

   • Lesson C5Cross Coverage
4. What IfWhen the Impossible Cell HappensL2 Mid-Level

   What if the design one day accepts a long READ? Who notices?

   Reveal the Model Answer

   Nobody, if the only trace of the rule is the ignore_bins. The ignored cell takes the hit silently, and coverage stays at 100%. Every exclusion needs a matching check, such as an assertion on the interface or a scoreboard error. The exclusion keeps the number honest, and the check catches the bug.

   Self-Check

   Tick each key point you covered in your answer.

   Key point 1 Nobody, if the only trace of the rule is the ignore_bins. Key point 2 The ignored cell takes the hit silently, and coverage stays at 100%. Key point 3 Every exclusion needs a matching check, such as an assertion on the interface or a scoreboard error. Key point 4 The exclusion keeps the number honest, and the check catches the bug.

   Buzzword Without Mechanism

   "The exclusion documents the rule, so the rule is verified."

   Documenting is not checking. A coverage exclusion tells the tool not to count; it never compares behaviour against the spec.

   Source Mehta, SystemVerilog Assertions and Functional Coverage (3rd ed.), §26.19 guidelines (PDF p477)

   • Lesson C5Cross Coverage
   • Lesson A1.1Why Assertions
5. Break ItOne Wrong Operator in an Ignore ExpressionL2 Mid-Level

   How could the exclusion itself hide holes? Suppose someone writes || instead of &&.

   Reveal the Model Answer

   With ||, the expression selects every READ cell and every long cell, so it removes four of the six cells. Only WRITE one and WRITE short remain, and short writes alone close the cross. Review exclusions by listing the cells they remove, not by reading the expression.

   Cell	Removed with &&	Removed with ||
   READ, one	no	yes
   READ, short	no	yes
   READ, long_	yes	yes
   WRITE, one	no	no
   WRITE, short	no	no
   WRITE, long_	no	yes

   Listing the removed cells shows the mistake at once: || removes four cells instead of one.

   Self-Check

   Tick each key point you covered in your answer.

   Key point 1 With ||, the expression selects every READ cell and every long cell, so it removes four of the six cells. Key point 2 Only WRITE one and WRITE short remain, and short writes alone close the cross. Key point 3 Review exclusions by listing the cells they remove, not by reading the expression.

   Misconception

   "|| and && give the same result here, since only one cell is impossible."

   || takes the union of the two selections. The twin closes the cross with two short WRITEs.

   Run It

   The exclusion written with ||, and a regression of short WRITEs.

   RUNVerilator (coverage build) · simulator service

   Edit the code, then run it

   OutputWaves

   RunReset codeExpected: cross alone=100.00 after short WRITEs only FAIL: with || the ignore removed every READ cell and every long cell, so short WRITEs close the cross

   See the Fix

   module tb;
     typedef enum bit {READ, WRITE} cmd_t;
     cmd_t cmd;
     bit [3:0] len;
     covergroup cg;
       c: coverpoint cmd;
       l: coverpoint len { bins one = {1}; bins short_ = {[2:4]}; bins long_ = {[5:8]}; }
       x: cross c, l {
         ignore_bins rd_long = binsof(c) intersect {READ} && binsof(l.long_);   // the fix: both conditions
       }
     endgroup
     covergroup cross_only;   // the same cross alone, to read its own number
       c: coverpoint cmd { option.weight = 0; }
       l: coverpoint len { bins one = {1}; bins short_ = {[2:4]}; bins long_ = {[5:8]}; option.weight = 0; }
       x: cross c, l { ignore_bins rd_long = binsof(c) intersect {READ} && binsof(l.long_); }
     endgroup
     cg cov = new();
     cross_only xo = new();
     initial begin
       // The regression only ever sent short WRITEs.
       cmd = WRITE; len = 1; cov.sample(); xo.sample();
       cmd = WRITE; len = 3; cov.sample(); xo.sample();
       $display("cross alone=%0.2f after short WRITEs only", xo.get_coverage());
       if (xo.get_coverage() == 100.0) $display("FAIL: with || the ignore removed every READ cell and every long cell, so short WRITEs close the cross");
       else $display("PASS: with && only READ/long is removed, and the READ and long cells stay as holes");
     end
   endmodule
   

   Prints: cross alone=40.00 after short WRITEs only PASS: with && only READ/long is removed, and the READ and long cells stay as holes

   • Lesson C5Cross Coverage
   • Lesson C7Closing Holes
6. Prove ItSolve 7.5.9: The Cross That Can Never CloseSimulator-graded

   Show it, don't just say it: this Silicon Lab problem is graded by the simulator.

   Open Problem 7.5.9