SystemVerilog Queue

Some simulators produce different results for edge-case slice expressions, so using the dedicated queue methods covered further down is generally recommended over relying on slicing for insert/delete logic.

module tb;
  	// Create a queue that can store "string" values
  string   fruits[$] =  '{ "orange", "apple", "lemon", "kiwi" };
  
	initial begin
   		// Select a subset of the queue
      	$display ("citrus fruits = %p", fruits[1:2]);
  
      	// Get elements from index 1 to end of queue
      	$display ("fruits = %p", fruits[1:$]);
  
      	// Add element to the end of queue
      	fruits[$+1] = "pineapple";
      	$display ("fruits = %p", fruits);
  
      	// Delete first element
        fruits = fruits[1:$];
      	$display ("Remove orange, fruits = %p", fruits);

	end  
endmodule

Output

Compiler version J-2014.12-SP1-1; Runtime version J-2014.12-SP1-1;  May 15 16:21 2018
citrus fruits = '{"apple", "lemon"}
fruits = '{"apple", "lemon", "kiwi"}
fruits = '{"orange", "apple", "lemon", "kiwi", "pineapple"}
Remove orange, fruits = '{"apple", "lemon", "kiwi", "pineapple"}
           V C S   S i m u l a t i o n   R e p o r t

Writing to fruits[$+1] is a common idiom for appending — since $ is the last valid index, $+1 is exactly one past the end, which extends the queue rather than going out of bounds.

Queue slicing is handy for scoreboard cleanup — for example, pending_txns = pending_txns[1:$]; to discard a transaction once it's been checked and move on to the next one.

SystemVerilog Queue Methods

In addition to the array operators above, queues expose dedicated methods for the same operations, which read more clearly in testbench code.

SystemVerilog Queue Methods Example

module tb;
	string fruits[$] = '{"apple", "pear", "mango", "banana"};
  
	initial begin
		// size() - Gets size of the given queue
		$display ("Number of fruits=%0d   fruits=%p", fruits.size(), fruits);
  
		// insert() - Insert an element to the given index
		fruits.insert (1, "peach");
		$display ("Insert peach, size=%0d fruits=%p", fruits.size(), fruits);
  
		// delete() - Delete element at given index
		fruits.delete (3);
		$display ("Delete mango, size=%0d fruits=%p", fruits.size(), fruits);
  
		// pop_front() - Pop out element at the front
		$display ("Pop %s,    size=%0d fruits=%p", fruits.pop_front(), fruits.size(), fruits);
  
		// push_front() - Push a new element to front of the queue
		fruits.push_front("apricot");
		$display ("Push apricot, size=%0d fruits=%p", fruits.size(), fruits);
  
		// pop_back() - Pop out element from the back
		$display ("Pop %s,   size=%0d fruits=%p", fruits.pop_back(), fruits.size(), fruits);
  
		// push_back() - Push element to the back
		fruits.push_back("plum");
		$display ("Push plum,    size=%0d fruits=%p", fruits.size(), fruits);
	end
endmodule

Output

ncsim> run
Number of fruits=4   fruits='{"apple", "pear", "mango", "banana"}
Insert peach, size=5 fruits='{"apple", "peach", "pear", "mango", "banana"}
Delete mango, size=4 fruits='{"apple", "peach", "pear", "banana"}
Pop apple,    size=3 fruits='{"peach", "pear", "banana"}
Push apricot, size=4 fruits='{"apricot", "peach", "pear", "banana"}
Pop banana,   size=3 fruits='{"apricot", "peach", "pear"}
Push plum,    size=4 fruits='{"apricot", "peach", "pear", "plum"}
ncsim: *W,RNQUIE: Simulation is complete.

Notice that fruits.delete(3) deletes by current index, not original index — after the earlier insert, "mango" had shifted from index 2 to index 3, which is why delete(3) is the call that removes it.

This exact pattern — push_back() for arriving transactions and pop_front() for processing them in order — is the standard way to model an in-order scoreboard or a FIFO-style pipeline stage in a testbench.

How to Create a Queue of Classes in SystemVerilog?

A queue can hold class handles just as easily as it holds simple types like int or string.

// Define a class with a single string member called "name"
class Fruit;
  string name;
  
  function new (string name="Unknown");
   	this.name = name;
  endfunction  
endclass

module tb;
  // Create a queue that can hold values of data type "Fruit"
  Fruit list [$];
  
  initial begin
    // Create a new class object and call it "Apple"
    // and push into the queue
    Fruit f = new ("Apple");
    list.push_back (f);
  
    // Create another class object and call it "Banana" and
    // push into the queue
    f = new ("Banana");
    list.push_back (f);
  
    // Iterate through queue and access each class object
    foreach (list[i])
      $display ("list[%0d] = %s", i, list[i].name);
  
    // Simply print the whole queue, note that class handles are printed
    // and not class object contents
    $display ("list = %p", list);
  end
endmodule

Output

ncsim> run
list[0] = Apple
list[1] = Banana
list = '{$unit_0x4ccdf83b::Fruit@2_1, $unit_0x4ccdf83b::Fruit@4_1}
ncsim: *W,RNQUIE: Simulation is complete.

Printing list directly with %p shows each element's class handle (an internal reference), not its field values — if you want to see name, you need to access it explicitly, as the foreach loop does above.

A queue of class handles is exactly how most UVM-style scoreboards store outstanding transactions — each entry is a handle to a transaction object, not a copy of raw data.

How to Create a Queue of Dynamic Arrays in SystemVerilog?

A queue's element type can itself be a dynamic array, giving you a queue whose entries are variable-length lists.

// Declare a dynamic array to store strings as a datatype
typedef string str_da [];

module tb;
  // This is a queue of dynamic arrays
  str_da list [$];

  initial begin
    // Initialize separate dynamic arrays with some values
    str_da marvel = '{"Spiderman", "Hulk", "Captain America", "Iron Man"};
    str_da dcWorld = '{"Batman", "Superman" };
  
    // Push the previously created dynamic arrays to queue
    list.push_back (marvel);
    list.push_back (dcWorld);
  
    // Iterate through the queue and access dynamic array elements
    foreach (list[i])
      foreach (list[i][j])
        $display ("list[%0d][%0d] = %s", i, j, list[i][j]);
  
    // Simply print the queue
    $display ("list = %p", list);
  end
endmodule

Output

ncsim> run
list[0][0] = Spiderman
list[0][1] = Hulk
list[0][2] = Captain America
list[0][3] = Iron Man
list[1][0] = Batman
list[1][1] = Superman
list = '{'{"Spiderman", "Hulk", "Captain America", "Iron Man"}, '{"Batman", "Superman"}}
ncsim: *W,RNQUIE: Simulation is complete.

The outer foreach (list[i]) walks each dynamic array in the queue, and the inner foreach (list[i][j]) walks the elements within that array — the same nested pattern used for any multidimensional unpacked structure.

Common Mistakes

module tb;
  int expected_q [$];

  initial begin
    expected_q.push_back(10);
    expected_q.push_back(20);
    expected_q.push_back(30);

    while (expected_q.size() > 0) begin
      $display("Popped %0d, remaining size=%0d", expected_q.pop_front(), expected_q.size());
    end
  end
endmodule