Queues

// ── Declaration ──────────────────────────────────────────────────
int           fifo  [$];            // unbounded queue of ints
string        names [$];            // unbounded queue of strings
logic [7:0] bytes [$];            // unbounded queue of bytes
int           bfifo [$:15];        // bounded: max 16 elements (0..15)
 
// ── Push — add elements ──────────────────────────────────────────
fifo.push_back(10);               // [10]
fifo.push_back(20);               // [10, 20]
fifo.push_front(5);              // [5, 10, 20]
 
// ── Pop — remove and return ───────────────────────────────────────
int v = fifo.pop_front();         // v=5  queue=[10, 20]
int t = fifo.pop_back();          // t=20 queue=[10]
 
// ── Indexed access ────────────────────────────────────────────────
fifo[0]         // front element (same as peek without removing)
fifo[$]         // last element  ($ = size-1)
fifo[$-1]       // second from last
 
// ── Size ──────────────────────────────────────────────────────────
fifo.size()     // number of current elements
$size(fifo)    // equivalent
 
// ── insert / delete at arbitrary position ────────────────────────
fifo.insert(1, 99);               // insert 99 at index 1 — shifts rest right
fifo.delete(0);                  // delete element at index 0 — shifts rest left
fifo.delete();                   // delete ALL elements (clear)
 
// ── Slice — range of elements ────────────────────────────────────
int first3 [$] = fifo[0:2];      // elements 0, 1, 2 as a new queue
int last2  [$] = fifo[$-1:$];    // last two elements
 
// ── Concatenation-style build ────────────────────────────────────
fifo = {fifo, 100};               // append 100 to back (same as push_back)
fifo = {0, fifo};                 // prepend 0 to front (same as push_front)
 
// ── foreach and whole-queue operations ───────────────────────────
foreach (fifo[i]) $display("%0d", fifo[i]);
int copy [$] = fifo;              // whole-queue deep copy
if (fifo == copy) $display("equal");

module tb_queue_basics;
 
  int q [$];
 
  initial begin
    // SystemVerilog requires every declaration in a begin-end block to precede
    // the first statement (IEEE 1800 §9.3.1). Declaring `tail` further down,
    // next to the slice that fills it, reads better but does not compile.
    int tail [$];
 
    // ── Build the queue ───────────────────────────────────────────
    q.push_back(10);
    q.push_back(20);
    q.push_back(30);
    q.push_front(5);
    $display("After pushes: %p  size=%0d", q, q.size());  // '{5,10,20,30} 4
 
    // ── Indexed access without removing ──────────────────────────
    $display("front=q[0]=%0d  back=q[$]=%0d", q[0], q[$]); // 5  30
 
    // ── FIFO dequeue ──────────────────────────────────────────────
    $display("pop_front = %0d", q.pop_front());  // 5
    $display("pop_front = %0d", q.pop_front());  // 10
    $display("Queue now: %p", q);                // '{20,30}
 
    // ── insert at arbitrary position ─────────────────────────────
    q.insert(1, 25);
    $display("After insert(1,25): %p", q);        // '{20,25,30}
 
    // ── slice ────────────────────────────────────────────────────
    tail = q[$-1:$];
    $display("Last 2 elements: %p", tail);         // '{25,30}
 
    // ── Concatenation-style append ───────────────────────────────
    q = {q, 99};
    $display("After concat append: %p", q);        // '{20,25,30,99}
 
    // ── Clear ─────────────────────────────────────────────────────
    q.delete();
    $display("After delete: size=%0d", q.size());   // 0
 
    $finish;
  end
 
endmodule

After pushes: '{5, 10, 20, 30}  size=4
front=q[0]=5  back=q[$]=30
pop_front = 5
pop_front = 10
Queue now: '{20, 30}
After insert(1,25): '{20, 25, 30}
Last 2 elements: '{25, 30}
After concat append: '{20, 25, 30, 99}
After delete: size=0

