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
47
48
49
50
51

class link_base;
  protected int unsigned timeout = 100;   // subclasses may tune this
  local int unsigned in_flight;           // only link_base's own methods change it

  function void start();
    in_flight++;
  endfunction

  function void finish();
    if (in_flight > 0) in_flight--;
  endfunction

  function int unsigned pending();
    return in_flight;
  endfunction
endclass

class slow_link extends link_base;
  function new();
    timeout = 500;                        // OK: protected is visible to subclasses
  endfunction

  function void send_one();
    start();                              // OK: the base's public method
    // in_flight++;                       // COMPILE ERROR: local to link_base
    finish();
  endfunction

  function int unsigned get_timeout();
    return timeout;
  endfunction
endclass

module tb_visibility;
  slow_link l;
  int errors = 0;
  initial begin
    l = new();
    l.start();
    if (l.pending() != 1) errors++;
    l.send_one();
    if (l.pending() != 1) errors++;       // send_one started and finished its own
    l.finish();
    if (l.pending() != 0) errors++;
    if (l.get_timeout() != 500) errors++;
    // l.timeout = 0;                     // COMPILE ERROR: protected, outside code
    if (errors == 0) $display("PASS: the subclass tuned the protected timeout and moved the local count only through methods");
    else $fatal(1, "FAIL: %0d visibility checks failed", errors);
    $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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

class mini_txn;
  local int id;            // local: only mini_txn code may touch these
  local int unsigned data;

  function new(int i, int unsigned d);
    id = i;
    data = d;
  endfunction

  // Same-class access: this method may read rhs's locals, another handle of mini_txn.
  function bit compare(mini_txn rhs);
    return (id == rhs.id) && (data == rhs.data);
  endfunction
endclass

class in_order_checker;
  // Hidden: only this class touches the queue and tallies,
  // so hits plus misses always equals the number of checks.
  local mini_txn expected_q[$];
  local int hits;
  local int misses;

  function void add_expected(mini_txn t);
    expected_q.push_back(t);
  endfunction

  function void check_actual(mini_txn t);
    mini_txn exp;
    if (expected_q.size() == 0) begin
      misses++;
      return;
    end
    exp = expected_q.pop_front();
    if (exp.compare(t)) hits++;
    else misses++;
  endfunction

  // Read-only view of hidden state; no setter is part of this API.
  function int get_hits();
    return hits;
  endfunction

  function int get_miss_count();
    return misses;
  endfunction
endclass

module top;
  in_order_checker chk;
  mini_txn e0;
  mini_txn e1;
  mini_txn g0;
  mini_txn g1;
  mini_txn surprise;
  int errors = 0;
  initial begin
    chk = new();
    e0 = new(0, 32'hA1);
    e1 = new(1, 32'hB2);
    g0 = new(0, 32'hA1);   // matches e0
    g1 = new(1, 32'h00);   // wrong data for e1
    surprise = new(7, 32'hFF);
    chk.add_expected(e0);
    chk.add_expected(e1);
    chk.check_actual(g0);
    chk.check_actual(g1);
    chk.check_actual(surprise);   // queue is empty: counts as a miss
    // chk.hits = 0;  // COMPILE ERROR: hits is local to in_order_checker
    if (chk.get_hits() !== 1) errors++;
    if (chk.get_miss_count() !== 2) errors++;
    if (chk.get_hits() + chk.get_miss_count() !== 3) errors++;
    if (errors == 0) $display("PASS: the checker tallied 1 hit and 2 misses over 3 checks");
    else $fatal(1, "FAIL: hit and miss tallies differ from 1 and 2");
    $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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

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

class pkt_txn;
  kind_e     kind;
  bit [1:0]  dest;
  bit [3:0]  len;
  bit [7:0]  payload[$];

  function new(kind_e k, bit [1:0] d, bit [7:0] p[$]);
    kind = k; dest = d; payload = p; len = 4'(p.size());
  endfunction

  function bit compare(pkt_txn other);
    if (kind != other.kind || dest != other.dest || len != other.len) return 0;
    foreach (payload[i]) if (payload[i] != other.payload[i]) return 0;
    return 1;
  endfunction
endclass

// PacketFIFO's checker: the expected queue and the tallies are hidden.
class pkt_checker;
  local pkt_txn expected_q[$];
  local int     matched, mismatched;

  function void wrote(pkt_txn p);         // a packet went into the FIFO
    expected_q.push_back(p);
  endfunction

  function void read(pkt_txn p);          // a packet came out
    pkt_txn exp;
    if (expected_q.size() == 0) begin
      mismatched++;                       // nothing was expected
      return;
    end
    exp = expected_q.pop_front();
    if (exp.compare(p)) matched++;
    else mismatched++;
  endfunction

  function int get_matched();    return matched;           endfunction
  function int get_mismatched(); return mismatched;        endfunction
  function int get_pending();    return expected_q.size(); endfunction
endclass

module tb_pkt_checker;
  pkt_checker chk;
  pkt_txn     p;
  int errors = 0;
  initial begin
    chk = new();
    p = new(DATA, 2, '{8'hA5, 8'h3C}); chk.wrote(p);
    p = new(CTRL, 1, '{8'h07});        chk.wrote(p);
    p = new(DATA, 2, '{8'hA5, 8'h3C}); chk.read(p);    // matches
    p = new(CTRL, 1, '{8'h08});        chk.read(p);    // one payload byte wrong
    p = new(DATA, 0, '{8'h11});        chk.wrote(p);   // still inside at the end
    // chk.expected_q.delete();                    // COMPILE ERROR: local
    $display("matched=%0d wrong=%0d pending=%0d", chk.get_matched(), chk.get_mismatched(), chk.get_pending());
    if (chk.get_matched() != 1 || chk.get_mismatched() != 1 || chk.get_pending() != 1) errors++;
    if (errors == 0) $display("PASS: pkt_checker counted 1 match, 1 wrong packet and 1 packet still expected");
    else $fatal(1, "FAIL: checker tallies wrong");
    $finish;
  end
endmodule