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

// snippet: the classes, run in the bench below
class base_txn;
  rand bit [7:0] len;
  rand bit [3:0] prio;
  constraint len_c  { len inside {[1:16]}; }
  constraint prio_c { prio < 8; }
endclass
class jumbo_txn extends base_txn;
  // Same name: REPLACES the parent block, so relaxation works
  constraint len_c { len inside {[1:255]}; }
endclass
class urgent_txn extends base_txn;
  // New name: ADDS, so it meets the inherited blocks
  constraint urgent_c { prio inside {[6:7]}; }
endclass
// jumbo_txn:  len in [1:255] (parent [1:16] is gone), prio < 8
// urgent_txn: len in [1:16], prio in {6, 7} from prio<8 met with [6:7]

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

// snippet: two personalities of one base class
class axi_txn;
  rand bit [31:0] addr;
  rand bit [7:0]  len;
  rand bit        write;
  constraint legal_c { len inside {[1:16]}; addr[1:0] == 0; }
  constraint shape_c { soft write dist { 1 :/ 1, 0 :/ 1 }; }
endclass
// Personality 1: write-heavy small bursts near a hotspot
class hotspot_txn extends axi_txn;
  constraint shape_c {   // replaces the base shape_c
    write dist { 1 :/ 9, 0 :/ 1 };
    len inside {[1:4]};
    addr inside {[32'h8000:32'h80FF]};
  }
endclass
// Personality 2: out-of-spec lengths for error checking
class badlen_txn extends axi_txn;
  constraint legal_c { addr[1:0] == 0; }   // replaces: the len rule is dropped
  constraint bad_c   { len inside {[17:64]}; }
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
36
37
38

class axi_txn;
  rand bit [31:0] addr;
  rand bit [7:0]  len;
  constraint legal_c { len inside {[1:16]}; addr[1:0] == 0; }
  virtual function axi_txn clone_empty();
    axi_txn t = new();
    return t;
  endfunction
endclass
class hotspot_txn extends axi_txn;
  constraint legal_c { len inside {[1:4]}; addr[1:0] == 0; }
  virtual function axi_txn clone_empty();
    hotspot_txn t = new();
    return t;   // subclass object behind a base-typed handle
  endfunction
endclass
// The same idea without UVM: a virtual create hook
class txn_factory;
  static axi_txn proto = null;   // the test installs one prototype
  static function axi_txn create();
    if (proto == null) begin axi_txn t = new(); return t; end
    return proto.clone_empty();  // virtual call returns the subclass instance
  endfunction
endclass
module tb_factory;
  initial begin
    hotspot_txn proto;            // declarations first, statements after
    axi_txn t;
    proto = new();
    txn_factory::proto = proto;   // one line in the test reshapes every sequence
    t = txn_factory::create();
    void'(t.randomize());         // solves the hotspot_txn block set
    if (!(t.len inside {[1:4]}))
      $fatal(1, "FAIL: len=%0d, the base legal_c was solved", t.len);
    $display("PASS: the factory returned a hotspot_txn, len=%0d", t.len);
    $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

class base_txn;
  rand bit [7:0] len;
  rand bit [3:0] prio;
  constraint len_c  { len inside {[1:16]}; }
  constraint prio_c { prio < 8; }
endclass

class jumbo_txn extends base_txn;
  constraint len_c { len inside {[1:255]}; }      // same name: REPLACES the parent block
endclass

class urgent_txn extends base_txn;
  constraint urgent_c { prio inside {[6:7]}; }    // new name: ADDS to the inherited blocks
endclass

class badlen_txn extends base_txn;
  constraint len_c { len inside {[17:64]}; }      // replaces: out-of-spec lengths for error tests
endclass

module tb_override;
  base_txn b; jumbo_txn j; urgent_txn u; badlen_txn x;
  int jumbo_big = 0;
  initial begin
    b = new(); j = new(); u = new(); x = new();
    repeat (300) begin
      if (!b.randomize() || !j.randomize() || !u.randomize() || !x.randomize()) $fatal(1, "FAIL: randomize failed");
      if (b.len < 1 || b.len > 16 || b.prio >= 8) $fatal(1, "FAIL: base len %0d prio %0d", b.len, b.prio);
      if (j.len == 0 || j.prio >= 8) $fatal(1, "FAIL: jumbo len %0d prio %0d", j.len, j.prio);
      if (j.len > 16) jumbo_big++;
      if (u.len < 1 || u.len > 16 || !(u.prio inside {6, 7})) $fatal(1, "FAIL: urgent len %0d prio %0d", u.len, u.prio);
      if (x.len < 17 || x.len > 64) $fatal(1, "FAIL: badlen len %0d", x.len);
    end
    $display("jumbo lengths above 16: %0d of 300", jumbo_big);
    if (jumbo_big == 0) $fatal(1, "FAIL: the jumbo override did not widen len");
    $display("PASS: same-name blocks replaced the parent rule, a new block added to it, over 300 solves each");
    $finish;
  end
endmodule