Dynamic Arrays in SystemVerilog

by Praful Kharade Posted on

Dynamic arrays are powerful data structures in SystemVerilog that allow you to allocate and resize memory at runtime. Unlike fixed-size arrays, dynamic arrays can grow or shrink as needed, providing greater flexibility in managing collections of data. This post will explore the features, advantages, and usage of dynamic arrays in SystemVerilog.

Declaring a Dynamic Array

A dynamic array can be declared using the following syntax:

Verilog
bit [7:0] myArray[]; // Declare a dynamic array

In this example, myArray is declared as a dynamic array of 8-bit elements. Note that no size is specified during the declaration.

Allocating Memory

To allocate memory for a dynamic array, use the new keyword followed by the desired size:

Verilog
myArray = new[10]; // Allocate memory for 10 elements

This allocates memory for 10 elements in myArray.

Assigning Values

Once memory is allocated, you can assign values to the elements in the dynamic array:

Verilog
for (int i = 0; i < myArray.size(); i++) begin
    myArray[i] = i + 1; // Assign values from 1 to 10
end

Here, the loop assigns values from 1 to 10 to the dynamic array.

Displaying Values

You can display the values stored in the dynamic array using the $display system task

Verilog
$display("Dynamic Array Values:");
for (int i = 0; i < myArray.size(); i++) begin
    $display("myArray[%0d] = %0d", i, myArray[i]);
end

Resizing the Dynamic Array

Dynamic arrays can be resized at any point during runtime. To resize, simply allocate a new array of the desired size:

Verilog
myArray = new[20]; // Resize to hold 20 elements

After resizing, you can assign new values as needed:

Verilog
for (int i = 0; i < myArray.size(); i++) begin
    myArray[i] = i + 10; // Assign values from 10 to 29
end

Full Example

Here is the complete example demonstrating the use of a dynamic array in SystemVerilog:

Verilog
module dynamic_array_example;
    bit [7:0] myArray[]; // Declare a dynamic array

    initial begin
        myArray = new[10]; // Allocate memory for 10 elements

        // Assign values to the dynamic array
        for (int i = 0; i < myArray.size(); i++) begin
            myArray[i] = i + 1; // Assign values from 1 to 10
        end

        // Display values
        $display("Dynamic Array Values:");
        for (int i = 0; i < myArray.size(); i++) begin
            $display("myArray[%0d] = %0d", i, myArray[i]);
        end

        // Resize the dynamic array
        myArray = new[20]; // Resize to hold 20 elements
        // Assign new values
        for (int i = 0; i < myArray.size(); i++) begin
            myArray[i] = i + 10; // Assign values from 10 to 29
        end

        // Display new values
        $display("Resized Dynamic Array Values:");
        for (int i = 0; i < myArray.size(); i++) begin
            $display("myArray[%0d] = %0d", i, myArray[i]);
        end
    end
endmodule

You can try it on EDA Playground by clicking the link below

EDA Playground

Advantages of Dynamic Arrays

Dynamic arrays offer several advantages over other array types in SystemVerilog:

  1. Flexible Size: One of the most significant benefits of dynamic arrays is their ability to resize. This flexibility allows you to allocate only the necessary amount of memory based on runtime requirements, optimizing memory usage.
  2. Ease of Use: The syntax for creating and managing dynamic arrays is straightforward. Developers can easily allocate, resize, and access elements without complex logic.
  3. Memory Management: Dynamic arrays enable better memory management. They can be allocated and deallocated as needed, reducing the risk of memory wastage associated with fixed-size arrays.
  4. Runtime Configuration: In scenarios where the number of elements is not known until runtime, dynamic arrays provide a perfect solution. They allow programs to adapt to varying data sizes without compromising performance.
  5. Support for Complex Data Types: Dynamic arrays can hold complex data types, such as user-defined types or classes, enhancing their versatility in various applications.

Why Choose Dynamic Arrays Over Fixed-Size Arrays?

Dynamic arrays are preferred over fixed-size arrays in many situations due to their adaptability:

  • When Data Size Varies: In applications where the size of the data set is not fixed or known beforehand, dynamic arrays provide the necessary flexibility.
  • When Memory Optimization is Critical: For applications with limited memory resources, dynamic arrays can be allocated and resized as needed, preventing memory waste.
  • When Implementing Complex Data Structures: For advanced data structures such as lists, stacks, or queues, dynamic arrays provide the necessary foundation for implementation due to their flexible size.

Conclusion

Dynamic arrays in SystemVerilog provide flexibility in memory management, allowing developers to create, assign, and resize arrays at runtime. They offer significant advantages over fixed-size arrays, especially in applications where data size varies or memory optimization is critical. Understanding how to use dynamic arrays effectively can greatly enhance your programming capabilities in SystemVerilog and improve the performance of your designs.