1
2
3
4
5
6
7
8
9
10
11

// not-run: Verilator 5.048 ignores covergroups (COVERIGN) and Icarus 13 has none; the bins model counts it
covergroup proto_cg @(posedge clk iff txn_done);
  cp_dir  : coverpoint is_write { option.weight = 1;
                                  bins rd = {0}; bins wr = {1}; }
  cp_resp : coverpoint resp     { option.weight = 3;   // plan-critical
                                  bins okay = {0}; bins exok = {1};
                                  bins slverr = {2}; bins decerr = {3}; }
  cp_id   : coverpoint txn_id   { option.weight = 0;   // feeds the cross only
                                  bins ids[4] = {[0:15]}; }
  x_id_resp : cross cp_id, cp_resp { option.weight = 2; }
endgroup

1
2
3
4
5
6
7
8
9
10
11
12
13

// not-run: Verilator 5.048 ignores covergroups (COVERIGN) and Icarus 13 has none; the bins model counts it
covergroup err_cg @(posedge clk iff txn_done);
  option.goal = 90;            // plan accepts 90% on this group

  cp_err : coverpoint err_kind {
    option.at_least = 4;       // a bin needs 4 hits to count
    bins parity  = {0};
    bins timeout = {1};
    bins crc     = {2};
  }
endgroup
// With at_least = 4, a bin hit twice is still uncovered.
// Stimulus must exercise each error repeatedly, not by luck.

1
2
3
4
5
6
7
8

// not-run: Verilator 5.048 ignores covergroups (COVERIGN) and Icarus 13 has none; the bins model counts it
covergroup cg @(posedge clk);
  type_option.weight  = 2;        // this type counts double in the scope rollup
  type_option.comment = "vplan section 4";
  option.per_instance = 1;        // instance-level knob

  cp : coverpoint mode { bins m[4] = {[0:3]}; }
endgroup

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// uses: covmodel
// The weighted rollup from this lesson, then at_least and goal on an error coverpoint.
module tb_weights;
  cm_group proto = new("proto_cg");
  cm_point cp_dir = new("cp_dir"), cp_resp = new("cp_resp"), cp_id = new("cp_id"), cp_err = new("cp_err");
  cm_cross x_id_resp;
  initial begin
    real weighted, unweighted;
    cp_dir.add("rd", 0, 0); cp_dir.add("wr", 1, 1);                                     // option.weight = 1
    cp_resp.add("okay", 0, 0); cp_resp.add("exok", 1, 1); cp_resp.add("slverr", 2, 2); cp_resp.add("decerr", 3, 3);
    cp_resp.weight = 3;                                                                 // plan-critical
    cp_id.add_split("ids", 0, 15, 4);  cp_id.weight = 0;                                // feeds the cross only
    x_id_resp = new("x_id_resp", cp_id, cp_resp);  x_id_resp.weight = 2;
    proto.points.push_back(cp_dir); proto.points.push_back(cp_resp); proto.points.push_back(cp_id);
    proto.crosses.push_back(x_id_resp);
    begin
      int dirs[4] = '{0, 1, 0, 1};
      int ids[4]  = '{0, 4, 8, 12};
      int resps[4] = '{0, 1, 0, 1};                                                     // no error responses yet
      foreach (ids[i]) begin cp_dir.sample(dirs[i]); cp_id.sample(ids[i]); cp_resp.sample(resps[i]); x_id_resp.sample(); end
    end
    proto.report();
    weighted = proto.get_coverage();
    cp_dir.weight = 1; cp_resp.weight = 1; cp_id.weight = 1; x_id_resp.weight = 1;      // every weight left at 1
    unweighted = proto.get_coverage();
    $display("  weighted %0.2f%%, unweighted %0.2f%%: same simulation", weighted, unweighted);
    // option.at_least = 4 and option.goal = 90 on the error coverpoint.
    cp_err.add("parity", 0, 0); cp_err.add("timeout", 1, 1); cp_err.add("crc", 2, 2);
    cp_err.at_least = 4; cp_err.goal = 90;
    repeat (4) cp_err.sample(0);
    repeat (2) cp_err.sample(1);                                                        // seen, but not 4 times
    repeat (5) cp_err.sample(2);
    cp_err.report();
    if (weighted != 50.0 || unweighted != 68.75 || cp_err.n_covered() != 2) $fatal(1, "FAIL: rollup math");
    $display("PASS: weighted 50%% against unweighted 68.75%%; timeout hit twice is still a hole at at_least 4");
    $finish;
  end
endmodule