SystemVerilog 学习笔记

计算单位

1.频率计算：

容量用1024是因为地址是二进制的，多一根地址线容量翻倍。秒不是二进制的，所以频率没这回事。 时钟周期 - 运行频率换算： 1ns↔1GHz。10ns就是1GHz÷10 = 100MHz 1/10ns = 100Mhz

宏

`ifndef … define守卫宏 防止被include两次。package重复定义是编译错误，一旦别的文件也include这个就会报错

• 比如经常有代码文件被”送进编译器”了两次：一次靠filelist，一次靠include，这样就需要靠宏来放防守

笔记结构对照当前所学课程目录（第一~八章）整理。课程未覆盖到的旧笔记内容归入文末「附录」，不打乱主线。

目录

• 第一章 SV简介：1.1 SV 简介 ✅
• 第二章 数据类型：2.1 SV数据类型 ✅ / 2.2 数组 ✅ / 2.3 数组的操作 ✅ / 2.4 结构体、联合体与枚举 ✅
• 第三章 过程语句与子程序：3.1 过程语句 ✅ / 3.2 SV子程序 ✅
• 第四章 激励时序与接口：4.1 SV的激励时序 ✅ / 4.2 SV的接口 ✅ / 4.3 SV接口的驱动和采样 ✅
• 第五章 面向对象编程：5.1 SV类 ✅ / 5.2 SV类的成员操作 ✅ / 5.3 SV类的封装和继承 ✅ / 5.4 SV的多态 ✅ / 5.5 类型转换 ✅ / 5.6 虚接口 ✅ / 5.7 包的使用 ✅ / 5.8 多线程间通信 ✅
• 第六章 随机化：6.1 SV随机化基础 ✅ / 6.2 随机化约束的种类(实操) / 6.3 随机约束控制 ✅ / 6.4 随机约束控制(实操) / 6.5 随机化约束的概率 ✅ / 6.6 数组约束 ✅
• 第七章 断言：7.1 断言基础语法 ✅
• 第八章 覆盖率：8.1 SV覆盖率类型 ✅ / 8.2 覆盖策略及覆盖组 ✅ / 8.3 覆盖率数据采样 ✅ / 8.4 交叉覆盖率及覆盖选项 ✅
• 第九章 DPI：9.1 DPI基础用法 ✅
• 附录：复位 / 运算符与移位 / 编译指令
• HDLBits练习

第一章 SV简介

1.1 SV 简介

SV语言的一些feature：

• OOP
• Assertions
• Coverage
• New data types
• interfaces
• Random Gneration
• DPI
• Synchro IPC

第二章 数据类型

2.1 SV数据类型

1. Verilog 默认类型（wire / reg）

在 Verilog 中，如果你在端口列表（module 的括号内）声明了一个 output、input 或 inout，但没有显式指定它是 reg，也没有指定它是 logic(SystemVerilog)，那么它默认就是 wire 类型。

module top_module (
    input  a,    // 隐式默认为 wire
    output b     // 隐式默认为 wire
    
	input logic [31:0] a, // 推荐
	input [31:0] b, // 不推荐：虽然合法，但隐式默认为 wire
);
    // wire 类型必须使用 assign 语句进行连续赋值
    assign b = a; 

endmodule

补充知识 ： assign: b ──────→ a 单向，写反了就不通 tran: a ══════ b 双向，等价于焊在一起

wire 类型的变量代表物理连线。在仿真开始的瞬间（Time 0），在任何驱动源（如 assign 语句或门级输出）生效之前，或者如果没有驱动源连接它，wire 的默认值是 z(High Impedance / 高阻态)。

wire 对比 reg 类型： 如果 zero 被声明为 reg 类型（例如在 testbench 中），reg 的默认初始值通常是 x(未知态)，直到被赋值。

不定态 x，高阻态 z。

2. SV 数据类型总览

默写：

• 常见二值逻辑类型有int byte和bit
• 常见有符号数据类型有bit reg和logic
• 四值逻辑转换成二值逻辑，x和z会转换成0

default value:

• logic - x（没人赋值就永远停在default value x。）
• bit - 0

2.2 数组

1. 定宽数组

int lo_hi[0:15]; 或 int lo_hi[16]; //16个整数

2. 多维数组

int array[0:1][0:2] 或 int array[2] [3] //2行3列

> 注意：int array[0:1][0:2] = int [0:1][0:2] array（只是写法不同）

3. packed

bit [3:0][7:0] bytes; //四个元素，每个8bit宽（属于合并数组）

logic [3:0][7:0] a; //总位宽4*8=32bit，四个元素，每个8bit宽

多维合并数组：
logic [1:0][2:0][7:0] data;
- 第一层 `[1:0]`：有 2 个大单位。
- 第二层 `[2:0]`：每个大单位里有 3 个小单位。
- 第三层 `[7:0]`：每个小单位是 8 bit。
  总位宽：2*3*8 = 48 bit
  
虽然写成了三维，但在硬件和仿真器眼中，它依然是一个 连续的、扁平的 48-bit 向量。

比如可以将 32 个 32 位寄存器（每个 32 位）合并成一个 1024 位宽的数组。

• 合并数组将所有位压缩成一个连续的位向量
• 合并数组通常用于需要大量连续位数据的场景，如信号传输、总线操作等。

4. unpacked

bit [7:0] b_unpack[3] //3个8bit元素
bit [27:0] exp_aperture_addr[4][64]; //unpacked array

在设计一个寄存器文件时，每个寄存器通常作为一个独立的存储单元，独立操作，因此非合并数组更符合这一要求。

一句话总结： packed 是一整根位向量，能当大数字整体运算/跨元素切位；unpacked 是若干独立存储单元，只能整体赋值（dst=src）或逐元素 foreach，不能跨元素切位/当数字运算——区别不在”内存连不连续”，在”能不能当一个数字整体操作”。

2.3 数组的操作

1. 动态数组

在程序执行之前不知道数组宽度，可以使用 [ ] 留空来定义动态数组。 此时数组最开始是空的，但在调用之前，必须使用new [ ] 来指定宽度。

int  dyn[], d2[];           //声明动态数组
initial begin
  dyn=new[5];               // 分配5个元素
  foreach(dyn[j]) dyn[j]=j; // 对元素进行初始化
  d2=dyn;                   //复制一个动态数组
  d2[0]=5;                  //更改元素的值
  dyn=new[20](dyn);         //分配20个整数值并进行复制，把新的数组的开始5个数用旧的元素覆盖
  dyn=new[100];             //分配100个新的元素，旧值不复存在
  dyn.delete();             //(清空数组)删除所有元素，删除之后，数组大小为0
end

2. 队列 queue

队列（queue）是一种动态数组类型

data_type queue_name[$];  
//data_type 是元素类型，比如 int, bit [7:0] 等。  
[$] 表示这是一个队列。

特点: 队列 不像静态数组需要提前定义长度，队列可以在 运行时 自动扩展或收缩

使用：

push_front() / push_back()：从队首或队尾插入元素。  
pop_front() / pop_back()：从队首或队尾取出元素。  
可以通过索引访问，例如 q[0]。  
可以用 size() 获取队列长度。  

例子：

int q[$];  
q.push_back(10);   // 队尾插入 10  
q.push_back(20);   // 队尾插入 20  
q.push_front(5);   // 队首插入 5   => 队列内容: {5,10,20}  
$display("%0d", q.pop_back());  // 输出 20, 队列变成 {5,10}

---
int j=1,
    q2[$]={3,4},
    q[$]={0,2,5};       //声明队列,并初始化一些元素
initial begin
    q.insert(1, j);     // 在q队列的第二个元素(排列位置从0开始数)之前插入j,
                        // 队列q变成{0,1,2,5}
    q.insert(3,q2[0]);  //在q队列的第四个元素(排列位置从0开始数)之前
    q.insert(4,q2[1]);  // 插入队列q2的元素，队列q变成{0,1,2,3,4,5}
    $display(q);
    q.delete(1);        //删除第1个元素(排列位置从0开始数), 队列变成{0,2,3,4,5}
    q.push_front(6);    //在队列前插入6, q队列变成{6,0,2,3,4,5}
    j = q.pop_back;     //把最后一个元素pop出来,赋值给j, j=5, q队列变成{6,0,2,3,4}
    q.push_back(8);     //在队列尾部插入8, q队列变成{6,0,2,3,4,8}
    j = q.pop_front;    //把第一个元素pop出来,赋值给j, j=6, q队列变成{0,2,3,4,8}
    foreach (q[i])
        $display(q[i]); //打印整个队列
    q.delete();         //删除整个队列
end

数组 vs 队列：

• 数组：适合存储固定数量的数据，例如寄存器文件、查找表。
• 队列：适合存储动态数据流，比如 FIFO 模拟、事务列表、数据包缓冲。

3. 动态数组 vs 队列

两者都能运行时改大小，区别在怎么改：动态数组要手动 new[] 整体重开+复制；队列直接 push_back/push_front 单个增删，无需重开。

int dyn[];
dyn = new[2];        dyn[0]=a; dyn[1]=b;
dyn = new[3](dyn);   dyn[2]=c;   // 每加一个都要重新 new+复制，O(n)

int q[$];
q.push_back(a);
q.push_back(b);
q.push_back(c);                  // 直接追加，O(1)，无需重开

选队列的典型场景（如 scoreboard）：需要频繁单个增删/FIFO 消费（push_back 塞入 expected，pop_front 取出比对）。动态数组没有 push/pop 原语，只能手动整体重开搬运。

4. 数组的操作

// for和 foreach循环

initial begin
    bit [31:0] src[5], dst[5];
	    for (int i=0; i<$size(src); i++) //for循环不方便
        src[i] = i;
	
	//方法2，SV提供了foreach关键字，更加方便
    foreach (dst[j])
        dst[j] = src[j] * 2; // dst doubles src values
end

// 对于多维数组：
int md[2][3]='{'{0,1,2},'{3,4,5}};
initial begin
    $display("Initial value:");
    foreach(md[i,j])
        $display("md[%0d][%0d]=%0d",i,j,md[i][j]);
end

数组复制

bit [31:0] src[5] = '{0,1,2,3,4},
           dst[5];
           
dst = src;       // 数组复制
src[0] = 5;      // 只改变一个元素的值

$display(dst);   // 打印dst，看其是否得到了src的值，元素[0]是旧的值还是新值；（旧值）
$display(src);   // 打印src，看是否改变了src[0]的值

数组比较

可以使用数组名比较，也可以使用片段比较

// 在不使用循环的情况下，也可以利用“==”或者“!=”来比较数组的内容，
// 不过结果仅限于内容相同或者不相同。

bit [31:0] src[5] = '{0,1,2,3,4},
           dst[5] = '{5,4,3,2,1};

if (src==dst) $display("src == dst"); // 比较数组
else $display("src != dst");

dst = src;   // 数组复制
src[0] = 5;  // 只改变一个元素的值

//所有元素是否相等
$display("src %s dst", (src==dst)? "==":"!=");

//使用数组片段对第1-4个元素进行比较
$display("src[1:4] %s dst[1:4] ", (src[1:4]==dst[1:4])? "==":"!=");

bit [31:0] src[5] = '{0,1,2,3,4},
           dst[5] = '{5,4,3,2,1};

dst = src;  // 数组复制
src[0] = 5; // 只改变一个元素的值

foreach (dst[i]) begin
    if (dst[i]==src[i])
        $display("src[%d] == dst[%d]",i,i);
    else
        $display("src[%d] != dst[%d]",i,i);
end

2.4 数据结构

Verilog的最大缺陷之一是没有数据结构，SV中可以使用struct语句创建结构，跟C语言类似。

• 不过struct的功能少，他只是一个数据大集合，其通常的使用方式是将若干相关的变量组合到一个struct结构定义中。
• 伴随typedef可以用来创建新的类型，并利用新的类型来声明更多变量

1. packed

左边是unpacked struct：r、g、b各占一个独立的存储单元，灰色是空着的位。右边加了packed：三个成员按声明顺序连成一个24 bit的向量，先声明的r在最高位[23:16]，g在[15:8]，b在[7:0]。（图中类型名写作pixel_t，与正文的pixel_s是同一个结构体。）

//1. 非压缩结构体（Unpacked Struct）- 默认状态
typedef struct {
    bit [7:0] r;
    bit [7:0] g;
    bit [7:0] b;
} pixel_s;

pixel_s my_pixel; // 声明变量（struct初始化）
my_pixel = '{'h10, 'h10, 'h10}; // 赋值必须带单引号 ' //按结构体成员逐个赋值

//2.压缩结构体（Packed Struct）- 硬件友好型
typedef struct packed {
    bit [7:0] r;
    bit [7:0] g;
    bit [7:0] b;
} pixel_s;

pixel_s my_pixel; 

// 赋值方式的区别：
my_pixel =  {8'h10, 8'h10, 8'h10}; // 【不带'】作为整体向量拼接赋值(带'也不会报错)

• “非压缩”占地随意，赋值必加单引号；
• “压缩”连成一根线，加不加引号都能算（但底层逻辑不同，一个是按成员，一个是按位拼接）。

2. union packed

packed

• 它告诉编译器（或综合工具），这个联合体中的数据是以连续的比特位（Bits）形式存储的，中间没有空隙。

union(联合体)：联合体内的所有成员共享同一个存储空间。

• packed union 所有成员共享同一段存储且必须等宽；这里 raw_data 与 fields 都是 32 bit，访问同一位置——改 fields.enable 会同时改变 raw_data。

// 32 位联合体：raw_data 视图 + 字段视图，二者同址、等宽
typedef union packed {
    logic [31:0] raw_data;     // 视图1: 看作 32 位原始数据

    struct packed {            // 视图2: 看作控制字段（合计 32 bit，与 raw_data 同址）
        logic [15:0] reserved; // 高 16 位保留
        logic [7:0]  data;     // 中间 8 位数据
        logic        enable;   // 1 位使能
        logic        start;    // 1 位开始
        logic        error;    // 1 位错误
        logic [4:0]  mode;     // 5 位模式
    } fields;
} control_reg_u;

control_reg_u my_reg;

initial begin
    my_reg.raw_data      = 32'h0;  // 用法A: 整体清零
    my_reg.fields.enable = 1'b1;   // 用法B: 单独设 enable（同时改变 raw_data）
    // logic [31:0] bus_data = my_reg; // 用法C: 合法，被视为 packed
end

在 SystemVerilog 中，packed struct 的默认存储顺序是从高位到低位（First member is MSB）。

typedef union packed {  
        logic [31:0] word;  
        struct packed {  
            logic [11:0] i_imm;  
            logic [4:0]  rs1;  
            logic [2:0]  funct3;  
            logic [4:0]  rd;  
            rv32i_opcode opcode;  
        } i_type;  
} instr_t;

为什么要写成 [11:0] 而不是 [31:20]？

答：取值方便性。当你使用 inst.i_type.i_imm 时，你希望得到的是一个数值（例如立即数 12）。

• 如果是 logic [11:0]，你读出来的就是一个 12 位的数，可以直接参与运算。只不过编译器自动把它安排在了 [31:20]。
• 如果是”绝对位置”的概念，你读出来的数据可能需要右移 20 位才能得到真实的数值。SV 的写法让你取出来就是”对齐”到低位的值，非常方便。

3. struct vs union

类型不是硬件

上面说typedef是「图纸」，本身不占内存。放到硬件里也一样：typedef struct、typedef union只定义形状，不生成任何电路。用它声明的变量综合成什么，跟Verilog的reg一样，看在哪赋值：

• 在always_ff @(posedge clk)里赋值：触发器
• 用assign、always_comb赋值，或者直接接端口：组合逻辑、连线

以5级流水CPU为例，同一个类型声明两个变量，只是赋值的地方不同：

typedef struct packed {
    logic [31:0] pc;
    logic [63:0] order;          // 指令序号（验证用）
    logic        valid;
} id_reg_t;                      // 只是形状，不生成电路

id_reg_t id_next;                // 同一个类型
id_reg_t id_reg;                 // 同一个类型

always_comb begin                // 在组合块里赋值 → 97根线
    id_next.pc    = pc_if;
    id_next.order = order_if;
    id_next.valid = !flush;
end

always_ff @(posedge clk)         // 在时序块里赋值 → 97个触发器，就是IF/ID流水寄存器
    id_reg <= id_next;

id_next是这一拍算出来的值，id_reg在时钟沿把它存住，下一拍给ID级用。

packed struct：一根宽向量

id_reg是一个97位的寄存器，不是三个独立的寄存器。字段名只是给其中几段起的名字（先声明的字段放高位）：

id_reg_t = pc(32) + order(64) + valid(1) = 97位
id_reg.pc    就是 id_reg[96:65]
id_reg.order 就是 id_reg[64:1]
id_reg.valid 就是 id_reg[0]

• 写一个字段只动那几位：id_reg.valid <= !flush只改1个触发器
• 也能整体操作：id_reg <= '0一次清掉97位
• 级间要传的信号打成一包，一个端口input id_reg_t id_reg就传完；以后加字段只改typedef，端口不用动

对比

打个比方：struct是一排格子，各放各的；union是同一张纸，套不同的模板看。是不是寄存器，两者都看在哪赋值。

4. enum

枚举：人话与数字的对应关系

不使用enum：  
  
// 极其难读的代码  
if (light_signal == 2'd0) begin  
    // 停车  
end else if (light_signal == 2'd2) begin  
    // 通行  
end  
  
---------------  
  
// 定义枚举：==人话与数字的对应关系==  
typedef enum logic [1:0] {  
    RED    = 2'd0,  
    YELLOW = 2'd1,  
    GREEN  = 2'd2  
} traffic_light_t;  
  
// 使用枚举的代码  
traffic_light_t current_light; // 声明变量  
  
if (current_light == RED) begin  
    // 停车  
end else if (current_light == GREEN) begin  
    // 通行  
end

5. 类型转换（静态转换操作符 ’）

目标类型'(被转换的表达式)

//type文件：  
typedef enum logic [6:0] {  
        base           = 7'b0000000,  
        variant        = 7'b0100000  
    } funct7_t;  
  
//instr_cg.svh文件  
all_funct7 : coverpoint funct7_t'(instr.r_type.funct7);

为什么要转换？（这对 Verification 很重要）

一句话：符号 ’ 就是为了把冷冰冰的数字变成有意义的枚举名字。如果不加这个转换，覆盖率报告会很难看。

不转换：

• 直接写 coverpoint instr.r_type.funct7;
  • 覆盖率工具只知道这是一个 7 位的信号。
  • 它会自动生成 128 个 bin（从 0 到 127）。
  • 报告里全是数字：auto[0], auto[32]… 你根本看不出这是什么指令。

加上转换后：

• 过滤与重命名：工具会参照 funct7_t 的定义表。
  • 它只关注 base 和 variant 这两个值。
• 报告里会清晰地显示：
  • bin base：(显示覆盖次数) —— 代表你测过 ADD/SRL/OR 等指令了。
  • bin variant：(显示覆盖次数) —— 代表你测过 SUB/SRA 等指令了。

第三章 过程语句与子程序

需要清楚哪些语句应该被放于硬件世界，哪些程序应该被放置于软件世界

• module/endmodule，interface/endinterface可以被视为硬件世界。
• program/endprogram, class/ endclass可以被视为软件世界。

3.1 过程语句

过程赋值（写在 always/initial 块内）既可建模组合逻辑也可建模时序逻辑——阻塞赋值 = 多用于组合、非阻塞赋值 <= 多用于时序；连续赋值（assign）驱动 wire/net，用于组合逻辑。

• begin_end 语句——标识顺序执行的语句
• fork_join 语句——标识并行执行的语句

always和initial都是从0时刻开始运行的

条件语句分为两种：if-else 语句和 case 语句；它们都是顺序语句，应放在 “always” 块内！

对于 case 条件语句，若控制表达式的所有情况都列出，则无需写 default。

避免生成锁存器的原则：

• 如果用到 if 语句，最好写上 else 项；
• 如果用到 case 语句，最好写上 default 项。

1. Inferred Latch

在 always_comb 块中，如果输出信号在某些条件下没有被赋值，综合器会认为你希望它”记住上一次的值”，于是自动生成锁存器（latch）。

• 注意：Inferred Latch只会存在于always_comb 块中，因为在 always_ff（时序块）里，if/case 没写全是正常现象（没写的分支=寄存器保持原值，这就是寄存器该有的行为，不是bug）

2. fork … join_any / join_none

fork join里面所有都执行完才跳出

fork … join_any：父进程只等到任意一个子进程完成，就会继续往下执行，其他子进程仍然在后台执行。

fork … join_none：父进程不等待任何子进程，立即继续执行。子进程在后台独立运行。常用于启动一些”后台任务/守护线程”，不需要等待它们结束。

• 也就是开启并行执行之后立即跳出fork join向下执行

如何强制杀死线程？

disable 不是优雅退出，而是直接 强制终止，相当于杀线程。

initial begin  
  fork : my_fork  
    begin : taskA  
      #5  $display("Task A done");  
    end  
    begin : taskB  
      #10 $display("Task B done");  
    end  
  join_any  
  disable taskB;  // 只杀掉 taskB，不影响 taskA （即使它还没到 10ns）  
end

3. 并行处理语句 automatic

task core_class::do_sth_on_all_cores();  
  for(int i = 0; i < `PROJ_CORE_N; i++) begin  
    fork  
      automatic k = i; //每个fork启动的线程 都有自己独立的k, 和static相对立  
      do_sth_on_core(k);  
    join_none //使主线程不等待任何子线程，确保所有 core 的任务可以立即并行启动  
  end  
