简介：面向计算机系统结构课程与数字逻辑进阶实践的MIPS五级流水线CPU工程，适合正在做课程设计、FPGA实验或准备体系结构方向面试的学生对照学习。项目以Verilog硬件描述语言实现取指、译码、执行、访存、写回完整五级流水，支持动态流水线调度，并配有指令码与测试数据文件，可用于仿真验证与上板调试。压缩包共154个文件、约756KB，以34个v源文件为核心，辅以coe与mif存储器初始化数据、do与udo仿真脚本、xdc约束、qdb与qpf等Quartus工程配置，以及bat批处理、sh脚本和说明文档，覆盖从编码到综合仿真的完整工程链条。已有65人学习下载。读者可据此理清流水线寄存器划分、数据前递与冲突处理思路，参考测试用例搭建自己的仿真流程，并直接复用工程目录结构与脚本，减少环境配置上的重复摸索。

1. 五级流水线不是画张图就完事：先想清楚哪条指令会撞上哪条

用 Verilog 写一个 MIPS 指令集的五级流水线 CPU，是计算机系统结构课设里最经典、也最容易做到一半就开始怀疑人生的题目。取指、译码、执行、访存、写回五段一画，看着跟课本插图一样干净；真正动手才发现，干净的是图，脏的是时序——上一条lw的数据还在存储器里没出来，下一条add就已经伸手去要了。

这里说的“动态流水线”，指的是流水线在运行时根据指令间的真实相关性动态决定转发、停顿和冲刷，而不是每类指令都固定占用同样数量的周期。判断依据来自硬件实时比对的寄存器编号，不是编译器提前排好的静态调度。这也意味着：能跑通一条add不算本事，能跑通一段带 load-use、带分支回跳、带$0写回的循环，才算把设计立住。下面按“骨架—冒险—冲刷—排查—验收”的顺序，把这条路走一遍，新手能跟着敲，熟手能对参数。

2. 从单周期到五段流水：段间寄存器里到底该装什么

单周期 CPU 做对了，转流水线时最容易犯的错不是逻辑写错，而是“信息没带够”。单周期里所有信号都在同一拍内可见，你想什么时候用就什么时候用；流水线里指令每走一级，上一级的东西就没了，只有你主动存进段间寄存器的字段才活得下去。所以第一个要解决的问题不是 ALU 怎么算，而是每一级到底要把哪些东西打包传给下一级。

2.1 五段流水线里，哪一级该保存什么：段间寄存器字段清单

判断标准只有一条：这条指令在后续任何一级还会用到的信息，都必须在当前这级结束时锁进段间寄存器。译码出来的控制信号尤其容易被漏掉——很多初次实现会把控制单元的输出直接连到 EX 段，结果发现 EX 段手里根本没有当前指令的 opcode，因为 IF/ID 里早换成下一条了。

表里最值得多说一句的是“目标寄存器号”。它有三种来源：R 型指令取rd，lw/addi这类取rt，jal取$31。常见做法是在 ID 段就把这三选一定下来，作为一个独立字段一路传到 MEM/WB，而不是等到写回段再回头看指令字——那时候指令字早就不在流水线里了。这个字段同时也是冒险检测和转发单元比较的对象，早定下来能让后面两个单元的逻辑干净很多。

另一个容易被忽略的细节是“气泡”怎么造。当流水线需要停顿一拍时，我们不是把某级清空，而是往 ID/EX 里写一组控制信号全为 0 的无效指令。这条无效指令会正常流过 EX、MEM、WB 三级，因为regwrite=0、memwrite=0，它什么副作用都不产生。控制信号全零这件事必须写死在复位和冲刷逻辑里，不能只清数据字段，否则气泡流过 MEM 段时可能莫名产生一次写存储器。

2.2 用 Verilog 搭出 PC 与 IF/ID 的最小可仿真骨架

整条流水线里，IF 段是唯一一个“必须知道全局什么时候停、什么时候跳”的段。把它单独拆成一个模块，先跑通波形，再接后面的译码和执行，调试成本会低很多。下面这段只包含 PC、指令存储器、IF/ID 段间寄存器三个部件，但已经把stall、flush、redirect三个控制口的语义定死了。

