1. 为什么我们要亲手造一个CPU如果你和我一样是个对计算机底层充满好奇的“技术宅”那你肯定不止一次想过这个问题我每天用的电脑、手机里面的CPU到底是怎么工作的那些复杂的指令和数据是怎么在指甲盖大小的硅片上跑起来的《计算机组成原理》这门课讲了很多理论但总觉得隔着一层纱看得见摸不着。几年前我刚开始学数字电路和Verilog的时候也有同样的困惑。直到我的导师扔给我一个任务“别光看用Verilog写一个能跑起来的单周期CPU试试。” 当时我头都大了觉得这简直是天方夜谭。但硬着头皮搞了两个月当第一个简单的加法指令在仿真波形里正确执行时那种“我造出了一个大脑”的成就感至今难忘。这不仅仅是完成一个作业而是真正打通了从软件指令到硬件电路的任督二脉。所以这个实战项目就是带你复现我当年的路径。我们不用任何现成的IP核就从最基础的逻辑门和寄存器开始用Verilog HDL这门硬件描述语言一步步搭出一个精简版的MIPS单周期CPU。它可能比不上Intel、AMD的处理器复杂但它具备了CPU最核心的骨架取指令、译码、执行、访存、写回。理解了这个你再去看那些复杂的多级流水线、超标量、乱序执行就有了坚实的立足点。这个项目适合谁呢首先是计算机、电子、自动化等相关专业的学生它能让你把课本上枯燥的“数据通路”、“控制信号”变成看得见、能调试的代码。其次是刚入行的数字IC前端工程师这是一个绝佳的练手项目能帮你建立完整的数字系统设计思维。当然也适合所有有Verilog基础、想挑战一下自己的硬件爱好者。别担心我们会像搭积木一样从最小的模块开始我会把我踩过的坑、调试的技巧都分享出来保证你能跟着做出来。2. 开工前的准备理解单周期CPU的“设计图纸”在动手写代码之前我们得先搞清楚要造个什么东西。单周期CPU顾名思义就是执行任何一条指令都严格占用一个时钟周期。不管这条指令是简单的加法还是需要访问内存的加载指令都在一个周期内完成所有步骤取指令、译码、执行、访存如果需要、写回如果需要。这听起来很理想但也是它最大的特点或者说缺点时钟周期必须按最慢的那条指令来设计比如访存指令所以效率上不是最优。但正是这种简单性让它成为了学习CPU设计的完美起点。我们的CPU将基于经典的MIPS 32位指令集。选择MIPS是因为它的指令格式规整只有R、I、J三种格式寻址方式简单非常利于教学和理解。你可以把它想象成我们CPU能听懂的“语言”。那么CPU的“身体结构”——数据通路长什么样呢我画了一张简化的核心数据通路图你可以把它贴在墙上这是我们整个工程的蓝图[PC寄存器] - (取指令地址) - [指令存储器] - (取回32位指令) | v (PC4计算器) - [下条地址选择器] | | | v | (指令译码与控制单元) | | v v [寄存器堆] ------ (写回数据选择器) | ^ | | v | [操作数选择器A/B] | | | v | [算术逻辑单元ALU] --------- (结果) | | v | [数据存储器] ------------- (存储数据) | | v | [写回数据选择器] ----------数据通路就像CPU的“高速公路网”数据指令、地址、运算数在上面跑。它主要由几个功能部件组成程序计数器PC、指令存储器、寄存器堆、算术逻辑单元ALU、数据存储器以及连接它们的多路选择器和符号扩展器。控制单元则是这条高速公路的“交通指挥中心”。它“解读”每一条取回来的指令主要是操作码Op字段然后生成一系列的控制信号比如ALU做什么运算第二个操作数是来自寄存器还是立即数要不要写寄存器写回的数据是来自ALU还是内存要不要跳转这些控制信号就像红绿灯和路标精确地引导数据在正确的路径上流动。举个例子对于一条add $t0, $t1, $t2指令R型控制单元会解析出这是一条加法指令然后发出信号让寄存器堆读出$t1和$t2的值让ALU执行加法操作让写回选择器选择ALU的结果并允许写回寄存器堆的$t0位置。而对于一条lw $t0, 4($t1)指令I型加载字控制信号就不同了它需要将立即数4符号扩展与$t1的值在ALU中相加得到内存地址然后发出读内存信号最后选择内存读出的数据写回$t0。理解了这个“图纸”和“指挥”的关系我们就能把一个大问题分解成一个个小模块来实现了。3. 核心模块设计与Verilog实现好了理论铺垫完毕我们卷起袖子开始写代码。我会把每个核心模块的设计思路、Verilog实现以及我调试时遇到的“坑”都讲清楚。我们使用自顶向下的设计方法先规划好顶层CPU的接口和结构再逐一实现下层模块。3.1 顶层CPU模块把“积木”拼装起来顶层模块CPU就像我们的总装车间。它不实现具体逻辑只负责实例化所有子模块并按数据通路图把它们正确地连接起来。定义好顶层接口后面的工作就清晰了。module CPU( input wire Clk, // 全局时钟 input wire Reset, // 同步复位高电平有效 // 以下输出信号主要用于仿真调试观察实际芯片可能不会引出这么多 output wire [31:0] Inst, // 当前执行的指令 output wire [31:0] ALU_R, // ALU运算结果 output wire [31:0] Qa, Qb, // 从寄存器堆读出的两个数据 output wire [31:0] Addr, // 当前PC地址 output wire [31:0] D // 写回寄存器堆的数据 ); // 内部连线声明 wire [31:0] PC_Addr, PC_Next, PC_Plus4; wire [31:0] Instruction; wire [31:0] Imm_Extended, Imm_Shifted, Jump_Addr; wire [31:0] RegWriteData, MemReadData, ALU_Result; wire [31:0] ALU_SrcA, ALU_SrcB; wire [4:0] WriteReg; // 要写入的寄存器编号 wire Zero; // ALU结果为零标志 // 控制信号总线 wire RegWrite, MemWrite, ALUSrc, MemtoReg, Branch, Jump, RegDst; wire [1:0] ALUOp; wire [2:0] ALUControl; // 模块实例化开始 // 1. 取指阶段 PC u_PC (.clk(Clk), .reset(Reset), .next_addr(PC_Next), .current_addr(PC_Addr)); Adder u_PCAdder (.a(PC_Addr), .b(32d4), .result(PC_Plus4)); // PC4 InstructionMemory u_IMem (.addr(PC_Addr), .instruction(Instruction)); // 2. 译码阶段 ControlUnit u_Control ( .opcode(Instruction[31:26]), .funct(Instruction[5:0]), .RegWrite(RegWrite), .MemWrite(MemWrite), .ALUSrc(ALUSrc), .MemtoReg(MemtoReg), .RegDst(RegDst), .Branch(Branch), .Jump(Jump), .ALUOp(ALUOp) ); ALUControl u_ALUCtrl ( .ALUOp(ALUOp), .funct(Instruction[5:0]), .ALUControl(ALUControl) ); RegisterFile u_RegFile ( .clk(Clk), .we(RegWrite), .read_addr1(Instruction[25:21]), // rs .read_addr2(Instruction[20:16]), // rt .write_addr(WriteReg), .write_data(RegWriteData), .read_data1(Qa), .read_data2(Qb) ); SignExtend u_SignExt (.imm(Instruction[15:0]), .ext_imm(Imm_Extended)); // 3. 执行阶段 // 选择ALU的第二个操作数来自寄存器还是立即数 assign ALU_SrcA Qa; assign ALU_SrcB ALUSrc ? Imm_Extended : Qb; ALU u_ALU ( .a(ALU_SrcA), .b(ALU_SrcB), .alu_control(ALUControl), .result(ALU_Result), .zero(Zero) ); // 计算分支目标地址 (PC4 (offset2)) ShiftLeft2 u_ShiftImm (.in(Imm_Extended), .out(Imm_Shifted)); Adder u_BranchAdder (.a(PC_Plus4), .b(Imm_Shifted), .result(Branch_Target)); // 4. 访存阶段 DataMemory u_DMem ( .clk(Clk), .we(MemWrite), .addr(ALU_Result), .write_data(Qb), .read_data(MemReadData) ); // 5. 写回阶段 下条PC计算 // 选择写回寄存器的数据来自ALU还是内存 assign RegWriteData MemtoReg ? MemReadData : ALU_Result; // 选择要写入的寄存器编号rt还是rd assign WriteReg RegDst ? Instruction[15:11] : Instruction[20:16]; // 计算下一条PC地址 // 跳转地址拼接 assign Jump_Addr {PC_Plus4[31:28], Instruction[25:0], 2b00}; // 分支判断 wire PCSrc Branch Zero; // 以beq为例bne则为 Branch ~Zero // 四选一选择下条PC Mux4 #(.WIDTH(32)) u_PCMux ( .in0(PC_Plus4), .in1(Branch_Target), .in2(Qa), // 用于jr指令这里简化先接Qa .in3(Jump_Addr), .sel({Jump, PCSrc}), // 选择逻辑需根据指令集精确设计 .out(PC_Next) ); // 将内部信号连接到输出端口便于观察 assign Inst Instruction; assign ALU_R ALU_Result; assign Addr PC_Addr; assign D RegWriteData; endmodule这个顶层模块把数据通路的五个阶段清晰地展现出来。注意看那些wire连线它们就是数据高速公路。ControlUnit和ALUControl产生的控制信号则像开关一样控制着各个多路选择器Mux和功能部件的使能。在写顶层模块时我的经验是先把所有需要的内部连线wire声明好画一张连接图然后再实例化模块这样不容易接错线。3.2 大脑皮层控制单元的设计与实现控制单元是CPU的“大脑皮层”它决定了CPU的“智商”。我们的单周期CPU采用硬连线控制即用组合逻辑直接根据操作码生成控制信号。这种方案速度快但设计好后指令集就固定了。我们需要根据MIPS指令格式为每类指令定义一套控制信号。下面是一个简化的控制信号真值表指令OpcodeRegWriteMemWriteBranchJumpMemtoRegALUSrcRegDstALUOpR-type000000100000110lw100011100011000sw1010110100x1x00beq0001000010x0x01addi001000100001000j0000100001xxxxx注x表示不关心don‘t care。根据这个表我们可以用case语句或if-else链来实现控制单元。我更喜欢用case语句因为它更清晰综合器也容易优化。module ControlUnit ( input wire [5:0] opcode, output reg RegWrite, MemWrite, Branch, Jump, output reg MemtoReg, ALUSrc, RegDst, output reg [1:0] ALUOp ); always (*) begin // 给所有输出一个默认值避免生成锁存器 {RegWrite, MemWrite, Branch, Jump, MemtoReg, ALUSrc, RegDst, ALUOp} 10b0; case (opcode) 6b000000: begin // R-type RegWrite 1b1; RegDst 1b1; ALUOp 2b10; // 告诉ALU控制单元去查funct字段 end 6b100011: begin // lw RegWrite 1b1; MemtoReg 1b1; ALUSrc 1b1; ALUOp 2b00; // 加法 end 6b101011: begin // sw MemWrite 1b1; ALUSrc 1b1; ALUOp 2b00; // 加法 end 6b000100: begin // beq Branch 1b1; ALUOp 2b01; // 减法并检查zero标志 end 6b001000: begin // addi RegWrite 1b1; ALUSrc 1b1; ALUOp 2b00; // 加法 end 6b000010: begin // j Jump 1b1; end default: begin // 遇到未定义指令可以将所有控制信号置零或产生异常 {RegWrite, MemWrite, Branch, Jump, MemtoReg, ALUSrc, RegDst, ALUOp} 10b0; end endcase end endmodule这里有个关键点ALUOp是一个2位的“二级控制”信号。它并不直接告诉ALU做什么而是告诉下一级的ALUControl模块该如何解释funct字段。比如ALUOp2‘b10时ALUControl模块就会去看R型指令的funct字段低6位来决定具体的ALU操作add, sub, and, or等。这种两级译码的结构让控制逻辑更模块化。3.3 运算核心ALU与寄存器堆ALU算术逻辑单元是CPU的“心脏”负责所有计算。我们的ALU需要支持加、减、与、或、小于则置位等基本操作。实现ALU有很多方法可以直接用Verilog的运算符,-,,|等也可以自己用门电路搭。为了学习我们采用前者但会展示其内部选择逻辑。module ALU ( input wire [31:0] a, b, input wire [2:0] alu_control, // 来自ALUControl模块 output reg [31:0] result, output wire zero ); always (*) begin case (alu_control) 3b000: result a b; // AND 3b001: result a | b; // OR 3b010: result a b; // ADD 3b110: result a - b; // SUBTRACT 3b111: result (a b) ? 32d1 : 32d0; // SLT (set less than) default: result 32b0; endcase end // 零标志位当结果为0时置1常用于beq、bne指令判断 assign zero (result 32b0); endmodule而ALUControl模块则根据ALUOp和funct字段生成上述alu_control信号。module ALUControl ( input wire [1:0] ALUOp, input wire [5:0] funct, output reg [2:0] ALUControl ); always (*) begin case (ALUOp) 2b00: ALUControl 3b010; // 对于lw/sw/addi做加法 2b01: ALUControl 3b110; // 对于beq做减法 2b10: begin // R-type看funct case (funct) 6b100000: ALUControl 3b010; // add 6b100010: ALUControl 3b110; // sub 6b100100: ALUControl 3b000; // and 6b100101: ALUControl 3b001; // or 6b101010: ALUControl 3b111; // slt default: ALUControl 3b010; // 默认加法 endcase end default: ALUControl 3b010; endcase end endmodule寄存器堆是CPU的“高速便签本”用来暂存数据。它通常有32个32位寄存器MIPS架构。我们需要支持同时读两个寄存器rs, rt并在时钟上升沿写一个寄存器rd或rt。这里的关键是写操作是时序的需要时钟沿而读操作是组合的地址变化输出立即变化。module RegisterFile ( input wire clk, input wire we, // 写使能 input wire [4:0] read_addr1, read_addr2, // 读地址rs, rt input wire [4:0] write_addr, // 写地址 input wire [31:0] write_data, // 写数据 output wire [31:0] read_data1, read_data2 // 读数据 ); // 32个32位寄存器 reg [31:0] registers [0:31]; // 初始化寄存器0为0其他可以任意仿真时观察用 integer i; initial begin for (i 0; i 32; i i 1) registers[i] 32b0; // MIPS约定$zero寄存器恒为0 // registers[0] 32b0; 初始化已保证 end // 读端口组合逻辑 assign read_data1 (read_addr1 ! 0) ? registers[read_addr1] : 32b0; assign read_data2 (read_addr2 ! 0) ? registers[read_addr2] : 32b0; // 写端口时序逻辑在时钟上升沿且写使能有效时写入 always (posedge clk) begin if (we (write_addr ! 0)) begin // $zero寄存器不可写 registers[write_addr] write_data; end end endmodule这里有个重要的MIPS约定寄存器$zero编号0的值恒为0且不可写。我们在读的时候做了判断如果读地址是0直接返回0在写的时候也判断如果写地址是0则忽略写操作。这是很多初学者容易忽略的细节会导致仿真结果诡异。3.4 记忆单元指令与数据存储器在真实的处理器中指令和数据通常存放在统一的内存中。但为了教学清晰我们采用哈佛结构即指令存储器IMem和数据存储器DMem分开。它们都用Verilog中的reg数组来模拟。指令存储器是只读的ROM在CPU启动时就需要加载好程序。我们可以用$readmemh系统任务从文件加载指令这样测试起来非常方便。module InstructionMemory ( input wire [31:0] addr, output reg [31:0] instruction ); // 假设地址按字节编址但我们的指令是32位4字节对齐的 // 所以实际寻址时addr[31:2]作为索引 reg [31:0] mem [0:1023]; // 深度1K存储1024条指令 initial begin // 初始化所有指令为nop (sll $0, $0, 0) for (integer i0; i1024; ii1) mem[i] 32b0; // 从文件加载程序 $readmemh(program.hex, mem); end always (*) begin instruction mem[addr[31:2]]; // 字寻址 end endmodule数据存储器是可读可写的RAM。它有一个时钟端口写操作在时钟上升沿发生。module DataMemory ( input wire clk, input wire we, input wire [31:0] addr, input wire [31:0] write_data, output reg [31:0] read_data ); reg [31:0] mem [0:1023]; // 深度1K存储1024个字 integer i; initial begin for (i0; i1024; ii1) mem[i] 32b0; end always (*) begin read_data mem[addr[31:2]]; // 组合逻辑读 end always (posedge clk) begin if (we) begin mem[addr[31:2]] write_data; // 时序逻辑写 end end endmodule注意这里读写都是字寻址addr[31:2]忽略了最低两位。这是一个简化模型真实的存储器系统要考虑字节使能、非对齐访问等复杂情况。对于我们的学习目标这个简化模型足够了。4. 集成、测试与波形调试所有模块写完就像造好了汽车的所有零件接下来就是总装和试车。我们需要一个测试平台Testbench来验证CPU的功能。4.1 编写测试程序首先我们需要一个MIPS汇编程序并把它转换成机器码存放到program.hex文件中。我们可以写一个简单的测试程序比如计算斐波那契数列的前几项或者做一些算术逻辑运算。这里用一个更基础的例子测试几条核心指令# program.asm # 假设初始内存和寄存器为0 main: addi $1, $0, 5 # $1 5 addi $2, $0, 3 # $2 3 add $3, $1, $2 # $3 8 (53) sub $4, $1, $2 # $4 2 (5-3) sw $3, 4($0) # mem[4] 8 lw $5, 4($0) # $5 mem[4] 8 beq $5, $3, label # 相等应该跳转 addi $6, $0, 1 # 这条指令应被跳过 label: ori $7, $0, 0x00FF # $7 0x000000FF j end # 无条件跳转 addi $8, $0, 2 # 这条指令应被跳过 end: andi $9, $7, 0x00F0 # $9 0x000000F0你需要一个MIPS汇编器比如Mars或自己写个小脚本把这些汇编指令转换成32位二进制机器码并保存为十六进制文本文件program.hex每行一个32位字。例如addi $1, $0, 5的机器码可能是0x20010005。4.2 搭建Testbench并运行仿真Testbench的主要任务是生成时钟和复位信号实例化我们的CPU并在仿真中观察关键信号的变化。timescale 1ns / 1ps module cpu_tb; reg clk; reg reset; // 连接到CPU的调试输出端口 wire [31:0] inst, alu_result, reg_qb, reg_qa, pc_addr, reg_write_data; // 实例化被测CPU CPU uut ( .Clk(clk), .Reset(reset), .Inst(inst), .ALU_R(alu_result), .Qb(reg_qb), .Qa(reg_qa), .Addr(pc_addr), .D(reg_write_data) ); // 生成时钟周期20ns占空比50% initial begin clk 0; forever #10 clk ~clk; end // 生成复位信号 initial begin reset 1b1; // 开始复位 #5 reset 1b0; // 5ns后释放复位 #500 $finish; // 仿真运行500ns后结束 end // 监控关键信号打印到控制台 always (posedge clk) begin $display(Time%t, PC%h, Inst%h, $time, pc_addr, inst); $display( Reg[$1]%h, Reg[$2]%h, ALU_Result%h, reg_qa, reg_qb, alu_result); end // 将波形保存到VCD文件便于用GTKWave等工具查看 initial begin $dumpfile(cpu_wave.vcd); $dumpvars(0, cpu_tb); // 保存所有层次的信号 end endmodule在仿真工具如ModelSim、Vivado Simulator、iverilogGTKWave中运行这个Testbench。你会看到控制台打印出每个时钟周期PC、指令和各寄存器的值。更重要的是你可以打开生成的cpu_wave.vcd文件用波形查看器直观地观察所有信号的时序关系。4.3 波形调试像侦探一样排查问题第一次仿真几乎肯定会出问题。别慌调试是数字设计工程师的日常。波形图是你最好的朋友。我通常按以下步骤排查检查取指首先看PC和Inst。PC每个周期是否正常4取出的指令机器码和你期望的一致吗如果不一致检查指令存储器的初始化文件和地址计算。检查译码观察控制信号RegWrite,MemWrite,ALUSrc等。对于当前指令这些信号的值符合我们之前列出的真值表吗如果不符合检查ControlUnit和ALUControl模块的逻辑。检查寄存器读看Qa和Qb输出。是不是你期望的寄存器值注意$zero寄存器是否恒为0。检查执行看ALU_Result。ALU的输入a和b对吗alu_control信号对吗计算结果符合预期吗检查访存和写回对于lw/sw看数据存储器的地址和数据。对于需要写回的指令看RegWriteData是否正确以及目标寄存器编号WriteReg是否正确。检查跳转对于beq,j指令看PCSrc和Jump信号以及计算出的Branch_Target和Jump_Addr是否正确。下个周期的PC是否跳转到了正确地址我印象最深的一次调试是一个beq指令死活不跳转。在波形里盯了半天发现是Zero标志位在ALU做减法后没有及时更新我错误地用了非阻塞赋值在组合逻辑的ALU里。改成阻塞赋值后问题立刻解决。这个教训让我牢牢记住了组合逻辑用时序逻辑用的编码规范。5. 从单周期出发思考与优化当你看到测试程序的所有指令都按照预期在波形中正确执行时恭喜你你的第一个CPU诞生了但这只是起点。单周期CPU设计简单但性能瓶颈明显。因为时钟周期由最慢的指令通常是lw因为它要经过取指、译码、执行、访存、写回五个阶段决定导致执行快的指令也在空等。理解了单周期你自然就能想到优化方向流水线这是最经典的优化。把一条指令的执行过程拆分成多个阶段如取指IF、译码ID、执行EX、访存MEM、写回WB让多条指令像工厂流水线一样重叠执行。理想情况下每个时钟周期都能完成一条指令极大提升吞吐率。当然这会带来数据冒险、控制冒险等新问题需要增加转发、停顿、分支预测等机制来解决。增加指令我们的CPU只实现了MIPS指令集的一个子集。你可以尝试加入乘除法指令需要额外的周期或硬件、移位指令、比较指令等让它的功能更强大。性能分析你可以统计一下你的测试程序在单周期CPU上需要多少个时钟周期。然后思考如果引入流水线理想情况下能加速多少倍现实中因为冒险导致的停顿又会损失多少性能这个亲手搭建的单周期CPU就像你计算机体系结构知识大厦的第一块基石。它可能简陋但五脏俱全。以后再学习超标量、乱序执行、多发射这些高级概念时你脑子里会有一个清晰的、可以触摸的参照物。你会明白所有复杂的优化都是为了解决“让指令执行得更快”这个根本问题。最后我建议你把代码放到GitHub上写好详细的注释和README。这不仅是一个学习记录也是你技术 portfolio 里一个亮眼的项目。当你在面试中被问到“CPU是如何工作的”时没有什么比说“我亲手用Verilog实现过一个”更有说服力了。