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
39
40
41
42
43
44
45
46

class axi_txn;
  rand bit [31:0] addr;
  rand bit [3:0]  len;
  rand bit [2:0]  size;
  rand bit        is_wrap;

  constraint align_c { addr % (1 << size) == 0; }
  constraint size_c  { size inside {[3'd2:3'd3]}; }  // planted: 4- or 8-byte beats
  constraint wrap_c  { is_wrap -> len inside {1, 3, 7, 15}; }
  constraint page_c  { addr[11:0] + ((len + 1) << size) <= 4096; }
  constraint hot_c   { addr inside {[32'h1001:32'h1003]}; }  // no multiple of 4
endclass

module top;
  initial begin
    axi_txn t;
    bit saved_align, saved_size, saved_wrap, saved_page, saved_hot;
    t = new();
    if (!t.randomize()) begin
      // Binary search: disable half, test, then narrow the guilty half.
      saved_align = t.align_c.constraint_mode();
      saved_size  = t.size_c.constraint_mode();
      t.align_c.constraint_mode(0);
      t.size_c.constraint_mode(0);
      if (t.randomize()) $display("conflict involves the align/size half");
      // Restore each block to its own saved state, never to a blanket 1.
      t.align_c.constraint_mode(saved_align);
      t.size_c.constraint_mode(saved_size);
      // Step 2: disable the other half and test again.
      saved_wrap = t.wrap_c.constraint_mode();
      saved_page = t.page_c.constraint_mode();
      saved_hot  = t.hot_c.constraint_mode();
      t.wrap_c.constraint_mode(0);
      t.page_c.constraint_mode(0);
      t.hot_c.constraint_mode(0);
      if (t.randomize()) $display("the other half also takes part: the core spans both");
      t.wrap_c.constraint_mode(saved_wrap);
      t.page_c.constraint_mode(saved_page);
      t.hot_c.constraint_mode(saved_hot);
      // Next: split each half again. The core is align_c, size_c, hot_c.
    end
    else $fatal(1, "FAIL: the planted conflict solved");
    $display("PASS: the planted conflict failed and both halves took part");
    $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

class axi_txn;
  rand bit [31:0] addr;
  rand bit [3:0]  len;
  rand bit [2:0]  size;
  rand bit        is_wrap;
  constraint align_c { addr % (32'd1 << size) == 0; }
  constraint size_c  { size inside {[3'd2:3'd3]}; }               // 4- or 8-byte beats
  constraint wrap_c  { is_wrap -> len inside {1, 3, 7, 15}; }
  constraint page_c  { 32'(addr[11:0]) + ((32'(len) + 1) << size) <= 4096; }
  constraint hot_c   { addr inside {[32'h1001:32'h1003]}; }       // planted: no multiple of 4

  // Switch one named block on or off by index.
  function void set_block(int i, bit on);
    case (i)
      0: align_c.constraint_mode(on);
      1: size_c.constraint_mode(on);
      2: wrap_c.constraint_mode(on);
      3: page_c.constraint_mode(on);
      4: hot_c.constraint_mode(on);
    endcase
  endfunction
endclass