SystemVerilog 数据类型详解

概述

SystemVerilog 提供了丰富的数据类型体系，涵盖从基本标量到复杂对象的各种需求。理解这些数据类型是编写高效、可维护代码的基础。

一、标量类型 (Scalar Types)

1.1 基本位类型

bit：1位，值域 {0, 1}，二值逻辑，无 X/Z，适合控制信号
logic：1位，值域 {0, 1, X, Z}，四值逻辑，可综合，适合数据信号
reg：1位，值域 {0, 1, X, Z}，存储型，用于过程赋值
wire：1位，值域 {0, 1, X, Z}，连线型，用于连续赋值

**应用示例：**

```systemverilog

// 二值逻辑，适合控制信号

bit clk;

bit reset_n;

// 四值逻辑，适合数据信号

logic $7:0$ data_in;

logic valid;

// reg 用于时序逻辑

reg $31:0$ counter;

// wire 用于组合逻辑

wire $15:0$ addr_bus;

```

1.2 整型类型

**有符号整型：**

byte：8位，有符号，值域 -128 ~ 127
shortint：16位，有符号，值域 -32768 ~ 32767
int：32位，有符号，值域 -2^31 ~ 2^31-1
longint：64位，有符号，值域 -2^63 ~ 2^63-1

**无符号整型：**

ubyte：8位，无符号，值域 0 ~ 255
ushortint：16位，无符号，值域 0 ~ 65535
uint：32位，无符号，值域 0 ~ 2^32-1
ulongint：64位，无符号，值域 0 ~ 2^64-1

**应用示例：**

```systemverilog

// 计数器使用无符号类型

uint packet_count;

// 数组索引使用 int

int array_index;

// 大数值计算使用 longint

longint file_size;

// 字节数据使用 byte

byte buffer $256$ ;

```

二、向量类型 (Vector Types)

2.1 位向量

```systemverilog

// 基本位向量

logic $7:0$ byte_data; // 8位数据

logic $31:0$ word_data; // 32位数据

logic $127:0$ cache_line; // 128位缓存行

// 非连续位选择

logic $3:0$ $7:0$ dword; // 4个字节，可单独访问 dword $0$ ~dword $3$

// 位拼接

logic $15:0$ addr;

logic $7:0$ high_byte = addr $15:8$ ;

logic $7:0$ low_byte = addr $7:0$ ;

```

2.2 向量操作

```systemverilog

logic $31:0$ a = 32'h12345678;

logic $31:0$ b = 32'h87654321;

// 位操作

logic $31:0$ result_and = a & b; // 按位与

logic $31:0$ result_or = a | b; // 按位或

logic $31:0$ result_xor = a ^ b; // 按位异或

logic $31:0$ result_not = ~a; // 按位取反

// 移位操作

logic $31:0$ shifted_left = a << 2; // 左移2位

logic $31:0$ shifted_right = a >> 2; // 右移2位（逻辑移位）

logic $31:0$ arith_shift = a >>> 2; // 算术右移

// 拼接与复制

logic $63:0$ doubled = {a, a}; // 拼接

logic $31:0$ replicated = {4{a $7:0$ }}; // 复制4次低字节

```

三、数组类型 (Array Types)

3.1 固定大小数组

```systemverilog

// 一维数组

int scores $100$ ; // 100个int元素

logic $7:0$ buffer $256$ ; // 256个字节

// 二维数组

int matrix $4$ $4$ ; // 4x4矩阵

logic $31:0$ ram $512$ $8$ ; // 512行，每行8个32位字

// 初始化

int fib $10$ = '{0, 1, 1, 2, 3, 5, 8, 13, 21, 34};

// 访问

scores $0$ = 100;

matrix $2$ $3$ = 42;

```

3.2 动态数组 (Dynamic Array)

```systemverilog

// 声明

int dyn_array\[\];

// 创建和调整大小

dyn_array = new $100$ ; // 创建100个元素

dyn_array = new $200$ (dyn_array); // 扩展到200个，保留原有数据

// 常用方法

dyn_array.size(); // 获取大小

dyn_array.delete(); // 删除所有元素

dyn_array.push_back(42); // 添加到末尾

dyn_array.pop_back(); // 从末尾移除

// 遍历

foreach (dyn_array $i$ ) begin

$display("Element %0d: %0d", i, dyn_array $i$ );

end

```

3.3 队列 (Queue)

