8. 【SV】SystemVerilog Structure（结构体）

芯片验证：SystemVerilog结构体实战指南

结构体是验证工程师的数据打包神器！用最接地气的方式告诉你，为什么结构体能让你的验证代码从"乱糟糟"变成"整齐齐"。

一、结构体：验证数据的"行李箱"

数组 vs 结构体

先看这个核心对比：

// 数组：一堆同类型的东西，像超市货架
int scores[10]; // 全是整数，像10瓶一样的可乐
bit [7:0] memory[256]; // 全是字节，像256罐一样的啤酒

// 结构体：不同类型的东西打包，像旅行箱
struct {
string name; // 姓名（字符串）
int age; // 年龄（整数）
byte score; // 分数（字节）
bit passed; // 是否通过（位）
} student; // 把不同类型打包成一个"学生"

简单说：

• 数组：装一样的东西
• 结构体：装不一样但相关的东西

二、结构体基础：从定义到使用

基本定义（不推荐）

// 方式1：直接定义结构体变量（只能用一个变量）
struct {
string name;
int age;
bit is_student;
} person1; // 只能创建person1这一个变量

// 想再创建一个？不行！
// struct { … } person2; // 错误！要重复写一遍结构体定义

正确方式：用typedef定义类型

// 方式2：定义结构体类型（推荐！）
typedef struct {
string name;
int age;
bit is_student;
} person_t; // _t表示这是类型（type）

// 现在可以创建多个变量
person_t alice;
person_t bob;
person_t charlie[10]; // 甚至数组！

// 这就是为什么需要typedef：一次定义，多次使用

三、验证中的结构体实战

场景1：数据包定义（最常见！）

// 以太网数据包结构
typedef struct {
bit [47:0] dest_mac; // 目的MAC地址
bit [47:0] src_mac; // 源MAC地址
bit [15:0] ether_type; // 以太网类型
byte payload[]; // 动态数组：数据载荷
bit [31:0] fcs; // 帧校验序列
} eth_packet_t;

// 使用方法
eth_packet_t tx_packet, rx_packet;

initial begin
// 初始化整个结构体
tx_packet = '{ // 注意单引号和大括号
dest_mac: 48'hAABBCCDDEEFF,
src_mac: 48'h112233445566,
ether_type: 16'h0800, // IPv4
payload: new[100], // 动态数组需要分配空间
fcs: 32'h0
};

// 填充payload
for (int i = 0; i < 100; i++) begin
tx_packet.payload[i] = i;
end

// 访问单个字段
$display("发送到 MAC: %h", tx_packet.dest_mac);
$display("载荷长度: %0d 字节", tx_packet.payload.size());
end

场景2：配置寄存器组

// DMA控制器配置寄存器
typedef struct {
bit [31:0] src_addr; // 源地址寄存器
bit [31:0] dst_addr; // 目标地址寄存器
bit [31:0] length; // 传输长度寄存器
bit [7:0] control; // 控制寄存器
bit [7:0] status; // 状态寄存器
} dma_config_t;

class dma_driver;
dma_config_t config_regs;

function void configure_dma();
// 设置DMA配置
config_regs.src_addr = 32'h4000_0000;
config_regs.dst_addr = 32'h8000_0000;
config_regs.length = 1024; // 传输1KB
config_regs.control = 8'b1000_0001; // 使能 + 启动

$display("DMA配置: %p", config_regs);
// 输出: '{src_addr:1073741824, dst_addr:2147483648, length:1024, control:129, status:0}
endfunction

function void read_status();
if (config_regs.status[0]) begin // 检查完成位
$display("DMA传输完成");
end
endfunction
endclass

场景3：测试结果记录

// 测试结果结构体
typedef struct {
string test_name; // 测试名称
int test_id; // 测试ID
bit passed; // 是否通过
real run_time; // 运行时间（纳秒）
int error_count; // 错误数量
string error_msg[$]; // 错误消息队列
} test_result_t;

class test_manager;
test_result_t results[$]; // 结果队列

