SystemVerilog for Verification (OOP, CRV & SVA)

// ---- The timeout idiom: whichever finishes first wins -----------------
task automatic wait_for_done_or_timeout();
  fork
    begin : normal
      @(posedge dut_done);
      $display("[%0t] transfer completed", $time);
    end
    begin : watchdog
      #10us;
      $error("[%0t] TIMEOUT waiting for dut_done", $time);
    end
  join_any

  disable fork;   // kill the loser - without this, the watchdog keeps
                  // running and fires on a LATER, unrelated transfer
endtask


// ---- The classic loop-variable bug ------------------------------------
task automatic spawn_wrong();
  for (int i = 0; i < 4; i++) begin
    fork
      drive_channel(i);   // BUG: all 4 threads see i AFTER the loop ends
    join_none
  end
  wait fork;
endtask

task automatic spawn_right();
  for (int i = 0; i < 4; i++) begin
    // `automatic` gives each iteration its OWN copy, captured now.
    automatic int idx = i;
    fork
      drive_channel(idx);
    join_none
  end
  wait fork;             // block until every spawned thread finishes
endtask

class Transaction;
  rand bit [31:0] addr;
  rand bit [31:0] data;
  rand bit        write;

  // Constructor. Always `function new`, always returns nothing.
  function new(bit [31:0] addr = '0);
    this.addr = addr;
  endfunction

  // VIRTUAL - so a derived class can override it and still be called
  // correctly through a base handle. See the trap below.
  virtual function void display(string prefix = "");
    $display("%s addr=%h data=%h write=%b", prefix, addr, data, write);
  endfunction

  // Deep copy. Assigning handles copies the POINTER, not the object.
  virtual function Transaction clone();
    Transaction t = new();
    t.addr  = this.addr;
    t.data  = this.data;
    t.write = this.write;
    return t;
  endfunction
endclass


class BurstTransaction extends Transaction;
  rand bit [3:0] len;

  function new(bit [31:0] addr = '0);
    super.new(addr);            // base constructor MUST be called first
  endfunction

  virtual function void display(string prefix = "");
    $display("%s BURST len=%0d addr=%h", prefix, len, addr);
  endfunction
endclass

// ---- MAILBOX: a typed, blocking FIFO of objects -----------------------
// Parameterise it. A bare `mailbox` accepts ANY type and turns a type
// error into a runtime surprise.
mailbox #(Transaction) mbx = new();      // unbounded
mailbox #(Transaction) bnd = new(16);    // bounded: put() blocks when full

task generator();
  repeat (100) begin
    Transaction t = new();
    if (!t.randomize()) $fatal(1, "randomize failed");
    mbx.put(t);                 // blocks if the mailbox is full
  end
endtask

task driver();
  Transaction t;
  forever begin
    mbx.get(t);                 // blocks until something arrives
    drive_on_bus(t);
  end
endtask
// Non-blocking variants: try_put / try_get return 0 instead of blocking.
// peek() reads without removing.


// ---- SEMAPHORE: keys for a shared resource ---------------------------
semaphore bus_lock = new(1);    // 1 key == a mutex

task send(Transaction t);
  bus_lock.get(1);              // blocks until a key is free
  drive_on_bus(t);              // critical section - exclusive access
  bus_lock.put(1);              // ALWAYS return the key
endtask


// ---- EVENT: a pure notification --------------------------------------
event reset_done;

initial begin
  apply_reset();
  -> reset_done;                // trigger
end

initial begin
  wait (reset_done.triggered);  // safe: does not miss a same-timestep trigger
  // @(reset_done);             // UNSAFE: misses a trigger that already fired
  start_test();
end

class Packet;
  rand  bit [10:0] length;      // 0 .. 2047
  randc bit [3:0]  stream_id;   // visits all 16 values before repeating
  rand  bit [1:0]  kind;
  rand  bit        inject_err;

  // Weighted distribution. ":=" gives the weight to EACH value in the
  // range; ":/" spreads ONE weight across the whole range.
  constraint c_length {
    length dist { [64:127]   := 50,      // small packets, most common
                  [128:511]  := 30,
                  [512:1518] := 20 };
  }

  constraint c_err  { inject_err dist { 0 := 95, 1 := 5 }; }

  constraint c_kind { kind inside {[0:2]}; }   // 3 is reserved

  // Hint to the solver about ORDER. See below - this changes the
  // probability distribution, not the set of legal solutions.
  constraint c_order { solve kind before length; }
endclass


// Randomization can FAIL (over-constrained). Always check the return.
task run_test();
  Packet p = new();
  repeat (1000) begin
    if (!p.randomize()) $fatal(1, "packet randomization failed");
    send(p);
  end

  // Inline constraints for one specific call, ANDed with the class ones.
  if (!p.randomize() with { length > 1000; inject_err == 1; })
    $fatal(1, "constrained randomization failed");
endtask

covergroup cg_packet @(posedge clk);
  option.per_instance = 1;

  cp_kind: coverpoint pkt.kind {
    bins read    = {2'b00};
    bins write   = {2'b01};
    bins burst   = {2'b10};
    illegal_bins reserved = {2'b11};     // hitting this is an error
  }

  cp_len: coverpoint pkt.length {
    bins small  = {[64:127]};
    bins medium = {[128:511]};
    bins large  = {[512:1518]};
  }

  // Cross coverage: did we see EVERY kind at EVERY size? 3 x 3 = 9 bins.
  // This is where the real holes usually are.
  x_kind_len: cross cp_kind, cp_len;
endgroup

cg_packet cg = new();     // covergroups must be explicitly instantiated

// ---- Immediate assertion: procedural, evaluated like an if ------------
always_comb begin
  assert (!(wr_en && full))
    else $error("write attempted while FIFO full");
end

// ---- Concurrent assertion: temporal, evaluated every clock ------------
property p_req_ack;
  @(posedge clk) disable iff (!rst_n)      // ignore checks during reset
  req |-> ##[1:5] ack;                     // ack within 1 to 5 cycles
endproperty

a_req_ack: assert property (p_req_ack)
  else $error("ack did not arrive within 5 cycles of req");

// The Volume 4.5 one-hot check, now enforced by the simulator on EVERY
// cycle of EVERY test rather than by a comment nobody reads.
a_onehot: assert property (
  @(posedge clk) disable iff (!rst_n) $onehot(state)
) else $error("FSM state is not one-hot: %b", state);

// Useful sampling functions inside properties:
//   $rose(x) $fell(x) $stable(x) $past(x, n)
a_stable_cfg: assert property (
  @(posedge clk) disable iff (!rst_n) busy |-> $stable(cfg_mode)
) else $error("config changed mid-transaction");

// `cover` reports how often something HAPPENED - functional coverage
// for temporal sequences, not a pass/fail check.
c_back_to_back: cover property (
  @(posedge clk) req ##1 req
);