end

4. wait 和 @ 的区别

program automatic test_event();
    logic clk,a,b,c;
    
    // 线程组1：控制时钟翻转
    initial begin
        clk = 1'b0;
        #3 clk = 1'b1;  // 在第3个时间单位，clk从0变1
    end

    // 线程组2：fork...join 内部的两个begin...end块会【同时】启动
    initial fork
        // 子线程 A (测试 wait)
        begin
            #5 ;        // 先硬等5个时间单位
            wait(clk)   // 此时再去检查clk的状态
            $display("i have reached clk"); //仿真：第二个打印
        end
        
        // 子线程 B (测试 @)
        begin
            @(clk)      // 从0时刻开始死盯clk的跳变边沿
            $display("reached posedge of clk"); //仿真：第一个打印
        end
    join
endprogram

3.2 SV子程序

function 在模块内部定义，通常在本模块中调用，也能根据按/模块层次分级命名的函数名从其他模块调用。而 task 只能在同一模块内定义与调用！

1. function

模仿数学函数（如 y = f(x)）。它的目的是经过计算返回唯一的一个值。

function 需要通过赋值的方式来调用其返回值，因为 function 是有返回值的。

• 定义函数时至少要有一个输入参量！且
  • Verilog： 只能”单向输入”：数据只能从外面传进函数里（input）。
  • SystemVerilog： 函数（function）是允许有 output、inout 甚至 ref（引用）参数的！
