Dynamic Arrays

// ── Declaration (no allocation yet — size = 0) ───────────────────
logic [7:0] bytes [];          // unallocated byte array
int           scores [];         // unallocated int array
string        names [];          // unallocated string array
 
// ── Allocation ────────────────────────────────────────────────────
bytes  = new[16];               // allocate 16 elements (logic → X-initialized)
scores = new[8];                // allocate 8  elements (int   → 0-initialized)
bytes  = new[8]('{default:8'hFF}); // allocate + initialize via literal
 
// ── Resize — keep existing data ───────────────────────────────────
bytes = new[32](bytes);         // grow from 16 to 32; old data preserved [0..15]
bytes = new[8](bytes);          // shrink to 8; elements [8..15] dropped
 
// ── Element access — identical to static array ────────────────────
bytes[0] = 8'hAB;
logic [7:0] val = bytes[3];
 
// ── Size query ────────────────────────────────────────────────────
$size(bytes)    // current number of elements
bytes.size()   // equivalent method call form
 
// ── Iteration ─────────────────────────────────────────────────────
foreach (bytes[i])
  bytes[i] = i;
 
// ── Whole-array copy (deep copy) ──────────────────────────────────
logic [7:0] copy [];
copy = bytes;                    // deep copy — independent storage
copy[0] = 8'hFF;                // does NOT affect bytes[0]
 
// ── Whole-array comparison ────────────────────────────────────────
if (bytes == copy) …             // element-wise equal (never X even if elements are X)
if (bytes !== copy) …           // case inequality — catches X differences too
 
// ── Delete ────────────────────────────────────────────────────────
bytes.delete();                   // free memory, size becomes 0
// bytes.size() == 0 after delete

module tb_dyn_basics;
 
  int arr [];
 
  initial begin
    // Every declaration in a begin-end block must precede the first statement
    // (IEEE 1800 §9.3.1), so `copy` is declared here rather than beside its use.
    int copy [];
 
    // ── Allocate ──────────────────────────────────────────────────
    arr = new[4];
    $display("After new[4]: size = %0d", $size(arr));     // 4
 
    // ── Fill ──────────────────────────────────────────────────────
    foreach (arr[i]) arr[i] = (i + 1) * 10;
    $display("Filled: %p", arr);                       // '{10, 20, 30, 40}
 
    // ── Grow and preserve ─────────────────────────────────────────
    arr = new[6](arr);
    $display("After grow to 6: %p", arr);              // '{10, 20, 30, 40, 0, 0}
 
    // ── Shrink ────────────────────────────────────────────────────
    arr = new[2](arr);
    $display("After shrink to 2: %p", arr);            // '{10, 20}
 
    // ── Deep copy: b = a  →  independent ─────────────────────────
    copy = arr;
    copy[0] = 999;
    $display("arr[0]=%0d  copy[0]=%0d", arr[0], copy[0]); // 10  999 — independent
 
    // ── Delete ────────────────────────────────────────────────────
    arr.delete();
    $display("After delete: size = %0d", $size(arr));    // 0
 
    $finish;
  end
 
endmodule

After new[4]: size = 4
Filled: '{10, 20, 30, 40}
After grow to 6: '{10, 20, 30, 40, 0, 0}
After shrink to 2: '{10, 20}
arr[0]=10  copy[0]=999
After delete: size = 0

