SV -- Array 数组

SV -- Array

整理下system verilog中数组的用法，备忘。

目录

• SV -- Array
  • 1.定宽数组
    • 1.1 Packed array
    • 1.2 Unpacked array
  • 2. 动态数组(new)
    • 2.1 重新定义动态数组大小
  • 3. 关联数组(字典)
  • 4. 队列（Queue,$)

1.定宽数组

int array1 [6];            //fixed size single dimension array
int array2 [5:0];          //fixed size single dimension array
int array3 [3:0][2:0];     //fixed size multi dimension array
bit array4[2:0];           //unpacked array declaration
bit [2:0][7:0] array5;     //packed array declaration
bit [2:0][7:0] array6 [3]; //mixed packed and unpacked array

• 只在array名字之前定义位宽的是packed array，packed array的元素是单独的位
• array名字之后定义数组大小的是unpacked array;
• 名字前后都有定义的是混合array
• array3是多维数组

array赋初值：

array1 = '{0,1,2,3,4,5};
array2 = '{0,1,2,3,4,5};
array3 = '{ '{0,1,2,3},'{4,5,6,7},'{8,9,10,11}};

1.1 Packed array

• 封装的数组(packed array)可以是单位数据类型(reg、logic、bit)、枚举类型以及递归封装的数组和封装结构
• 一维的packed array也被称为Vector
• 一个packed array被表示为一个连续的位集合。
  例如：
  bit [2:0] [7:0] array5;
  在存储时是连续的：

1.2 Unpacked array

• 可以是任意数据类型
• 定义数组大小在名字之后
• 在存储上bit组是不连续的

例如：
bit [7:0] array4[2:0];
在存储时：

2. 动态数组(new)

定义：data_type array_name [ ];
function:

• new[ ] –> allocates the storage.
• size( ) –> returns the current size of a dynamic array.
• delete( ) –> empties the array, resulting in a zero-sized array.

例子：

//declaration
bit [7:0] d_array1[ ];
int d_array2[ ];
 
//memory allocation
d_array1 = new[4]; //dynamic array of 4 elements
d_array2 = new[6]; //dynamic array of 6 elements
 
//array initialization
d_array1 = {0,1,2,3};
foreach(d_array2[j]) d_array2[j] = j;

2.1 重新定义动态数组大小

主要有两种方法：

1. d_array1 = new[10];
2. d_array1 = new[10]（d_array2）;

对于第一种，会将数组清空，然后重新分配为大小为10的数组。
对于第二种，会保留原来的4个数据，然后分配新的6个元素的空间。

删除动态数组:d_array1.delete;,没有括号。

Example:

module dynamic_array;
   
  //dynamic array declaration
  bit [7:0] d_array1[];
  int       d_array2[];
 
  initial begin
    //memory allocation
    d_array1 = new[2];
    d_array2 = new[3];
         
    //array initialization
    d_array1 = {2,3};
    foreach(d_array2[j])  d_array2[j] = j;
 
    $display("----- d_array1 Values are -----");
    foreach(d_array1[i])   $display("\td_aaray1[%0d] = %0d",i, d_array1[i]);
 
    $display("----- d_array2 Values are -----");
    foreach(d_array2[i])   $display("\td_aaray2[%0d] = %0d",i, d_array2[i]);
     
    //Increasing the size by overriding the old values
    d_array1 = new[4]; //Create dynamic array of 4 elements
    $display("Size of Array d_array1 %0d",d_array1.size());
    $display("----- d_array1 Values are -----");
    foreach(d_array1[i])   $display("\td_aaray1[%0d] = %0d",i, d_array1[i]);
 
    //Increasing the size by retaining the old values
    d_array2 = new[5](d_array2); //Create dynamic array of 5 elements, retaining old values
    $display("Size of Array d_array2 %0d",d_array2.size());
    $display("----- d_array2 Values are -----");
    foreach(d_array2[i])   $display("\td_aaray2[%0d] = %0d",i, d_array2[i]);
$display("---------------------------------");
    //delete array
    d_array1.delete;
    d_array2.delete;
     
    $display("After Array Delete");
    $display("\tSize of d_array1 %0d",d_array1.size());
    $display("\tSize of d_array2 %0d",d_array2.size());
  end
endmodule

仿真结果：

----- d_array1 Values are -----
d_aaray1[0] = 2
d_aaray1[1] = 3
----- d_array2 Values are -----
d_aaray2[0] = 0
d_aaray2[1] = 1
d_aaray2[2] = 2
Size of Array d_array1 4
----- d_array1 Values are -----
d_aaray1[0] = 0
d_aaray1[1] = 0
d_aaray1[2] = 0
d_aaray1[3] = 0
Size of Array d_array2 5
----- d_array2 Values are -----
d_aaray2[0] = 0
d_aaray2[1] = 1
d_aaray2[2] = 2
d_aaray2[3] = 0
d_aaray2[4] = 0
---------------------------------
After Array Delete
Size of d_array1 0
Size of d_array2 0

3. 关联数组(字典)

语法：data_type array_name [ index_type ];

• 将内容存储在稀疏矩阵中
• 关联数组只在被使用时才分配存储空间
• 在关联数组中，索引表达式不限于整数表达式，但可以是任何类型
• 关联数组为数组元素分配一个查找表，其中索引作为键
• 类似于字典

例如：

int a_array1[*] ;            // associative array of integer (unspecified index)
bit [31:0] a_array2[string]; // associative array of 32-bit, indexed by string
ev_array [myClass];          //associative array of event,indexed by class

Methods:

Method	Description
.num()	返回元素个数
.delete(index)	删除index索引的键和值，如果不加index则删除所有键和值
.exists(index)	检查index键是否在数组中
.first(var)	将第一个键赋给var
.last(var)	将最后一个键赋给var
.next(var)	将下一个键赋给var，如果后面没有键，则返回最后一个键
.prev(var)	将上一个键赋给var，如果前面没有键，则返回第一个键

module associative_array;
  //array declaration
  int a_array[*];  
  int index;
  
  initial begin
    //allocating array and assigning value to it 
    repeat(3) begin
      a_array[index] = index*2;
      index=index+4;
    end
    
    //prev()-Associative array method
    a_array.prev(index);
    $display("entry is a_array[%0d] = %0d",index,a_array[index]);
    
    //next()-Associative array method
    a_array.next(index);
    $display("entry is a_array[%0d] = %0d",index,a_array[index]);
    a_array.next(index);
    $display("entry is a_array[%0d] = %0d",index,a_array[index]);
     a_array.prev(index);
    $display("entry is a_array[%0d] = %0d",index,a_array[index]);
  end
endmodule

结果：

entry is a_array[0] = 0
entry is a_array[4] = 8
entry is a_array[8] = 16
entry is a_array[4] = 8

4. 队列（Queue,$)

使用与unpacked数组相同的语法声明，但是在定义时使用$符号作为数组大小。在队列中，0表示第一个条目，$表示最后一个条目。
写法：data_type queue_name[$];
分为两种：第一种是bounded queue，定义了上界的queue;而第二种是unbounded，没有定义上界的。例如：

bit    queue_1[$];     // queue of bits  (unbound queue)
int    queue_2[$];     // queue of int 
byte   queue_3[$:255]; // queue of byte (bounded queue with 256 entries)
string queue_4[$];     // queue of strings

初始化方法：queue = {7,3,1,0,8};
Methods:

其中insert(index,var)，将var插入到index这个位置，后面的往后挪。
push和pop的几个函数的功能如下：

---

此外，对于定容的队列，push_back将不起作用，而push_front则会将第一个值替换。