SystemVerilog

终于进入了systemverilog的学习，接续加油！！

基础

语法-数据类型

SV中引入logic类型，和传统verilog中的reg和net的区别和联系：

• verilog作为描述语言，倾向于设计人员懂得寄存器和线网类型变量。利于后端综合工具
• SV侧重验证的语言，对logic对应的硬件并不十分关切，只作为单纯的变量进行赋值操作，这些变量也属于软件环境构建。

注意：

logic不能有多个结构性的驱动，也就是logic类型只能有一个驱动，如果存在多个驱动，那么编译时就会出现错误。 ！！！

当然，有些信号你本来就希望它有多个驱动，例如双向总线，这些信号就需要被定义成线网类型，例如wire。

logic相对应的是bit类型，他们均可以构建矢量类型（vector），而他们的区别在于

• logic为4值逻辑，即可以表示0，1，x，z

• bit为2值逻辑，只有0,1

为什么有了四值了，还搞个2值的？将硬件世界与软件世界分离

按四值逻辑类型和二值逻辑类型划分：

• 四值：integer、logic、reg、net-type（wire，wand。。。）
• 二值：byte、shortint、int、longint、bit

按有符号和无符号划分：

• 有符号类型：byte、shortint、int、longint、integer
• 无符号类型：bit、logic、reg、net-type（逻辑信号）

图中画圈部分，从有符号数到无符号数的转化，即为静态转化，在编译的时候完成检查

对应的动态转换$cast(tgt, src),和静态转化均为显式转化。对应上面的隐式转化

所以在不同数据类型进行操作时应注意变量的：

• 逻辑数值类型
• 符号类型
• 矢量位宽

使用typedef创建新的类型

创建数据自己的数据类型，可以用来声明变量

typedef bit [31:0] uint; // 32比特双状态无符号数
typedef int unsigned uint; //等效的定义

可以用来定义一个struct

typedef struct packed {
    bit[31:0] data;
    bit[1:0] id;
  } mon_data_t;

类型转换

静态转换：如整形和实数的转换

inti; 
real r; 
i=int'(10.0-0.1);  ／／转换是非强制的
r= real'(42);   ／／转换是非强制的

动态转换: $cast

枚举类型

定义常量的另 一种方法是使用参数。 但参数需要对每个数值进行单独的定义，而枚举类型却能够自动为列表中的每个名称分配不同的数值

例如：enum {RED, BLUE, GREEN} color;

创建署名的枚举类型有利于声明更多新变量，尤其是当这些变量被用作子程序参数或模块端口时。 你需要首先创建枚举类型，然后再创建相应的变量。 使用内建的name(）函数，你可以得到枚举变量值对应的字符串

／／创建代表0,1,2的数据类型
typedef enum {INIT1 DECODE,IDLE} fsmstate_e; 
f smstate 
_ e pstate, nstate;
initial begin 
        case(pstate)
        IDLE: nstate = INIT; 
        INIT: nstate=DECODE;
        default: nstate=IDLE; 
    endcase 
    $display ("Next state is 号s"，
    nstate.name ()); 
end

还可以指定枚举值

typedef enum ｛INIT, DECODE= 2, IDLE} fsmtype _e;

注意：第一个值只能默认缺省或指定为0值

枚举类型的方法

(1) first（）返回第一个枚举常量。

(2) last（）返回最后一个枚举常量。

(3) next(）返回下一个枚举常量。

(4) next (N)返回以后第N个枚举常量。

(5) prev(）返回前一个枚举变量。

(6) prev (N)返回以前第N个枚举变量。

操作符

verilog、SystemVerilog的所有操作符

数组

定宽数组

声明：

int ascend[4];
ascend = '{0,1,2,3};
int array[2][3];
array = '{'{0,1,2},'{3,4,5}};

合并数组

例如：

bit[2:0] [7:0] array5;

在存储时是连续的：此时内存占用为1个word（32位操作系统）

非合并数组

eg：

bit[7:0] array4[2:0] 或 bit[7:0] array4[3]

在存储时是非连续地址：此时内存占用为4个word

注：合并数组和非合并数组可以混用，例如：可以理解为连续的一维数组4*8bit进行了二维扩展

bit[3:0] [7:0] barray[3]; //合并：3x32比特

常量数组

int ascend [ 4] ='{ 0, 1, 2, 3} ;  //对4个元素进行初始化
in descend [5];       
descend='{4, 3, 2, 1, 0};  //为5个元素赋值
descend [0: 2] ='{ 5, 6, 7};  //为前3个元素赋值
ascend ='{ 4 { 8} } ;      //四个值全部为8
descend='{ 9, 8, default: 1};   // 默认补全{9,8,1,1,1}

数组遍历（for、foreach）

注意多维数组中foreach的使用：

int md[2][3] ='{'{ 0, 1, 2},'{ 3, 4, 5}};
initial begin 
    $display("Initial value:"); 
    foreach (md[i, j]） //这是正确的语法格式
	$display ("New value:"); 
	//对最后三个元素重复赋值5
    foreach (md[ i, j]) //这是正确的语法格式
        $display ("md[%0d][%0d]=%0d",i, j,md[i][j]);
    $display ("New value:");
    //对最后三个元素重复赋值5
    md ='{'{ 9, 8, 7},'{ 3 { 32'd5 } } } ;
    foreach (md[ i, j])
        $display ("mci[ %0d]［%0d]= %0d", i, j, md[i][j]);
end

打印结果

Initial value: 
md[0][0]=0
md[0][1]=1 
md[0][2]=2 
md[1][0]=3 
md[1][1]=4 
md[1][2]=5 
New value: 
md[0][0]= 9 
md[0][ 1]= 8 
md[0][2]=7 
md[0][ 0]= 5 
md[1][1] = 5 
md[1][2]=5

动态数组（new）

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

类似于列表，可以动态扩展

只要基本数据类型相同，例如都是int，定宽数组和动态数组之间就可以相互赋值。

在元素数目相同的情况下，可以把动态数组的值复制到定宽数组。

当你把一个定宽数组复制给一个动态数组时，SystemVerilog会调用构造函数new[]来分配空间并复制数值。

int dyn[], d2[];               //声明动态数组
 
initial begin
    dyn = new[5];              //分配5个元素的空间内存
    foreach(dyn[j]) dyn[j] = j;//对元素进行初始化
    d2 = dyn;                  //复制一个动态数组，这是d2会自动调用new函数
    d2[0] = 5;                 //修改复制值
    $display(dyn[0],d2[0]);    //显示数字（0和5）
    dyn = new[20](dyn);        //分配20个整数值并进行复制
    dyn = new[100];            //分配100个新的整数值，旧值不复存在
    dyn = dyn.delete();        //删除所有元素，此时数组大小为0
end

队列

队列与链表相似，可以在一个队列中的任何地方增加或删除元素，这类操作在性能上的损失比动态数组小很多，因为动态数组需要分配新的数组并复制所有元素的值。

队列定义：

• 第一种是bounded queue，定义了队列的上界；
• 第二种是unbounded queue，没有定义上界。

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

队列方法：

int  j = 1;
int  q[$] = {3,4};  //队列的常量不需要使用单引号'
int  q2[$]= {0,2,5};
 
initial begin
    q2.insert(1,j);  //{0,1,2,5}在2之前插入1
    q2.insert(3,q); //{0,1,2,3,4,5}在q2中插入一个队列
    q2.delete(1);    //{0,2,3,4,5}删除第一个元素
 
    //下面的操作执行速度很快
    q.push_front(6);//{6,0,2,3,4,5}在队列前面插入
    j = q.pop_back; //{6,0,2,3,4} j = 5
    q.push_back(8); //{6,0,2,3,4,8}在队列末尾插入
    j = q.pop_front;//{0,2,3,4,8} j = 6
    foreach(q[i])begin
        $display(q[i]);
    end
    q.delete();     //{}删除整个队列
end

关联数组

类似于哈希表，是键值对应关系进行存储

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

数组方法

缩减方法

sum（和），product（积），and（与），or（或），和xor（异或）

bit on[lO]; 
int total; 
initial begin 
foreach(on[i]) 
    on[i]=i;  //单比特数组, on[i]的值为0或1(奇数为1，偶数为0)