```systemverilog

// 声明

int queue $$$ ;

// 操作方法

queue.push_front(1); // 插入到前面

queue.push_back(2); // 插入到后面

queue.insert(1, 3); // 在位置1插入

queue.delete(0); // 删除位置0的元素

queue.pop_front(); // 弹出第一个元素

queue.pop_back(); // 弹出最后一个元素

// 队列特性

// 动态大小，高效插入删除

// 类似链表，但随机访问效率高

```

3.4 关联数组 (Associative Array)

```systemverilog

// 声明 - 整数索引

int assoc $int$ ;

// 声明 - 字符串索引

string info $string$ ;

// 赋值

assoc $42$ = 100;

info $"name"$ = "John";

info $"age"$ = "30";

// 遍历

foreach (assoc $i$ ) begin

$display("Key: %0d, Value: %0d", i, assoc $i$ );

end

// 检查是否存在

if (assoc.exists(42)) begin

$display("Key 42 exists");

end

// 删除

assoc.delete(42);

```

四、结构体 (Structures)

4.1 非打包结构体 (Unpacked Struct)

```systemverilog

// 定义结构体类型

typedef struct {

logic $31:0$ addr;

logic $63:0$ data;

logic write;

logic valid;

} transaction_t;

// 使用

transaction_t tr;

tr.addr = 32'h1000_0000;

tr.data = 64'hDEAD_BEEF_CAFE_BABE;

tr.write = 1'b1;

tr.valid = 1'b1;

// 初始化

transaction_t tr_init = '{32'h0, 64'h0, 1'b0, 1'b0};

```

4.2 打包结构体 (Packed Struct)

```systemverilog

// 打包结构体 - 连续位布局

typedef struct packed {

logic $3:0$ opcode;

logic $27:0$ addr;

} instruction_t;

// 打包结构体可以作为整体赋值

instruction_t inst = 32'h12345678;

logic $31:0$ inst_bits = inst; // 直接转换为位向量

// 位域访问

logic $3:0$ op = inst.opcode;

logic $27:0$ addr = inst.addr;

```

五、联合体 (Unions)

5.1 非打包联合体

```systemverilog

// 联合体 - 共享存储空间

typedef union {

logic $31:0$ word;

logic $15:0$ halfword $2$ ;

logic $7:0$ byte_array $4$ ;

} data_union_t;

// 使用

data_union_t data;

data.word = 32'h12345678;

// 访问不同视图

$display("Word: %0h", data.word);

$display("Byte 0: %0h", data.byte_array $0$ ); // 78

$display("Byte 1: %0h", data.byte_array $1$ ); // 56

```

5.2 打包联合体

```systemverilog

// 打包联合体

typedef union packed {

logic $31:0$ value;

struct packed {

logic $7:0$ a;

logic $7:0$ b;

logic $7:0$ c;

logic $7:0$ d;

} bytes;

} packed_union_t;

// 可以直接进行位操作

packed_union_t u;

u.value = 32'hAABBCCDD;

u.bytes.a = 8'hEE; // 修改部分位

```

六、枚举类型 (Enumerations)

6.1 基本枚举

```systemverilog

// 定义枚举类型

typedef enum {IDLE, READ, WRITE, DONE} state_t;

// 使用

state_t current_state;

current_state = IDLE;

// 枚举值转换

int state_int = current_state; // 0

current_state = state_t'(2); // WRITE

// 遍历枚举

foreach (state_t'(i)) begin

$display("State %0d: %s", i, state_t'(i).name());

end

```

6.2 带值枚举

```systemverilog

// 指定枚举值

typedef enum logic $2:0$ {

S0 = 3'b000,

S1 = 3'b001,

S2 = 3'b010,

ERROR = 3'b111

} fsm_state_t;

// 使用

fsm_state_t state = S1;

if (state == ERROR) begin

$display("Error state detected");

end

```

七、字符串类型 (String)

```systemverilog

// 声明和赋值

string message = "Hello, SystemVerilog!";

// 常用方法

message.len(); // 获取长度

message.putc(0, 'H'); // 修改字符

message.substr(0, 4); // 子串 "Hello"

message.toupper(); // 转大写

message.tolower(); // 转小写

// 字符串拼接

string name = "World";

string greeting = {"Hello, ", name, "!"};

// 字符串比较

if (message == "Hello") begin

$display("Match!");

end

```

八、类类型 (Class Types)

8.1 类定义

```systemverilog

class Transaction;

// 成员变量

rand logic $31:0$ addr;

rand logic $63:0$ data;

logic valid;

// 约束

constraint addr_range {

addr inside { $0:1023$ };

}

// 成员方法

function void print();

$display("Addr: %0h, Data: %0h, Valid: %0b",

addr, data, valid);

endfunction

endclass

// 使用

Transaction tr = new();

tr.randomize();

tr.valid = 1'b1;

tr.print();

```