• 在函数的定义中必须有一条赋值语句，给函数中的一个内部寄存器赋以函数的结果值，该内部寄存器与函数同名。
  • 只能”通过函数名”返回结果：函数想要输出结果，必须通过函数本身的返回值（即 return 或赋值给函数名），而不能通过参数列表把数据”带”出去。

 function [7:0] add_numbers;  
        input [7:0] a, b;  // 输入参数 a 和 b  
        reg [7:0] result;   // 用于存储计算结果的内部寄存器  
          
        begin  
            result = a + b;  // 给 result 赋值，计算 a 和 b 的和  
            add_numbers = result; // 将 result 赋给函数名，作为返回值  
        end  
    endfunction  
  
assign sum = add_numbers(x, y);  
  
// SV 允许 void 函数（不返回值），并通过 output 参数把结果带出去 —— 就相当于task了  
function void get_results(input int a, input int b, output int sum, output int sub);  
    sum = a + b; // 通过 output 参数输出  
    sub = a - b; // 通过 output 参数输出  
endfunction  
  
initial begin  
    int x, y;  
    get_results(10, 5, x, y); // 调用后，x变成15，y变成5  
end

2. ref 关键字（引用传递）

ref 让形参直接引用实参本身，不拷贝——子程序内部改形参，实参跟着变。

task no_ref(int arr[]);                 // 默认 input：传拷贝
    foreach (arr[i]) arr[i] = arr[i] * 2;
endtask

task automatic with_ref(ref int arr[]); // ref：传本体
    foreach (arr[i]) arr[i] = arr[i] * 2;
endtask

initial begin
    int a[3] = '{1, 2, 3};
    no_ref(a);
    $display(a);   // {1, 2, 3}  没变——改的是拷贝

    int b[3] = '{1, 2, 3};
    with_ref(b);
    $display(b);   // {2, 4, 6}  变了——改的是本体
end

不加 ref 时，改的值改在哪、后来去哪了？ —— 改在子程序自己临时开的局部变量里（形参是独立拷贝，存在这次调用的栈帧上），跟调用者的变量是两块不同内存。endtask/endfunction 一结束，栈帧连同这份拷贝一起被销毁，改动随之消失，调用者的原变量从头到尾没被碰过：

• 不加 ref（默认 input）：拷贝一份传进去，数组越大拷贝开销越大，子程序内部怎么改都不影响外面，改动随栈帧一起被销毁（如上图）。
• 加 output：不拷贝进，但结束时把子程序局部的值整体拷贝给调用者的实参——笔记前面 get_results 例子（3.2 SV子程序 → function）已经示范过，这里再放一个最小例子对比：

task with_output(output int result);
    result = 99;   // 子程序内部先改自己局部的 result
endtask            // 结束时才把这份值拷贝给调用者的实参

initial begin
    int x;
    with_output(x);
    $display(x);   // 99 —— 结束时才拷贝出来，不是全程同步
end

• 加 ref：不拷贝，全程共享同一份存储，省开销，中途改的值外面立刻可见（不用等子程序结束）。

不加 ref 不是没用——只读场景就该用默认 input，防止手滑改坏调用者变量：

task show_sum(int a, int b);  // 没写方向关键字 = 隐式默认 input（同 input int a, input int b）
    $display("sum=%0d", a + b);  // 只读，不用带值出去
endtask

function 也能用 ref，不只 task，且能和 task 不一样——ref 改本体的同时，还能有真正的返回值（task 没有返回值通道）：

function automatic int sum_and_double(ref int arr[]);
    foreach (arr[i]) arr[i] *= 2;             // ref：直接改本体
    foreach (arr[i]) sum_and_double += arr[i]; // 返回值：赋给函数名
endfunction

initial begin
    int a[3] = '{1, 2, 3};
    int total = sum_and_double(a);
    $display(a);      // {2, 4, 6}  —— ref 生效，本体被改
    $display(total);  // 12          —— 同时还带回一个返回值
end

ref 必须配 automatic（LRM 强制，否则编译报错）：automatic = 每次调用独立开一份局部变量（类似栈帧）；默认 static = 所有调用共享同一份存储。ref 要绑定”这一次调用”的实参，static 局部变量却全局唯一一份，并发/递归调用会互相踩——所以 LRM 强制 ref 子程序必须 automatic。

3. task

模仿过程或操作。它可以没有返回值，也可以通过端口返回多个值。

task 不返回值，它会直接对传入的参数或模块内部的变量进行修改（即通过传参或内部变量的改变来实现功能）。 如果task语句中存在return，则只能返回空值用作中断task跳出，不能返回数值。

task my_task(input [7:0] a, input [7:0] b);  
    // 在 task 内部进行一些操作  
    $display("The sum is: %d", a + b);  
endtask  
  
// 调用 task  
initial begin  
    my_task(8'd10, 8'd20);  
end

注意：对于 function，和 task 一样，传入的参数需要对应其内部定义的 input 变量。

4. automatic / static

模块内 task/function 默认 static：所有调用共享同一份局部变量存储；声明 automatic 后，每次调用各开一份独立副本。

task static_cnt();           // 默认 static
    int cnt = 0;              // 只在仿真最开始初始化一次！
    cnt++;
    $display("static cnt=%0d", cnt);
endtask

task automatic auto_cnt();   // 显式 automatic
    int cnt = 0;              // 每次调用都重新初始化
    cnt++;
    $display("auto cnt=%0d", cnt);
endtask

initial begin
    static_cnt();  // static cnt=1
    static_cnt();  // static cnt=2   ← 沿用上次的存储，不是新变量
    auto_cnt();     // auto cnt=1
    auto_cnt();     // auto cnt=1   ← 每次都是新的一份，互不影响
end

static 的坑：递归或并发调用（fork 出多个分支同时调这个 task）会共享同一份局部变量、互相踩——这种场景必须用 automatic。

5. $timeformat

// 常用于指定%t显示的时间格式，例如$display, $monitor等
$timeformat [ ( units_number , precision_number ,
                suffix_string , minimum_field_width ) ] ;
// units_number : -9 表示ns；-12表示ps；-15表示fs；
// precision_number: 数据精度,小数点后的多少位;
// suffix_string: 时间值之后的字符串;
// minimum_field_width: 时间字符串字段的最小宽度;

module timing;
    timeunit 1ns;       // 时间单位
    timeprecision 1ps;  // 时间精度
    initial begin
        $timeformat(-9,3,"ns",8);
        #1      $display("%t",$realtime); // 1.000ns
        #2ns    $display("%t",$realtime); // 3.000ns
        #0.1    $display("%t",$realtime); // 3.100ns
        #41ps   $display("%t",$realtime); // 3.141ns
    end
endmodule

第四章 激励时序与接口

4.1 SV的激励时序

1. Race / Hazard