// Behavioral model of a 4-deep, 8-bit FIFO
module tb_fifo_model;
 
  parameter int DEPTH = 4;
  logic [7:0] fifo [$:3];    // bounded: max 4 entries (0..3)
 
  task automatic enqueue(input logic [7:0] d);
    if (fifo.size() >= DEPTH) begin
      $error("FIFO OVERFLOW — capacity %0d, tried to push 0x%02h", DEPTH, d);
      return;
    end
    fifo.push_back(d);
    $display("PUSH 0x%02h  [depth=%0d/%0d]", d, fifo.size(), DEPTH);
  endtask
 
  task automatic dequeue(output logic [7:0] d);
    if (fifo.size() == 0) begin
      $error("FIFO UNDERFLOW — cannot pop from empty FIFO");
      d = 8'hXX;
      return;
    end
    d = fifo.pop_front();
    $display("POP  0x%02h  [depth=%0d/%0d]", d, fifo.size(), DEPTH);
  endtask
 
  function automatic bit is_full();  return fifo.size() >= DEPTH; endfunction
  function automatic bit is_empty(); return fifo.size() == 0;    endfunction
 
  logic [7:0] d_out;
 
  initial begin
    enqueue(8'hAA); enqueue(8'hBB); enqueue(8'hCC); enqueue(8'hDD);
    enqueue(8'hEE);   // overflow!
    dequeue(d_out); dequeue(d_out);
    $display("is_full=%0b  is_empty=%0b", is_full(), is_empty());
    $finish;
  end
 
endmodule

PUSH 0xAA  [depth=1/4]
PUSH 0xBB  [depth=2/4]
PUSH 0xCC  [depth=3/4]
PUSH 0xDD  [depth=4/4]
ERROR: FIFO OVERFLOW — capacity 4, tried to push 0xEE
POP  0xAA  [depth=3/4]
POP  0xBB  [depth=2/4]
is_full=0  is_empty=0

module tb_scoreboard_queue;
 
  typedef struct {
    logic [7:0] opcode;
    logic [31:0] data;
  } txn_t;
 
  txn_t expected [$];   // in-order expected transactions
  txn_t received [$];   // captured DUT responses
  int   mismatch_cnt = 0;
 
  // Driver: enqueue expected transactions as they are sent
  task automatic send_txn(input txn_t t);
    expected.push_back(t);
  endtask
 
  // Monitor: enqueue captured responses
  task automatic capture_txn(input txn_t t);
    received.push_back(t);
  endtask
 
  // In-order compare: drain both queues together
  task automatic drain_and_compare();
    while (expected.size() > 0 && received.size() > 0) begin
      txn_t exp = expected.pop_front();
      txn_t got = received.pop_front();
      if (exp.opcode !== got.opcode || exp.data !== got.data) begin
        $error("MISMATCH: exp={op:0x%02h d:0x%08h} got={op:0x%02h d:0x%08h}",
               exp.opcode, exp.data, got.opcode, got.data);
        mismatch_cnt++;
      end else
        $display("PASS op=0x%02h data=0x%08h", got.opcode, got.data);
    end
    if (expected.size() != 0)
      $error("%0d expected transactions with no matching response", expected.size());
    if (received.size() != 0)
      $error("%0d unexpected responses from DUT", received.size());
  endtask
 
  initial begin
    send_txn('{8'h10, 32'hAAAA_0001});
    send_txn('{8'h20, 32'hBBBB_0002});
 
    capture_txn('{8'h10, 32'hAAAA_0001});  // match
    capture_txn('{8'h20, 32'hCCCC_0002});  // data mismatch
 
    drain_and_compare();
    $display("Total mismatches: %0d", mismatch_cnt);
    $finish;
  end
 
endmodule

PASS op=0x10 data=0xAAAA0001
ERROR: MISMATCH: exp={op:0x20 d:0xBBBB0002} got={op:0x20 d:0xCCCC0002}
Total mismatches: 1

module tb_queue_corners;
 
  int q [$];
 
  initial begin
    // All declarations first — see the note in Example 1.
    int    arr [5] = '{1,2,3,4,5};
    int    q2  [$];
    int    aa  [string];
    string keys [$];
 
    // ── $ index: last element shorthand ──────────────────────────
    q = '{10, 20, 30, 40};
    $display("q[$]   = %0d  (last)",       q[$]);      // 40
    $display("q[$-1] = %0d  (2nd last)",  q[$-1]);   // 30
    $display("q[$-2] = %0d  (3rd last)",  q[$-2]);   // 20
 
    // ── Safe pop: check size first ───────────────────────────────
    q.delete();
    if (q.size() > 0)
      $display("popped: %0d", q.pop_front());
    else
      $display("Queue empty — pop guarded");
 
    // ── Sorting: sort() and rsort() work on queues ───────────────
    q = '{50, 10, 40, 20, 30};
    q.sort();
    $display("Sorted asc:  %p", q);    // '{10,20,30,40,50}
    q.rsort();
    $display("Sorted desc: %p", q);    // '{50,40,30,20,10}
 
    // ── Building from array literal ───────────────────────────────
    foreach (arr[i]) q2.push_back(arr[i]);
    $display("From array: %p", q2);     // '{1,2,3,4,5}
 
    // ── Using queue as collect-keys buffer (from assoc array) ─────
    aa["z"]=3; aa["a"]=1; aa["m"]=2;
    foreach (aa[k]) keys.push_back(k);    // collect sorted keys
    $display("Keys: %p", keys);           // '{a, m, z}
 
    $finish;
  end
 
endmodule

q[$]   = 40  (last)
q[$-1] = 30  (2nd last)
q[$-2] = 20  (3rd last)
Queue empty — pop guarded
Sorted asc:  '{10, 20, 30, 40, 50}
Sorted desc: '{50, 40, 30, 20, 10}
From array: '{1, 2, 3, 4, 5}
Keys: '{"a", "m", "z"}

// ── 1. IN-ORDER SCOREBOARD ─────────────────────────────────────────
txn_t exp_q [$];   // driver enqueues expected; monitor dequeues for comparison
// Driver: exp_q.push_back(txn);
// Monitor: if (exp_q.size()>0) { txn_t e = exp_q.pop_front(); compare(e, got); }
 
// ── 2. UVM SEQUENCE: dynamic stimulus list ─────────────────────────
// class my_sequence extends uvm_sequence;
//   my_item items [$];
//   task body();
//     foreach (items[i]) `uvm_do(items[i]);
//   endtask
// endclass
 
// ── 3. PIPELINE DEPTH TRACKING ─────────────────────────────────────
int pipeline [$];   // models DUT pipeline: push on accept, pop on output
always @(posedge clk) begin
  if (valid_in)  pipeline.push_back(data_in);
  if (valid_out && pipeline.size()>0) pipeline.pop_front();
end
 
// ── 4. COLLECTING KEYS FOR SAFE AA DELETE ─────────────────────────
int map [string];
string expired [$];
foreach (map[k]) if (map[k] < threshold) expired.push_back(k);
foreach (expired[i]) map.delete(expired[i]);  // safe: not during AA iteration
 
// ── 5. LAST-N TRANSACTIONS (sliding window) ───────────────────────
parameter int WINDOW = 8;
logic[31:0] recent [$];
// In monitor:
// recent.push_back(data);
// if (recent.size() > WINDOW) void'(recent.pop_front()); // keep last N
 
// ── 6. ASSERTION HELPER: N-CYCLE DELAY MODEL ─────────────────────
int delay_q [$];
// Verify that output matches input delayed by exactly N cycles:
// always @(posedge clk) begin
//   delay_q.push_back(data_in);
//   if (delay_q.size() > LATENCY)
//     assert(data_out === delay_q.pop_front());
// end

int q [$];   // empty
 
// BUGGY: pop on empty queue — FATAL
int v = q.pop_front();     // Fatal: "pop_front of empty queue"
 
// BUGGY: $ index on empty queue — FATAL
int last = q[$];            // Fatal: out-of-bounds (size=0, index=-1)
 
// CORRECT: always check size before pop or $ access
if (q.size() > 0) v = q.pop_front();
if (q.size() > 0) last = q[$];

// ── Context 1: Declaration — [$] declares a queue type ───────────
int q [$];        // DECLARATION: q is an unbounded queue of int
int b [$:7];       // DECLARATION: b is a bounded queue (max 8 elements)
 
// ── Context 2: Expression — q[$] accesses the last element ───────
q = '{10, 20, 30};
int last = q[$];  // EXPRESSION: last = 30 (last element, index = size-1)
int prev = q[$-1]; // EXPRESSION: prev = 20 (second from last)
 
// ── Common confusion: thinking q[$] declares a 1-element queue ───
// q[$] in an expression is NOT a 1-element bounded queue declaration
// It is reading the LAST ELEMENT of q
$display("q[$] = %0d", q[$]);     // 30 — always the last element
 
// ── Another trap: modifying via $ index ──────────────────────────
q[$] = 99;        // modifies the last element in-place — queue[2] = 99
$display("%p", q); // '{10, 20, 99}

class bad_txn;
  rand logic [7:0] data [$];  // queue — not constraint-solver-friendly for size
  rand int            len;
 
  // BUGGY: solver cannot allocate queue size the same way as dynamic array
  constraint sz { data.size() == len; }  // tool-dependent — may not work
endclass
 
// CORRECT: use a dynamic array for variable-size rand data fields
class good_txn;
  rand logic [7:0] data [];   // dynamic array — works with constraint solver
  rand int            len;
  constraint sz { len inside {[1:16]}; data.size() == len; }  // works
endclass
 
// After randomizing good_txn, copy data into a queue if queue behavior needed:
// int q [$];
// foreach (good_txn.data[i]) q.push_back(good_txn.data[i]);