A dynamic array is one dimension of an unpacked array whose size can be set or changed at runtime. The space for a dynamic array doesn’t exist until the array is explicitly created at runtime.
The syntax to declare a dynamic array is:
data_type array_name [];
where data_type is the data type of the array elements. Dynamic arrays support the same types as fixed-size arrays.
For example:
bit [3:0] nibble[]; // Dynamic array of 4-bit vectorsinteger mem[]; // Dynamic array of integers
The new[] operator is used to set or change the size of the array.
The size() built-in method returns the current size of the array.
The delete() built-in method clears all the elements yielding an empty array (zero size).
new[]
The built-in function new allocates the storage and initializes the newly allocated array elements either to their default initial value or to the values provided by the optional argument.
size()
The prototype for the size() method is:
function int size();
The size() method returns the current size of a dynamic array, or zero if the array has not been created.
int j = addr.size;
addr = new[ addr.size() * 4 ] (addr); // quadruple addr array
Note: The size method is equivalent to $length( addr, 1 ).
delete()
The prototype for the delete() method is:
function void delete();
The delete() method empties the array, resulting in a zero-sized array.
int ab [] = new[ N ]; // create a temporary array of size N
ab.delete; // delete the array contents
$display( "%d", ab.size ); // prints 0
Array assignment
Assigning to a fixed-size unpacked array requires that the source and the target both be arrays with the same number of unpacked dimensions and the length of each dimension be the same. The assignment is done by assigning each element of the source array to the corresponding element of the target array, which requires that the source and target arrays be of compatible types. Compatible types are types that are assignment-compatible.
Assigning fixed-size unpacked arrays of unequal size to one another shall result in a type check error.
int A[10:1]; // fixed-size array of 10 elements
int B[0:9]; // fixed-size array of 10 elements
int C[24:1]; // fixed-size array of 24 elements
A = B; // ok. Compatible type and same size
A = C; // type check error: different sizes
An array of wires can be assigned to an array of variables having the same number of unpacked dimensions and the same length for each of those dimensions, and vice-versa.
wire [31:0] W [9:0];
assign W = A;
initial #10 B = W;
A dynamic array can be assigned to a one-dimensional fixed-size array of a compatible type if the size of the dynamic array is the same as the length of the fixed-size array dimension. Unlike assigning with a fixed-size array, this operation requires a run-time check that can result in an error.
int A[100:1]; // fixed-size array of 100 elementsint B[] = new[100]; // dynamic array of 100 elementsint C[] = new[8]; // dynamic array of 8 elementsA = B; // OK. Compatible type and same sizeA = C; // type check error: different sizes
A dynamic array or a one-dimensional fixed-size array can be assigned to a dynamic array of a compatible type. In this case, the assignment creates a new dynamic array with a size equal to the length of the fixed-size array. For example:
int A[100:1]; // fixed-size array of 100 elementsint B[]; // empty dynamic arrayint C[] = new[8]; // dynamic array of size 8B = A; // ok. B has 100 elementsB = C; // ok. B has 8 elements
The last statement above is equivalent to:
B = new[ C.size ] (C);
Similarly, the source of an assignment can be a complex expression involving array slices or concatenations.
For example:
string d[1:5] = { "a", "b", "c", "d", "e" };
string p[];
p = { d[1:3], "hello", d[4:5] };
The preceding example creates the dynamic array p with contents: “a”, “b”, “c”, “hello”, “d”, “e”.
Arrays as arguments
Arrays can be passed as arguments to tasks or functions. The rules that govern array argument passing by value are the same as for array assignment. When an array argument is passed by value, a copy of the array is passed to the called task or function. This is true for all array types: fixed-size, dynamic, or associative.
Note that unsized dimensions can occur in dynamic arrays and in formal arguments of import DPI functions. If one dimension of a formal is unsized, then any size of the corresponding dimension of an actual is accepted.
For example, the declaration:
task fun(int a[3:1][3:1]);
declares task fun that takes one argument, a two-dimensional array with each dimension of size three. A call to fun must pass a two-dimensional array and with the same dimension size 3 for all the dimensions. For example,
given the above description for fun, consider the following actuals:
int b[3:1][3:1]; // OK: same type, dimension, and size
int b[1:3][0:2]; // OK: same type, dimension, & size (different ranges)
reg b[3:1][3:1]; // OK: assignment compatible type
event b[3:1][3:1]; // error: incompatible type
int b[3:1]; // error: incompatible number of dimensions
int b[3:1][4:1]; // error: incompatible size
A subroutine that accepts a dynamic array can be passed a dynamic array of a compatible type or a one-dimensional fixed-size array of a compatible type
For example, the declaration:
task ABC( string arr[] );
declares a task that accepts one argument, a dynamic array of strings. This task can accept any one-dimensional array of strings or any dynamic array of strings.
An import DPI function that accepts a one-dimensional array can be passed a dynamic array of a compatible type and of any size if formal is unsized, and of the same size if formal is sized. However, a dynamic array cannot be passed as an argument if formal is an unsized output.