//打印出单比特和，结果为1，on.sum为1位
$display ("on.sum= %0d", on.sum) ; 
//打印出32比特和，结果为5，on.sum为32位，此时才是正确的求和结果
$display ("on.sum = %0d", on.sum + 32'd0); 
//用total来表示on.sum,由于total是32比特变量，所以数组和也是32比特
total = on.sum; 
$display("total = %0d"，total); // total=S 
//将数组和与一个32比特数进行比较
if (on.sum > = 32'd5)
    $display ("sum has 5 or more 1's"); 
//使用带32比特有符号运算的with表达式
$display ("int sum = %0d", on.sum with (int'(item))) ; 
end

数组定位方法

数组定位方法：min、max、unique

int f[6] = '{ 1, 6, 2, 6, 8, 6}; 
int d[] = '{2, 4, 6, 8, 10}; 
int q[$] =｛1, 3, 5, 7}, tq[$] ; 
tq = q.min () ;  // {l}
tq= d.max();     // {10}
tq= f.unique();  // {1,6,2,8}

数组定位方法：find

int d[] ='{ 9, 1, 8, 3, 4, 4},  tq[$]； 
//找出所有大于3的元素
tq=d.find with (item >3);
tq=d.find_index with (item >3); //{0,2,4,5}
tq=d.find_first with (item> 99); //{} 没找到
tq=d.find_first_index with (item == 8); //{2} 第2个下标为8
tq=d.find_last with (item==4);  //{4}
tq=d.find last_index with (item== 4);  //{5}

数组的排序

int d[]='{9,1,8,3,4,4}; 
d.reverse(); //'{4,4,3,8,1,9} 
d. sort();  //'{1,3,4,4,8,9} 
d.rsort();  //'{9,8,4,4,3,1} 
d. shuffle();  //'{9,4,3,8,1,4}

变量生命周期

对于automic方法，内部所有声明的变量默认是局部变量，伴随automic方法产生和销毁

对于static方法，内部所有声明的变量默认全局变量

可通过automic或static关键字显示声明变量

static声明的全局变量在编译时被创建加载，在整个运行期间存在

不同位置变量的默认生命周期

• module，program，interface，function，task之外声明的变量，默认为static变量，存在于整个仿真阶段
• module，program，interface之内，function，task之外声明的，默认为static变量，作用域在该块中
• module，program，interface中定义的function和task默认都是static类型
• function和task可以通过显示的姓名automic来改变其内部变量作用域！！

过程语句和子程序

initial块：类似于c的main方法，是启动程序的入口，可以有多个initial块并行，除class外，别的块都可以有

always：硬件行为，只能用于硬件块中！

硬件世界：module，interface；

软件世界：class，programe；

过程语句

SystemVerilog的新增

• for循环：continue，break

• begin-end：可省略（）

  task multiple_lines; 
  $display ("First line"); 
  $display ("second line"); 
  endtask : multiple_lines

• return 语句：显式返回；function会返回一个与方法名同名的变量，可以直接对该变量进行修改

  typedef int fixed_array5[5]; 
  
  function fixed_array5 init (int start); 
      foreach (f[i]) 
          init[i]= i + start;   //直接对返回值进行修改
  endfunction
  
  fixed_arrayS f5; 
  initial begin 
      f5= init(5); 
      foreach (f5[i]) 
          $display("..."） ； 
  end

  当然，针对数组的操作函数，最好使用ref进行

function和task

区别：verilog中function不能消耗时间，不能调用task，function必须有返回值

Systemverilog中放宽限制，function可以调用task，但只能在fork-join_none块中

返回值问题：

声明无返回值的方法：void 修饰

忽略有返回值方法的返回值：void’ ($fscanf (file,”%d II, i))

传入参数：

Verilog对参数的处理方式很简单：在子程序的开头把input和inout的值复制给本地变量，在子程序退出时则复制output和inout此的值。 除了标量以外，没有任何把存储器传递给Verilog子程序的办法。

可以在参数列表中指定输入参数（input），输出参数（output），输入输出参数（inout），引用类型（ref），这些参数形式区别于软件的参数

• input说明参数流入，在参数未表明传输方向时是默认的

• output定义输出方向，方法结束后该参数其实是一个输出值

  class trans；
  endclass
  initial begin
      trans t;
      trans s;
      t = new();
      s = new();
      copyof（t,s）;
  end
  function void copyof(trans t, trans s);
      t=s;
  endfunction

  默认为input参数，和软件的形参一样，input类型的参数在方法内部就是一个动态变量，和此时方法内的t和外面的t没有任何关系！！！

  function void copyof(output trans t, input trans s);
      t=s;
  endfunction

  通过output修饰，则对变量的修改可以传出方法

• inout：双向端口

• ref：类似于inout，传入变量的引用，实际也就是内存地址或者说指针，方法内对变量的修改实际是对内存的修改，是立即发生的！！！

  对应变量，可以理解为传入的是一个指针

  对应句柄，可以理解为传入的是一个句柄！！

  function void initial(ref trans t);
  	t=new();
  endfunction

ref专题

在SystemVerilog中，参数的传递方式可以指定为引用而不是复制。 这种ref参数类型比input、output或inout更好用。

为什么要使用ref？

• System Verilog允许不带ref进行数组参数的传递，这时数组会被复制到堆栈区里。这种操作的代价很高，除非是对特别小的数组。
• ref参数的第二个好处是在任务里可以修改变量而且修改结果对调用它的函数随时可见。 当你有若干并发执行的线程时，这可以给你提供一种简单的信息传递方式。

const ref声明参数又有何作用？

编译器会进行检查，以确保数组不被子程序修改，子程序存在修改操作，编译器会报错~

实例：

一旦bus.enable有效，初始化块中的thread2块马上就可以获取来自存储器的数据，而不用等到bus_read任务完成总线上的数据处理后返回，这可能需要若干个时钟周期。 由于参数data是以ref方式传递的，所以只要任务里的data有变化，@data语句就会触发。 如果你把data声明为output，则＠data语句就要等到总线处理完成后才能触发。

task bus_ read (
    input logic [31: o] addr, 
	ref logic [ 31: O] data); 
	bus.request= l'bl; 
    @ (posedge bus.grant) bus.addr = addr; 
	@ (posedge bus.enable) data=bus.data; 
    bus.request= 1'bO; 
	@ (negedge bus.grant); 
endtask 
logic [ 31: o] addr, data; 
initial 
    fork 
        bus_read(addr,data); 
        thread2: begin 
            @data;
            $display ("Read th from bus", data); 
        end 
    join

参数默认值

实例：

七ask many (input int a= 1, b= 2, c= 3, d= 4); 
$display ("%0d %0d %0d %0d", a, b, c, d); 
endtask 
initial begin 
    many(6,7,8,9); 
    many(); 
    many (.c(5)) ;
    many (,6,.d(8)) ;
end

接口interface

通过module端口进行连接：信号名映射的连接方法存在许多缺点：

• 增加了代码输入量
• 信号多时更加复杂
• 增加新的信号，需要对模块端口和顶层连接都进行修改

接口就是解决这种层次化的配置，将所有连线提取出来封装到一起。在使用时对接口进行例化，依此来简化连接

modport

接口中使用了点对点的无信号方向的连接方式。在使用该端口的原始网单里包含了方向信息，编译器依此检查连线错误。

接口中使用modport结构能够将信号分组并指定方向。

如在test和dut的接口中引入monitor模块的接口：

interface arb_if(input clk);
    logic[1:0] grant, request;
    logic[32:0] data;
    modport TEST(
    	output request, rst;
        input grant, clk;
        inout data;
    );
    modport DUT(
    	input request, rst, clk;
        output grant;
        inout data;
    );
    modport MONITOR(
    	input request;
        input grant;
        input data;
        input clk;
        input rst;
    );
endinterface

此时接口例化时需要指明modport

module arb(arb_if.DUT aif);
    ...
endmodule
//---------------------------
module test(arb_if.TEST aif);
endmodule

激励时序

对应时钟周期级的测试平台，需要在相对于时钟信号的合适时间点驱动和接收同步信号。驱动的太晚或采样的太早，测试平台就会错过一个时钟周期。即使在同一个时间片内，设计和测试平台的时间也会引起竞争状态，即在时钟的有效边沿处进行信号的驱动或采样是很容易出现竞争状态的。

对于测试平台来说：

驱动：时钟有效沿时，dut对连接线上的数据进行锁存和处理，测试平台应将本次驱动延时，以保证数据的保持时间

采样：时钟有效沿时，测试平台想要采到当前连接线上的数据，因此需要在dut驱动数据之前，即提前时钟有效沿采样，否侧新的信号被dut驱动到连接线，本次数据丢失

时钟块

竞争问题实例

在45ns时，clk1在上升沿处打印结果d1，clk2在45ns处采样的d1应该是多少？

在一般手绘仿真波形的时候，都会将d1的数值变化较时钟上升沿延后，但是在仿真软件中无法直接看出

如何打开delta-cycle模式，捕捉时序关系

将detla-cycle展开，看一下实际的时序关系

竞争问题的理解

• 由于各种可能性，clk与被采样数据之间如果只存在若干个delta-cycle的延迟，假如出现了时钟的复用，那么采样可能会存在问题，也就如上面例子中所示，相同时钟在同样的时刻中得到的是不同的采样结果，因此采样数据中的竞争问题会成为潜在困扰仿真采样准确性的问题。

  如上面的例子所示，45ns处clk1和clk2（实际是45+delta-cycle）的打印结果不同，这显然是不符合逻辑的！！！clk2采样到了新更新的数值，这是不对的

  不一定是测试环境，就算是在设计环境中，clk2对通过clk1上升沿时驱动的数据进行采样也都是有问题的

• 为了避免在RTL仿真行为中发生的信号竞争问题，建议通过非阻塞赋值或特定的信号延迟来解决同步的问题。

• 默认情况下，时钟对于组合电路的驱动会添加一个无限最小时间(delta-cycle)的延迟，而该延迟无法用绝对时间单位衡量，它要比最小时间单位精度还小。

• 在一个时间片(time-slot)中可以发生很多事情，例如在仿真器中敲命令“run 0”，即是让仿真器运行一个无限最小时间，一个时间片包含无限多个delta-cycle。 s >

  ms > ns > ps > fs > delta-cycle

• 查看delta-cycle可以观察在特定时间点，时序逻辑或组合逻辑中，参与硬件模拟仿真的硬件变量之间的准确时序前后关系。

竞争问题的解决

• 在驱动时，添加相应的人为延迟。模拟真实的延迟行为（模拟保持时间的驱动要求，即将输入保持一定时间），同时加大clk与变量之间的延迟，以此提高DUT使用信号时的准确性和TB采样信号时的可靠性。

  比如说在clk1上升沿到达后，给1个1ps的延时后再做信号变更，此时仿真里面也就不存在delta-cycle的竞争问题

• 对于一些设计中的没有进行上述延迟处理的信号，也就是采样时依然存在的delta-cycle延迟的信号，我们还可以依靠在采样事件前的某段时刻进行采样，来模拟建立时间的采样要求（即信号在时钟到来前已经建立一段时间），确保采样的可靠性。

时钟块怎么用

实例：

• 硬件世界和软件世界的连接可以通过灵活的interface实现，也可以通过modport来进一步限定信号传输的方向，避免端口的连接错误。
• 也可以在接口中声明clocking(时序块)和采样的时钟信号，用来做信号的同步和采样。
• clocking块基于时钟周期对信号进行驱动或采样的方式，使得testbench不再苦恼于如何准确及时地对信号驱动或者采样，消除了信号竞争的问题。
• clocking块不但可以定义在interface中，也可以定义在module和program中。
• clocking中列举的信号不是自己定义的，而是应该由interface或其它声明clocking的模块定义的。
• clocking在声明完名字之后，应该伴随着定义默认的采样事件，即“default input/output event”。如果没有定义，则会默认地在clocking采样事件前的1step对输入进行采样，在采样事件后的# 0 对输出进行驱动。

结论

在我看来interface中对于时间块的定义，实际上就是软件系统（tb）对硬件系统（dut）的一个模仿，可以把tb的时钟理解为clk1，dut的时钟理解为clk2，此时在clk1的上升沿，通过驱动的延时，就给了dut相对于clk2的一个保持时间；

另外tb采样的过程和驱动过程是独立起来看的，如果把dut的时钟理解为clk1，tb的时钟理解为clk2，则此时tb的采样结果和dut的输出结果

为了避免可能的采样竞争问题，应该在验证环境的驱动环节就添加固定延迟，使得在仿真波形中更容易体现出时钟与被驱动信号之间的时序前后关系，同时也便于DUT的准确处理和TB的准确采样。
如果TB在采样从DUT送出的数据，在时钟与被驱动信号之间在存在delta-cycle时，应该考虑时钟采样沿的更早时间段去模拟建立时间要求采样，这种方法也可以避免由于delta-cycle问题带来的采样竞争问题。
当我们把clocking运用到interface中，用来声明各个接口与时钟的采样和驱动关系后，可以大大提高数据驱动和采样的准确性，从根本上消除采样竞争的可能性。

类和包的使用

面向对象

包的使用

• 包的意义

  SV语言提供了一种在多个module、interface和program之中共享parameter、data、type、task、function、class等的方法，即利用package的方式来实现。通常将不同模块的类定义归整到不同的package中。
  package的好处是将一簇相关的类组织在了单一的命名空间namespace下，使得分属于不同模块验证环境的类来自于不同的package，这样可以通过package来解决类的归属问题。

• 包的定义

  package regs_pkg;
  	'include "stimulator.sv" 
  	'include "monitor.sv"
  	'include "chker.sv"
  	'include "env.sv"
  endpackage
  package arb_pkg;
  	'include "stimulator.sv"
  	'include "monitor.sv"
  	'include "chker.sv"
  	'include "env.sv"
  endpackage

注意：

​ 两个package中都定义了4个与模块验证相关的类，而这两个package中同名的类，它们的内容是不相同的，实现的也是不同的功能。将这些重名的类归属到不同的package中编译，不会发生重名的编译冲突，因为package是将命名空间分隔开来的。使用时需要注明使用哪一个package中的类。

module mcdf_tb;
	regs_pkg::monitor mon1 = new();
	arb_pkg::monitor mon2 = new();

• 包与库的区分

  尽管regs_pkg和arb_pkg中都存在着一个名字为monitor的类，我们可以在引用类名的时候通过域名索引::操作符的方式来显式支出所引用的monitor类具体来自于哪一个package，这样能很好地通过不同名的package来管理同名的类。package这个容器可以对类名做一个隔离的作用。
  package更多的意义在于将软件(类、类型、方法等)封装在不同的命名空间中，一次来与全局的命名空间进行隔离。package需要额外定义，容纳各种数据、方法、类。
  library是编译的产物，在没有介绍软件之前，硬件(module、interface、program)都会编译到库中，如果不指定编译库的话，会被编译进入默认的库中。从容纳的类型来看，库既可以容纳硬件类型，也可以容纳软件类型，例如类和方法，也包括package。

• 包的命名规则

  在创建package的时候，已经在指定包名称的时候隐含地指定了包的默认路径，即包文件所在的路径。如果有其他要被包含在包内的文件在默认路径之外，需要在编译包的时候加上额外指定的搜寻路径选项“+incdir+PATH”。
  如果遵循package的命名习惯，不但要求定义的package名称独一无二，其内部定义的类应该也尽可能的独一无二。
  如果不同package中定义的类名也不相同时，在顶层的引用也可以通过 import pkg_name::*的形式，来表示在module mcdf_tb中引用的类，如果在当前域中没有定义的话，会搜寻regs_pkg和arb_pkg中定义的类，又由于它们各自包含的类名不相同，因此不用担心搜寻中会遇到同名类冲突问题。

  package regs_pkg;
  	'include "regs_stm.sv"
  	'include "regs_mon.sv"
  	'include "regs_chk.sv"
  	'include "regs_env.sv"
  endpackage
  package arb_pkg;
  	'include "arb_stm.sv"
  	'include "arb_mon.sv"
  	'include "arb_chk.sv"
  	'include "arb_env.sv"
  endpackage
  module mcdf_tb;
  	import regs_pkg::*;
  	import arb_pkg::*;
  	
  	regs_mon mon1 = new();
  	arb_mon  mon2 = new();
  endmodule

• 使用包的注意事项

  在包中可以定义类、静态方法和静态变量。
  如果将类封装在某一个包中，那么它就不应该在其它地方编译，这么做的好处在于之后对类的引用更加方便。
  包是类的归宿，类是包的子民。
  一个完整模块的验证环境组件类，应该由一个定义的模块包来封装。
  使用’include的关键字完成类再包中的封装，要注意编译的前后顺序来放置各个’include的类文件。
  编译一个包的背后实际是将各个类文件“平铺”在包中，按照顺序完成包和各个类的有序编译。
  使用类可以通过import完成包中所有类或者某一个类的导入，使得新的环境可以识别出该类，否则类会躺在包这个盒子里不被外部识别。

类型转换

1.静态转换

在需要转换的表达式前面加单引号

这种方式不会对转换值做检查。如果转换失败，我们也无从得知

2.动态转换

动态转换需要调用系统函数$cast(tgt,src)做转换，把src转换成tgt的类型。

比如声明了父类句柄的子类src，转化为子类句柄的tgt

==son tgt = （son）src；

类句柄的向下转换

父类句柄转换为子类句柄时，需要使用$cast()函数进行转换，否则会出现编译错误；

$cast()会检查句柄所指向的对象的类型，而不是检查句柄本身;

子类句柄赋值给父类句柄（也就是将子类句柄拷贝成父类句柄），编译器认为合法;

父类句柄拷贝给子类对象，需要使用$cast检查句柄所指向的对象类型，一旦源对象跟目的对象是同一类型，就可以从父类句柄拷贝子类对象的地址给子类句柄。

【注意】:

当$cast作为任务来使用时（直接调用，不需要返回值时），如果转换失败会给出一个错误报告
当$cast作为函数使用时（需要返回值），转换失败返回0，不给出错误报告

3.显式和隐式转换

动态转换和静态转换都需要操作符或者系统函数的介入，称为显式转换

不需要转换的操作，称为隐式转换；

如：右侧是4位的矢量，左侧是5位的矢量，赋值时会隐式的做位扩展，然后再赋值

虚函数（virtual）

看一下”virtual”关键字有哪些使用场景：

1. 主要应用场景在virtual class，virtual interface 以及 virtual task/function。
2. OOP三大特性（封装，继承，多态）中的 多态 在SystemVerilog中一般通过 “virtual” 关键字实现。

1. virtual interface

• 在interface定义时，如果不使用关键字 “virtual” 那么在多次调用该接口时，在其中的一个实例中对接口中某一信号的修改会影响其他实例接口；如果使用了 “virtual” 关键字，那么每个实例是独立的。
• 习惯上在声明interface时均添加 “virtual”关键字。

2. virtual task/function

子类在实现方法的继承时可以发生方法的重写，此时子类只有通过调用super.fun()才能访问父类方法

• 多态的元素之一，没有声明virtual的方法，父类句柄=子类对象时，父类句柄无法访问到子类，只能访问到父类本身的function（）。一旦声明virtual，则该方法实现动态绑定，父类句柄则可以访问到子类的function（）！！！
• virtual方法只需要定义在最顶层的类中，其所有子类及子类的子类中的重写方法都实现了动态绑定，通过最顶层的类的句柄=子类实例都可以实现调用子类的该方法

3. virtual class

即抽象类

虚类一般用来定义类的格式,、类的成员、类的参数等，虚类不能被实例化，只能被扩展（重载）后实例化，用于在项目中定义一些标准的类。

虚类中的方法通常使用关键字 “ pure virtual “ 纯虚方法。同时OOP规定，只要class中存在一个没有被实现的pure function，就不允许例化这个class

pure virtual function（纯虚方法）：没有实体的方法原型，相当于一个声明，只能在抽象类中定义。

对象拷贝

当需要赋值一个对象，以防止对象的方法修改原始对象的值，或者在一个发生器中保留约束时，可以对对象做拷贝

1. 浅拷贝

只拷贝成员变量：String，int，句柄等

packet p = p1;packet p = p2;p1 = new();p2 = new() p1;

此时p1和p2是两个对象，区别于直接句柄赋值：p1=p2

2. 自定义拷贝

拷贝函数和新对象生成函数分开写：

• 父类和子类成员均可以完成拷贝，拷贝方法声明为virtual，遵循只考虑该类的域成员的原则，父类的成员拷贝调用父类的拷贝函数
• copy_data()需要注意句柄的类型转换，保证转换后的句柄可以访问类的成员变量

实验进化2

要从实验1完成哪些进化：

interface的提取

• test和dut的连接关系(initiator)：

  initiator的目的更像是创建虚拟的硬件模型，通过该module的实例化创建具有驱动能力的数据发送模块（给data就能按照需要进行发送，task chnl_write（））

  实验1：通过module进行例化

  实验2：通过interface实例化再传入module

  //实验1的initiator_nodule
  module chnl_initiator(
      //创建模型的第一部分，创建需要的输入输出接口
    input               clk,
    input               rstn,
    output logic [31:0] ch_data,
    output logic        ch_valid,
    input               ch_ready,
    input        [ 5:0] ch_margin
  );
  
  string name;
  //给个名字作为标识
  function void set_name(string s);
    name = s;
  endfunction
  //赋予该模型驱动能力，即给MCDT写入的能力
  task chnl_write(input logic[31:0] data);
    // USER TODO
    // drive valid data
    // ...
    @(posedge clk);
    ch_valid <= 1;
    ch_data <= data;
    @(negedge clk);
    wait(ch_ready === 'b1);
    $display("%t channel initial [%s] sent data %x", $time, name, data);
    chnl_idle();
  endtask
  //赋予该模型等待的能力
  task chnl_idle();
    // USER TODO
    // drive idle data
    // ...
    @(posedge clk);
    ch_valid <= 0;
    ch_data <= 0;
  endtask
  
  endmodule
  //实例化为3个channel
  chnl_initiator chnl0_init(
    .clk      (clk),
    .rstn     (rstn),
    .ch_data  (ch0_data),
    .ch_valid (ch0_valid),
    .ch_ready (ch0_ready),
    .ch_margin(ch0_margin) 
  );
  
  chnl_initiator chnl1_init(
    .clk      (clk),
    .rstn     (rstn),
    .ch_data  (ch1_data),
    .ch_valid (ch1_valid),
    .ch_ready (ch1_ready),
    .ch_margin(ch1_margin) 
  );
  
  chnl_initiator chnl2_init(
    .clk      (clk),
    .rstn     (rstn),
    .ch_data  (ch2_data),
    .ch_valid (ch2_valid),
    .ch_ready (ch2_ready),
    .ch_margin(ch2_margin) 
  );

  //实验2的initiator_interface(添加了clock块，对采样和驱动数据进行过滤)interface chnl_intf(input clk, input rstn);  logic [31:0] ch_data;  logic        ch_valid;  logic        ch_ready;  logic [ 5:0] ch_margin;  clocking drv_ck @(posedge clk);    default input #1ns output #1ns;    output ch_data, ch_valid;    input ch_ready, ch_margin;  endclockingendinterface//用interface把接口摘出去，再建立初始化模型module chnl_initiator(chnl_intf intf);  string name;  int idle_cycles = 1;    //增加模块功能，动态调整idle（等待）周期  function automatic void set_idle_cycles(int n);    idle_cycles = n;  endfunction  function automatic void set_name(string s);    name = s;  endfunction	    //添加赋予驱动的功能  task automatic chnl_write(input logic[31:0] data);    @(posedge intf.clk);    //时钟上升时设置驱动    intf.drv_ck.ch_valid <= 1;    intf.drv_ck.ch_data <= data;    @(negedge intf.clk);    //等待半拍，接收信号reday为高电平则    wait(intf.ch_ready === 'b1);    $display("%t channel initiator [%s] sent data %x", $time, name, data);    //这一步就决定了idle的执行次数    repeat(idle_cycles) chnl_idle();  endtask    //添加空闲等待功能  task automatic chnl_idle();    @(posedge intf.clk);    intf.drv_ck.ch_valid <= 0;    intf.drv_ck.ch_data <= 0;  endtaskendmodule

generator的提取

• 驱动数据data的生成：

  实验1：在test功能module中进行创建

  initial begin  chnl0_arr = new[100];  chnl1_arr = new[100];  chnl2_arr = new[100];  foreach(chnl0_arr[i]) begin    chnl0_arr[i] = 'h00C0_00000 + i;	chnl1_arr[i] = 'h00C1_00000 + i;	chnl2_arr[i] = 'h00C2_00000 + i;  endend

  实验2：抽象出generator模块，通过interface实例化再传入module，此时结构明显更清晰了

  module chnl_generator;  int chnl_arr[$];  int num;  int id;  function automatic void initialize(int n);    id = n;    num = 0;  endfunction  function automatic int get_data();    int data;    data = 'h00C0_0000 + (id<<16) + num;    num++;    chnl_arr.push_back(data);    return data;  endfunctionendmodule

将interface和generator的module按照需要进行实例化

并对实例化结果赋想要的初值

可以看到因为把接口提取出去，module的实例化不需要再对

chnl_intf chnl0_if(.*);  chnl_intf chnl1_if(.*);  chnl_intf chnl2_if(.*);  chnl_initiator chnl0_init(chnl0_if);  chnl_initiator chnl1_init(chnl1_if);  chnl_initiator chnl2_init(chnl2_if);  chnl_generator chnl0_gen();  chnl_generator chnl1_gen();  chnl_generator chnl2_gen();      initial begin     // verification component initializationi    chnl0_gen.initialize(0);    chnl1_gen.initialize(1);    chnl2_gen.initialize(2);    chnl0_init.set_name("chnl0_init");    chnl1_init.set_name("chnl1_init");    chnl2_init.set_name("chnl2_init");    chnl0_init.set_idle_cycles(0);    chnl1_init.set_idle_cycles(0);    chnl2_init.set_idle_cycles(0);     end

test的module

将generator的值装配到initiator中，然后执行

随机

1. 随机约束和分布

class Packet;
    //The random variable
    rand bit [31:0] src, dst, data[8];
    randc bit [7:0] kind;
    //Limit the values for src
    constraint c { src > 10;
                   src < 15;    }
    endclass
 
Packet p;
initial begin
    p = new();    //Create a packet 
    assert (p.randomize())     else
    $fatal(0, "Packet::randomize failed");
    transmit(p);
end

rand：以扑克牌为例，每次随机都是抽回一张牌，然后再放回去

randc：每次随机抽回的牌都不放回

随机值必须是二值逻辑，4值逻辑中的x，z随机不出来

assert：==if

p.randomize()：生成随机数，返回是否成功（0则为失败）

约束

constraint：约束求解器

父类约束被子类继承

dist：权重分布关键词（主要涉及:=表示赋值和:/表示平均概念的理解）

rand int src, dst;
constraint c_dist{    
    src dist {0:=40,[1:3]:=60};    //src = 0, weight = 40/220    //src = 1, weight = 60/220    //src = 2, weight = 60/220    //src = 3, weight = 60/220     
    dst dist {0:/40,[1:3]:/60};    //src = 0, weight = 40/100    //src = 1, weight = 20/100    //src = 2, weight = 20/100    //src = 3, weight = 20/100
}

inside表示约束中变量是某一值的集合，除非还存在其他约束，否则随机变量在集合中取值概率相同。

rand int c;    //随机变量
int lo, hi;    //作为上限和下限的非随机变量
constraint c_rang{c inside {[lo:hi]};    //lo<=c&&c<=hi}

使用$指定最大值和最小值。

rand bit [6:0] b;     //0 <= b <= 127rand 
bit [5:0] e;     //0 <= e <= 63
constraint c_range{    
    b inside {[$:4], [20:$]};    //0<= b <=4 || 20 <= b <=127    
	e inside {[$:4], [20:$]};    //0<= b <=4 || 20 <= b <=63
}

对于条件约束，可以通过->或者if-else让约束表达式在特定时刻有效

class BusOp;    ...    
    constraint c_io {        
        (io_space_mode) -> addr[31] == 1'b1; //1时生效
   } 
class BusOp;    ...    
    constraint c_len_rw {        
        if(op == READ)            
            len inside {[BYTE:LWRD]};        
        else            
            len == LWED;
    }

对于约束而言，是双向约束，是一种声明性质的代码，并行的，不是自上而下的，所有约束表达式同时有效

一旦发生约束冲突，则会同时失败。

rand logic [15:0] r, s, t;constraint c_bidir {    r < t;    s == r;    t < 30;    s > 25;}

2. 约束块控制

在一个对象中，可能会有很多的约束块，在实际使用时，我们希望一些随机块起作用，一些随机块不起作用，这就需要控制开关来控制约束块。在system verilog中提供了constrian_mode()函数来打开或关闭约束，同时也提供了随机变量的控制函数rand_mode()来控制变量的随机性，当随机变量的随机属性被关闭时，它就不在是一个随机变量，randomize()函数不会对其赋值。

constraint_mode()

可以被类调用，也可以被约束块调用，让该作用域下的约束打开或关闭

class Packet;    
    rand int length;//进行两个冲突的约束length    
    constraint c_short {length inside [1:32];}     
    constraint c_long  {length inside [1000:1023];}
    external virtual function int reasonable_constraint_mode (bit on_off);
endclass Packet p;

initial begin    
    p = new(); //Create a long packet by disabling short constraint    
    p.c_short.constraint_mode(0);    
    assert(p.randmize());    
    transmit(p); //Create a short packet by disabling all constraints then enabling only the shart constraint    	
    p.constraint_mode(0);   
    p.c_short.constraint_mode(1);    
    assert(p.randomize());    
    transmit(p);
end

rand_mode()

当rand_mode()作为task调用时，控制随机变量的随机属性开和关；

和constraint_mode的使用方法相同，只是一个是直接屏蔽constraint，一个是不对随机变量进行随机赋值

class Packet;
	rand integer source_value, dest_value;
	... other declarations
endclass
int ret;
Packet packet_a = new;
// Turn off all variables in object
packet_a.rand_mode(0);
// ... other code
// Enable source_value
packet_a.source_value.rand_mode(1);
ret = packet_a.dest_value.rand_mode();

randomize().with可以在外部增加约束，每次生成随机的时候只在当前有效，多次randomize的结果不会互相影响！！！

问：t.randomize().wiht({addr inside [200,300]； date inside [0,10]；});

这次随机化能不能实现？

答，可以，soft关键字表示在发生约束冲突时，soft修饰的约束失效！！

3. 随机函数

• 对于上面提到的randomize（）函数的注意点：

  • 可以传入参数，rand声明的变量没传入就不会随机化，没被rand声明的变量传入也会被随机化
  • 无论是否传入参数，约束条件都生效

  class Rising;
      byte low;        //未被随机约束变量
      rand byte med, hi;    //随机化的变量,8位有符号值
      constraint up
          {    low < med; med < hi;}
  endclass
   
  initial begin
      Rising r;
      r = new();
      r.randomize();        //    随机化hi,但是不改变low
      r.randomize(med);     //    只随机化med
      r.randomize(low);     //    只随机化low
  end

  问：上述代码中，例化了r之后，先调用r.randomize(low)，那么low,med和hi的组合值可能是下面哪一组？

  （A）low = -1,med=0, hi=0（B）low = -1,med=1, hi=2（C）low = 报错,med=0, hi=0（D）low = 报错,med=null, hi=报错

  答：c，因为约束条件不满足，随机化失败

4. 数组的约束

可以加约束的两个层面：size（）和content

动态数组分别可以对其长度和内容做随机化处理。此外，还可以通过在约束中结合数组的其它方法sum(), product(), and(), or()和xor()。

class good_sum5;    
    rand uint len[];    
    constraint c_len{ 
        foreach (len[i]) len[i] inside {[1:255]}; //元素约束        
     	len.sum() < 1024;  //元素求和        
     	len.size() inside {[1:8]}；  //数组长度    
    }
endclass

randc并不能让数组的每个元素随机化时不重复

可采用以下方法：

• 1.数组的每个元素遍历

• ```verilog
  class UniqueSlow;

  rand bit [7:0] ua[64];    
  constraint c {        
      foreach (ua[i])        //对数组中每一个元素操作            
          foreach (ua[j])                
              if(i != j)     //除了元素自己                    
                  ua[i] != ua[j];     //和其它元素比较
  }
  

  endclass

    
  - 2.创建randc变量，在`pre_randomize()`方法中给数组赋值
  
  - ```verilog
    class randc8;    randc bit [7:0] val;    //随机变量的值的范围为0~255，每一次randmize的256次值都不相同endclass class LittleUniqueArray;    bit [7:0] ua [64];      //定义一个含有64个元素的数组    function void pre_randomize();        randc8 rc8;        rc8 = new();        foreach (ua[i])    begin            assert(rc8.randomize());    //从256个元素中随机化64次，每次随机化的值都不同            ua[i] = rc8.val;            //之后将随机化后的值赋值给数组        end    endfunctionendclass

案例1：

class packet;    rand bit[3:0] da[];                  //rand修饰动态数组    constraint int da    {        da.size() inside {[3:5]};        //约束数组的个数为3-5        foreach(da[i]) da[i] <= da[i+1];            }endclasspackat p;initial begin    p = new();    p.randomize() with {da.size() inside {3,5};};    //约束da数组的个数或者3或者5end

本题中考查动态数组的范围，边界范围da[4] < da[5]中超出了范围。

随机化句柄数组

这里需要特别注意的：随机函数会随机每个句柄的对象

案例2：

parameter MAX_SIZE = 10;
    class RandStuff;
        bit[1:0] value = 1;
endclass
class RandArray;
    rand RandStuff array[];
    constraint c {
        array.size() inside
        {[1:MAX]};
    }
function new();
    //分配最大容量
    array = new[MAX_SIZE];
    foreach (array[i])
        array[i] = new();
    endfunction
endclass
 
RandArray ra;
initial begin
    //构造数组所有对象
ra = new();
    //随机化数组，但是可能会减小数组
assert(ra.randomize());
foreach (ra.array[i])
    $display(ra.array[i].value);
end

问：ra.randomize() with {array.size == 2}的合法求解是多少呢？

答：array[0].value = 1,array[1].value = 1

因为句柄对象没有rand修饰，随意randomize（）进不到对象里面

问：RandArray类中bit[1:0] value加上rand修饰会怎么样？

答：此时随机化方法会向句柄对象中继续寻找，然后给value变量进行随机化

5. 随机控制

生成随机序列

（1）产生随机事务序列的另一种方法就是使用SV的 randsequence结构。这对于随机安排组织原子（atomic）测试序列很有帮助。

initial begin
    for (int i=0; i<15; i++) begin
//按照要求发送激励
        randsequence (stream)
            stream : cfg_read := 1 | io_read :=2 | mem_read :=5;        
//cfg_read和io_read以及mem_read的可能性1:2:5
            cfg_reead : {cfg_read_task;} | {cfg_read_task;} cfg_read;
            mem_reead : {mem_read_task;} | {mem_read_task;} mem_read;
            io_reead  : {io_read_task;}  | {io_read_task;}  io_read;
        endsequence
    end
end

（2）randcase来建立随机决策树，但是它带来的 问题就是没有变量 可以提供追踪 调试。

initial begin    int len;    randcase        1:len = $urandom_range(0,2);    //10%:0,1,or2        8:len = $urandom_range(3,5);    //80%:3,4,or5        1:len = $urandom_range(6,7);    //10%:6or7    endcase    $dsiplay("len = %0d", len);end

总结：

（1）randsequence和randcase都是针对轻量级的随机控制应用。而我们可以 通过定义随机类 取代上述随机控制并且由于类的继承 性使得在后期维护代码的时候更加方便。

（2）randsequence的相关功能我们在协调激励组件和测试用例的时候可能会用到。

（3）randcase对应着随机约束中dist权重约束if-else条件约束组合。

线程

核心：

fork … join
fork … join_none
fork … join_any

三者区别：执行顺序

• fork-join：执行完该并行块才继续执行
• fork-join_none：先执行后面的，这个块和后面的语句属于并行
• fork-join_any：最快的一句执行完，就和后面的语句并行

一旦initial块执行结束，线程中未完成的语句也结束

线程控制

• 如何确保fork-join和fork-none在退出前执行完呢

  在end之前调用wait fork

• 停止多个线程：disable fork

  initial begin
      check_trans(tr0);    //线程0
      //创建一个线程来限制disable fork的作用范围
      fork    //线程1
          begin
              check_trans(tr1);    //线程2
              fork                 //线程3
                  check_tans(tr2);    //线程4
              join
              //停止线程1-4，单独保留线程0
              #(TIME_OUT/2) disable fork
          end
      join
  end

  disable线程1，以及其衍生出来的线程

• 停止多次 调用的任务

  如果你给某一个任务或者线程指明标号，那么当这个线程被调用多次后，如果通过disable去禁止这个线程标号，所有衍生的同名线程都将被禁止。

  task wait_for_time_out (int id);
      if(id == 0)
          fork
              begin
                  #2;
                  $display("@%0t: disable wait_for_time_out", $time);
                  disable wait_for_time_out;
              end
              join_none
              fork: just_a_little
                  begin
                      $display("@%0t: %m: %0d enteriing thread", $time,id);
                      #TIME_OUT;
                      $display("@%0t； %m: %0d done", $time,id);
                  end
              join_none
  endtask

  可以看到该task占用的线程只是点火启动

  initial begin
      wait_for_time_out(0);    //Spawn thread 0
      wait_for_time_out(1);    //Spawn thread 1
      wait_for_time_out(2);    //Spawn thread 2
      #(TIME_OUT*2) $display("@%0t: All done", $time);
  end

  若果执行上述语句，则在执行完id=0的task后，所用其他由该task开辟的线程被全部截止

线程通信

event

event关键字：声明即实例

看一下线程间的相互阻塞

event e1,e2;
    initial begin
        $display("@%0t: 1:before trigger", $time);
        -> e1;
        @e2;
        $display("@%0t: 1:after trigger", $time);
    end
    initial begin
        $display("@%0t: 2:before trigger", $time);
        ->e2;
        @e1;
        $display("@%0t: 2:after trigger", $time);
    end

e1和e2在同一时刻被触发，但是由于delta cycle的时间 差是的两个 初始化块可能无法等到e1或者e2

因为存在date-cycle，e1和e2总是有一个先触发，触发e1时等待e2，触发e2时等待e1。打印结果为：

@0:1：before trigger    @0:2：before trigger    @0:1：after trigger

可以看到@e1导致的阻塞没有办法解决

triggered()

此时就可以对阻塞方式进行一下修改：

更加安全的方式使用event的方法triggered()，将边沿触发改为电平触发

event e1,e2;
    initial begin
        $display("@%0t: 1:before trigger", $time);
        -> e1;
        wait (e2.tregger);
        $display("@%0t: 1:after trigger", $time);
    end
    initial begin
        $display("@%0t: 2:before trigger", $time);
        ->e2;
        wait (e1.tregger);
        $display("@%0t: 2:after trigger", $time);
    end

此时只有e1，e2执行就代表电平触发已经完成，不会再造成阻塞

@和triggered()的使用时机

module road;
initial begin
    sutomatic begin
    byd.drive();
end
endmodule
 
class car;
    bit   static = 0;
    task  launch();
        start = 1;
        $display("car is launched");
    endtask
    task move();
        wait(start == 1);
        $display("car is moving");
    endtask
task drive();
    fork
        this.launch();
        this.move();
    join
endtask
endclass

为了保证发动方法在前，通过bit位控制move（）方法阻塞

此时只要执行了launch（），move（）方法随便执行

此时可以直接换成event和triggered

class car;    event  e_start;    task  launch();        -> e_start;        $display("car is launched");    endtask    task move();        wait(e_start.triggered());        $display("car is moving");    endtasktask drive();    fork        this.launch();        this.move();    joinendtaskendclass

那如果再增加一个显示速度的方法，要求每次增加速度都会显示，此时就要使用边沿触发@，因为电平触发只会发生一次，后续wait(triggered())的返回值会一直为1，阻塞检测激励将不复存在

lass car;
    event e_start;
    event e_speedup;
    int speed = 0;
    ...
    task speedup();
        #10ns;
        ->e_speedup;
    endtask
    task display();
        forever begin
            @e_speedup;
            speed++;
            $display("speed is %0d",speed);
        end
    endtask
    task drive();
        fork
            this.speedup();
            this.display();
        join_none
    endtask
endclass

旗语（semaphore）

也就是锁

program automatic test(bus_ifc.TB.bus);
    semaphore sem;    //创建一个semaphore
    initial begin
        sem = new(1);    //分配一个钥匙
        fork
            sequencer();    //产生两个总线实物线程
            sequencer();
        join
    end
    task sequencer;
        repeat($urandom%10)    //随机等待0-9个周期
        @bus.cb;
        sendTrans();            //执行总线事务
    endTask
    task sendTrans;
        sem.get(1);            //获取总线钥匙
        @bus.cb;                //把信号驱动到总线上
        bus.cb.addr <= t.addr;
        ...
        sem.put(1);            //处理完成时把钥匙返回
    endtask
endprogram

semaphore 钥匙数是傻瓜式的增减：

new() ：不传参就没钥匙

get（）：调用就少一把

put（）：调用就多一把

上面这种调用方式可能出现的问题，钥匙越来越多

class car;
    semaphore key;
    function new();
        key = new(1);
    endfunction
    task get_on(string p);
        $display("%s is waiting for the key", p);
        key.get();
        #1ns;
        $display("%s got on zhe car", p);
    endtask
    task get_off(string p);
        $display("%s is got off the car", p);
        key.put();
        #1ns;
        $display("%s return the key", p);
    endtask
endlass
module family;
car byd = new();
string p1 = "husband";
string p2 = "wife";
initial begin
    fork
        begin    //    丈夫开车
            byd.get_on(p1);
            byd.get_off(p1);  
        end
        begin    //    妻子开车
            byd.get_on(p2);
            byd.get_off(p2);            
        end
    jion
end
endmodule

如果没注意还了一把钥匙，就会导致钥匙数在意料之外变多，如何避免这种情况

class carkeep;
    int key = 1;
    string q[$];            //队列
    string user;
    task keep_car();
        fork
            forever begin    //管理钥匙和分发
                wait(q.size() != 0 && key != 0);
                user = q.pop_front();    //等待
                key--;
            end
        join_none;
    endtask
    task get_key(string p);    //拿钥匙
        q.push_back(p);        //把名字告诉
        wait(user == p);        //等待了
    endtask
    task put_key(string p);    //还钥匙
        if(user == p)    begin    //拿钥匙的和还钥匙的是一个人
            user = "none";
            key++；
        end
    endtask
endclass

增加一个用户队列，此时用户没有资格获取钥匙，由keep_car()统一分发！！！用户只可以还钥匙，并将该用户删除

这就保证了最多只能有1把钥匙！！！

• 调用还钥匙方法：user是锁死的，只有同一个user才可以还，还完别的user无法访问，钥匙数最多只能为1
• 调用取钥匙方法：一旦队列有人，并且有钥匙，马上分配！！此时key为0，队列进入等待，直到取钥匙的user还钥匙

mailbox

线程同步只需要event来保证，只有线程之间传递消息时使用mailbox

• try_get()，try_put（)，try_peek()是非阻塞
• 限定mailbox可以传入的参数类型：mailbox #(int)
• new() ：表示变长，new（N）表示定长

program automatic bounded;
    mailbox mbx;
    initial begin
        mbx = new(1);    //容量为1
        fork
            //线程1
            for(int i =1; i<4 ; i++) begin
                $display("Producer: before put(%0d)", i);
                mbx.put(i);
                $display("Producer: after put(%0d)", i);
            end
            //Consumer线程
            repeat(4) begin
                int j;
                #1ns mbx.get(j);
                $display("Consumer: after put(%0d)", j);
            end
        join
    end
endprogram

program automatic bounded;
    mailbox mbx;
    initial begin
        mbx = new(1);    //容量为1
        fork
            //线程1
            for(int i =1; i<4 ; i++) begin
                $display("Producer: before put(%0d)", i);
                mbx.put(i);
                $display("Producer: after put(%0d)", i);
            end
            //Consumer线程
            repeat(4) begin
                int j;
                #1ns mbx.get(j);
                $display("Consumer: after put(%0d)", j);
            end
        join
    end
endprogram

总结

覆盖率

• 代码覆盖率：工具会自动搜集已经编写好的代码，常见的代码覆盖率如下：

  • 行覆盖率（line coverage）：记录程序的各行代码被执行的情况。
  • 条件覆盖率（condition coverage）：记录各个条件中的逻辑操作数被覆盖的情况。
  • 跳转覆盖率（toggle coverage）：记录单bit信号变量的值为0/1跳转情况，如从0到1，或者从1到0的跳转。
  • 分支覆盖率（branch coverage）：又称路径覆盖率（path coverage），指在if，case，for，forever，while等语句中各个分支的执行情况。
  • 状态机覆盖率（FSM coverage）：用来记录状态机的各种状态被进入的次数以及状态之间的跳转情况

• 功能覆盖率：是一种用户定义的度量，主要是衡量设计所实现的各项功能，是否按预想的行为执行，即是否符合设计说明书的功能点要求，功能覆盖率主要有两种如下所示：

  • 面向数据的覆盖率（Data-oriented Coverage）-对已进行的数据组合检查.我们可以通过编写覆盖组（coverage groups）、覆盖点（coverage points）和交叉覆盖（cross coverage）获得面向数据的覆盖率.
  • 面向控制的覆盖率（Control-oriented Coverage）-检查行为序列（sequences of behaviors）是否已经发生.通过编写SVA来获得断言覆盖率(assertion coverage).

需要指出的是: 代码覆盖率达到要求并不意味着功能覆盖率也达到要求，二者无必然的联系。而为了保证验证的完备性，在收集覆盖率时，要求代码覆盖率和功能覆盖率同时达到要求。

功能覆盖率建模

功能覆盖率主要关注设计的输入、输出和内部状态，通常以如下方式描述信号的采样要求；

对于输入，它检测数据端的输入和命令组合类型，以及控制信号与数据传输的组合情况。
对于输出，它检测是否有完整的数据传输类别，以及各种情况的反馈时序。
对于内部设计，需要检查的信号与验证计划中需要覆盖的功能点相对应。通过对信号的单一覆盖、交叉覆盖或时序覆盖来检查功能是否被触发，以及执行是否正确。

覆盖组——covergroup

   使用覆盖组结构（covergroup）定义覆盖模型，覆盖组结构（covergroup construct）是一种用户自定义的结构类型，一旦被定义就可以创建多个实例就像类（class）一样,也是通过new()来创建实例的。覆盖组可以定义在module、program、interface以及class中。

每一个覆盖组（covergroup）都必须明确一下内容：

covergroup cov_grp @(posedge clk);    //用时钟明确了覆盖点的采样时间,上升沿采样覆盖点，也可省略clk，在收集覆盖率时在根据情况注明
  cov_p1: coverpoint a;//定义覆盖点,cov_p1为覆盖点名，a为覆盖点中的变量名，也就是模块中的变量名
endgroup
 
cov_grp cov_inst = new();//实例化覆盖组

上述例子用时钟明确了覆盖点的采样时间,上升沿采样覆盖点，也可省略clk，在收集覆盖率时在根据情况注明，如下示例：

covergroup cov_grp;
  cov_p1: coverpoint a;//cov_p1为覆盖点名，a为覆盖点中的变量名，也就是模块中的变量名
endgroup
 
cov_grp cov_inst = new();
cov_inst.sample();          //sample函数收集覆盖率

上面的例子通过内建的sample()方法来触发覆盖点的采样.

覆盖组中允许带形式参数，外部在引用覆盖组时可以通过传递参数，从而对该覆盖组进行复用。

logic [7:0] address;
covergroup address_cov (ref logic [7:0] address,input int low, int high) @ (posedge ce);
    ADDRESS : coverpoint address {
      bins low  = {0,low};
      bins med  = {low,high};
    }
endgroup
 
address_cov acov_low  = new(addr,0,10);
address_cov acov_med  = new(addr,11,20);
address_cov acov_high = new(addr,21,30);

覆盖点——coverpoint

  一个覆盖组可以包含多个覆盖点,每个覆盖点有一组显式bins值，bins值可由用户自己定义，每个bins值与采样的变量或者变量的转换有关。一个覆盖点可以是一个整型变量也可以是一个整型表达式。覆盖点为整形表达式的示例如下：注意覆盖点表达式写法。

class Transaction();
   rand bit[2:0]  hdr_len;       //取值：0~7
   rand bit[3:0]  payload_len;   //取值：0~15
   ...
endclass

Transaction   tr；

covergroup Cov;
    len16: coverpoint(tr.hdr_len + tr.payload_len);    //注：求和结果为3位2进制，取值范围为0~15
    len32：coverpoint(tr.hdr_len + tr.payload_len + 5'b0);   //注：求和结果为5位2进制，取值范围为0~31
endgroup

 当进行仿真后，len16的覆盖点覆盖率最高可达100%，而覆盖点len32的覆盖率最高只能达到23/32=71.87%。由于总的bins数量为32个，而实际最多只能产生产生len_0,len_1,len2,…,len22共23个bins，所以覆盖率永远不可能达到100%

如果要使覆盖点len32达到100%的覆盖率，可以手动添加自定义bins，代码如下：

covergroup Cov;
   len32：coverpoint(tr.hdr_len + tr.payload_len + 5'b0);   //注：取值范围为0~31  
                    {bins  len[] = {[0:22]};} 
endgroup

盖点元素——隐式bin与显式bins

隐式或自动bin：覆盖点变量，其取值范围内的每一个值都会有一个对应的bin，这种称为自动或隐式的bin。例如，对于一个位宽为nbit的覆盖点变量，若不指定bin个数，2^n个bin将会由系统自动创建，需要注意的是自动创建bin的最大数目由auto_bin_max内置参数决定，默认值64。

program automatic test(busifc.TB ifc);        //接口例化
   class Transaction;
      rand bit [3:0]  data;
      rand bit [2:0]  port;
   endclass

   covergroup Cov;           //定义覆盖组，未添加时钟信号，此时需要使用sample（）函数采集覆盖率
      coverpoint  tr.port;     //设置覆盖点
   endgroup

   initial begin
      Transaction  tr=new();     //例化数据包
      Cov          ck=new();     //例化覆盖组
      repeat(32) begin
         tr.randomize();
         ifc.cb.port <= tr.port;
         ifc.cb.data <= tr.data;
         ck.sample();            //采集覆盖率
         @ifc.cb;
      end
   end
   
endprogram

显式bins：”bins”关键字被用来显示定义一个变量的bin，用户自定义bin可以增加覆盖的准确度，它属于功能覆盖率的一个衡量单位。在每次采样结束时，生成的数据库中会包含采样后的所有bins，显示其收集到的具体覆盖率值。最终的覆盖率等于采样的bins值除以总的bins值。

针对某一变量，我们关心的可能只是某些区域的值或者跳转点，因此我们可以在显示定义的bins中指定一组数值（如3，5，6）或者跳转序列（如3->5->6）。 显示定义bins时，可通过关键字default将未分配到的数值进行分配。

covergroup  Cov;
    coverpoint  tr.data{             //data变量的取值范围为0~15，不设置显示bins时，理论上会有2^16个bin
               bins  zero = {0};            //取值：0
               bins  lo = {[1:3],5};        //取值：1,2,3,5
               bins  hi[] = {[8:$]};        //取值：8~15，使用动态数组方法时相当于创建了hi[0],hi[1],...,hi[7]一共8个bins
               bins  misc = default;        //余下的所有值：4,6,7
   }

覆盖点的状态跳转——=> 与 ?通配符

  除了在bins中定义数值，还可以定义数值之间的跳转，操作符（=>），如下所示：

bit[2:0]     v;
covergroup  sg@(posedge clk);
   coverpoint  v{bins b1=(3=>4),(4=>5),(5=>6);   
                 bins b2=(3 => 4 => 5);   //跳转次序为 3->4->5，如果没有执行这个次序，则这个bins没有覆盖
                 bins b3=(1,5 => 6,7);   //(1=>6)、(1=>7)、(5=>6)、(5=>7)
                 bins b5=(5[*3]);         //3 consecutive 5's(连续重复，数值5的3次重复连续)
                 bins b6=(3[*3:5]);       //(3=>3=>3)、(3=>3=>3=>3)、(3=>3=>3=>3=>3)
                 bins b7=(4[->3]=>5);     //...=>4...=>4...=>4=>5（跟随重复，4出现3次，可以不连续，但在最后一个4出现后，下一个数值为5）
                 bins b8=(2[=3]=>5);      //...=>2...=>2...=>2...=>5（非连续重复，数值2出现3次）
                 bins anothers=default_sequence;
                 }
endgroup

  除操作符外，还可使用关键词wildcard和通配符?来表示状态和状态跳转

wildcard bins abc = {2'b1?};//覆盖10,11
 
wildcard bins abc = (2'b1x => 2'bx0};
 
//覆盖 10=>00 ,10=>10 ,11=>00 ,11=>10
 
covergroup address_cov () @ (posedge ce);
  ADDRESS : coverpoint addr {
    // Normal transition bibs
    wildcard bins adr0  = {3'b11?};
    // We can use wildcard in transition bins also
    wildcard bins adr1  = (3'b1x0 => 3'bx00);
    wildcard bins adr2  = (3'b1?0 => 3'b?00);
  }
endgroup

覆盖点之间的交叉覆盖率——cross

  交叉覆盖是在覆盖点或变量之间指定的，必须先指定覆盖点，然后通过关键字cross定义覆盖点之间的交叉覆盖。

//通过覆盖点来定义交叉覆盖
bit [3:0] a, b;
covergroup cg @(posedge clk);
  c1: coverpoint a;
  c2: coverpoint b;
  c1Xc2: cross c1,c2;    //1. 定义交叉覆盖使用关键字cross，利用**覆盖点名字**定义交叉覆盖
endgroup : cg
 
//通过变量名来定义交叉覆盖
bit [3:0] a, b;
covergroup cov @(posedge clk);
  aXb : cross a, b;      //2. 定义交叉覆盖使用关键字cross，直接利用**变量名字**定义交叉覆盖
endgroup
 
//交叉覆盖的通用定义格式： 
交叉覆盖名：cross 交叉覆盖点名1，交叉覆盖点名2;

由于上面每个覆盖点都有16个bin，所以它们的交叉覆盖总共有256（16*16）个交叉积（cross product），也就对应256个bin。

代码code——约束与覆盖率的运用

void sample() : Triggers the sampling of covergroup 触发覆盖组的采样
real get_coverage() : Calculate coverage number, return value will be 0 to 100 返回覆盖组覆盖率
real get_inst_coverage() :Calculate coverage number for given instance, return value will be 0 to 100 返回覆盖组实例的覆盖率
void set_inst_name(string) :Set name of the instance with given string 设置实例名
void start() :Start collecting coverage 开启覆盖率收集
void stop() :Stop collecting coverage 结束收集覆盖率

如何提高覆盖率

module test();
 
logic [2:0] addr;
wire [2:0] addr2;
 
assign addr2 = addr + 1;
 
covergroup address_cov;
  ADDRESS : coverpoint addr {
    option.auto_bin_max = 10;
  }
  ADDRESS2 : coverpoint addr2 {
    option.auto_bin_max = 10;
  }
endgroup
 
address_cov my_cov = new;
 
initial begin
  my_cov.ADDRESS.option.at_least = 1;
  my_cov.ADDRESS2.option.at_least = 2;
  // start the coverage collection
  my_cov.start();
  // Set the coverage group name
  my_cov.set_inst_name("ASIC-WORLD");
  $monitor("addr 8'h%x addr2 8'h%x",addr,addr2);
  repeat (10) begin
    addr = $urandom_range(0,7);
    // Sample the covergroup
    my_cov.sample();
    #10;
  end
  // Stop the coverage collection
  my_cov.stop();
  // Display the coverage
  $display("Instance coverage is %e",my_cov.get_coverage());
end
 
endmodule

通过修改随机化次数——提高覆盖率（覆盖点变量取值范围小）

或者说改变激励的生成和测试次数

通过添加约束constraint、自定义bins——提高覆盖率（覆盖点变量取值范围大）

在自定义bins，而不添加约束constraint的情况下：

module cov_demo();

  class transaction;
      rand bit[31:0]  data;        //2^32种可能
      rand bit[2:0]  port;         //0~7，一共8种可能
  endclass
    
   covergroup cov_port;
       port_bin : coverpoint tr.port;
       data_bin : covergroup tr.data{
                         bins min={[0:100]};        //此时，随机化生成该范围内任意一个数，该bins便被覆盖
                         bins mid={[101:9999]};
                         bins max={[10000:$]};       //$—-表示最大的边界
                      }
    endgroup
     
    transaction    tr=new;      //声明类的句柄，创建对象
    cov_port       ck=new;      //声明覆盖组的句柄，创建对象； covergroup和class类似
    
    initial begin
        repeat(32)begin           //生成得数据包的数量会影响覆盖率，也可以通过添加约束constraint来提升覆盖率，或者自定义bins。
            tr.randomize;        //随机化生成数据
            ck.sample();         //搜集覆盖率
        end
    end 

endmodule

在自定义bins，并缩小约束constraint范围的情况下：

module cov_demo();

  class transaction;
      rand bit[31:0]  data;        //2^32种可能
      rand bit[2:0]  port;         //0~7，一共8种可能
      constraint data_c1{
                    data inside {[0:100],[101:9999],[10000:12000]};       //由于data的可能性太多，故对其施加约束
                    }
   endclass
    
   covergroup cov_port;
       port_bin : coverpoint tr.port;
       data_bin : covergroup tr.data{
                         bins min={[0:100]};        //此时，随机化生成该范围内任意一个数，该bins便被覆盖
                         bins mid={[101:9999]};
                         bins max={[10000:$]};       //$—-表示最大的边界
                      }
    endgroup
     
    transaction    tr=new;      //声明类的句柄，创建对象
    cov_port       ck=new;      //声明覆盖组的句柄，创建对象； covergroup和class类似
    
    initial begin
        repeat(32)begin           //生成得数据包的数量会影响覆盖率，也可以通过添加约束constraint来提升覆盖率，或者自定义bins。
            tr.randomize;        //随机化生成数据
            ck.sample();         //搜集覆盖率
        end
    end 

endmodule

通过权重dist——调整hit次数分布

将代码中的constraint约束调整为权重dist处理后，其各个bins的hit次数分布更加均匀，如下所示：

constraint data_c1{
    data dist {[0:100]:/ 100, [101:9999]:/ 100, [10000:12000]:/ 120};      
              }

断言

https://www.cnblogs.com/pcc-uvm/p/14771685.html

断言的理解：断言更像是对信号的一个要求，不满足就不行！

断言被用来：

（1）检查特定条件或事件序列的发生；

（2）提供功能覆盖（functional coverage），使用 cover 关键字 ；

存在两种断言：立即断言和并发断言；

1. 立即断言=~if

立即断言在当前仿真时间检查条件，类似于if…else语句，但是断言带有控制.立即断言必须放在过程块定义中.

当断言带了else 语句，则失败后进入else；没带else语句，失败后直接执行$error

失败后的错误信息：

“test.sv”, 7: top.t1.a1: started at 55ns failed at 55ns
//显示和断言定义相违背
offending '(bus.cbb.grant == 2'b1)'

下面展示一个简单的断言：

断言格式如下：

assert(condition) 
$display(“Condition is True”); 
else 
$display(“Condition is False”);
 
 
assert(condition) 
$display(“Condition is True”);
 
assert(condition) 
$(“Condition is True”); 
else
$fatal(“Condition is False”);
 
assert(condition)
  else begin
     …….
     …….
    $fatal(“Condition is False”);
  end
 
assert(condition) 
else 
$warning(“Condition is False”);
//推荐使用的格式 
label: assert(condition) 
$(“Condition is True”); 
else 
$warning(“Condition is False”);

如果断言失败，并且没有指定任何其他else子句，则默认情况下，该工具将调用$error

2. 定制断言

a1: assert(bus.cb.grant==2'b01)
else $error("Grant noe asserted");

4个在断言中输出消息的函数：

• $info
• $warning
• $error
• $fatal

3. 并发断言 Concurrent Assertions(edge采样)

与时序相关，常用

并发断言可以认为是一个连续运行的模块，为整个仿真过程检查信号，所以需要在并发断言内指定一个采样时钟。

需要指出的是：

并发断言只有在时钟沿才会执行；

可以在过程块、module、interface和program块内定义并发断言；

c_assert:  assert property(@(posedge clk) not(a && b));
//下面为通用格式
 
断言名：assert property (判断条件);

实例：request信号除了在复位期间，其他任何时候都不能是X或者Z

interface arc_if(input bit clk);
    logic[1:0] grant, request;
    logic rst;
    
    property request_2state;
        @(poseedge clk) disable iff (rst);
        $isunknown(request) == 0;//确保没有z或x存在
    endproperty
    assert_request: assert property(request_2state);
endinterface

通用格式：

c_assert:  assert property(@(posedge clk) not(a && b));
//下面为通用格式
 
断言名：assert property (判断条件);

4. iff的使用

屏蔽不定态：

当信号被断言时，如果信号是未复位的不定态，不管怎么断言，都会报告：“断言失败”，为了在不定态不报告问题，在断言时可以屏蔽。

如：

​ @(posedge clk) (q == $past(d))，当未复位时报错，屏蔽方法是将该句改写为：

​ @(posedge clk) disable iff (!rst_n) (q == $past(d)) //rst是低电平有效