1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// not-run: fragment (bus_txn is the class from the previous lesson; clk and drive() are not defined here)
// Typical test-level mix of all three tools:
task run_traffic(bus_txn t);
  int n_txns, mode;

  // joint local decision: std::randomize
  assert (std::randomize(n_txns, mode) with {
            n_txns inside {[10:50]};
            mode   inside {[0:2]};
            (mode == 2) -> n_txns > 30;    // stress mode needs volume
          });

  repeat (n_txns) begin
    assert (t.randomize());                 // transaction: class solve
    drive(t);
    repeat ($urandom_range(0, 5))           // simple gap: plain draw
      @(posedge clk);
  end
endtask

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

// not-run: fragment (clk and send_burst() are not defined here)
task drive_idle_gap();
  int unsigned gap;
  bit [3:0]    burst;

  // Solve gap and burst TOGETHER under shared constraints
  if (!std::randomize(gap, burst) with {
        gap inside {[1:100]};
        burst inside {[1:8]};
        gap > burst * 10;          // relationship between the two
      })
    $error("std::randomize failed");

  repeat (gap) @(posedge clk);
  send_burst(burst);
endtask

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// not-run: illustration with no self-check; Icarus also rejects a $urandom seed that is not a variable
module top;
  bit [31:0] raw;
  int unsigned d6;
  initial begin
    raw  = $urandom;                  // full 32-bit draw
    d6   = $urandom_range(6, 1);      // inclusive [1:6]
    d6   = $urandom_range(1, 6);      // same: arguments may be swapped
    raw  = $urandom(42);              // seed is an input expression: reseeds this
                                      // thread's RNG (unlike $random's inout seed)

    // What $urandom CANNOT do:
    //   pick (a,b) with a+b==100        -> needs std::randomize with
    //   honor class legality rules      -> needs class randomize
    //   cyclic no-repeat values         -> needs randc
  end
endmodule

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

module tb_tools;
  int ok, n_txns, mode, gap;
  initial begin
    // 1. std::randomize solves local variables jointly.
    repeat (100) begin
      if (!std::randomize(n_txns, mode) with { n_txns inside {[10:50]}; mode inside {[0:2]}; (mode == 2) -> n_txns > 30; })
        $fatal(1, "FAIL: std::randomize failed");
      if (mode == 2 && n_txns <= 30) $fatal(1, "FAIL: stress mode with only %0d txns", n_txns);
    end
    // 2. $urandom_range: bounds inclusive, arguments in either order.
    repeat (100) begin
      gap = $urandom_range(5, 0);
      if (gap < 0 || gap > 5) $fatal(1, "FAIL: gap %0d", gap);
    end
    $display("PASS: std::randomize and $urandom_range held their rules");
    $finish;
  end
endmodule

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

typedef enum bit [1:0] {DATA = 2'd0, CTRL = 2'd1, ERR = 2'd2} kind_e;

// PacketFIFO transaction with rand fields: the solver now builds legal packets.
class pkt_txn;
  rand kind_e     kind;
  rand bit [1:0]  dest;
  rand bit [3:0]  len;
  rand bit [7:0]  payload[8];          // fixed size; only the first len bytes are sent
  constraint c_len  { len inside {[1:8]}; }

  function bit [7:0] header();
    return {kind, dest, len};
  endfunction

  function bit [7:0] check_byte();
    bit [7:0] c = header();
    for (int i = 0; i < len; i++) c ^= payload[i];
    return c;
  endfunction
endclass

module tb_pkt_rand;
  pkt_txn p = new();
  int lens[int];
  int kinds[int];
  initial begin
    repeat (500) begin
      if (!p.randomize()) $fatal(1, "FAIL: randomize failed");   // every call checked
      if (p.len < 1 || p.len > 8) $fatal(1, "FAIL: illegal len %0d", p.len);
      lens[int'(p.len)]++;
      kinds[int'(p.kind)]++;
    end
    $display("lengths seen: %0d of 8, kinds seen: %0d of 3", lens.num(), kinds.num());
    if (lens.num() != 8 || kinds.num() != 3) $fatal(1, "FAIL: some legal value never appeared");
    $display("PASS: 500 checked solves gave legal packets covering every length and kind");
    $finish;
  end
endmodule