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

// not-run: class only, no module, and crc32() is not defined here
class eth_frame;
  rand bit [7:0]  payload[];
  rand bit [11:0] vlan_id;
  bit  [31:0]     fcs;          // NOT rand: derived, not solved
  bit             vlan_en;      // state knob set by the test

  constraint c_size { payload.size() inside {[46:1500]}; }

  function void pre_randomize();
    // setup the solver's world BEFORE it runs
    vlan_id.rand_mode(vlan_en);   // freeze vlan_id unless enabled; the mode
                                  // is sticky, so set it on every call
  endfunction

  function void post_randomize();
    // derive what the solver cannot: a function of the random result
    fcs = crc32(payload);
  endfunction
endclass

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

// snippet: the trap, shown, never run
class msg;
  rand bit [7:0] data[4];
  bit            parity;

  function void post_randomize();
    parity = ^{data[0], data[1], data[2], data[3]};   // derive: fine

    // THE TRAP: re-randomizing inside the hook re-enters the hooks,
    // re-solves everything, and burns randc slots. Never do this:
    // if (parity) assert (this.randomize());
  endfunction
endclass

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

// snippet: msg is the class above; external_filter_ok() stands for any outside check
// Call-site retry pattern (instead of hook recursion):
module top;
  msg m = new();
  int tries = 0;
  bit ok;
  initial begin
    do begin
      assert (m.randomize());
      tries++;
      ok = external_filter_ok(m);
    end while (!ok && tries < 100);
    // Test ok, not tries == 100: the 100th try may have succeeded.
    if (!ok) $error("could not produce acceptable msg");
  end
endmodule
// Better still: encode the filter rule as a constraint,
// so the solver only ever produces acceptable messages.