1
2
3
4
5
6
7
8
9

// snippet: checked in the bench below
class dma_txn;
  rand bit       small_mode;
  rand bit [7:0] len;

  constraint len_c { small_mode -> len <= 8; }
endclass
// small_mode==1 implies len in 0..8.
// small_mode==0 leaves len in 0..255: full range, NOT len above 8.

1
2
3
4
5
6
7
8
9
10

// snippet: checked in the bench below
class bi_demo;
  rand bit       flag;
  rand bit [3:0] val;

  constraint c1 { flag -> val == 9; }
  constraint c2 { val inside {[0:7]}; }   // 9 is impossible here
endclass
// flag==1 needs val==9, but c2 forbids 9, so every solution has flag==0.
// randomize still SUCCEEDS here: solutions exist, with flag forced to 0.

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

// snippet: checked in the bench below
class pkt;
  rand bit        jumbo;
  rand bit [13:0] len;

  // Both branches pinned down, with no open hole:
  constraint len_c {
    if (jumbo) len inside {[1501:9000]};
    else       len inside {[64:1500]};
  }

  // Identical meaning written as two implications:
  constraint len_c2 {
    jumbo  -> len inside {[1501:9000]};
    !jumbo -> len inside {[64:1500]};
  }
endclass

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

// snippet: a richer shape, same rules
class mem_txn;
  typedef enum {READ, WRITE, ATOMIC} op_e;
  rand op_e      op;
  rand bit [3:0] burst;
  rand bit       locked;

  constraint shape_c {
    // Atomic ops are single-beat and locked
    op == ATOMIC -> (burst == 1 && locked == 1);
    // Writes longer than 8 beats stay unlocked
    (op == WRITE && burst > 8) -> locked == 0;
  }
endclass
// (op==WRITE && burst>8) -> locked==0 is the flattened form of
// op==WRITE -> (burst>8 -> locked==0): identical solution set.

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

// snippet: the two classes, run in the bench below
class skew_demo;
  rand bit       flag;
  rand bit [3:0] val;
  constraint c { flag -> val == 9; }
endclass

class shaped_demo;
  rand bit       flag;
  rand bit [3:0] val;
  constraint c { flag -> val == 9; }
  constraint order_c { solve flag before val; }
endclass

1
2
3
4
5
6
7
8
9

// snippet: errors only at one address, made likely by ordering
class bus_txn;
  rand bit        inject_err;
  rand bit [31:0] addr;
  constraint err_c {
    inject_err -> addr == 32'hDEAD_BEEF;
    solve inject_err before addr;
  }
endclass

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

class skew_demo;
  rand bit       flag;
  rand bit [3:0] val;
  constraint c { flag -> val == 9; }
endclass

class shaped_demo;
  rand bit       flag;
  rand bit [3:0] val;
  constraint c { flag -> val == 9; }
  constraint order_c { solve flag before val; }
endclass

module tb_solve_order;
  skew_demo   s = new();
  shaped_demo h = new();
  int n = 1700;
  int sf = 0, hf = 0;
  int pairs_s[int], pairs_h[int];
  initial begin
    repeat (n) begin
      if (!s.randomize() || !h.randomize()) $fatal(1, "FAIL: randomize failed");
      if ((s.flag && s.val != 9) || (h.flag && h.val != 9)) $fatal(1, "FAIL: an illegal pair");
      sf += s.flag;
      hf += h.flag;
      pairs_s[{s.flag, s.val}]++;
      pairs_h[{h.flag, h.val}]++;
    end
    $display("legal pairs reached: without solve-before %0d, with it %0d (17 exist)", pairs_s.num(), pairs_h.num());
    $display("flag == 1: without solve-before %0d of %0d (%0.1f%%), with it %0d (%0.1f%%)", sf, n, 100.0 * sf / n, hf, 100.0 * hf / n);
    $display("standard: about 5.9%% without solve-before, about 50%% with it");
    $display("PASS: all %0d solves of both classes were legal pairs", 2 * n);
    $finish;
  end
endmodule