`timescale 1ns/1ps // IF 段 + IF/ID 段间寄存器：可脱离其他四级单独仿真 module stage_if ( input wire clk, input wire rst_n, // 低有效异步复位 input wire stall_if, // 冒险检测拉高：冻结 PC 与 IF/ID input wire flush_if, // 分支/跳转拉高：丢弃已取错的指令 input wire redirect_en, // 与 flush_if 配合，选择新的 PC 来源 input wire [31:0] pc_redirect, // 分支目标或跳转目标 output wire [31:0] if_id_pc4, output wire [31:0] if_id_instr, output wire [31:0] pc_out ); reg [31:0] pc; wire [31:0] pc_plus4 = pc + 32'd4; wire [31:0] instr; // 指令存储器：256 条指令，按字寻址，因此丢掉地址低 2 位 imem u_imem (.addr(pc[9:2]), .inst(instr)); reg [31:0] r_pc4, r_instr; always @(posedge clk or negedge rst_n) begin if (!rst_n) begin pc <= 32'h0000_0000; r_pc4 <= 32'd0; r_instr <= 32'd0; end else if (flush_if) begin // 冲刷优先级最高：被冲掉的指令绝不能进 ID 段 r_pc4 <= 32'd0; r_instr <= 32'd0; // 全零字即 sll $0,$0,0，等价 nop pc <= redirect_en ? pc_redirect : pc_plus4; end else if (!stall_if) begin r_pc4 <= pc_plus4; r_instr <= instr; pc <= redirect_en ? pc_redirect : pc_plus4; end // stall_if 有效时 pc、r_pc4、r_instr 全部保持，等效于把 IF 段整体冻住 end assign if_id_pc4 = r_pc4; assign if_id_instr = r_instr; assign pc_out = pc; endmodule

这段代码里最关键的不是那几行赋值，而是三个条件的先后顺序。flush_if必须排在stall_if前面：如果同一拍既要停又要冲，说明前面发生了分支跳转，而分支指令已经在执行段，此时停是停不住的，必须让 PC 立刻跳到目标地址，同时把取错的那条清掉。这个优先级写反了，现象是循环体第一次跳转总是少执行一条，波形上看起来像是“偶尔抽风”，实际上是每轮都错，只是前几轮刚好没触发。

参数上有两个约定要提前定。rst_n用异步复位更贴近课程里常见的写法，但如果后面要上板，建议改成“异步复位、同步释放”，避免复位撤销时刻正好卡在时钟沿附近导致段间寄存器进入亚稳态。指令存储器地址取pc[9:2]，意味着存储深度是 256 字，这个值要和你$readmemh加载的程序长度对得上，程序超过 256 条指令会被静默截断，仿真时表现为“跑到一半突然开始执行 nop”，很难第一眼看出来。

2.3 寄存器堆的读写时序：WB 和 ID 撞在同一拍怎么办

流水线正确性里最隐蔽的一类错误，出在寄存器堆的读写冲突上。写回段（WB）在时钟上升沿把结果写进寄存器堆，而译码段（ID）在同一拍读寄存器堆拿操作数。如果写和读指向同一个寄存器，读出来的是新值还是旧值？答案取决于你怎么写这段代码，而两种写法带来的整条流水线行为完全不同。

课本上常提“前半拍写、后半拍读”，落到 Verilog 里就是让写发生在negedge、读是组合逻辑。但更多人会用posedge写，这时候组合读逻辑拿到的必然是写之前的旧值——然后你就会发现add $1,$2,$3紧跟add $4,$1,$1时，后者拿到的是$1的旧值，而转发单元因为$1已经过了 MEM/WB 段，救不了它。这个坑的后悔药是在寄存器堆内部做一次转发：

module regfile ( input wire clk, input wire we, input wire [4:0] waddr, input wire [31:0] wdata, input wire [4:0] raddr1, raddr2, output wire [31:0] rdata1, rdata2 ); reg [31:0] regs [0:31]; integer i; initial for (i = 0; i < 32; i = i + 1) regs[i] = 32'd0; // 必须初始化，否则波形开头全是 X // 同拍写读命中检测：$0 永远不参与 wire hit1 = we && (waddr != 5'd0) && (waddr == raddr1); wire hit2 = we && (waddr != 5'd0) && (waddr == raddr2); // 读口：$0 硬连 0；命中同拍写则直接旁路写数据 assign rdata1 = (raddr1 == 5'd0) ? 32'd0 : hit1 ? wdata : regs[raddr1]; assign rdata2 = (raddr2 == 5'd0) ? 32'd0 : hit2 ? wdata : regs[raddr2]; // 写口：$0 不可写，这是 MIPS 的硬约定 always @(posedge clk) if (we && waddr != 5'd0) regs[waddr] <= wdata; endmodule

hit1/hit2这两个旁路条件看起来只是省了一次冒险检测，实际上它把“WB 与 ID 同拍”这个特例从冒险单元里彻底摘出去了，冒险单元就只需要关心 EX 段和 MEM 段，逻辑量和出错面都小一圈。raddr == 5'd0的三目判断也不能省：$0在 MIPS 里恒为 0，一旦被sw、addi $0,...之类的指令意外写入，整个程序会以极难定位的方式崩掉——所有依赖$0的nop、jr $ra都会跟着错。

注意：initial块初始化在多数综合工具里不被支持，只适合仿真。上板版本要改成复位时用计数器逐拍清零，或者干脆不依赖初值、在 testbench 里先把 32 个寄存器扫一遍写零。

3. 数据冒险的两种解法：转发通路怎么连，load-use 为什么要停

数据冒险是五级流水线里唯一躲不掉、又必须做对的部分。核心问题只有一句话：指令在 EX 段要用的操作数，可能还在前面某条指令的肚子里没算完。解决办法无非两种——要么把还没写回的结果提前“偷”过来用（转发），要么让当前指令在流水线里等一拍（停顿）。转发能解决大约八成的 RAW 冒险，剩下两成必须靠停顿，其中最典型的就是 load-use。

3.1 转发通路的两条回灌路径与优先级

转发单元本质上是一个多路选择器的控制逻辑，它盯着 EX 段当前指令的两个源寄存器编号，去和后面两级的目标寄存器编号比对。命中就改选择器，让 ALU 的输入不来自寄存器堆，而来自 EX/MEM 或 MEM/WB 段间寄存器里已经算好的值。

两条回灌路径的时机不同。EX/MEM 这条路径送回来的是上一条指令的 ALU 结果，它在上一拍刚算完，此时正好赶上当前指令要进 ALU；MEM/WB 这条路径送回来的是上上条指令的最终写回值，可能是 ALU 结果，也可能是存储器读出的数据。两条路径同时命中同一个寄存器时，必须选 EX/MEM——因为它对应的是更晚、更新的那次写入。这个优先级写反了，波形上表现为某些add链式运算的结果比预期小了一个值，而且只在特定指令间隔下出现，非常像玄学。

还有一条容易被漏掉的规则：目标寄存器是$0时不能转发。$0恒为 0，如果addi $0,$0,5这类指令被当成正常写回，转发单元会把 5 送进下一条指令，整条链就歪了。所以两个命中判断里都要加rd != 5'd0这个前提。

3.2 load-use 为什么必须停一拍，而 ALU 连 ALU 不用停

要理解 load-use 为什么特殊，得看数据在时间轴上的位置。add指令的结果在 EX 段末尾就出现在 EX/MEM 段间寄存器的 ALU 结果字段里，此时下一条指令正好进 EX，转发完全来得及。但lw的数据在 EX 段结束时根本还没拿到——EX 段只是算出了地址，真正的存储器访问发生在 MEM 段，数据要到 MEM 段末尾才写进 MEM/WB 段间寄存器。

也就是说，lw后面紧跟一条要用它结果的指令时，那条指令进 EX 的那一刻，数据还在存储器里飘着。这时候不管转发哪条路径都拿不到值。唯一的办法是让流水线停一拍：PC 保持、IF/ID 保持（不让新指令进来），同时往 ID/EX 里塞一个气泡，让后面那条指令推迟一拍到 EX 段。等它真正进 EX 时，lw已经把数据放进 MEM/WB 了，走 MEM/WB 转发路径正好。

这里有个判断细节很多人写错：不是“ID/EX 里是lw就停”，而是“ID/EX 里是lw且当前 IF/ID 里的指令真的把lw的目标寄存器当源操作数读”。addi $1,$2,10只读 rs 不读 rt，lui两者都不读，这些都不需要停。如果不加这个区分，流水线会多停很多拍，功能是对的，但 CPI 会明显偏高，报告中一算加速比就露馅了。

3.3 转发单元与冒险检测单元的 Verilog 实现

两个单元都是纯组合逻辑，加起来不到五十行，但它们是整条流水线里最需要逐条对着波形核的地方。下面这份实现把优先级、$0保护和“该不该停”的判断都写进去了。

module forward_unit ( input wire [4:0] ex_rs, ex_rt, // EX 段当前指令的两个源寄存器 input wire [4:0] mem_rd, wb_rd, // EX/MEM、MEM/WB 的目标寄存器 input wire mem_regwrite, input wire mem_memread, // 关键：判断 EX/MEM 里是不是 load input wire wb_regwrite, output reg [1:0] fwd_a, fwd_b // 00=寄存器堆 10=EX/MEM 01=MEM/WB ); always @(*) begin // rs 口：EX/MEM 优先于 MEM/WB；load 的 ALU 结果是地址，不能转发 if (mem_regwrite && !mem_memread && (mem_rd != 5'd0) && (mem_rd == ex_rs)) fwd_a = 2'b10; else if (wb_regwrite && (wb_rd != 5'd0) && (wb_rd == ex_rs)) fwd_a = 2'b01; else fwd_a = 2'b00; // rt 口：判定规则完全相同，只是比较对象换成 ex_rt if (mem_regwrite && !mem_memread && (mem_rd != 5'd0) && (mem_rd == ex_rt)) fwd_b = 2'b10; else if (wb_regwrite && (wb_rd != 5'd0) && (wb_rd == ex_rt)) fwd_b = 2'b01; else fwd_b = 2'b00; end endmodule module hazard_unit ( input wire [5:0] if_id_opcode, input wire [4:0] if_id_rs, if_id_rt, // ID 段指令的源寄存器 input wire [4:0] id_ex_rt, // ID/EX 的目标寄存器（load 用 rt） input wire id_ex_memread, // ID/EX 是不是 lw output wire stall_if, stall_id, flush_id_ex ); // IF/ID 里的指令是否真的把 rt 当源操作数读 wire id_uses_rt = (if_id_opcode == 6'b000000) // R 型 | (if_id_opcode == 6'b101011) // sw：rt 是被存的数据 | (if_id_opcode == 6'b000100) // beq | (if_id_opcode == 6'b000101); // bne // addi / lw / lui 只用 rs 和立即数，不需要为 rt 停顿 assign stall_if = id_ex_memread && id_uses_rt && ((id_ex_rt == if_id_rs) || (id_ex_rt == if_id_rt)); assign stall_id = stall_if; assign flush_id_ex = stall_if; // 往 EX 段插一个气泡，让后一条指令推迟一拍 endmodule

mem_memread这个信号是整个转发单元里最容易被忽略的一根线。少了它，lw后面跟一条用同一寄存器的指令时，转发单元会热情地把 ALU 算出来的地址当成数据转发出去，结果是个看起来“有值但完全不对”的数——比如访问数组时总是拿到下标而不是元素。这种错误不会让程序崩，只会让结果偏移，排查起来非常费时间。

id_uses_rt的判定也需要克制。严格来说，sw的 rt 是源操作数、beq/bne的 rt 也是源操作数，都要算进去；而lw、addi、lui的 rt 是目标寄存器，不需要停。如果你图省事直接写成“只要id_ex_memread且寄存器号命中就停”，功能不会错，但每个lw后面不管跟什么都会多停一拍，跑一段循环下来 CPI 明显偏高，答辩时被问“你的流水线理想 CPI 是 1，实测多少”就不好答了。

4. 控制冒险：分支在哪一段解析，决定你要冲刷几条指令

控制冒险的本质是“取指的时候还不知道该不该跳”。五级流水线里，PC 每拍都在往前推，等分支指令走到能判定跳不跳的那一级时，后面已经有好几条指令被取进来、甚至已经译码完了。这些指令如果本来不该执行，就必须在它们产生副作用之前清掉——这就是冲刷（flush）。

4.1 分支在 EX 段解析，代价是两条指令的冲刷

最直观的做法是把比较器放在 ALU 里，让分支指令走到 EX 段才判定。这样做的好处是复用 ALU 的减法器，beq/bne的比较和普通 R 型指令的运算共用一套硬件，控制单元也简单；代价是分支判定出来的时候，IF 段和 ID 段里已经各有一条指令了。

这两条指令必须全部清掉。ID 段那条刚从 IF/ID 寄存器里出来，还没读寄存器堆、没产生任何写信号，清掉它只需要把 ID/EX 的控制信号置零；IF 段那条更早，直接让 IF/ID 寄存器写入一个全零字就行。同时 PC 要立刻改成分支目标地址，而目标地址是 EX 段刚算出来的——pc+4加上左移两位的立即数。所以 EX 段除了常规 ALU 结果，还要额外算一条pc+4+(imm<<2)的通路，这条通路只给分支用。

算一下代价：每次分支跳转成功，流水线浪费两个周期。一段执行一千次循环的程序，如果循环体里有两条分支，光冲刷就吃掉四千个周期。这个数字在写报告时是要算清楚的，也是后面引出静态预测的动机。

4.2 静态预测与延迟槽：两种省事但代价不同的取舍

静态预测的思路很朴素：既然分支跳不跳不知道，那就先猜一个方向，猜对了不花钱，猜错了再冲刷。猜“不跳”是最省硬件的选择，因为猜不跳意味着 PC 照常加 4，取指逻辑一行都不用改，只有分支真的跳转时才触发冲刷。对于for循环这种“跳很多次、只不跳一次”的结构，猜不跳的准确率很难看；但对顺序执行的代码，它就是免费的正确。

延迟槽是另一种思路：干脆承认分支后面那一拍取指是白费的，规定这条指令无论如何都执行，把“浪费”变成“约定”。编译器（或者手写汇编的人）可以把一条有用的指令挪到延迟槽里，也可以塞一条nop。从硬件角度看，实现延迟槽反而更省事：分支判定时，ID 段里那条指令正是延迟槽，必须让它继续走下去，只需要冲掉 IF 段刚取的那一条，比不带延迟槽的方案少冲一级。

两种方案在课设里都常见，选哪个要看你的验证成本。静态预测对汇编程序完全透明，写测试程序时不用考虑指令排布；延迟槽要求你写的每一条分支后面都跟一条能安全执行的指令，一旦漏了，现象是分支目标地址莫名其妙偏了一条指令的位置。我个人一般倾向于在课设里做静态预测 + 不跳转猜测，因为测试程序可以直接用现成的汇编例子，不用逐条检查延迟槽。

4.3 冲刷信号的 Verilog 写法与它的作用范围

冲刷逻辑最容易出的错不是条件写错，而是冲错了对象。要冲的是“已经取进来但不该执行的指令所在的段间寄存器”，不是当前正在执行的指令。这个区别在分支和跳转两种情况下还不一样。

// 分支在 EX 段解析：beq 取 zero，bne 取 !zero wire ex_is_branch = id_ex_branch; wire ex_take = ex_is_branch & (id_ex_branch_ne ? ~alu_zero : alu_zero); // 跳转在 ID 段解析：j / jal 的 opcode 直接可见 wire id_is_jump = (if_id_instr[31:26] == 6'b000010) || (if_id_instr[31:26] == 6'b000011); // 分支跳转：EX 段是分支，ID 和 IF 里的两条都作废 // 跳转在 ID 解析：只有 IF 里那一条作废，ID 段自己就是跳转指令 assign flush_if_id = ex_take | id_is_jump; assign flush_id_ex = ex_take; // 重定向目标二选一：分支目标是 EX 算的，跳转目标是 ID 拼的 assign redirect_en = ex_take | id_is_jump; assign pc_redirect = ex_take ? ex_branch_target : {if_id_pc4[31:28], if_id_instr[25:0], 2'b00};

flush_id_ex只在分支跳转时拉高，因为跳转指令在 ID 段解析时，ID/EX 里放的还是上一条指令，不该被冲。这个不对称是很多人第一版必踩的地方：把flush_id_ex也接到id_is_jump上，结果每次j跳转都会把前一条指令的执行结果吞掉，表现为“跳转前的那次加法没生效”。

pc_redirect的拼接也值得看一眼：j的目标地址是{pc+4[31:28], instr[25:0], 2'b00}，高 4 位取自当前pc+4，不是取自pc。这个细节在程序地址超过 256MB 时才看得出来，课设里通常碰不到，但写对了不费事，写错了将来上板跑大程序会是个很难查的问题。

还有一个必须处理的优先级冲突：如果同一拍既要冲刷又要停顿，冲刷赢。因为停顿的语义是“等前面那条指令出结果”，而冲刷的语义是“前面那条指令已经判定跳转了，后面全作废”。两者同时发生时，唯一正确的行为是执行冲刷并保持stall信号无效，否则 PC 会被冻在错误路径上，跳转永远不生效。

5. 避坑与排查：五个让波形对不上的高频故障

流水线设计的调试时间和代码量严重不成比例。真正卡住人的往往不是“不会写”，而是“写完了波形不对，但看不出哪不对”。下面这五条是我在几轮迭代里反复撞过的，每一条都给出从现象到原因再到解决的完整链路，照着对照波形基本能定位。

5.1 复位与初始化：波形开头就飘 X 的三个来源

现象一：仿真第 0 到第 3 拍，EX 段的 ALU 输入是红色的 X，之后突然恢复正常。原因是有段间寄存器没进复位分支——常见于后来新增的字段，比如给分支加的branch_ne标志，或者给jal加的链接地址寄存器。没复位的 reg 初值是 X，X 会顺着组合逻辑一路传播，直到被某条指令的有效值覆盖。解决方式是把所有段间寄存器统一写在一个always块里，用if (!rst_n)一次性赋初值，而不是分散在多个模块各写各的。字段一多就容易漏，集中写至少能一眼扫完。

现象二：程序跑到某个位置开始执行全零指令，PC 却还在正常递增。原因是指令存储器深度不够，程序超出 256 字后被截断，读出全零。全零字在 MIPS 里恰好是sll $0,$0,0，一条合法的 nop，所以流水线不报错，只是什么都不做。解决方式是仿真时在 testbench 里断言pc < 程序长度*4，越界立刻$display报错，别等结果比对时才发现。

现象三：寄存器堆里的$0读出来不是 0。原因是$0的保护写在了写口，但读口没做硬连 0。写口挡住了写入，读口却老老实实读regs[0]，而regs[0]的初值在部分仿真器里是 X。解决办法是在读口加(raddr == 5'd0) ? 32'd0 : ...的三目，这一行比在写口做保护更彻底，因为它同时挡住了未初始化的情况。

5.2 转发与停顿：差一拍就全错的两个判定

现象四：一串连续的add依赖运算，中间夹一条lw后，lw之后第一条指令拿到的值总是上一次循环的旧值。原因是转发单元的mem_memread判断漏了，把lw的 ALU 结果（地址）当成数据转发出去；或者更隐蔽的一种，lw的停顿逻辑生效了，但停顿期间 ID/EX 没有正确插入气泡，导致后一条指令实际上还是按时进了 EX。区分这两种情况看波形很快：如果 EX 段 ALU 输入的那个值是地址，是前一种；如果后一条指令进 EX 的时刻没有推迟一拍，是后一种。解决办法分别是补上!mem_memread条件和确认stall时id_ex的控制字段被清零。

现象五：sw指令写进存储器的数据总是少一次或者多一次。这种情况八成出在EX/MEM段间寄存器的 rt 值上。sw要写的数据来自 rt，而 rt 的值必须在 ID 段读出来、经 ID/EX 传到 EX/MEM，不能在 MEM 段现读寄存器堆——那时候寄存器堆的读地址早就换成别的指令了。如果你的实现里sw偶尔写对偶尔写错，检查一下 rt 是不是被某个转发逻辑改写了：sw的 rt 是源操作数，虽然不需要转发，但它和 R 型指令共用同一套选择器，选择器条件写宽了就会误伤。

还有一条不算故障但很影响效率的问题：stall信号拉高期间，IF/ID 必须保持，否则被停住的那条指令会在下一拍消失，流水线里凭空多出一个气泡，功能可能还对，但 CPI 会莫名偏高。查这个的办法是在 testbench 里统计stall拉高的周期数和实际执行的指令数，两个数一对就能算出真实的停顿开销。

6. 让设计敢交付：随机指令流比对与覆盖率验收

手写几条汇编跑对了，只说明流水线在你能想到的指令组合上是对的。真正让设计站得住的是随机指令流比对：让脚本生成几百条合法指令，用软件模型算出每条指令执行完之后的 32 个寄存器值，再和 Verilog 仿真跑完的结果逐字比对。这个方法的成本不高，但它能把“转发优先级写反”“$0被写”“load-use 少停一拍”这类只在特定指令间隔下出现的问题一次性暴露出来。

6.1 用 Python 生成随机程序并算出黄金寄存器值

脚本只要覆盖指令子集，不用全指令集。生成时保证每个寄存器在使用前被写过一次，避免读到未定义初值；同时按顺序模拟执行，把每条指令的结果累加进一个 32 元素的数组。

import random random.seed(20240501) REGS = [0] * 32 # 黄金参考模型 prog = [] for _ in range(300): op = random.choice(["add", "sub", "and", "or", "lw", "sw", "beq"]) if op in ("add", "sub", "and", "or"): rd, rs, rt = (random.randrange(1, 32) for _ in range(3)) a, b = REGS[rs], REGS[rt] REGS[rd] = {"add": a + b, "sub": a - b, "and": a & b, "or": a | b}[op] & 0xFFFFFFFF prog.append(f"{op} ${rd},${rs},${rt}") elif op == "lw": # 数据存储器单独建模，地址按字对齐 rt, rs = random.randrange(1, 32), random.randrange(0, 32) base = random.randrange(0, 64) * 4 REGS[rt] = DMEM[(REGS[rs] + base) >> 2] prog.append(f"lw ${rt},{base}(${rs})") # sw / beq 略：前者不改寄存器，后者需要维护分支历史 print("\n".join(prog)) print("EXPECT:", " ".join(f"{v:08x}" for v in REGS))

生成出来的程序通过$readmemh加载进指令存储器，跑完之后在 testbench 里把 32 个寄存器 dump 成一行十六进制，和EXPECT那行逐字比对。这一步的关键是两边必须用同一套溢出和符号规则：Python 里& 0xFFFFFFFF是必须的，sub出现负数时也要按补码截断，否则比对会因为高位不同而误报。

6.2 覆盖率清单：哪些指令组合必须打到

随机流能覆盖大部分情况，但有些组合出现概率低，必须定点补测。我一般会单独准备一张小表，每一条都对应一个已经踩过的坑：

最后说个我自己的习惯：每改一次冒险或冲刷逻辑，先把这张表里的五条重跑一遍，再跑随机流。随机流适合发现“没想到的问题”，定点表适合确认“刚改的地方没改坏”，两者顺序反了，你会在几百条随机指令的波形里反复溺水。

这套东西做完，五级流水线的正确性基本可以交差。血泪经验是：不要指望靠读代码找出时序错误，能靠波形定位的问题就别靠推理。希望帮到你。

本文还有配套的精品资源，点击获取