function void add_result(string name, int id, bit pass, real time);
test_result_t result;

result.test_name = name;
result.test_id = id;
result.passed = pass;
result.run_time = time;
result.error_count = 0;

results.push_back(result);
$display("记录测试结果: %s – %s", name, pass ? "通过" : "失败");
endfunction

function void generate_report();
int total = results.size();
int passed = 0;

foreach (results[i]) begin
if (results[i].passed) passed++;

$display("测试 %0d: %s – %s (%.1f ns)",
results[i].test_id,
results[i].test_name,
results[i].passed ? "✅" : "❌",
results[i].run_time);
end

$display("
=== 测试总结 ===");
$display("总计: %0d", total);
$display("通过: %0d", passed);
$display("失败: %0d", total – passed);
$display("通过率: %.1f%%", (real'(passed)/total)*100);
endfunction
endclass

四、打包结构体（Packed Struct）：验证工程师的"寄存器映射器"

什么是打包结构体？

打包结构体是把所有成员紧密打包成一个位向量，就像硬件寄存器一样。

// 控制寄存器：32位，分为多个字段
typedef struct packed {
bit [3:0] mode; // 位[31:28]：模式
bit [7:0] divisor; // 位[27:20]：分频系数
bit en; // 位[19]：使能
bit int_en; // 位[18]：中断使能
bit [17:0] reserved; // 位[17:0]：保留
} ctrl_reg_t; // 总共32位

// 使用：就像操作普通寄存器一样
ctrl_reg_t ctrl_reg;

initial begin
// 方式1：按字段赋值
ctrl_reg.mode = 4'hA;
ctrl_reg.divisor = 8'd100;
ctrl_reg.en = 1'b1;
ctrl_reg.int_en = 1'b0;
ctrl_reg.reserved = 18'h0;

// 整个寄存器值：0xA_64_60_0000
$display("控制寄存器: 0x%08h", ctrl_reg);

// 方式2：整体赋值（就像写硬件寄存器）
ctrl_reg = 32'hA64C0000; // 直接赋值给整个结构体

// 字段会自动解析
$display("模式: %h, 分频: %0d, 使能: %b",
ctrl_reg.mode, ctrl_reg.divisor, ctrl_reg.en);
end

打包结构体的核心优势

验证实战：寄存器模型

// PCIe配置空间头寄存器（64位）
typedef struct packed {
bit [15:0] vendor_id; // 厂商ID
bit [15:0] device_id; // 设备ID
bit [15:0] command; // 命令寄存器
bit [15:0] status; // 状态寄存器
bit [7:0] revision_id; // 修订ID
bit [23:0] class_code; // 类别代码
bit [7:0] cache_line; // 缓存行大小
bit [7:0] latency_timer; // 延迟定时器
bit multifunction; // 多功能
bit [6:0] header_type; // 头类型
bit bist; // BIST能力
} pcie_config_header_t;

module pcie_verif;
pcie_config_header_t config_header;
bit [63:0] raw_register;

initial begin
// 从硬件读取原始寄存器值
raw_register = read_pcie_config(0); // 假设的函数

// 转换为打包结构体（自动解析字段）
config_header = pcie_config_header_t'(raw_register);

// 检查字段
$display("厂商ID: 0x%04h", config_header.vendor_id);
$display("设备ID: 0x%04h", config_header.device_id);

// 修改字段并写回
config_header.command[0] = 1'b1; // 使能I/O空间
config_header.command[1] = 1'b1; // 使能内存空间
config_header.command[2] = 1'b1; // 使能总线master

// 转换回原始值并写回硬件
raw_register = bit [63:0]'(config_header);
write_pcie_config(0, raw_register);
end
endmodule

五、结构体数组：批量处理验证数据

三种数组类型

// 1. 固定数组：大小固定
typedef struct {
int id;
string name;
} student_t;

student_t class_2024[30]; // 固定30个学生

// 2. 动态数组：大小可变
student_t online_course[]; // 开始时不知道有多少学生

// 3. 关联数组：按键值访问
student_t students_by_id[int]; // 键是ID，值是学生

验证实战：测试向量管理

// 测试向量结构体
typedef struct {
bit [31:0] addr; // 地址
bit [31:0] data; // 数据
bit is_write; // 写操作
int delay; // 延时（周期数）
} test_vector_t;

class test_generator;
// 动态数组：测试开始时不知道需要多少向量
test_vector_t vectors[];

// 关联数组：按测试ID组织测试集
test_vector_t test_suite[int][$]; // 二维：test_id -> 向量队列

function void create_random_test(int num_vectors);
// 分配空间
vectors = new[num_vectors];

for (int i = 0; i < num_vectors; i++) begin
vectors[i].addr = $urandom_range(0, 32'hFFFF_FFFF);
vectors[i].data = $urandom();
vectors[i].is_write = $urandom_range(0, 1);
vectors[i].delay = $urandom_range(1, 10);

$display("向量 %0d: %s 地址=0x%08h, 数据=0x%08h, 延时=%0d",
i,
vectors[i].is_write ? "写" : "读",
vectors[i].addr,
vectors[i].data,
vectors[i].delay);
end
endfunction

function void organize_by_test_id(int test_id, test_vector_t new_vectors[$]);
// 将一组向量添加到指定测试ID中
test_suite[test_id] = new_vectors;

$display("测试ID %0d: 添加了 %0d 个向量",
test_id, test_suite[test_id].size());
endfunction

function void run_test(int test_id);
if (test_suite.exists(test_id)) begin
$display("运行测试 %0d，共 %0d 个向量",
test_id, test_suite[test_id].size());

foreach (test_suite[test_id][i]) begin
apply_vector(test_suite[test_id][i]);
end
end else begin
$error("测试ID %0d 不存在", test_id);
end
endfunction
endclass

六、结构体在UVM验证平台中的应用

UVM事务（Transaction）结构体

// 典型的UVM事务结构
typedef struct {
bit [31:0] addr; // 地址
bit [31:0] data; // 数据
bit rw; // 读写：1=写，0=读
int id; // 事务ID
time timestamp; // 时间戳
bit error; // 错误标志
} bus_transaction_t;

// 在UVM sequence中使用
class bus_sequence extends uvm_sequence;
rand bus_transaction_t trans;

constraint addr_c {
trans.addr inside {[32'h4000_0000:32'h4000_1000]};
}

constraint data_c {
trans.data dist {
32'h0 :/ 10,
32'hFFFF_FFFF :/ 10,
[1:32'hFFFF_FFFE] :/ 80
};
}

task body();
// 创建事务结构
trans = '{default:0}; // 所有字段初始化为0

for (int i = 0; i < 10; i++) begin
// 随机化结构体字段
trans.addr = $urandom();
trans.data = $urandom();
trans.rw = $urandom_range(0, 1);
trans.id = i;
trans.timestamp = $time;

// 发送事务
start_item(req);
// 将结构体复制到UVM事务对象
copy_struct_to_uvm_object(trans, req);
finish_item(req);
end
endtask
endclass

配置结构体

// 验证环境配置结构体
typedef struct {
string test_name; // 测试名称
int num_transactions; // 事务数量
bit error_injection; // 错误注入使能
bit [1:0] test_mode; // 测试模式
real clock_frequency; // 时钟频率（MHz）
int timeout; // 超时时间（ns）
} test_config_t;

class test_base extends uvm_test;
test_config_t cfg;

function void build_phase(uvm_phase phase);
// 从命令行或配置文件读取配置
read_configuration();

// 根据配置设置环境
uvm_config_db#(int)::set(this, "*", "num_transactions", cfg.num_transactions);
uvm_config_db#(bit)::set(this, "*", "error_injection", cfg.error_injection);

$display("测试配置:");
$display(" 名称: %s", cfg.test_name);
$display(" 模式: %0d", cfg.test_mode);
$display(" 事务数: %0d", cfg.num_transactions);
$display(" 时钟: %.1f MHz", cfg.clock_frequency);
endfunction

function void read_configuration();
// 从命令行参数读取
if ($test$plusargs("TESTNAME=")) begin
$value$plusargs("TESTNAME=%s", cfg.test_name);
end

if ($test$plusargs("NUMTRANS=")) begin
$value$plusargs("NUMTRANS=%d", cfg.num_transactions);
end

// 默认值
if (cfg.test_name == "") cfg.test_name = "default_test";
if (cfg.num_transactions == 0) cfg.num_transactions = 1000;
cfg.clock_frequency = 100.0; // 100MHz默认
endfunction
endclass

七、结构体高级技巧

嵌套结构体

// 地址结构体
typedef struct {
bit [31:0] base_addr;
bit [31:0] offset;
} address_t;

// 数据包结构体
typedef struct {
address_t src_addr; // 嵌套结构体
address_t dst_addr; // 嵌套结构体
bit [31:0] data;
int length;
} packet_t;

// 使用
packet_t packet;
packet.src_addr.base_addr = 32'h4000_0000;
packet.src_addr.offset = 32'h0000_0100;
$display("源地址: 0x%08h", packet.src_addr.base_addr + packet.src_addr.offset);

结构体赋值技巧

typedef struct {
int a;
int b;
string s;
} my_struct_t;

my_struct_t s1, s2;

// 1. 整体赋值（复制所有字段）
s1 = '{a: 1, b: 2, s: "hello"};
s2 = s1; // 深拷贝！修改s2不会影响s1

// 2. 部分赋值
s1 = '{a: 3, b: 4}; // s.s保持原值
s1 = '{s: "world"}; // a和b保持原值

// 3. 默认值赋值
s1 = '{default: 0}; // a=0, b=0, s=""（字符串清空）
s1 = '{default: '1}; // a=-1, b=-1, s=""（整数全1）

// 4. 带类型强制转换的赋值
s1 = my_struct_t'{int: 5, default: 0}; // a=5, b=0, s=""

结构体比较

// 结构体可以整体比较！
if (s1 == s2) begin
$display("结构体相同");
end else begin
$display("结构体不同");
end

// 打印整个结构体（调试神器！）
$display("s1 = %p", s1);
// 输出: '{a:1, b:2, s:"hello"}

八、常见陷阱与解决方案

陷阱1：忘记字符串是引用类型

typedef struct {
string name;
int age;
} person_t;

person_t p1, p2;

p1 = '{"Alice", 25};
p2 = p1; // 注意：字符串是浅拷贝！

p2.name = "Bob"; // 这会同时修改p1.name！
$display("p1.name = %s", p1.name); // 输出: Bob（意外！）

// 解决方案：深拷贝函数
function person_t deep_copy(person_t src);
person_t dst;
dst.name = src.name; // 字符串复制，创建新对象
dst.age = src.age;
return dst;
endfunction

p2 = deep_copy(p1);
p2.name = "Bob"; // 现在只修改p2
$display("p1.name = %s", p1.name); // 输出: Alice（正确！）

陷阱2：打包结构体位宽不对齐

// ❌ 错误：位宽不是2的幂，某些工具可能不支持
typedef struct packed {
bit [5:0] field1; // 6位
bit [3:0] field2; // 4位
} bad_struct_t; // 总共10位，不是8/16/32/64

// ✅ 正确：使用标准位宽
typedef struct packed {
bit [7:0] field1; // 8位
bit [7:0] field2; // 8位
} good_struct_t; // 总共16位，对齐

陷阱3：动态数组成员需要手动分配

typedef struct {
byte data[];
} dynamic_struct_t;

dynamic_struct_t ds;

// ❌ 错误：直接访问未分配的数组
// ds.data[0] = 8'hFF; // 运行时错误！

// ✅ 正确：先分配空间
ds.data = new[100]; // 分配100个字节
for (int i = 0; i < 100; i++) begin
ds.data[i] = i;
end

九、验证工程师的结构体最佳实践

实践1：命名规范

// 结构体类型加 _t 后缀
typedef struct {
// 字段名有意义
bit [31:0] src_address; // 不要用 sa 这种缩写
bit [31:0] dest_address; // 不要用 da
int packet_length; // 不要用 len
bit is_valid; // 不要用 valid_flag
} packet_header_t; // _t 表示类型

实践2：添加默认值

// 为结构体定义默认值函数
typedef struct {
bit [31:0] addr;
bit [31:0] data;
bit rw;
int id;
} transaction_t;

function transaction_t get_default_transaction();
transaction_t t;
t.addr = 32'h0;
t.data = 32'h0;
t.rw = 1'b0; // 默认读
t.id = –1; // 无效ID
return t;
endfunction

// 使用
transaction_t trans = get_default_transaction();

实践3：验证专用结构体

// 1. 断言检查结构体
typedef struct {
bit [31:0] min_val;
bit [31:0] max_val;
string field_name;
} range_check_t;

// 2. 覆盖率收集结构体
typedef struct {
int read_count;
int write_count;
int error_count;
real avg_latency;
} coverage_stats_t;

// 3. 性能监控结构体
typedef struct {
time start_time;
time end_time;
int transaction_count;
real throughput;
} performance_monitor_t;

实践4：使用%p格式化打印

// %p 是调试结构体的神器
typedef struct {
string name;
int age;
bit [7:0] score;
} student_t;

student_t s = '{"Alice", 20, 95};

$display("学生信息: %p", s);
// 输出: 学生信息: '{name:"Alice", age:20, score:'h5f}

// 在验证平台中广泛使用
$display("[%0t] 事务: %p", $time, transaction);
$display("配置: %p", config);
$display("错误: %p", error_info);

十、结构体与面向对象的结合

结构体作为类的成员

class packet_analyzer;
// 结构体作为内部数据结构
typedef struct {
int total_packets;
int corrupted_packets;
int timeout_packets;
real avg_packet_size;
} statistics_t;

statistics_t stats;

function new();
stats = '{default: 0};
endfunction

function void update_stats(packet_t pkt);
stats.total_packets++;

if (pkt.crc_error) stats.corrupted_packets++;
if (pkt.timeout) stats.timeout_packets++;

// 更新平均大小
stats.avg_packet_size =
(stats.avg_packet_size * (stats.total_packets–1) + pkt.length)
/ stats.total_packets;
endfunction

function void print_report();
$display("=== 数据包分析报告 ===");
$display("总计: %0d", stats.total_packets);
$display("损坏: %0d (%.1f%%)",
stats.corrupted_packets,
(real'(stats.corrupted_packets)/stats.total_packets)*100);
$display("超时: %0d (%.1f%%)",
stats.timeout_packets,
(real'(stats.timeout_packets)/stats.total_packets)*100);
$display("平均大小: %.1f 字节", stats.avg_packet_size);
endfunction
endclass

十一、给验证工程师的终极建议

什么时候用结构体？

结构体选择指南

// 1. 硬件寄存器 → 用打包结构体
typedef struct packed {
bit [3:0] mode;
bit [2:0] cfg;
bit en;
} ctrl_reg_t;

// 2. 数据包 → 用未打包结构体
typedef struct {
bit [47:0] mac_addr;
bit [15:0] ether_type;
byte payload[];
} eth_frame_t;

// 3. 配置信息 → 用带默认值的结构体
typedef struct {
string test_name = "default";
int num_iterations = 1000;
bit debug_enable = 0;
} test_config_t;

// 4. 嵌套结构 → 层次化数据
typedef struct {
address_t src;
address_t dst;
data_t payload;
checksum_t crc;
} packet_t;

调试技巧

十二、总结：结构体让验证更专业

朋友，记住结构体的三大价值：

最后一句忠告：在你定义第五个相关变量时，就应该考虑用结构体了。

从现在开始，让你的验证数据告别零散变量，拥抱结构体！

当你养成使用结构体的习惯后，你会发现：

• 函数参数更少（传一个结构体代替10个参数）
• 代码更清晰
• 调试更容易
• 你看起来更专业