class axi_write_txn;
  rand logic [31:0] addr;
  rand int unsigned  burst_len;        // 1 to 16 beats
  rand logic [31:0] data [];           // size unknown until constrained
 
  constraint len_range  { burst_len inside {[1:16]}; }
  constraint data_size  { data.size() == burst_len; } // dynamic size constraint
  constraint addr_align { addr[1:0] == 2'b00; }
 
  // Solver calls new[] automatically when a dynamic array size is constrained
 
  function void print();
    $display("AXI WRITE addr=0x%08h len=%0d", addr, burst_len);
    foreach (data[i])
      $display("  beat[%0d] = 0x%08h", i, data[i]);
  endfunction
 
endclass
 
module tb_axi_dyn;
  initial begin
    axi_write_txn txn = new();
    repeat (3) begin
      if (!txn.randomize())
        $fatal(1, "Randomize failed");
      txn.print();
    end
    $finish;
  end
endmodule

module tb_event_log;
 
  typedef struct {
    int           timestamp;
    logic [7:0] opcode;
    logic [31:0] addr;
  } event_t;
 
  event_t  log [];       // starts empty
  int       log_count = 0;
 
  // Append one event — resizes the array by +1 each call
  task automatic log_event(input int ts, input logic [7:0] op, input logic [31:0] a);
    log = new[log_count + 1](log);   // grow by 1, preserve existing entries
    log[log_count] = '{ts, op, a};
    log_count++;
  endtask
 
  // Print all logged events
  task automatic dump_log();
    $display("=== Event Log (%0d entries) ===", log_count);
    foreach (log[i])
      $display("  [%0d] t=%0d op=0x%02h addr=0x%08h",
               i, log[i].timestamp, log[i].opcode, log[i].addr);
  endtask
 
  initial begin
    log_event(100, 8'h10, 32'h0000_1000);
    log_event(200, 8'h20, 32'h0000_2000);
    log_event(300, 8'hFF, 32'hFFFF_FFFF);
    dump_log();
    $display("Final log size: %0d", $size(log));
    $finish;
  end
 
endmodule

=== Event Log (3 entries) ===
  [0] t=100 op=0x10 addr=0x00001000
  [1] t=200 op=0x20 addr=0x00002000
  [2] t=300 op=0xFF addr=0xFFFFFFFF
Final log size: 3

class packet;
  int payload [];
  function new(int sz); payload = new[sz]; endfunction
endclass
 
module tb_copy_trap;
 
  initial begin
 
    // ── Case 1: Standalone dynamic arrays — DEEP copy ─────────────
    int a [] = new[3]('{1, 2, 3});
    int b [];
    b = a;                         // deep copy of array data
    b[0] = 99;
    $display("Standalone: a[0]=%0d b[0]=%0d", a[0], b[0]); // 1  99 — independent ✓
 
    // ── Case 2: Class handle copy — SHALLOW (DANGEROUS!) ─────────
    packet p1 = new(3);
    p1.payload = '{10, 20, 30};
    packet p2;
    p2 = p1;                       // SHALLOW: p2 points to same object as p1
    p2.payload[0] = 99;
    $display("Class handle: p1.payload[0]=%0d p2.payload[0]=%0d",
             p1.payload[0], p2.payload[0]);   // 99  99 — SAME! Bug!
 
    // ── FIX: use new to create an independent copy ────────────────
    packet p3 = new p1;           // copy constructor — shallow copy of fields
    // But p3.payload still shares storage with p1.payload!
    // True deep copy requires explicitly re-allocating the array:
    p3.payload = new[p1.payload.size()](p1.payload);
    p3.payload[0] = 999;
    $display("Deep copy: p1.payload[0]=%0d p3.payload[0]=%0d",
             p1.payload[0], p3.payload[0]);   // 99  999 — independent ✓
 
    $finish;
  end
 
endmodule

Standalone: a[0]=1 b[0]=99
Class handle: p1.payload[0]=99 p2.payload[0]=99
Deep copy: p1.payload[0]=99 p3.payload[0]=999

// ─────────────────────────────────────────────────────────────────────────────
//  Proves four dynamic-array semantics that are easy to state and easy to get
//  backwards:
//     1. new[N]        discards the old contents      (default-initialised)
//     2. new[N](arr)   preserves them, default-fills  (the grow idiom)
//     3. new[N](arr)   with N < size truncates        (keeps the first N)
//     4. b = a         is a DEEP copy for standalone arrays (not aliasing)
//
//  vcs -sverilog dyn_resize_proof.sv && ./simv    |    xrun -sv dyn_resize_proof.sv
// ─────────────────────────────────────────────────────────────────────────────
module dyn_resize_proof;
 
  int errors = 0;
 
  // Compare a dynamic array against an expected list; report and count.
  function automatic void check(string label, const ref int got [], input int exp []);
    if (got.size() != exp.size()) begin
      errors++;
      $display("  ** FAIL %-22s size %0d, expected %0d", label, got.size(), exp.size());
      return;
    end
    foreach (exp[i])
      if (got[i] !== exp[i]) begin
        errors++;
        $display("  ** FAIL %-22s [%0d] = %0d, expected %0d", label, i, got[i], exp[i]);
        return;
      end
    $display("     ok   %-22s %p", label, got);
  endfunction
 
  initial begin
    int arr [];
    int copy [];
 
    arr = new[4];
    foreach (arr[i]) arr[i] = (i + 1) * 10;          // 10,20,30,40
    check("initial", arr, '{10,20,30,40});
 
    // ── 1. new[N] without the argument: reallocation, not resize ──────────
    arr = new[6];
    check("new[6] discards", arr, '{0,0,0,0,0,0});
 
    // ── 2. new[N](arr): the grow idiom ───────────────────────────────────
    arr = new[4];
    foreach (arr[i]) arr[i] = (i + 1) * 10;
    arr = new[6](arr);
    check("new[6](arr) preserves", arr, '{10,20,30,40,0,0});
 
    // ── 3. Shrinking truncates from the TAIL, keeping the head ───────────
    arr = new[2](arr);
    check("new[2](arr) truncates", arr, '{10,20});
 
    // ── 4. Standalone array assignment is a DEEP copy ─────────────────────
    //    (Contrast Example 4: a dynamic array INSIDE a class object is shared
    //     when the class HANDLE is copied - the array is not what aliases.)
    copy = arr;
    copy[0] = 999;
    check("source after deep copy", arr,  '{10,20});
    check("copy after mutation",   copy, '{999,20});
 
    // ── 5. delete() empties it; size() is then 0 and any index is fatal ──
    arr.delete();
    if (arr.size() != 0) begin
      errors++;
      $display("  ** FAIL delete() left size %0d", arr.size());
    end else
      $display("     ok   delete()               size=0");
 
    if (errors == 0) $display("\n  [PASS] all dynamic-array resize semantics held");
    else             $display("\n  [FAIL] %0d check(s) failed", errors);
    $finish;
  end
 
endmodule

     ok   initial                '{10, 20, 30, 40}
     ok   new[6] discards        '{0, 0, 0, 0, 0, 0}
     ok   new[6](arr) preserves  '{10, 20, 30, 40, 0, 0}
     ok   new[2](arr) truncates  '{10, 20}
     ok   source after deep copy '{10, 20}
     ok   copy after mutation    '{999, 20}
     ok   delete()               size=0
 
  [PASS] all dynamic-array resize semantics held

// ── 1. TRANSACTION CLASS: variable-length burst payload ───────────
class axi_burst;
  rand int unsigned len;
  rand logic [31:0] data [];
  constraint c { len inside {[1:256]}; data.size() == len; }
endclass
 
// ── 2. SCOREBOARD: collect all received transactions, then compare ─
logic [31:0] rcv_data [];      // grows as beats arrive
int           rcv_count = 0;
 
// In monitor task — called per beat:
// rcv_data = new[rcv_count+1](rcv_data);
// rcv_data[rcv_count++] = captured_beat;
 
// End of burst — compare against expected:
// if (rcv_data !== exp_data) $error("burst mismatch");
 
// ── 3. CONSTRAINT: size-dependent payload pattern ─────────────────
class pkt_with_crc;
  rand int unsigned payload_len;
  rand logic [7:0]  payload [];
  rand logic [15:0] crc;
  constraint len_c   { payload_len inside {[4:64]}; }
  constraint size_c  { payload.size() == payload_len; }
  // post-randomize: compute real CRC from payload
  function void post_randomize();
    crc = 16'h0;
    foreach (payload[i]) crc ^= {8'h0, payload[i]};
  endfunction
endclass
 
// ── 4. UVM sequence item: standard pattern ────────────────────────
// class my_seq_item extends uvm_sequence_item;
//   rand logic [7:0] data [];
//   rand int unsigned len;
//   constraint data_sz { data.size() == len; }
// endclass
 
// ── 5. COVERAGE: collect unique values seen ───────────────────────
int seen_values [];   // grows as new values are observed
function void record_value(int v);
  foreach (seen_values[i])
    if (seen_values[i] == v) return;  // already recorded
  seen_values = new[seen_values.size()+1](seen_values);
  seen_values[seen_values.size()-1] = v;
endfunction

int buf [];    // declared but not allocated — size = 0
 
// BUGGY: accessing index 0 on a size-0 array
buf[0] = 42;   // FATAL: "dynamic array index out of range" — simulation crashes
 
// Also fatal:
foreach (buf[i]) $display(buf[i]);  // safe only if size>0; empty array = no iterations
// foreach is safe — it just loops 0 times on a size-0 array
// But buf[0] directly when size=0 is always fatal
 
// FIXED: always allocate before accessing by index
buf = new[4];    // allocate first
buf[0] = 42;    // now safe
 
// DEFENSIVE: check before access
if ($size(buf) > 0) buf[0] = 42;

class txn;
  logic [31:0] data [];
endclass
 
txn sent_txn = new();
sent_txn.data = new[4]('{1,2,3,4});
 
// BUGGY: scoreboard saves a "copy" to compare later
txn saved = sent_txn;          // SHALLOW COPY — both point to same object!
 
// Driver modifies the transaction for the next beat
sent_txn.data[0] = 99;         // also silently modifies saved.data[0]!
 
$display("saved.data[0] = %0d", saved.data[0]);  // 99 — WRONG, expected 1
 
// FIXED: allocate new object + copy array explicitly
txn saved_fixed  = new();
saved_fixed.data = new[sent_txn.data.size()](sent_txn.data);
sent_txn.data[0] = 99;
$display("saved_fixed.data[0] = %0d", saved_fixed.data[0]);  // 1 — correct

class bad_txn;
  rand logic [7:0] data [];
  rand int unsigned len;
 
  // BUGGY: no constraint linking len to data.size()
  // Solver picks random len and random data size independently
  // len=5 but data might have size=3 — they are unrelated!
  constraint len_c { len inside {[1:16]}; }
  // Missing: constraint size_c { data.size() == len; }
endclass
 
// CORRECT: link them explicitly
class good_txn;
  rand logic [7:0] data [];
  rand int unsigned len;
  constraint len_c  { len inside {[1:16]}; }
  constraint size_c { data.size() == len; }   // solver now allocates correctly
endclass