tangyangchao578-art SystemVerilog 使用技能
当用户需要使用 SystemVerilog 进行设计或验证时，启用此技能。此技能提供 SystemVerilog 最佳实践，区分设计可综合子集和验证特性。
When to Activate
- 编写新的 SystemVerilog RTL 设计
- 编写 SystemVerilog 验证平台
- 将老的 Verilog 代码转换为 SystemVerilog
- 调试 SystemVerilog 代码问题
- 代码审查 SystemVerilog 代码
第一部分：设计使用的 SystemVerilog 特性（可综合子集）
以下特性用于 RTL 设计，可被综合工具综合为硬件。
步骤 1：接口定义
1.1 创建基本接口
做什么： 定义接口，封装相关信号。
// 定义 AXI 接口
interface axi_if #(
parameter DATA_WIDTH = 32,
parameter ADDR_WIDTH = 32
)(
input wire clk,
input wire rst_n
);
// 写地址通道
logic [ADDR_WIDTH-1:0] awaddr;
logic [2:0] awprot;
logic awvalid;
logic awready;
// 写数据通道
logic [DATA_WIDTH-1:0] wdata;
logic [DATA_WIDTH/8-1:0] wstrb;
logic wvalid;
logic wready;
// 写响应通道
logic [1:0] bresp;
logic bvalid;
logic bready;
// 读地址通道
logic [ADDR_WIDTH-1:0] araddr;
logic [2:0] arprot;
logic arvalid;
logic arready;
// 读数据通道
logic [DATA_WIDTH-1:0] rdata;
logic [1:0] rresp;
logic rvalid;
logic rready;
// 定义 modport 明确方向
modport master (
output awaddr, awprot, awvalid,
input awready,
output wdata, wstrb, wvalid,
input wready,
input bresp, bvalid,
output bready,
output araddr, arprot, arvalid,
input arready,
input rdata, rresp, rvalid,
output rready
);
modport slave (
input awaddr, awprot, awvalid,
output awready,
input wdata, wstrb, wvalid,
output wready,
output bresp, bvalid,
input bready,
input araddr, arprot, arvalid,
output arready,
output rdata, rresp, rvalid,
input rready
);
endinterface
优点：
- 自动整理一堆连线，减少代码量
- 减少连线错误
- 接口协议改变，只需要改一处
- 在 UVM 验证中更容易传递接口
1.2 使用接口连接模块
做什么： 在模块中使用接口。
// 定义使用接口的模块
module axi_master #(
parameter DATA_WIDTH = 32,
parameter ADDR_WIDTH = 32
)(
input wire clk,
input wire rst_n,
axi_if.master axi // 使用接口
);
// 直接使用接口中的信号
always_ff @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
axi.awvalid <= 1'b0;
axi.awaddr <= '0;
end else begin
// 写地址逻辑
axi.awvalid <= w_aw_valid;
axi.awaddr <= w_aw_addr;
end
end
endmodule
// 顶层连接
module top;
logic clk;
logic rst_n;
// 实例化接口
axi_if #(.DATA_WIDTH(32), .ADDR_WIDTH(32)) axi_bus (.clk(clk), .rst_n(rst_n));
// 实例化主设备
axi_master u_master (
.clk(clk),
.rst_n(rst_n),
.axi(axi_bus) // 连接接口
);
// 实例化从设备
axi_slave u_slave (
.clk(clk),
.rst_n(rst_n),
.axi(axi_bus) // 连接接口
);
endmodule
步骤 2：always 块分类
2.1 时序逻辑使用 always_ff
做什么： 使用 always_ff 描述时序逻辑，让工具自动检查。
// 时序逻辑：使用 always_ff
always_ff @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
r_state <= ST_IDLE;
r_data <= '0;
end else begin
r_state <= w_next_state;
r_data <= w_next_data;
end
end
优点：
- 工具自动检查是否真的是时序逻辑
- 如果里面写了组合逻辑，工具会警告
2.2 组合逻辑使用 always_comb
做什么： 使用 always_comb 描述组合逻辑，让工具自动检查锁存。
// 组合逻辑：使用 always_comb
always_comb begin
case (sel)
2'b00: w_mux = a;
2'b01: w_mux = b;
2'b10: w_mux = c;
default: w_mux = '0;
endcase
end
优点：
- 工具自动检查是否完整赋值
- 如果产生锁存器，工具会警告
- 不需要写敏感列表，自动推断
2.3 锁存器使用 always_latch
做什么： 如果确实需要锁存器，使用 always_latch 明确告诉工具。
// 锁存器：使用 always_latch（确实需要时才用）
always_latch begin
if (enable) begin
latched_data = data_in;
end
end
步骤 3：类型定义
3.1 使用 typedef 定义类型
做什么： 定义自定义类型，提高代码可读性。
// 定义地址类型
typedef logic [31:0] addr_t;
// 定义数据类型
typedef logic [63:0] data_t;
// 定义状态枚举
typedef enum logic [2:0] {
ST_IDLE = 3'b000,
ST_DATA = 3'b001,
ST_WAIT = 3'b010,
ST_DONE = 3'b011,
ST_ERROR = 3'b100
} state_t;
// 定义结构体
typedef struct packed {
addr_t address;
data_t data;
logic valid;
logic ready;
} transaction_t;
// 使用自定义类型
module my_module (
input wire clk,
input wire rst_n,
input addr_t i_addr, // 使用 addr_t
input data_t i_data, // 使用 data_t
output transaction_t o_trans // 使用 transaction_t
);
state_t r_state; // 使用 state_t
// ...
endmodule
优点：
- 提高代码可读性
- 类型检查更严格
- 修改位宽只需要改一处
3.2 使用 struct 组织相关数据
做什么： 把相关数据放在一起。
// 定义配置结构体
typedef struct packed {
logic [3:0] mode;
logic [7:0] threshold;
logic enable;
logic interrupt_en;
} config_t;
// 定义状态结构体
typedef struct packed {
logic busy;
logic error;
logic [7:0] counter;
logic done;
} status_t;
// 使用
config_t r_config;
status_t r_status;
// 赋值
always_ff @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
r_config <= '0;
r_status <= '0;
end else begin
r_config.mode <= i_mode;
r_config.threshold <= i_threshold;
r_config.enable <= i_enable;
end
end
步骤 4：参数化设计
4.1 使用参数提高复用性
做什么： 使用参数让模块可配置。
module fifo #(
parameter DATA_WIDTH = 32,
parameter DEPTH = 16,
// 派生参数
parameter ADDR_WIDTH = $clog2(DEPTH)
)(
input wire i_clk,
input wire i_rst_n,
// 写接口
input wire [DATA_WIDTH-1:0] i_wr_data,
input wire i_wr_en,
output logic o_full,
// 读接口
output logic [DATA_WIDTH-1:0] o_rd_data,
input wire i_rd_en,
output logic o_empty
);
// 使用参数
logic [DATA_WIDTH-1:0] r_mem[DEPTH];
logic [ADDR_WIDTH-1:0] r_wr_addr;
logic [ADDR_WIDTH-1:0] r_rd_addr;
// ...
endmodule
// 实例化时配置参数
fifo #(
.DATA_WIDTH (64),
.DEPTH (32)
) u_fifo (
.i_clk (clk),
.i_rst_n (rst_n),
// ...
);
4.2 使用 generate 生成重复模块
做什么： 使用 generate 生成重复结构。
module multi_channel #(
parameter NUM_CHANNELS = 4,
parameter DATA_WIDTH = 32
)(
input wire i_clk,
input wire i_rst_n,
input wire [NUM_CHANNELS-1:0] i_valid,
input wire [NUM_CHANNELS*DATA_WIDTH-1:0] i_data,
output logic [NUM_CHANNELS-1:0] o_ready
);
genvar i;
generate
for (i = 0; i < NUM_CHANNELS; i = i + 1) begin: gen_channels
// 每个通道实例化一个处理模块
channel_processor #(
.DATA_WIDTH (DATA_WIDTH)
) u_processor (
.i_clk (i_clk),
.i_rst_n (i_rst_n),
.i_valid (i_valid[i]),
.i_data (i_data[i*DATA_WIDTH +: DATA_WIDTH]),
.o_ready (o_ready[i])
);
end
endgenerate
endmodule
要点：
genvar用于 generate 循环变量begin: name给生成的块命名，方便访问
步骤 5：可综合性检查
设计使用的 SystemVerilog 特性必须是可综合的。
5.1 可综合特性列表
| 特性 | 可综合？ | 说明 |
|---|---|---|
logic |
✅ | 替代 reg 和 wire |
always_ff |
✅ | 时序逻辑 |
always_comb |
✅ | 组合逻辑 |
always_latch |
✅ | 锁存器 |
interface |
✅ | 接口封装 |
modport |
✅ | 接口方向定义 |
typedef |
✅ | 类型定义 |
struct |
✅ | 结构体 |
enum |
✅ | 枚举 |
parameter |
✅ | 参数 |
localparam |
✅ | 局部参数 |
generate |
✅ | 生成 |
$clog2() |
✅ | 编译时计算对数 |
5.2 不可综合特性列表
以下特性只能用于验证，不能用于设计：
| 特性 | 可综合？ | 说明 |
|---|---|---|
class |
❌ | 类，只能用于验证 |
dynamic array |
❌ | 动态数组 |
associative array |
❌ | 关联数组 |
queue |
❌ | 队列 |
string |
❌ | 字符串 |
virtual |
❌ | 虚方法 |
program |
❌ | 程序块 |
clocking block |
❌ | 时钟块（设计不用） |
initial |
❌ | 初始块（综合忽略） |
#delay |
❌ | 延迟（综合忽略） |
fork/join |
❌ | 并发块 |
5.3 可综合性检查清单
- 没有使用动态数组
- 没有使用类
- 没有使用
initial赋初值 - 没有使用
#delay - 所有参数在编译时确定
- 所有循环次数在编译时确定
- 所有变量位宽确定
第二部分：验证使用的 SystemVerilog 特性
以下特性用于验证平台，不可综合。
步骤 6：面向对象编程
6.1 类定义
做什么： 使用类封装验证组件。
// 定义事务类
class transaction;
rand logic [31:0] addr;
rand logic [31:0] data;
rand bit read; // 0=write, 1=read
// 约束
constraint addr_align {
addr[1:0] == 2'b00; // 地址 4 字节对齐
}
constraint addr_range {
addr inside {[0:32'hFFFF_FFFF]};
}
// 打印函数
function void print();
$display("Transaction: addr=0x%h, data=0x%h, read=%b", addr, data, read);
endfunction
endclass
6.2 继承
做什么： 复用基类代码。
// 基类
class base_transaction;
rand logic [31:0] addr;
rand logic [31:0] data;
function void print();
$display("addr=0x%h, data=0x%h", addr, data);
endfunction
endclass
// 派生类
class burst_transaction extends base_transaction;
rand int burst_length;
constraint burst_range {
burst_length inside {[1:16];
}
function void print();
$display("addr=0x%h, data=0x%h, burst_length=%0d", addr, data, burst_length);
endfunction
endclass
6.3 多态
做什么： 运行时选择不同实现。
// 基类
virtual class sequence;
pure virtual task body();
endclass
// 派生类 1
class read_sequence extends sequence;
virtual task body();
// 读序列
endtask
endclass
// 派生类 2
class write_sequence extends sequence;
virtual task body();
// 写序列
endtask
endclass
// 使用多态
sequence seq;
seq = read_sequence::new();
seq.body(); // 执行读序列
seq = write_sequence::new();
seq.body(); // 执行写序列
步骤 7：约束随机验证
7.1 定义约束
做什么： 定义随机约束，生成合法激励。
class axi_transaction;
rand logic [31:0] addr;
rand logic [31:0] data;
rand logic [3:0] strb;
rand bit read; // 0=write, 1=read
rand int delay;
// 地址对齐约束
constraint addr_align {
addr % 4 == 0; // 4 字节对齐
}
// 地址范围约束
constraint addr_range {
addr inside {[32'h0000_0000:32'h0000_FFFF]}; // 64KB 范围
}
// 写选通约束
constraint strb_valid {
if (read) {
strb == 4'hF; // 读操作，选通全 1
} else {
strb inside {4'h1, 4'h3, 4'hF}; // 写操作，合法选通
}
}
// 延迟约束
constraint delay_range {
delay inside {[0:10]};
}
// 读写比例约束
constraint read_write_ratio {
read dist {0 := 60, 1 := 40}; // 60% 写，40% 读
}
endclass
7.2 使用约束
program test;
axi_transaction trans;
initial begin
trans = new();
repeat(100) begin
if (!trans.randomize()) begin
$error("Randomization failed");
end
trans.print();
// 发送事务
drive_transaction(trans);
end
end
endprogram
步骤 8：功能覆盖率
8.1 定义覆盖组
做什么： 定义功能覆盖点。
class axi_transaction;
rand logic [31:0] addr;
rand logic [31:0] data;
rand bit read;
// 覆盖组
covergroup addr_cg @(posedge clk);
option.per_instance = 1;
// 地址覆盖点
addr_cp: coverpoint addr {
bins low = {[0:32'h0000_3FFF]};
bins mid = {[32'h0000_4000:32'h0000_BFFF]};
bins high = {[32'h0000_C000:32'h0000_FFFF]};
bins others = default;
}
// 读写覆盖点
read_cp: coverpoint read {
bins write = {0};
bins read = {1};
}
// 交叉覆盖
addr_read_cross: cross addr_cp, read_cp;
endgroup
// 构造函数
function new();
addr_cg = new();
endfunction
endclass
8.2 使用覆盖组
program test;
axi_transaction trans;
initial begin
trans = new();
repeat(1000) begin
trans.randomize();
drive_transaction(trans);
trans.addr_cg.sample(); // 采样覆盖组
end
// 报告覆盖率
$display("Address coverage: %0.2f%%", trans.addr_cg.get_coverage());
end
endprogram
第三部分：编码风格
步骤 9：排版格式
9.1 缩进和行宽
规则：
- 缩进：4 个空格，不使用 Tab
- 行宽：最大 100 字符，超过换行对齐
// ✅ 好：缩进 4 空格，行宽合理
always_ff @(posedge clk or negedge rst_n) begin
if (!rst_n) begin
r_state <= ST_IDLE;
r_data <= '0;
end else begin
r_state <= w_next_state;
r_data <= w_next_data;
end
end
// ✅ 好：长行换行对齐
assign w_result = (sel == 2'b00) ? a :
(sel == 2'b01) ? b :
(sel == 2'b10) ? c : '0;
9.2 端口声明
规则： 每个端口单独一行，加注释。
module my_module #(
parameter DATA_WIDTH = 32
)(
// 时钟和复位
input wire i_clk, // 时钟
input wire i_rst_n, // 异步复位，低有效
// 配置接口
input wire [DATA_WIDTH-1:0] i_config, // 配置数据
// 数据输入
input wire [DATA_WIDTH-1:0] i_data, // 输入数据
input wire i_valid, // 输入有效
// 数据输出
output logic [DATA_WIDTH-1:0] o_data, // 输出数据
output logic o_valid // 输出有效
);
9.3 注释规范
文件头注释：
//-----------------------------------------------------------------------------
// Module: module_name
// Description: 模块功能描述（一句话）
// Author: 作者名
// Date: 创建日期
// Version: 版本号
// Modification History:
// Date | Author | Description
// -----------|---------|-------------------------------------------
// 2024-01-15 | XXX | Initial version
//-----------------------------------------------------------------------------
端口注释： 每个端口后面加注释
代码注释： 注释解释为什么，不解释做什么
// ✅ 好：注释解释为什么
// 格雷码计数器，降低功耗，因为只有一位翻转
always_ff @(posedge clk) begin
r_gray <= r_binary ^ (r_binary >> 1);
end
// ❌ 坏：注释解释做什么（代码已经说明了）
// 这是一个计数器
always_ff @(posedge clk) begin
r_counter <= r_counter + 1'b1;
end
第四部分：工具支持
步骤 10：工具使用
10.1 商业工具
| 工具 | 公司 | 用途 |
|---|---|---|
| VCS | Synopsys | 仿真 |
| Xcelium | Cadence | 仿真 |
| Questa | Siemens | 仿真 |
| Design Compiler | Synopsys | 综合 |
| Genus | Cadence | 综合 |
10.2 开源工具
| 工具 | 用途 |
|---|---|
| Verilator | Lint 检查、仿真 |
| Icarus Verilog | 仿真 |
| Yosys | 综合 |
最终检查清单
设计代码检查
- 没有使用动态数组、类等不可综合特性
- 使用
always_ff描述时序逻辑 - 使用
always_comb描述组合逻辑 - 组合逻辑有默认值，避免锁存器
-
case语句有default分支 - 所有参数在编译时确定
- 所有循环次数在编译时确定
- 文件名和模块名一致
- 命名符合约定
- 注释完整
验证代码检查
- 使用类封装验证组件
- 使用约束随机生成激励
- 使用功能覆盖率收集覆盖
- 测试用例有自检机制
- 覆盖率达到目标
反模式（要避免）
❌ 在设计中使用验证特性：动态数组、类、队列等不可综合
// ❌ 设计中错误使用
int dynamic_array[]; // 不可综合
class my_class; // 不可综合
❌ 没有给 generate 块命名：生成的模块层次不好访问
// ❌ 不好
generate
for (i = 0; i < 4; i++) begin // 没有名字
// ...
end
endgenerate
// ✅ 好
generate
for (i = 0; i < 4; i++) begin: gen_channels // 有名字
// ...
end
endgenerate
❌ 混合 Verilog 和 SystemVerilog 不必要：统一都用 SystemVerilog 更好
❌ 文件和模块名不一致：找代码困难
代理协作
- 使用
rtl-designer代理进行 RTL 设计 - 使用
verification-engineer代理进行验证平台开发 - 使用
code-reviewer代理进行代码审查