8.2 继承

```systemverilog

class ExtendedTransaction extends Transaction;

rand logic $7:0$ burst_len;

constraint burst_constraint {

burst_len inside { $1:8$ };

}

function void print();

super.print();

$display("Burst Length: %0d", burst_len);

endfunction

endclass

```

九、接口类型 (Interface Types)

```systemverilog

// 定义接口

interface AXI_Interface(input logic clk, input logic rst_n);

// 地址通道

logic $31:0$ addr;

logic $2:0$ prot;

logic valid;

logic ready;

// 数据通道

logic $31:0$ data;

logic $3:0$ strb;

logic last;

// 任务

task send_addr(logic $31:0$ a);

@(posedge clk);

addr <= a;

valid <= 1'b1;

@(posedge clk iff ready);

valid <= 1'b0;

endtask

endinterface

// 使用接口

AXI_Interface axi_if(clk, rst_n);

DUT dut(.axi(axi_if));

```

十、用户自定义类型 (User-defined Types)

10.1 TypeDef

```systemverilog

// 简单类型别名

typedef logic $31:0$ data_t;

typedef enum {READ, WRITE} op_t;

// 结构体类型

typedef struct {

data_t addr;

data_t data;

op_t op;

} request_t;

// 数组类型

typedef data_t data_array_t\[\];

typedef request_t request_queue_t $$$ ;

```

10.2 Parameterized Types

```systemverilog

// 参数化类

class Packet #(int WIDTH=32);

rand logic $WIDTH-1:0$ data;

function new();

$display("Packet width: %0d", WIDTH);

endfunction

endclass

// 使用不同参数

Packet #(32) p32 = new();

Packet #(64) p64 = new();

```

十一、类型转换

11.1 静态转换

```systemverilog

// 显式类型转换

int a = 42;

logic $7:0$ b = logic $7:0$ '(a); // 截断

// 使用 $cast

logic $31:0$ src = 32'hFFFFFFFF;

int dest;

if (!$cast(dest, src)) begin

$display("Cast failed");

end

```

11.2 动态转换

```systemverilog

class Base;

virtual function void print();

$display("Base");

endfunction

endclass

class Derived extends Base;

function void print();

$display("Derived");

endfunction

endclass

// 动态转换

Base b = new();

Derived d;

if ($cast(d, b)) begin

d.print(); // 调用 Derived::print()

end else begin

$display("Cast failed");

end

```

十二、数据类型选择指南

12.1 选择原则

控制信号：bit，二值逻辑，高效
数据信号：logic，四值逻辑，可综合
计数器：uint，无符号，适合计数
数组索引：int，有符号，支持负数
可变大小数据：queue/dynamic array，灵活调整大小
稀疏数据：associative array，节省空间
复杂数据结构：struct/class，组织相关数据
状态机：enum，可读性好，类型安全
验证激励：class，OOP特性，可随机化

12.2 性能考虑

```

避免不必要的宽位类型
使用合适的数组类型：

固定大小数组最快
队列适合频繁插入删除
关联数组适合稀疏数据

打包类型比非打包类型更紧凑
类的动态分配有开销，注意内存管理

```

十三、总结

13.1 数据类型分类总结

```

SystemVerilog 数据类型体系：

┌─────────────────────────────────────────┐

│ 标量类型 (Scalar) │

│ bit, logic, reg, wire, int, byte... │

├─────────────────────────────────────────┤

│ 复合类型 (Composite) │

│ ├── 向量 (Vector) │

│ ├── 数组 (Array) │

│ │ ├── 固定数组 │

│ │ ├── 动态数组 │

│ │ ├── 队列 │

│ │ └── 关联数组 │

│ ├── 结构体 (Struct) │

│ └── 联合体 (Union) │

├─────────────────────────────────────────┤

│ 抽象类型 (Abstract) │

│ ├── 枚举 (Enum) │

│ ├── 字符串 (String) │

│ ├── 类 (Class) │

│ └── 接口 (Interface) │

└─────────────────────────────────────────┘

```

13.2 关键要点

```

bit vs logic：bit 是二值，logic 是四值
reg vs wire：reg 存储，wire 连线
动态数组 vs 队列：队列支持高效插入删除
结构体 vs 类：结构体是值类型，类是引用类型
打包 vs 非打包：打包类型连续布局，可直接位操作
枚举提供类型安全和可读性

```

掌握这些数据类型及其应用场景，是编写高质量 SystemVerilog 代码的基础。