组合逻辑里，同一信号走多条延迟不同的路径汇合到同一个门，到达时间有先后，输出瞬间蹦出不该有的尖峰——这就是竞争冒险，尖峰叫毛刺(glitch)。

assign b = a & ~a;   // 逻辑上恒为0

~a 比 a 多经过一级非门的延迟。a 翻转的瞬间，直接进 AND 门的 a 立刻更新到新值，但 ~a 要多等一级非门延迟才更新、还停在旧值——这段延迟窗口里两者短暂同为1，AND门就蹦出一个毛刺，而不是稳稳的0。

2. TB 和 RTL 之间的竞争

组合逻辑毛刺只是铺垫。同一个仿真时刻，testbench 在初始化某个信号，RTL 同时在读这个信号——谁先谁后，语言标准不保证，换个仿真器/换种写法结果可能就变了：

// DUT
always @(posedge start) 
	if (write) 
	mem[addr] = data;

// TB，下面几行在同一个仿真时刻执行（对DUT来说无先后保证）
initial begin
    start = 0; 
    write = 0;
    #10;
    addr = 8'h42; 
    data = 8'h5a;
    start = 1; 
    write = 1;   // DUT 读到的是这次赋值前还是后的值？不确定
end

早期靠 #0、#1 硬插队都不靠谱（#0 语句一多，谁先谁后又说不清；#1 在不同 timescale 的 module 之间根本不等价）。SV 用 program block + clocking block 从根上解决这个问题——这才是本章要学的东西。

3. program block

SV 规定了一套调度顺序（分层事件队列），每个仿真时刻分成几个区域执行；RTL(module) 固定跑在 Active 区，testbench 代码如果放进 program 块，会被排到 Active 之后的 Reactive 区——保证 TB 读到的永远是这一拍 RTL 算完、稳定之后的值，从根上消除第2点的竞争。

program 语法长得像 module，但内部不能再嵌套 module/interface/program。

4. clocking block

program block 只解决”TB 整体排在 RTL 后面”，没解决”具体哪个时钟沿采样/驱动”。clocking block 把接口里信号的采样和驱动都跟指定时钟沿绑定：

interface arb_if(input bit clk);
    logic [1:0] grant, request;
    clocking cb @(posedge clk);
        output request;   // TB 通过 cb 驱动
        input  grant;      // TB 通过 cb 采样
    endclocking
    modport TEST (clocking cb);
endinterface

采样/驱动的具体时序规则（重点）放在 4.3 讲。

结论：TB永远读到RTL这一拍算稳定后的值；clocking block采样拿到的是前一拍的值

4.2 SV的接口

1. 为什么需要 interface

设计越来越复杂，模块间要连的信号一多，DUT 和 testbench 之间就是几百根线。interface 把这些信号打包成一捆”智能连线”，既管连接、也管同步，一根接口就能代表 DUT↔TB 之间的一整套信号。

interface arb_if(input bit clk);
    logic [1:0] grant, request;
    logic       grant_valid;
    logic       rst;
endinterface

2. interface vs 端口连接

不用 interface 的话，DUT、TB、顶层 3 处都要各写一遍完整的信号列表：

// 端口方式：grant/request/rst/clk... 每个模块都要重复声明一遍
module arb_port(output logic [1:0] grant, output logic grant_valid,
                 input  logic [1:0] request, input logic rst, input logic clk);
    // ...内部实现省略...
endmodule

module test(input logic [1:0] grant, /*...*/ output logic [1:0] request /*...*/);
    // ...内部实现省略...
endmodule

module top;
    logic [1:0] grant, request;
    logic       grant_valid;
    bit         clk, rst;
    arb_port a1(grant, grant_valid, request, rst, clk);
    test     t1(grant, grant_valid, request, rst, clk);
endmodule

DUT 端口一改，3 处都要跟着改。用 interface，信号只在 interface 里声明一次，模块间直接传”接口”这一个东西：

module arb (arb_if arbif);
    // ...内部实现省略...
endmodule

module test(arb_if arbif);
    // ...内部实现省略...
endmodule

module top;
    bit clk;
    arb_if arbif(clk);      // 例化接口
	arb    a1(arbif);       // 连接DUT
    test   t1(arbif);       // 连接TB
endmodule

新增一个信号，只改 interface 定义，top/arb/test 都不用动。（这里 arb/test 直接拿整个 arb_if，还没分方向——分方向是下一节 modport 的事） 注意：若DUT本身定义的时候没有使用interface，则顶层连接的时候需使用引用，如arbif.grant。

3. modport

interface 里的信号默认没有方向。modport 负责按”谁在用”把信号分组，并在每组里指定方向，指定的方向与实际模块内的信号方向一致

interface arb_if(input bit clk);
    logic [1:0] grant, request;
    logic       rst;
    modport TEST   (output request, rst, input  grant, clk);
    modport DUT    (input  request, rst, clk,   output grant);
    modport MONITOR(input  request, grant, rst, clk);          // 纯旁观，全input
endinterface

用的时候在端口声明里指定走哪个 modport： module arb(arb_if.DUT arbif); module test(arb_if.TEST arbif);

4. interface 的优缺点

优点：改动只在 interface 里做一次、少犯连线错误；modport 把方向和分组都锁死；接口本身可以整体复用到别的项目。

缺点：纯点对点连接时反而比直接列端口更啰嗦；调用信号必须写全”接口名.信号名”，代码变长；两个用不通用协议的模块之间硬套 interface，工作量不降反升。

• 如果使用interface的模块不多，则考虑是否使用interface
• 若原来DUT模块就没有使用interface，则考虑是否使用

4.3 SV接口的驱动和采样

1. 核心规则

clocking block 采样(input)拿到的是上一拍的值；驱动(output)在当前拍立刻生效。（背结论就够，机制不用深究）

想让TB代码稳定排在后面，就把它塞进program块里，这就是program block存在的全部意义。

TB通常要读DUT算出来的结果（比如grant信号），如果两者没有先后顺序、同时跑，TB可能读到DUT还没算完的中间值、不稳定的值——这就是最开始讲的竞争问题。让TB严格排在RTL后面执行，TB读到的永远是这一拍RTL算稳定之后的最终结果，不会读错。

2. 接口里的双向信号 (inout)

clocking block 里可以放 inout，用于总线这类三态信号：

interface master_if(input bit clk);
    wire [7:0] data;
    clocking cb @(posedge clk);
        inout data;
    endclocking
    modport TEST(clocking cb);   // 简写：直接沿用cb里定义的方向，不用像4.2.3那样把信号逐个列出来
endinterface

initial begin
    mif.cb.data <= 'z;               // 释放总线（高阻）
    @mif.cb; $display(mif.cb.data);  // 读
    @mif.cb; mif.cb.data <= 7'h5a;   // 驱动
    @mif.cb; mif.cb.data <= 'z;      // 用完再释放
end

SV 标准没规定这种异步双向信号该怎么驱动，实践上常见两种做法：连续赋值语句，或者用虚接口 virtual interface。

3. program 里为什么不能用 always

program块靠”最后一个initial跑完=仿真自动结束”来判断该收尾(等于隐式执行了 $finish)，而always天生不会结束，两者矛盾，所以语言直接禁止。

initial forever #5 heartbeat = ~heartbeat;   // program 里合法，效果类似 always

clk 更是特例——时钟发生器不该写在 program 里，因为时钟翻转和其他信号变化谁先谁后可能产生新的竞争，应该放进普通 module，用阻塞赋值：

module clock_generator(output bit clk = 1);
    always #5 clk = ~clk;
endmodule

第五章 面向对象编程

5.1 SV类

1. OOP术语速记

2. 类 vs struct

struct只是单纯数据集合；class除了数据（property），还能定义方法（method）处理这些数据，是”数据+方法的自洽体”。

• 此外struct在仿真开始的时候内存空间已经分配，而class是在仿真过程中分配的内存空间

3. 一个简单的类

class Transaction;
    logic [31:0] addr;      // Property
    logic        kind;
    logic [63:0] data;

    function new(logic [31:0] addr);    // Constructor
        this.addr = addr;
        this.kind = 'x;
        this.data = 'x;
    endfunction

    function void display();            // Method
        $display("addr=%h, kind=%b, data=%h", addr, kind, data);
    endfunction
endclass

使用：

