基于RISCV的FP32乘法指令运行分析(五级流水线)
一、项目背景与意义
从算法到硬件的挑战
浮点乘法器是现代处理器中最复杂的运算单元之一，其设计面临多重挑战：
1. 算法复杂性
- IEEE 754 标准: 必须精确处理规格化、四种舍入模式、特殊值（NaN/∞/±0）
- 多步骤流程: 符号计算 → 指数相加 → 尾数乘法 → 规格化 → 舍入 → 溢出检测
- 边界情况: 次规范数、舍入进位、指数溢出等需要特殊处理
2. 硬件时序约束
- 关键路径: 24×24 位乘法 + 48 位移位 + 舍入加法，总延迟约 60ns（单周期实现）
- 频率目标: 现代处理器要求 ≥300 MHz（周期 ≤3.3ns）
- 流水线分级: 需要将算法拆分到多级流水线以满足时序
3. 面积-性能权衡
- 48 位中间寄存器: 必须存储完整乘积以正确计算 Guard/Sticky 位
- 多路选择器: 规格化路径（shift 23 vs 24）需要数据选择逻辑
- 舍入硬件: 银行家舍入需要额外的进位链与奇偶检测
二、本文档的价值
本流程图文档提供：
- ✅ 模块化设计视图: 展示从顶层 RISC-V 核心到 FP32 乘法器子模块的层次结构
- ✅ 详细数据流图: ASCII 流程图展示每个阶段的输入/输出与控制信号
- ✅ 时序分析: 流水线时序图、关键路径分析、频率优化建议
- ✅ 测试覆盖: 10 个测试用例矩阵，覆盖边界情况与特殊值
- ✅ 信号连接: SystemC 模块间的信号绑定关系
三、 完整指令序列执行分析
c
float multiply(float a, float b) {
return a * b;
}RISC-V 汇编 (GCC -O2):
assembly
# -O2 优化后只需2条指令
fmul.s fa0, fa0, fa1 # Cycle 1-5: fa0 ← fa0 × fa1
ret # Cycle 2-6: 返回 (与 fmul 重叠)
# 总周期: 6 周期 (流水线重叠)五级流水线执行
Cycle: 0 1 2 3 4 5 6
├────┼────┼────┼────┼────┼────┼────┤
FMUL │ │ IF │ ID │ EX │MEM │ WB │ │ 完成!
│ └────┴────┴────┴────┴────┘ │
RET │ │ IF │ ID │ EX │MEM │ WB │ 完成!
│ └────┴────┴────┴────┴────┘
↑
Cycle 6 结束
说明:
- FMUL 在 Cycle 1-5 执行 (5个周期)
- RET 在 Cycle 2-6 执行 (5个周期，与 FMUL 重叠)
- 总周期 = 6 (从第一条指令开始到最后一条指令完成)性能指标:
- 指令数: 2 条
- 总周期: 6 周期
- CPI: 6 / 2 = 3.0
- 有效浮点运算效率: 1 / 6 ≈ 16.7%
如果没有流水线 (顺序执行):
FMUL: 5 周期 + RET: 5 周期 = 10 周期
四、 五级流水线逐周期执行
流水线结构: IF → ID → EX → MEM → WB (经典五级)
时间轴:
T=0ns T=5ns T=10ns T=15ns T=20ns T=25ns
│ │ │ │ │ │
├───────┼───────┼───────┼───────┼───────┤
Cyc0 Cyc1 Cyc2 Cyc3 Cyc4 Cyc5
指令: FMUL.S f3, f1, f2 (0x08208153)
Pipeline Stages (经典五级):
┌──────┬──────┬──────┬──────┬──────┬──────┐
│ Cyc0 │ Cyc1 │ Cyc2 │ Cyc3 │ Cyc4 │ Cyc5 │
├──────┼──────┼──────┼──────┼──────┼──────┤
│ │ IF │ │ │ │ │ Stage 1: 取指 (Fetch)
│ │ │ ID │ │ │ │ Stage 2: 译码 (Decode)
│ │ │ │ EX │ │ │ Stage 3: 执行 (Execute) - 完整 FP32 乘法
│ │ │ │ │ MEM │ │ Stage 4: 访存 (Memory) - 空操作
│ │ │ │ │ │ WB │ Stage 5: 写回 (WriteBack)
└──────┴──────┴──────┴──────┴──────┴──────┘
完成!
f3 = 3.0
关键路径分析:
EX 阶段内部时序:
1. 寄存器读取
2. 符号/指数提取
3. 24×24 乘法 (DSP)
4. 规格化移位
5. 银行家舍入
6. 结果打包
7. 寄存器写入
工艺对比:
┌──────────┬───────────┬──────────┬──────────┐
│ 工艺 │ 周期时间 │ 频率 │ 用途 │
├──────────┼───────────┼──────────┼──────────┤
│ 180nm │ 38ns │ 26 MHz │ 早期设计 │
│ 65nm │ 10ns │ 100 MHz │ 教学演示 │
│ 28nm │ 5ns │ 200 MHz │ 嵌入式 │
│ 7nm │ 2ns │ 500 MHz │ 高性能 │
│ 5nm │ 1ns │ 1 GHz │ 服务器 │
└──────────┴───────────┴──────────┴──────────┘Cycle 1: IF (取指)
操作:
1. PC 指向 0x1000
2. 从指令内存读取: Imem[0x1000] = 0x08208153
3. PC ← PC + 4 = 0x1004
4. 将指令传递给 IF/ID 流水线寄存器
硬件状态:
IF_ID_REG.instruction = 0x08208153
PC = 0x1004
SystemC 对应:
sc_uint<32> pc = 0x1000;
sc_uint<32> instruction = imem[pc >> 2]; // 读取指令,因为字对齐(Word Alignment)和字节寻址的转换
pc = pc + 4; // PC 自增
PS：
为什么要 pc >> 2？
原因: 地址空间不同
PC (程序计数器): 按字节寻址 (Byte Address)
imem[] (指令数组): 按字索引 (Word Index)
RISC-V 指令固定 32 位 = 4 字节
→ 每条指令占 4 个字节地址
→ 但数组只需要 1 个索引
转换关系:
字节地址 → 字索引 = 字节地址 ÷ 4 = 字节地址 >> 2
具体例子:
┌──────────────┬──────────────┬──────────────────────┐
│ PC │ pc >> 2 │ imem[index] │
├──────────────┼──────────────┼──────────────────────┤
│ 0x1000 │ 0x1000 >> 2 = 0x400 │ imem[0x400] │
│ 0x1004 │ 0x1004 >> 2 = 0x401 │ imem[0x401] │
│ 0x1008 │ 0x1008 >> 2 = 0x402 │ imem[0x402] │
│ 0x100C │ 0x100C >> 2 = 0x403 │ imem[0x403] │
└──────────────┴──────────────┴──────────────────────┘Cycle 2: ID (译码)
1. 解析指令字段:
opcode = instruction[6:0] = 0x53
funct7 = instruction[31:25] = 0x08
fs1 = instruction[19:15] = 1
fs2 = instruction[24:20] = 2
fd = instruction[11:7] = 3
rm = instruction[14:12] = 0
2. 根据 opcode 和 funct7 识别指令类型:
→ FMUL.S (单精度浮点乘法)
3. 读取浮点寄存器堆:
operand_a = FP_Regs[1] = 0x3FC00000 (1.5)
operand_b = FP_Regs[2] = 0x40000000 (2.0)
4. 传递给 ID/EX 流水线寄存器
硬件状态:
ID_EX_REG.operand_a = 0x3FC00000
ID_EX_REG.operand_b = 0x40000000
ID_EX_REG.dest_reg = 3
ID_EX_REG.alu_op = FMUL
SystemC 对应:
sc_uint<32> instruction = if_id_reg.instruction;
// 字段提取
sc_uint<7> opcode = instruction.range(6, 0);
sc_uint<5> fs1 = instruction.range(19, 15); // 源寄存器1编号
sc_uint<5> fs2 = instruction.range(24, 20); // 源寄存器2编号
sc_uint<5> fd = instruction.range(11, 7); // 目标寄存器编号
// 寄存器读取
sc_uint<32> op_a = fp_regfile[fs1]; // 读 f1 → 0x3FC00000
sc_uint<32> op_b = fp_regfile[fs2]; // 读 f2 → 0x40000000
// 直接调用 fp32_multiply 模块,传入测试数据
fp32_multiply_inst.operand_a.write(op_a);
fp32_multiply_inst.operand_b.write(op_b);Cycle 3: EX (执行完整 FP32 乘法)
输入:
operand_a = 0x3FC00000 (1.5 的 IEEE 754 编码)
operand_b = 0x40000000 (2.0 的 IEEE 754 编码)
操作步骤：
Step 1: 提取符号位
Step 2: 提取指数
Step 3: 提取尾数并加隐藏位
Step 4: 24×24 位乘法
Step 5: 规格化
Step 6: 舍入
Step 7: 打包输出Cycle 4: MEM (访存阶段)
┌─────────────────────────────────────────────────────┐
│ 为什么五级流水线要有 MEM 阶段？ │
├─────────────────────────────────────────────────────┤
│ 经典 RISC-V 五级流水线设计需要统一处理所有指令: │
│ │
│ 1. 算术指令 (ADD, FMUL 等): │
│ IF → ID → EX → MEM(空操作) → WB │
│ ↑ │
│ 在这里完成计算 │
│ │
│ 2. 访存指令 (LW, SW 等): │
│ IF → ID → EX(地址计算) → MEM(访问缓存) → WB │
│ ↑ │
│ 在这里访问数据内存 │
│ │
│ 如果没有 MEM 阶段,两类指令的流水线深度不一致 │
│ 会导致控制逻辑复杂化! │
└─────────────────────────────────────────────────────┘
对于 FMUL.S 指令:
FMUL.S 是寄存器到寄存器操作 (R-Type 指令)
→ 不需要访问数据内存
→ MEM 阶段变成"空操作" (Bubble / NOP)
→ 数据仅从 EX_MEM_REG 传递到 MEM_WB_REG
硬件行为:
┌──────────────┬────────────────┬────────────────┐
│ 指令类型 │ MEM 阶段操作 │ 实际行为 │
├──────────────┼────────────────┼────────────────┤
│ FMUL.S │ 空操作 (NOP) │ 寄存器传递 │
│ ADD, SUB │ 空操作 (NOP) │ 寄存器传递 │
│ LW (加载) │ 读数据缓存 │ 访问 D-Cache │
│ SW (存储) │ 写数据缓存 │ 访问 D-Cache │
└──────────────┴────────────────┴────────────────┘Cycle 5: WB (写回)
操作:
将 MEM/WB 流水线寄存器中的结果写回浮点寄存器堆
FP_Regs[3] ← MEM_WB_REG.result
FP_Regs[3] = 0x40400000
硬件状态:
FP_Regs[3] = 0x40400000
指令完成!
SystemC 对应:
fp_regfile[dest_reg] = result.read();五、SystemC设计
1. 模块层次结构
riscv_core (顶层)
│
├── IF_Stage (取指阶段)
│ ├── program_counter (PC 寄存器)
│ └── instruction_memory (指令存储器)
│
├── ID_Stage (译码阶段)
│ ├── instruction_decoder (指令译码器)
│ └── register_file (浮点寄存器堆)
│
├── EX_Stage (执行阶段)
│ └── fp32_multiply (FP32 乘法器)
│ ├── input_parser (输入解析)
│ ├── special_case_detector (特殊值检测)
│ ├── mantissa_multiplier (尾数乘法器 24×24)
│ ├── normalizer (规格化单元)
│ ├── guard_sticky_gen (Guard/Sticky 生成器)
│ ├── banker_rounder (银行家舍入器)
│ └── result_packer (结果打包器)
│
├── MEM_Stage (访存阶段，FP 运算 bypass)
│
└── WB_Stage (写回阶段)
└── register_file_writeback (寄存器写回)2. FP32 乘法器内部流程图
输入: operand_a[31:0], operand_b[31:0]
│
├───────────────────────────────────────────────────────────┐
│ Stage 1: 输入解析与特殊值检测 │
├───────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────┐ ┌─────────────────────┐ │
│ │ 提取 A 的 S/E/M │ │ 提取 B 的 S/E/M │ │
│ │ sign_a = A[31] │ │ sign_b = B[31] │ │
│ │ exp_a = A[30:23] │ │ exp_b = B[30:23] │ │
│ │ frac_a = A[22:0] │ │ frac_b = B[22:0] │ │
│ └──────────┬──────────┘ └──────────┬──────────┘ │
│ │ │ │
│ └───────────┬───────────────┘ │
│ ▼ │
│ ┌─────────────────────────────┐ │
│ │ 特殊值检测 │ │
│ │ • is_nan_a/b = (E==255 && M!=0) │
│ │ • is_inf_a/b = (E==255 && M==0) │
│ │ • is_zero_a/b = (E==0 && M==0) │
│ │ • is_denorm_a/b = (E==0 && M!=0) │
│ └─────────────┬───────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────┐ │
│ │ 短路判断 │ │
│ │ if (NaN || 0×∞) → qNaN │ │
│ │ if (∞) → ±∞ │ │
│ │ if (0) → ±0 │ │
│ │ else → 继续正常流程 │ │
│ └─────────────┬───────────────┘ │
└──────────────────────────┼───────────────────────────────┘
│
┌──────────────────────────┼───────────────────────────────┐
│ Stage 2: 符号、指数与尾数准备 │
├──────────────────────────┼───────────────────────────────┤
│ ▼ │
│ ┌─────────────────────────────┐ │
│ │ 符号计算 │ │
│ │ sign_result = sign_a ⊕ sign_b │
│ └─────────────┬───────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────┐ │
│ │ 指数初值 │ │
│ │ exp_sum = exp_a + exp_b - 127 │
│ └─────────────┬───────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────┐ │
│ │ 补隐含位（24 位尾数） │ │
│ │ mant_a = (E_a==0)? {0,frac_a} : {1,frac_a} │
│ │ mant_b = (E_b==0)? {0,frac_b} : {1,frac_b} │
│ └─────────────┬───────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────┐ │
│ │ 尾数乘法（24×24） │ │
│ │ product[47:0] = mant_a * mant_b │
│ │ 数值范围: [1.0, 4.0) │ │
│ └─────────────┬───────────────┘ │
└──────────────────────────┼───────────────────────────────┘
│
┌──────────────────────────┼───────────────────────────────┐
│ Stage 3: 规格化与 Guard/Sticky 生成 │
├──────────────────────────┼───────────────────────────────┤
│ ▼ │
│ ┌─────────────────────────────┐ │
│ │ 检查乘积大小 │ │
│ │ if (product[47] == 1) │ │
│ │ → 值 ≥ 2.0，需右移 24 位 │ │
│ │ → exp_adj = exp_sum + 1 │ │
│ │ → Guard = product[23] │ │
│ │ → Sticky = OR(product[22:0]) │
│ │ else if (product[46] == 1) │ │
│ │ → 值 ∈ [1.0, 2.0) │ │
│ │ → 右移 23 位 │ │
│ │ → exp_adj = exp_sum │ │
│ │ → Guard = product[22] │ │
│ │ → Sticky = OR(product[21:0]) │
│ └─────────────┬───────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────┐ │
│ │ 获取右移后尾数 │ │
│ │ mant_shifted[23:0] = │ │
│ │ (shift24)? product[47:24] : product[46:23] │
│ └─────────────┬───────────────┘ │
└──────────────────────────┼───────────────────────────────┘
│
┌──────────────────────────┼───────────────────────────────┐
│ Stage 4: 银行家舍入（Ties-to-Even） │
├──────────────────────────┼───────────────────────────────┤
│ ▼ │
│ ┌─────────────────────────────┐ │
│ │ 舍入决策 │ │
│ │ LSB = mant_shifted[0] │ │
│ │ │ │
│ │ if (Guard == 0) │ │
│ │ → round_up = 0 (不进位) │ │
│ │ else if (Sticky == 1) │ │
│ │ → round_up = 1 (>0.5 进位) │ │
│ │ else // Guard=1, Sticky=0 │ │
│ │ → round_up = LSB (奇进偶不进) │
│ └─────────────┬───────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────┐ │
│ │ 尾数加舍入 │ │
│ │ mant_rounded[24:0] = │ │
│ │ {0, mant_shifted} + round_up │
│ └─────────────┬───────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────┐ │
│ │ 检测舍入溢出 │ │
│ │ if (mant_rounded[24] == 1) │ │
│ │ → 再次规格化 │ │
│ │ → mant_final = mant_rounded[24:1] │
│ │ → exp_final = exp_adj + 1 │ │
│ │ else │ │
│ │ → mant_final = mant_rounded[23:0] │
│ │ → exp_final = exp_adj │ │
│ └─────────────┬───────────────┘ │
└──────────────────────────┼───────────────────────────────┘
│
┌──────────────────────────┼───────────────────────────────┐
│ Stage 5: 溢出/下溢检测与结果打包 │
├──────────────────────────┼───────────────────────────────┤
│ ▼ │
│ ┌─────────────────────────────┐ │
│ │ 边界检测 │ │
│ │ if (exp_final >= 255) │ │
│ │ → overflow = 1 │ │
│ │ → result = {sign, 8'hFF, 23'h0} (±∞) │
│ │ else if (exp_final <= 0) │ │
│ │ → underflow = 1 │ │
│ │ → result = {sign, 8'h00, 23'h0} (±0 或次规范) │
│ │ else │ │
│ │ → 正常结果 │ │
│ └─────────────┬───────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────┐ │
│ │ 结果打包 │ │
│ │ result[31] = sign_result │ │
│ │ result[30:23] = exp_out[7:0] │ │
│ │ result[22:0] = mant_final[22:0] (不含隐含位) │
│ └─────────────┬───────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────┐ │
│ │ 异常标志输出 │ │
│ │ flag_inexact = (Guard || Sticky) │
│ │ flag_overflow = overflow │ │
│ │ flag_underflow = underflow │ │
│ │ flag_invalid = (0×∞ 或 NaN) │
│ └─────────────┬───────────────┘ │
└──────────────────────────┼───────────────────────────────┘
│
▼
输出: result[31:0], flagsSystemC：
cpp
void fp32_multiply::multiply_process() {
// 读取输入
sc_uint<32> a = operand_a.read(); // 0x3FC00000 (1.5)
sc_uint<32> b = operand_b.read(); // 0x40000000 (2.0)
// ────────────────────────────────────────
// Step 1: 提取符号位
// ────────────────────────────────────────
sc_uint<1> sign_a = a[31]; // 0
sc_uint<1> sign_b = b[31]; // 0
sc_uint<1> sign_result = sign_a ^ sign_b; // 0 XOR 0 = 0
// ────────────────────────────────────────
// Step 2: 提取指数
// ────────────────────────────────────────
sc_uint<8> exp_a = a.range(30, 23); // 0x7F = 127
sc_uint<8> exp_b = b.range(30, 23); // 0x80 = 128
sc_uint<9> exp_sum = exp_a + exp_b; // 127 + 128 = 255
sc_uint<9> exp_biased = exp_sum - 127; // 255 - 127 = 128
// ────────────────────────────────────────
// Step 3: 提取尾数并加隐藏位
// ────────────────────────────────────────
sc_uint<23> frac_a = a.range(22, 0); // 0x400000
sc_uint<23> frac_b = b.range(22, 0); // 0x000000
// 加隐藏位 (1.xxxx 格式)
sc_uint<24> mant_a = (sc_uint<1>(1), frac_a); // 0xC00000
sc_uint<24> mant_b = (sc_uint<1>(1), frac_b); // 0x800000
// ────────────────────────────────────────
// Step 4: 24×24 位乘法
// ────────────────────────────────────────
sc_uint<48> product = mant_a * mant_b;
// product = 0xC00000 * 0x800000 = 0x600000000000
// ────────────────────────────────────────
// Step 5: 规格化
// ────────────────────────────────────────
sc_uint<48> normalized;
sc_uint<9> exp_final;
if (product[47] == 1) {
// 乘积在 [2.0, 4.0) 范围,右移 24 位
normalized = product >> 24;
exp_final = exp_biased;
} else if (product[46] == 1) {
// 乘积在 [1.0, 2.0) 范围,右移 23 位
normalized = product >> 23;
exp_final = exp_biased - 1; // 128 - 1 = 127
} else {
// 次规范数或零
normalized = product << 1;
exp_final = exp_biased - 2;
}
// ────────────────────────────────────────
// Step 6: 银行家舍入 (0.6ns)
// ────────────────────────────────────────
sc_uint<24> frac_normalized = normalized.range(46, 23); // 0x400000
//位提取
sc_uint<1> guard = normalized[23]; // 0
sc_uint<1> round = normalized[22]; // 0
sc_uint<1> sticky = (normalized.range(21, 0) != 0); // 0
// 舍入逻辑 (RNE - Round to Nearest, ties to Even)
sc_uint<24> frac_rounded;
bool need_round = false;
if (guard == 0) {
// GRS = 0xx → 向下舍入
need_round = false;
} else if (round == 1 || sticky == 1) {
// GRS = 1(1x or x1) → 向上舍入
need_round = true;
} else {
// GRS = 100 → ties, 看最低位 (银行家舍入)
need_round = (frac_normalized[0] == 1);
}
if (need_round) {
frac_rounded = frac_normalized + 1;
// 检查进位溢出
if (frac_rounded[23] == 1) {
frac_rounded = frac_rounded >> 1;
exp_final = exp_final + 1;
}
} else {
frac_rounded = frac_normalized; // 本例: 0x400000
}
// ────────────────────────────────────────
// Step 7: 打包输出
// ────────────────────────────────────────
sc_uint<32> result_value;
result_value[31] = sign_result; // bit[31] = 0
result_value.range(30, 23) = exp_final.range(7, 0); // bit[30:23] = 0x7F
result_value.range(22, 0) = frac_rounded.range(22, 0); // bit[22:0] = 0x400000
// 写入输出端口
result.write(result_value);
}测试代码：
cpp
int sc_main(int argc, char* argv[]) {
// 声明信号
sc_signal<sc_uint<32>> operand_a;
sc_signal<sc_uint<32>> operand_b;
sc_signal<sc_uint<32>> result;
// 实例化模块
fp32_multiply fp_mul("fp_mul");
fp_mul.operand_a(operand_a);
fp_mul.operand_b(operand_b);
fp_mul.result(result);
// 设置测试输入 (1.5 × 2.0)
operand_a.write(0x3FC00000); // 1.5
operand_b.write(0x40000000); // 2.0
// 触发计算 (组合逻辑立即计算)
sc_start(1, SC_NS);
// 读取结果
uint32_t res = result.read().to_uint();
printf("Result: 0x%08X (expected 0x40400000)\n", res);
// 输出: Result: 0x40400000 (expected 0x40400000)
return 0;
}3. SystemC 信号连接图
main.cpp (testbench)
│
├── clk (sc_clock)
├── rst_n (sc_signal<bool>)
│
▼
riscv_core
│
├── IF/ID 流水线寄存器
│ ├── pc_reg
│ ├── instruction_reg
│ └── ...
│
├── ID/EX 流水线寄存器
│ ├── operand_a_reg
│ ├── operand_b_reg
│ ├── funct3_reg
│ └── ...
│
├── fp32_multiply (EX 阶段实例)
│ ├── clk → 时钟输入
│ ├── rst_n → 复位输入
│ ├── enable → 使能信号
│ ├── operand_a → 来自 ID/EX.operand_a_reg
│ ├── operand_b → 来自 ID/EX.operand_b_reg
│ ├── result → 连接到 EX/MEM.result_reg
│ ├── result_valid → 握手信号
│ └── flag_* → 异常标志
│
├── EX/MEM 流水线寄存器
│ ├── result_reg
│ ├── dest_reg_addr
│ └── ...
│
└── MEM/WB 流水线寄存器
├── result_reg
├── dest_reg_addr
└── write_enable4. 测试用例覆盖矩阵
| 用例编号 | 场景描述 | 输入 A | 输入 B | 预期输出 | 验证点 |
|---|---|---|---|---|---|
| TC01 | 基本乘法 | 1.5 (0x3FC00000) | 1.5 | 2.25 (0x40100000) | 无舍入 |
| TC02 | 零乘法 | 2.0 | 0.0 | 0.0 | 短路路径 |
| TC03 | 无穷大 | 1.5 | +∞ | +∞ | 特殊值传播 |
| TC04 | NaN | NaN | 1.0 | NaN | NaN 传播 |
| TC05 | 无效操作 | 0.0 | ∞ | NaN | invalid flag |
| TC06 | 次规范数 | 2^-130 | 2.0 | 2^-129 | 次规范处理 |
| TC07 | Ties-to-even (偶) | 构造值 | 构造值 | LSB=0 不进位 | 舍入逻辑 |
| TC08 | Ties-to-even (奇) | 构造值 | 构造值 | LSB=1 进位 | 舍入逻辑 |
| TC09 | 溢出 | FLT_MAX | FLT_MAX | +∞ | overflow flag |
| TC10 | 下溢 | 2^-127 | 2^-100 | ≈0 | underflow flag |
建议观察：
operand_a/b与result的对应关系result_valid的时序与流水线延迟- 异常标志
flag_*在特殊用例下的置位
六、 参考资料
IEEE 754 标准与算法
- IEEE 754-2008: IEEE Standard for Floating-Point Arithmetic
- 本项目理论 :
IEEE754_Rounding_Normalization_CN.md - John Hauser, "SoftFloat" 参考实现
SystemC 硬件建模
- IEEE 1666-2011: SystemC Language Reference Manual
- Doulos SystemC : https://www.doulos.com/knowhow/systemc/
- "SystemC: From the Ground Up" (Black & Donovan)
流水线设计
- Hennessy & Patterson, "Computer Architecture" (6th Ed.)
- "Digital Integrated Circuit Design" (Rabaey et al.)
- "Low-Power CMOS Design" (Chandrakasan)
验证方法
- UVM: IEEE 1800.2-2017
- SVA: "SystemVerilog Assertions Handbook"
- GTKWave: VCD 波形查看器
RISC-V 浮点
- RISC-V ISA v2.2: 第 11 章 "F" Extension