Transaction tr_gen;        // 声明句柄（Handle），此时指向 null
tr_gen = new(32'h7788);    // 创建对象（Object）
tr_gen.kind = 1'h1;        // 句柄.属性
tr_gen.display();          // 句柄.方法

5.2 SV 类的成员操作

1. 访问权限：local / protected / public

class clock;
    local bit is_summer = 0;
    local int nclock = 6;
    function int get_clock();
        if (!is_summer) r
	        eturn this.nclock;
        else return this.nclock + 1;
    endfunction
endclass

clock ck;
initial begin
    ck = new();
    $display(ck.get_clock());  // OK，走方法访问
    $display(ck.nclock);        // ✗ 报错：Illegal access to local member nclock
end

2. 创建对象

new()开辟一块新内存，存放这个对象自己的成员变量和方法。Verilog的例化是静态的（编译链接时就定死）；SV class的例化是动态的（仿真任何时刻都能new，更灵活省空间）。

Transaction tr;   // 只声明句柄，此时是 null，没指向任何对象
tr = new();        // 真正创建对象，成员变量初始化为默认值（二值变量0，四值变量x）

3. 构造函数定制

new()不用（也不能）像普通function那样在前面写返回类型——它的返回类型语言已经定死了，永远是”指向本类对象的句柄”，不用用户手动声明，也改不成别的类型。可以给new()加参数、加默认值，让创建对象更灵活：

class Transaction;
    logic [31:0] addr, crc, data[8];
    function new(logic [31:0] a=3, d=5);
        addr = a;
        foreach(data[i]) data[i] = d;
    endfunction
endclass

Transaction tr;
tr = new(10);         // a=10, d用默认值5
tr = new(.a(10));     // 按名字传参，效果同上

4. 句柄的传递

不是复制对象，是复制指针——赋值只是让两个句柄指向同一个对象：

Transaction t1, t2;
t1 = new();
t2 = new();
t1 = t2;     // 把t2的指针赋给t1，t1和t2现在指向同一个对象
             // t1原来指向的对象没有句柄再指它，等着被回收
t2 = null;   // t2不指向任何对象了，但t1还指着（因为它们本来就是同一个对象）危险操作，初学谨慎使用

t1 = t2; 执行完之后的内存状态：

graph LR
    t1(("t1")) --> ObjB["对象B<br/>(t2一开始new的)"]
    t2(("t2")) --> ObjB
    ObjA["对象A<br/>(t1一开始new的)<br/>已无句柄指向<br/>等待被回收"]
    classDef orphan stroke-dasharray: 5 5,opacity:0.6
    class ObjA orphan

5. 浅拷贝 vs 深拷贝

先看简单情况（无嵌套handle）——浅拷贝就够：

class transaction;
    bit [7:0] addr, data;
endclass

transaction tr1, tr2;
tr1 = new();
tr1.addr = 1; tr1.data = 2;

tr2 = new tr1;          // 浅拷贝：属性值原样复制一份
tr2.addr = 3; tr2.data = 4;
// tr1.addr仍是1, tr1.data仍是2 —— 两份内存完全独立

存疑：

1. tr2 = new tr1 这一步做了什么？ ① 开一块全新内存（不是tr1那块）； ② 把tr1格子里的值（addr=1, data=2）抄一份进这块新格子。 现在存在两块独立内存（tr1的那块和tr2的那块），tr2指向的是自己那块新的， 不是tr1那块。“浅拷贝”这个”浅”字，指的就是这种”抄值、开新格子”的动作。

2. tr2.addr = 3修改的究竟是谁？

浅拷贝确实”开新格子、抄值、互不影响”。但是”浅拷贝=永远不影响原对象”——笔记1173行”嵌套handle的坑”马上会让这条经验碰到例外。

嵌套handle时的坑：

class packet;
    bit [7:0] payload;
endclass

class transaction;
    bit [7:0] addr, data;
    packet pkt;
    function new();
        pkt = new();         // transaction一创建就自带一个新packet
    endfunction
endclass

transaction tr1, tr2;
tr1 = new();
tr2 = new tr1;           // 浅拷贝：addr/data各自独立，但pkt只复制"指针"

tr2.pkt.payload = 99;
// tr1.pkt.payload 也变成99！tr1.pkt和tr2.pkt是同一个packet对象

存疑： tr2 = new tr1; 这一步做了什么？

tr1和tr2是两个独立的外框，对应两块完全分开的内存（addr/data各自独立，改一个不影响另一个）；

• 但每个框里的pkt字段存的不是数据本身，是一个地址值”0x500”——tr2 = new tr1这次浅拷贝把这个地址值原样抄给了tr2，所以两个框里的pkt都写着同样的”0x500”。
• 图右边那个packet{payload=99}只画了一个，两条箭头从tr1和tr2各自的pkt字段一起指向它——这就是”共享”的意思：tr1.pkt和tr2.pkt虽然是两个不同的字段（活在两个不同的框里），但它们存的地址值相同，指向的是同一块内存。
• 所以代码里tr2.pkt.payload=99改的正是这个被两边共享的框，tr1.pkt.payload读出来也会是99——不是tr1被”连累”了，是它们从浅拷贝那一刻起，pkt这个字段就注定指向同一个地方。

解决浅拷贝句柄嵌套问题——深拷贝

深拷贝：语言没有内置语法，得自己写一个copy()方法，把每个属性（包括嵌套对象）都手动new一份再复制：

• 深拷贝 = 嵌套链上每一层各自负责自己的copy()，外层显式调用内层的copy()，一层都不能漏。

class packet;
    bit [7:0] payload;
    function packet copy();
		copy = new();      //copy = 函数名，也是返回类型packet的隐式变量
        copy.payload = this.payload;
        return copy;       // 显式return它——写不写这行效果一样，copy已经被赋值了
    endfunction
endclass

class transaction;
    bit [7:0] addr, data;
    packet pkt;
    function transaction copy();
        copy = new();
        copy.addr = this.addr;
        copy.data = this.data;
        copy.pkt  = this.pkt.copy();   // 关键：嵌套对象也要手动copy
        return copy;
    endfunction
endclass

6. 对象的销毁

一个对象只要还有句柄指向它，就不会被回收；一旦没有任何句柄指向它了，SV自动把它销毁、回收内存——不像C需要手动管理内存。

5.3 SV类的封装和继承

1. 封装的意义

把对象的属性和行为打包封装在类里，对外隐藏实现细节，外部只能通过类开放的接口操作。好处：外部不能瞎改内部数据结构，可维护性更高。

2. class VS struct VS module

一句话记忆：struct是纯数据集合；module是定死的硬件盒子；class是数据+方法+能继承的软件抽象模板。

3. 继承（extends）

typedef enum {WHITE, BLACK} color_t;

class cat;
    protected color_t color;
    local bit is_good;
    function set_good(bit s);
        this.is_good = s;
    endfunction
endclass

class black_cat extends cat;
  function new();
	super.new(BLACK); // 显式传递必填参数，编译通过
  endfunction
endclass

black_cat自动拿到cat的color（protected，子类能访问）和set_good()方法，不用重写。

5.4 SV的多态

1. 多态的前提：继承

2. virtual

虚方法（多态的开关）：方法定义时加virtual关键字，才具备多态能力：

• 重写(override)时参数和返回值必须跟原型一致
• 虚方法会被子类的实现”整体接管”；普通方法被子类重写后，只在子类自己（及其子类）范围内生效，父类句柄拿不到子类的重写版本
• 一条继承链上，只认最后一个派生类里的那份重写实现

3. 虚方法机制

全章最重要的例子：

class packet;
    int a=1, b=2;
    function void display_a; $display("packet::a is %d",a); endfunction
    virtual function void display_b; $display("packet::b is %d",b); endfunction
endclass

class my_packet extends packet;
    int a=3, b=4;
    function void display_a; $display("my_packet::a is %d",a); endfunction
    virtual function void display_b; $display("my_packet::b is %d",b); endfunction
endclass

packet p1;
my_packet p2;
p1 = new(); p2 = new();
p1 = p2;              // 父类句柄p1，指向子类对象p2 —— （p1声明类型(packet)"和"实际类型(my_packet)"这俩现在不一样了）

p1.display_a;   // （静态绑定）输出 packet::a is 1    ← 普通方法，看句柄的"声明类型"(packet)（普通方法选中了父类那份代码）
p1.display_b;   // （动态绑定）输出 my_packet::b is 4 ← 虚方法，看句柄"实际指向的对象类型"(my_packet)

4. 静态绑定 / 动态绑定

1.静态绑定： 编译器一看p1声明类型是packet，packet类型下的display_a方法又不是virtual，编译阶段就直接把这行焼死成”调用packet::display_a()”

2.动态绑定： display_b两边都写了virtual。编译器看到virtual，不会在编译期烧死目标——只能生成一段”运行时再去问”的逻辑。

• 运行期：仿真跑到这行，去看p1这一刻实际指向的对象——是那个my_packet对象（p1=p2赋值来的）。读到my_packet，于是调用my_packet::display_b()
• 输出my_packet::b is 4——跟p1的声明类型(packet)无关，只认对象自己的标签

5.5 类型转换

1. 向上类型转换 upcast

class father;
    string m_name;
    function new(string name); m_name = name; endfunction
    function void print(); $display("Hello %s", m_name); endfunction
endclass

class child0 extends father;
    string car = "car";
    function new(string name); super.new(name); endfunction
endclass

father f;
child0 c0;
f = new("father");  f.print();          // Hello father
c0 = new("child0"); 
f = c0;     // 向上类型转换； 把子类对象塞进父类句柄，
f.print();  // Hello child0

子类对象天生”是一种”父类（is-a关系），塞进父类句柄不需要任何转换语法，永远安全——但通过父类句柄只能调用父类声明过的方法/属性，子类独有的东西（比如child0的car）访问不到。

2. 向下类型转换 downcast

父类句柄想转回子类类型，得用$cast（不能隐式转换）：

class child1 extends father;
    string plane;
    function new(string name); super.new(name); endfunction
endclass

child1 c1, c2;
father f;
c1 = new("child1"); 
f = c1;         // f(父类句柄)指向一个child1对象（先向上类型转换）
c1.plane = "big_plane";
$cast(c2, f);                        // 尝试把f转换成child1类型给c2（向下类型转换）   
$display(c2.plane);                  // 转换成功后c2就能访问child1独有的plane属性了

if (!\$cast(c2, f)) `uvm_fatal("CAST", "cast failed")

5.6 虚接口

1. 为什么需要virtual interface

interface把module的端口、方向(modport)、时序(clocking block)、task/function都封装在一起，简化了硬件模块之间的连接。 但class是纯软件构造，没法直接例化/引用一个interface的硬件层次路径——program、class里都不能直接new一个interface。

为解决这个问题，SV引入virtual interface：目的是消除TB代码里对硬件绝对路径的依赖，顶层例化结构变了，class内部代码不用跟着大改。

2. 本质：指向interface的指针

virtual interface本质是指向interface实例的指针——可以像int/class句柄一样，在class里声明、赋值、当函数参数传递。TB的class代码通过它间接摸到DUT的信号，不用写死层次路径引用。

3. 使用要求（3条）

三条对应下面代码里的①②③：

// interface —— 封装DUT的端口
interface counter_if(input logic clk);
    logic       load_valid;
    logic [3:0] load_value;
endinterface

// DUT
module counter(input logic clk, resetn, load_valid,
                input logic [3:0] load_value, output logic [3:0] q);
    always_ff @(posedge clk or negedge resetn)
        if (!resetn)         q <= 0;
        else if (load_valid) q <= load_value;
        else                 q <= q + 1;
endmodule

class driver;
    virtual counter_if vif;                    // ② class里声明virtual interface句柄，并有驱动 （不是"把interface例化进class"，是在class里声明一个指向interface的指针/句柄。）
    function new(virtual counter_if vif);
        this.vif = vif;
    endfunction
    task drive(logic valid, logic [3:0] value);
        @(posedge vif.clk);
        vif.load_valid <= valid;    // ②
        vif.load_value <= value;    // ②
    endtask
endclass

module tb_top;
    logic clk, resetn;
    logic [3:0] out;
    counter_if dutif(clk);                      // ① interface实例化，连到DUT
    counter u_counter(.resetn(resetn), .clk(clk),
                       .load_valid(dutif.load_valid), // ①
                       .load_value(dutif.load_value), .q(out)); // ①

    driver my_driver;
    initial begin
        my_driver = new(dutif);                 // ③ virtual interface指向实例化的interface
        my_driver.drive(1, 4'd5);
    end
endmodule

5.7 包的使用

1. package解决什么问题

SV允许在多个module/interface/program之间共享parameter、类型定义、task/function、class——用package实现。

真正的核心是命名空间隔离：把一整个验证环境的组件类（stimulator/monitor/checker/env…）归到同一个namespace下，解决”这个类到底属于哪个模块的验证环境”的归属问题。

两个verifier各自在自己的package里，都定义了名字完全相同的4个类，内容和实现完全不一样：

package regs_pkg;
    `include "stimulator.sv"
    `include "monitor.sv"
    `include "checker.sv"
    `include "env.sv"
endpackage

package arb_pkg;
    `include "stimulator.sv"
    `include "monitor.sv"
    `include "checker.sv"
    `include "env.sv"
endpackage

编译不冲突——package自带独立命名空间，同名类分属不同package互不干扰。

如果不用package、直接把这些class文件include进同一个编译单元，monitor就会重复定义，直接报错。这就是”为什么不能只靠include”的原因

2. 往package里装：include

裸class文件（没被package包着的.sv）没有名字可以引用，只能靠include文本插入。

关键约束：必须include在package体内部。

package regs_pkg;
    `include "monitor.sv"    // ← 在package体内，monitor成为regs_pkg的成员
endpackage

放在package外面，那些class会落进compilation unit scope，别的地方没法import它们。

路径问题：创建package时，包名隐含指定了默认路径——即包文件所在的目录。要include的文件不在这个目录下，编译时得加+incdir+PATH告诉编译器去哪搜。

3. 从package里取：:: 和 import

方式一：::作用域解析符，每次显式指定来自哪个package。

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

方式二：import通配导入，一次把package里所有内容引进当前作用域，之后直接写类名。

import regs_pkg::*;
monitor mon1 = new();       // 编译器去regs_pkg里找monitor

两个包有同名类时，import *会出事：

import regs_pkg::*;
import arb_pkg::*;
monitor mon;    // ✗ 编译错误：regs_pkg::monitor 和 arb_pkg::monitor 都能匹配，编译器无法决定

注意这个错误发生在引用的那一刻，不是import的那一刻——只import不用，不报错。

所以选择判据很简单：有重名风险用::，确定不重名才用import *。import通常写在文件开头。不import、也不用::，类就躲在包这个盒子里，外部代码识别不到。

4. include和import的本质区别

同一个对象，两个完全不同的阶段。

• include 是预处理器指令，发生在编译之前。它不认识package、不认识class，只认识文本——把文件内容原地复制粘贴。
• import 是语言级声明，发生在编译期。它作用于已经建好的符号表，不复制任何代码，只让那些名字在当前作用域可见。

比喻：include是把整本书复印一份夹进来；import是在桌上贴张便条——“以后说’张三’就指那本书里的张三”。

选哪个的判据不看文件类型，看目标是不是一个package：

5. 常见问题

• 为什么不直接include各个类文件，非要用package？ include只是文本粘贴，没有命名空间隔离——两个验证环境如果都写了同名的monitor类，直接include进同一个编译单元会命名冲突报错。package把每组类装进独立命名空间，同名也不冲突。
• pkg::class和import pkg::*怎么选？ 精确调用、怕命名冲突时用::；确定包内命名不跟当前scope冲突、图省事时用import *。这也是为什么实际工作要求”包名、类名都唯一”——降低import *撞车的风险。
• include和import能互相替代吗？ 不能，两个阶段的东西。include是编译前的文本复制，import是编译期的符号可见性。裸class只能include，package只能import。

5.8 多线程间通信

1. 为什么需要——信号握手不够用了

硬件模块里各个always块可以看成多个从0时刻就开始跑、永不退出的并发”线程”，它们之间的同步靠信号变化完成（req/ack、valid/ready握手）。但软件风格的多线程（fork出来的多个task、多个class对象各自的线程）之间没有物理信号可用，需要专门的机制——这就是event/semaphore/mailbox要解决的问题。

fork...join/join_any/join_none的语法3.1已经讲过，这里不重复；这节讲线程之间怎么打招呼(event)、怎么排队抢资源(semaphore)、怎么传数据(mailbox)。

2. event(事件)——通知”发生了”

本质是一个静态的同步对象句柄，可以像参数一样在task/function间传递。

触发：-> event_handle;　等待：@event_handle;（阻塞）或wait(event_handle.triggered)（查询”是否已经触发过”）

event e1, e2;
initial begin                      // 先执行
    -> e1;                         // 触发e1（瞬时，触发完立刻消失）
    @e2;                           // 此刻e2还没被触发，在这里阻塞等
    \$display("1:after trigger");   // e2稍后被下面那个块触发时，正好捕捉到——这行会执行
end
initial begin                      // 后执行
    -> e2;                         // 触发e2——上面那个块正好在@e2等着，被唤醒
    @e1;                           // 但e1早在上一个块里就触发过了，这里错过，永远等不到
    \$display("2:after trigger");   // 这行永远不会执行——本线程卡死在@e1
end

wait_order(a,b,c) 语句 else 语句：阻塞等待多个event按指定顺序触发，顺序对执行前面语句，不对执行else。

特征：event变量能互相赋值（e2 = e1;），两个handle会指向同一个底层事件对象，触发任意一个都算触发；也能当参数传给task/function/queue。

3. semaphore(旗语)——控制”同时几个能用”

解决同一资源被多方请求、但物理上只能单一驱动的问题（比如一条总线只能有一个driver在驱动，测试平台却有多个请求方）。

本质是一个装着N把”钥匙”的桶：new(N)创建时发N把钥匙；get()拿钥匙（拿不到就阻塞排队，FIFO顺序）；put()还钥匙；try_get()非阻塞尝试拿。

class bridge;
    semaphore key;
    function new();
        key = new(1);              // 只发1把钥匙 = 互斥锁(mutex)
    endfunction
    task go_on(string name);
        key.get();                 // 拿不到钥匙就一直等
        $display("%s go through the bridge", name);
    endtask
    task go_off(string name);
        key.put();                 // 用完还钥匙，给下一个排队的人
    endtask
endclass

4个人(Alex/Bob/Calvin/Denise)fork出去同时抢着”过桥”，桥上只有1把钥匙，永远只有1人在桥上，其他人排队——semaphore(1)当互斥锁用。

4. mailbox(信箱)——传”数据”，不只是通知

event只能说”发生了”，不带数据；mailbox负责在线程间传递真正的消息，什么SV类型都能装，包括class对象。

常用方法：new()创建；put()放消息(阻塞)/try_put()(非阻塞)；get()取消息(阻塞，取走)/peek()(只读不取走)——两者也都有try_get()/try_peek()非阻塞版本；num()查看邮箱里有几条消息。mailbox #(transaction)——参数化类型，限定这个邮箱只能装transaction。

class transaction;
    rand bit       valid;
    rand bit [7:0] data;
endclass

class generator;
    mailbox #(transaction) gen2drv;
    function new(mailbox #(transaction) gen2drv);
        this.gen2drv = gen2drv;
    endfunction
    task gen(int num);
        transaction tr;
        repeat (num) begin
            tr = new(); assert(tr.randomize());
            gen2drv.put(tr);           // 生产：塞进邮箱
        end
    endtask
endclass

class driver;
    mailbox #(transaction) gen2drv;
    function new(mailbox #(transaction) gen2drv);
        this.gen2drv = gen2drv;
    endfunction
    task run();
        transaction tr;
        forever gen2drv.get(tr);       // 消费：从邮箱取
    endtask
endclass

program test;
    mailbox #(transaction) gen2drv;
    generator gen; driver drv;
    initial begin
        gen2drv = new();
        gen = new(gen2drv); drv = new(gen2drv);   // 同一个邮箱给两边
        fork
            gen.gen(5);
            drv.run;
        join_any               // drv.run里是forever，永远不会自己结束——用join_any，gen.gen(5)一跑完就往下走，不等drv
    end
endprogram

5. 三者怎么选（总结表）

第六章 随机化

6.1 SV随机化基础

1. 为什么需要随机化

芯片规模变大、场景组合爆炸，定向测试（把每个场景一条条写死）写不过来，而且只能覆盖”你想到”的场景。随机测试能测到你根本没想到的边界组合，实际工作中常搭配功能覆盖率收敛”测没测全”（DV通用做法，非这份PPT内容）。随机测试代码量比定向测试少得多，产生的激励也更多样。

代价：环境要配套激励生成器、参考模型、自动比对（scoreboard）——不再靠人盯着看结果，让仿真自动跑上百次去收敛。

2. 随机化的对象

随机化不是只随机数据，常见5类：

• 器件配置：寄存器、系统信号
• 环境配置：时钟、外部反馈信号
• 原始输入数据：数据包长度、带宽、顺序
• 延时：握手信号的时序关系，比如valid/ready、req/ack之间隔几拍
• 协议异常：故意给出异常反馈，看设计后续处理是否还稳定

3. rand / randc / randomize()

class成员变量声明成rand，才能被randomize()随机赋值：

class Packet;
    rand  bit [31:0] src, dst, data[8];
    randc bit [7:0]  kind;              // 见下方randc说明
    constraint c { src > 10; src < 15; }
endclass

program testgen;
    Packet p;
    initial begin
        p = new();
        assert(p.randomize())    //随机pakcet里的四个变量
        else $fatal(0, "Packet::randomize failed");
        $display("data = %p",p.data);  //这里使用%p可以打印数组，当然也可以使用foreach遍历，%p更加简洁
    end
endprogram

rand vs randc：

• rand每次独立随机，可能连续抽到重复值；
• randc(random-cyclic周期性随机)不重复——取值域内所有值打乱抽一轮，一轮抽完才重新洗牌重抽，轮内绝不重复。

两种调用方式：

int delay;
std::randomize(delay) with { delay inside {[0:3]}; };  // delay = 0~3，不依赖任何class

4. constraint基础写法

constraint语法固定：关键字后必须紧跟一个约束名，再用{}包裹表达式——名字和花括号都不能省，不能把位选/类型直接塞在constraint后面当参数：

// ❌ 错语法
rand bit [15:0] a;
constraint [15:8] a inside {0:64};

// ✅ 对：具名block，位选写在block内部
class C;
    rand bit [15:0] a;
    constraint high_bits { a[15:8] inside {[0:64]}; }
    constraint low_bits  { a[7:0]  inside {[128:255]}; }
endclass

一个类可以有多个constraint块，randomize()时全部同时生效（后面”双向约束”细讲）。

5. 六类约束表达式

SV约束表达式常见6类：布尔表达式、权重分配、范围表达式、条件表达式、外部约束、双向约束。

1. 布尔表达式

最基础的比较表达式，但SV不支持链式比较：

constraint bad   { lo < med < hi; }    // ❌ 错：lo<med先算出0/1，再拿这个0/1去跟hi比，不是想要的传递比较
constraint right { lo < med; med < hi; }   // ✅ 对：拆成两条独立表达式

2. 权重分配（dist）

dist给随机值指定非均匀概率，两种权重语法：

constraint c_dist {
    src dist {0 := 40, [1:3] := 60};
    // src=0 权重40；src=1/2/3 各权重60（:=是每个值单独给权重）——共220，src=0概率40/220

    dst dist {0 :/ 40, [1:3] :/ 60};
    // dst=0 权重40；[1:3]区间总权重60，均分给3个值各20（:/是区间整体权重再平均）——共100，dst=0概率40/100
}

权重还能用变量代替常数（read_cmd dist {READ8 := read8_wt, ...}），运行时改变量就能动态调概率分布。 权重分配满不一定是100%

3. 范围表达式（inside）

rand int c;
int lo, hi;                                        // 非random变量，先赋值当边界
constraint c_range1 { c inside {[lo:hi]}; }         // lo <= c <= hi
constraint c_range2 { !(c inside {[lo:hi]}); }      // 取反：c < lo 或 c > hi

rand bit [6:0] b;                                   // 声明宽度决定$的上下限：0~127
constraint c_dollar { b inside {[$:4], [20:$]}; }   // $ = b自身类型的上下限，不是真无穷——等价于 0<=b<=4 || 20<=b<=127

int fib[5] = '{1, 5, 3, 9, 2};
constraint c_arr { b inside fib; }                  // fib是数组，b等于数组里任意一个元素

4. 条件表达式

两种写法等价，SV里更常用->（蕴含/implication），风格上更贴近约束块”声明式”的味道：

// 写法一：if-else
constraint c_stim {
    if (flag) { dst inside {[40:80]}; }
    else        dst inside {[2:10], [50:67]};
}

// 写法二：-> 蕴含（等价，更常用） //条件触发。箭头左侧是“前提条件”，右侧是“结果约束”
constraint c_stim {
    flag  -> dst inside {[40:80]};
    !flag -> dst inside {[2:10], [50:67]};
}

5. 外部约束

类内只声明空的constraint（占位，没内容），具体内容留到类外补：

class Packet;
    rand bit [7:0] length;
    rand bit [7:0] payload[];
    constraint c_valid { length > 0; payload.size() == length; }
    constraint c_external;                            // 只声明，不给内容(不一定非要实现，想实现的时候去实现或修改即可)
endclass

constraint Packet::c_external { length == 1; }         // 类外补内容

6. 双向约束

constraint块不是从上到下顺序执行的过程式代码，是声明式、并行生效的——SV求解器同时满足块里所有表达式，取它们的交集，有多组解时随机选一组：

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

数学表达式：25<r(s)<t<30

“双向”体现在：s依赖r（s==r），t的范围又同时受r<t和t<30两头夹逼——各表达式互相牵制，不是谁先算谁后算的固定顺序，SV求解器在满足全部约束的多组解里随机选一组。

6.3 SV的随机约束控制

1. constraint_mode()

对象.约束名.constraint_mode(0/1)单独开关一个约束块；对象.constraint_mode(0/1)（不带约束名）一次性开关该对象所有约束块。0=禁用，1=启用（默认启用）。

class Packet;
    rand int length;
    constraint c_short { length inside {[1:32]}; }
    constraint c_long  { length inside {[1000:1023]}; }
endclass

Packet p;
initial begin
    p = new();
    p.c_short.constraint_mode(0);       // 只关c_short
    assert(p.randomize());              // 此时只剩c_long生效，length落在[1000:1023]

    p.constraint_mode(0);               // 关掉p身上全部约束块
    p.c_short.constraint_mode(1);       // 单独重新打开c_short
    assert(p.randomize());              // 此时只有c_short生效，length落在[1:32]
end

2. rand_mode()

变量.rand_mode(0/1)控制这个rand变量本身要不要参与随机化——关掉后可以手动赋固定值当常量用。开关的是变量，不是约束块，跟constraint_mode()是两个独立正交的开关。

class Packet;
    rand bit [7:0] length, payload[];
    constraint c_valid { length > 0; payload.size() == length; }
endclass

Packet p;
initial begin
    p = new();
    p.length.rand_mode(0);    // length不再参与随机化
    p.length = 42;             // 手动定值
    assert(p.randomize());     // payload仍会被随机化——但constraint读到的length是42，payload.size()被强制等于42
    p.length.rand_mode(1);     // 恢复length参与随机化
    assert(p.randomize());     // 这次length和payload都重新随机
end

3. randomize() with {}

obj.randomize() with { 额外约束 }——这次随机化临时加约束，和类内原有constraint一起生效、取交集，不是替换关系。

class Transaction;
    rand bit [31:0] addr, data;
    constraint c1 { addr inside {[0:100], [1000:2000]}; }
endclass

Transaction t;
initial begin
    t = new();
    assert(t.randomize() with { addr >= 50; addr <= 1500; data < 10; });
    // c1的[0:100]∪[1000:2000]，交上with的[50:1500]，结果addr落在[50:100]或[1000:1500]，data<10

    assert(t.randomize() with { addr == 2000; data > 10; });
    // addr==2000本身也满足c1（2000在[1000:2000]区间内），没冲突，能成功
end

4. randomize(变量名)

obj.randomize(变量名)只随机化括号里指定的这个变量，其它变量（哪怕是rand的）保持原值不变；甚至能对着非rand变量用，临时越权随机化它一次。

class Rising;
    byte low;                  // 非random
    rand byte med, hi;
    constraint c_up { low < med; med < hi; }
endclass

Rising r;
initial begin
    r = new();
    r.randomize();           // med、hi都随机；low不变
    r.randomize(med);        // 只随机med；hi保持上次的值不变
    r.randomize(low);        // 只随机low（尽管它不是rand变量）
end

5. pre_randomize() / post_randomize()

两个都是function，不消耗仿真时间，SV自动在randomize()前后调用（类里定义了就会被自动触发，不用手动调）：

• pre_randomize()：randomize()之前调用，常用来动态设定/开关跟这次随机化相关的变量或约束
• post_randomize()：randomize()成功后调用，常用来做后续处理（根据随机出来的值算别的字段、校验合法性）

class wr_tran;
    int constraint_en;
    int broadcast;
    rand int wr_addr, wr_data;
    rand bit valid;
    constraint generic_c { valid == 1; wr_addr < 100; }

    function void pre_randomize();
        if (!constraint_en) generic_c.constraint_mode(0);   // 旗标决定要不要保留默认约束
    endfunction

    function void post_randomize();
        if (wr_addr == 1) broadcast = 1;
        else broadcast = 0;
    endfunction
endclass

wr_tran m_tr;
initial begin
    m_tr = new();
    m_tr.constraint_en = 0;                                   // 关掉默认约束
    m_tr.randomize() with { wr_addr == 200; wr_data == 3; valid == 0; };
    // valid==0、wr_addr==200都跟generic_c矛盾（generic_c要求valid==1、wr_addr<100）——但pre_randomize已经把generic_c关了，两条都不冲突，能成功
    // 跑完：wr_addr=200, wr_data=3, valid=0, broadcast=0（因为wr_addr!=1）
end

6. 约束的重载

两种”重载”约束的路子，效果完全不同，值得对比着看：

方式一：constraint_mode(0)关掉 + randomize() with{}补

class constrainend;
    rand bit x;
    rand bit [1:0] y;
    constraint c_xy { (x==0) -> y==0; }  //条件触发。箭头左侧是“前提条件”，右侧是“结果约束”
endclass

constrainend p;
initial begin
    p = new();
    p.c_xy.constraint_mode(0);                    // 先关掉c_xy——不关的话x==0;y==1;会跟c_xy的(x==0)->y==0直接矛盾
    assert(p.randomize() with { x==0; y==1; });   // 故意选一组违反原c_xy的值，证明disable确实起了作用（不disable这行会randomize失败）
end

方式二：子类extends父类，定义同名约束

class overwrite extends constrainend;
    constraint c_xy { x==0; y==0; }    // 同名c_xy，完全替换父类的定义
endclass

overwrite p;
initial begin
    p = new();
    assert(p.randomize());   // 生效的是子类这份c_xy，父类原来的(x==0)->y==0已经不存在了
end

6.5 SV随机化约束的概率

1. 约束怎么分配概率

没有约束时，rand变量互相独立、每个取值等概率——rand bit x（0或1）配rand bit[1:0] y（0~3），2×4=8种组合，每种1/8。

一旦引入约束，求解器的默认规则是：在所有满足约束的组合里均匀分配概率，不是对每个变量分别做均匀随机再挑合法的。

class impact1;
    rand bit x;
    rand bit [1:0] y;
    constraint c_xy { (x==0) -> y==0; }
endclass

x==0时y被逼成0（1种组合）；x==1时y自由取0~3（4种组合）。总共5种合法组合，每种1/5：

2. randc如何重塑分布

把上面例子里x或y其中一个换成randc，边缘分布会被强制拉回均匀——randc保证自己声明范围内所有值轮询到、必然各占一份，不受约束结构里”谁的分支组合多”影响。

x换成randc（y仍是rand）：X变量会先于Y变量进行解析

randc bit x;
rand  bit [1:0] y;
constraint c_xy { (x==0) -> y==0; }

（其余3种x=0,y≠0的组合概率为0）x被randc强制成50/50；x=0这条分支从1/5暴涨到1/2，x=1分支下的4个y值则从各1/5被压缩成各1/8。

y换成randc（x仍是rand）：Y变量会先于X变量进行解析

rand  bit x;
randc bit [1:0] y;
constraint c_xy { (x==0) -> y==0; }

3. 约束耦合消分支

多条约束取交集时，一条约束可能让另一个变量的某个取值彻底没有出路，即使那个变量本身看起来毫无约束：

class impact2;
    rand bit x;
    rand bit [1:0] y;
    constraint c_xy {
        y > 0;
        (x==0) -> y==0;
    }
endclass

y>0和(x==0)->y==0两条一起看：x0要求y0，但y>0又不许y0——x0这个分支无解，被两条约束联立间接判了死刑。合法组合只剩x==1那一支的y∈{1,2,3}，各1/3：

（其余5种组合——x=0的全部4种、以及x=1,y=0——概率都是0）

4. solve…before

显式告诉求解器”先满足谁的取值范围，再算别的”，概率分布效果跟第2点把某个变量声明成randc完全等价——都是把被指定变量的边缘分布拉成对自己声明范围均匀。但两者不是同一回事：solve...before不改变变量本身”是否轮询不重复”这个属性（变量仍是rand，允许重复取值），纯粹只管求解顺序/分布优先级。

constraint c_xy {
    (x==0) -> y==0;
    solve x before y;   // x的边缘分布被拉平——概率表跟"x是randc"那版完全一样（1/2、1/8×4）
}

constraint c_xy {
    (x==0) -> y==0;
    solve y before x;   // y的边缘分布被拉平——概率表跟"y是randc"那版完全一样（1/8×2、1/4×3）
}

5. 多个randc耦合

如果参与同一条约束的多个变量都声明成randc，联合概率分布会比第2点更复杂：

randc bit x;
randc bit [1:0] y;
constraint c_xy { (x==0) -> y==0; }

6.6 SV的数组约束

1. size()

.size()统计动态数组/队列的元素个数，能直接放进约束里限定数组长度：

class dyn_size;
    rand logic [31:0] d[];
    constraint d_size { d.size() inside {[1:10]}; }
endclass

2. sum()

.sum()计算动态数组/队列所有元素的和：

class dyn_sum;
    rand logic [7:0] d[];
    constraint d_sum { d.sum() == 9'd100; }
endclass

3. sum()的坑

三个bad example，需求都一样：1~8个无符号元素，每个元素落在[0:255]，元素之和小于1024。

bad_sum1——元素类型选错（有符号）：

class bad_sum1;
    rand byte len[];                    // byte是有符号8位（-128~127），不是无符号！
    constraint c_len {
        len.sum() < 1024;
        len.size() inside {[1:8]};
    }
endclass

没有任何一条约束限定每个元素自己的范围，byte又是有符号类型——随机出来的元素可以是负数，比如-58 -85 -115 112 -101 -62，真实和是-309。.sum()的结果位宽跟着byte（8位有符号）走，-309按8位有符号截断（-309+256=-53）后会显示成sum=-53——完全不满足”元素非负、和小于1024”这条需求，只是数字上凑巧”小于1024”这一半条件蒙对了。

bad_sum2——类型改成无符号，但还是没治根：

class bad_sum2;
    rand bit [7:0] len[];               // 改成无符号了
    constraint c_len {
        len.sum() < 1024;   //结果会被截断，相当于无效约束
        len.size() inside {[1:8]};
    }
endclass

• 核心原因：.sum的位宽和数组中的元素位宽一致，在以上例子中也就是定义的 “[7:0] ” 为8位，若数组里都取最大值255相加，则会超过8位位宽出现截断
• .sum()是把数组里所有元素加成一个总数，只有这一个总数拿去跟1024比。

4. 宽类型也会溢出

class bad_sum3;
    rand int len[];                     // int默认32位，位宽足够大了……，且int是有符号数
    constraint c_len {
        len.sum() < 1024;
        len.size() inside {[1:8]};
    }
endclass

高位进位截断之后会出现看起来较小的数，看起来满足要求了，实际是因为截断

5. 正确写法

class good_sum;
    rand int len[];
    constraint c_len {
        foreach (len[i]) len[i] inside {[1:255]};   // 补上：每个元素自己的范围（干掉了负数）
        len.sum() < 1024;
        len.size() inside {[1:8]};
    }
endclass

跑出来的一组合法解：sum=976, val=233 187 44 157 201 81 73（7个元素，加起来正好976，<1024）。

三条约束都要有，缺哪条都可能翻车：

• foreach约束每个元素范围——这是前面3个bad example唯一都漏掉的一条，也是根本原因
• len.sum() < 1024——限定和
• len.size() inside {[1:8]}——限定长度

元素范围定死在[1:255]后，最多8个元素、每个最多255，真实和最大也就8×255=2040，int（32位）装这个上限绰绰有余，不会像bad_sum1/2那样发生截断/溢出——len.sum() < 1024这条约束才真正管用。

第七章 断言

7.1 断言基础语法

1. Assertion是什么

嵌在代码里的实时检查器：条件/事件序列不符合预期就报警。数字电路设计里断言代码量一般要求不少于整体设计的30%。两种：Immediate Assertions、Concurrent Assertions。

两种放置方式：

• 写进RTL模块里：直接跟设计代码混在一起。经典例子——互斥检查（两个信号不能同时为1）：

property p_mutex;
    @(posedge clk) not (a && b);
endproperty
a_mutex: assert property (p_mutex);

• 放进单独的仿真环境：断言写在独立module里，通过端口接clk/rst跟DUT解耦，外面套 `ifdef SIM_ASSERTION_ON/ `endif 按需编译进去，不用就完全不占地方。

独立的module用bind挂进DUT。bind是SV关键字，把一个module例化进目标module里面，不用改RTL代码；目标module有几个instance，就各插一份。例如给同步FIFO挂一条cover property：

module fifo_cov (input logic clk, input logic rst_n, input logic full);
    c_fifo_full : cover property (@(posedge clk) disable iff (!rst_n) full);
endmodule

bind sync_fifo fifo_cov u_fifo_cov (.clk(clk), .rst_n(rst_n), .full(full));

仿真报告里这条cover property的路径是…u_fifo.u_fifo_cov.c_fifo_full，u_fifo_cov出现在FIFO的instance u_fifo下面，说明fifo_cov确实被插进了FIFO里，端口连的是FIFO内部的clk、rst_n、full。

激活关键字不止assert：

• assert property——失败会报错/挂仿真
• cover property——只统计”这个场景出现过几次”喂给功能覆盖率，不影响仿真跑
• assume property——主要用于formal验证，把这条当成对输入的既定约束，不是拿来检查的东西

第1、2、4个周期通过；第3个周期a、b同时为1，仿真当场报错。

c_full: cover property (@(posedge clk) full);

第3个周期full为1，c_full的命中次数加1，仿真照常往下跑。如果整个仿真full一直是0，也不报错，只是覆盖率报告里这一条命中0次，说明测试没把FIFO写满过。

2. Immediate Assertions

检查当下这一刻的条件，等价于if-else，必须写在过程块（initial/always/task/function）里，不能跨时钟周期。

语法：

label: assert(expression) action_block;

• action_block在断言表达式求值后立即执行，分成功/失败两条分支各自指定要做的操作
  • 写法：pass_statement; else fail_statement;
• action_block可以整个省略——check_a_and_b: assert(a && b);合法，失败时直接用默认严重度$error报错

always @(posedge clk) begin
    check_a_and_b: assert (a && b) $display("a&&b is true");
        else $error("a&&b is false");
end

补充信息：失败时的严重程度（依次递减）：$fatal（终止仿真）> $error（默认）> $warning > $info。

3. Concurrent Assertions

比Immediate Assertions多一个property关键字和一个采样时钟，能检查跨多个时钟周期的事件序列，不局限于当下这一拍。可以写在过程块/module/interface/program里，但不能写在class内部（class没有独立的时钟采样上下文）。UVM里Assertion常单独放进interface、再bind进DUT。

通用格式：断言名: assert property (判断条件);

Immediate写法（靠外层always提供时钟）：

always @(posedge clk) begin
    if (enable) begin
        // 【立即断言】只有当 enable 为 1 时，代码才会走到这里进行检查
        check_imm: assert (a && b); 
    end
end

Concurrent写法（时钟采样焊死在assert property内部，不用套always）：（相当于自身有电源驱动）

check_a_and_b: assert property (@(posedge clk) (a && b)) $display("a&&b is true");
    else $error("a&&b is false");

两段逻辑等价，但触发机制不同：

• Immediate版本的assert本身不认时钟——能不能查全靠外层always @(posedge clk)，改成always @*就变成信号一变就查；assert只是在过程流程走到这一行时看一眼当下的值。
• Concurrent版本的@(posedge clk)焊死在assert property(...)内部，不需要外层过程块”喂”时钟——语句一旦elaborate，从仿真开始就自己每个posedge clk检查一次。