计算机组成原理白中英怎么学：从入门到精通的底层逻辑
看了一堆视频，背了不少公式，一到真题还是懵？这是很多自学者在啃《计算机组成原理》（白中英版）时的共同噩梦。
你以为你在学计算机，其实你只是在背“死知识”。
真正的入门到精通，不是记住“ALU是什么”，而是理解数据在硬件里是怎么流动的。
今天不聊虚的，直接拆解这门课的“源码级”核心逻辑。
入口定位：别把书当圣经，把它当地图
白中英老师的这本教材，在国内高校里地位很高。但很多学生一上来就死磕第一章的数制转换，觉得那是基础。
错了。
对于想真正搞懂计算机的人，指令系统才是入口。
为什么？
因为指令是软件和硬件的接口。你写的每一行 C 代码，最终都要翻译成 CPU 能听懂的指令。
如果你不理解指令怎么被取出来、怎么被解析、怎么被执行，那你永远只是会做题，不会“造轮子”。
在准备考试或者做项目时，你要建立这样的认知链条：程序（软件层）：你写的 main 函数。
指令（接口层）：CPU 识别的二进制码。
微操作（硬件层）：数据在寄存器、ALU、内存之间的搬运。白中英的书里，关于指令周期的描述，就是这条链的核心。
很多教程只告诉你“指令执行分取指、译码、执行、写回”，但没告诉你为什么要这么分。
这就是痛点。
核心片段：指令周期的“伪代码”解剖
为了讲清楚，我们不看具体的汇编代码，而是看一个通用的指令执行微操作序列。
这段逻辑在《计算机组成原理》中对应着 CPU 的数据通路控制。我们可以用 Python 风格的伪代码来模拟这个过程，帮助你看懂硬件内部的“黑盒”。
假设我们要执行一条简单的加法指令：ADD R1, R2, R3（即 R1 = R2 + R3）。
# 模拟 CPU 执行一条加法指令的微操作流程
# 对应白中英教材中关于“单总线结构”或“多总线结构”的控制信号逻辑class CPU_Simulator:def __init__(self):self.PC = 0 # 程序计数器，指向下一条指令self.IR = 0 # 指令寄存器，存放当前正在执行的指令self.MAR = 0 # 内存地址寄存器self.MDR = 0 # 内存数据寄存器self.REG = {i: 0 for i in range(32)} # 通用寄存器组 R0-R31self.ALU_Result = 0 # ALU 运算结果暂存区def fetch_instruction(self):取指阶段 (Fetch)核心逻辑：PC - MAR - Memory - MDR - IR同时 PC 自增，准备下一条指令# 1. 将 PC 的内容送到 MAR# 硬件动作：PC 输出信号接到 MAR 输入端self.MAR = self.PC# 2. 启动内存读取 (Read)# 硬件动作：控制信号 MEM_R = 1# 模拟内存返回数据到 MDR# 假设内存中 PC 地址处存放的是指令代码 0x1002self.MDR = self.memory_read(self.MAR) # 3. 将 MDR 的内容送到 IR# 硬件动作：MDR 输出信号接到 IR 输入端self.IR = self.MDR# 4. PC 自增 (PC + 1)# 硬件动作：ALU 执行 PC + 1 操作，结果写回 PCself.PC = self.PC + 1return self.IRdef decode_instruction(self):译码阶段 (Decode)核心逻辑：IR - 控制器 (CU)CU 分析指令字段，生成控制信号# 1. 分离操作码 (Opcode) 和 操作数 (Operand)# 假设指令格式：[Opcode: 6 bits] [Rd: 5 bits] [Rs1: 5 bits] [Rs2: 5 bits]opcode = (self.IR 26) 0x3Frd = (self.IR 21) 0x1Frs1 = (self.IR 16) 0x1Frs2 = (self.IR 11) 0x1F# 2. 生成控制信号# 这里模拟控制单元(CU)的判断逻辑# 如果是 ADD 指令 (假设 opcode == 0x0B)if opcode == 0x0B:# 需要读取 Rs1 和 Rs2 的值self.REG_A = self.REG[rs1]self.REG_B = self.REG[rs2]self.Destination_Reg = rdreturn EXECUTE_ADDelse:return UNKNOWNdef execute_operation(self, signal):执行阶段 (Execute)核心逻辑：REG_A, REG_B - ALU - ALU_Resultif signal == EXECUTE_ADD:# 硬件动作：ALU 执行加法运算# 控制信号 ALU_OP = ADDself.ALU_Result = self.REG_A + self.REG_Bdef write_back(self):写回阶段 (Write Back)核心逻辑：ALU_Result - REG[Destination]# 硬件动作：将结果写入目标寄存器self.REG[self.Destination_Reg] = self.ALU_Resultdef run(self, instruction_code):# 模拟内存中只有一条指令self.memory_read_mock = lambda addr: instruction_code# 1. 取指self.fetch_instruction()# 2. 译码sig = self.decode_instruction()# 3. 执行self.execute_operation(sig)# 4. 写回self.write_back()return self.REG# 测试：执行 R0 = R1 + R2
# 假设 R1=10, R2=20
# 指令编码：Opcode(0x0B) Rd(0) Rs1(1) Rs2(2)
cpu = CPU_Simulator()
cpu.REG[1] = 10
cpu.REG[2] = 20# 构造指令：0x0B 00000 00001 00010 ...
# 简化为整数模拟
instr = (0x0B 26) | (0 21) | (1 16) | (2 11)result = cpu.run(instr)
print(fR0 的值是: {result.REG[0]}) # 输出: 30逐行解析这段“源码”背后的硬件真相：self.MAR = self.PC：这行代码对应硬件中的地址总线。CPU 把要取指令的地址发给内存。
self.MDR = self.memory_read(self.MAR)：对应数据总线。内存把取到的指令数据送回 CPU 的临时缓冲区（MDR）。
self.IR = self.MDR：指令进入指令寄存器。CPU 接下来要“读懂”它。
opcode = (self.IR 26) 0x3F：这是译码器的工作。通过移位和掩码，把指令拆成操作码和操作数。
self.ALU_Result = self.REG_A + self.REG_B：这是**运算器（ALU）**的核心任务。它只负责算，不负责存。
self.REG[self.Destination_Reg] = self.ALU_Result：结果写回寄存器堆。关键点：
很多初学者觉得“加法”很简单，但在硬件层面，这是一次多阶段的状态机迁移。
每一个箭头（-）都代表一根数据通路，每一个判断（if）都代表一个组合逻辑电路。
白中英教材里那张经典的“CPU 数据通路图”，其实就是在画这段伪代码的运行轨迹。
设计思想：为什么要分这四个阶段？
你可能会问：CPU 为什么不直接一口气把事做完？为什么要分取指、译码、执行、写回？
这涉及到计算机设计的核心权衡：速度 vs 复杂度。
1. 流水线的基础
如果 CPU 是一个大黑盒，一条指令要 100 个时钟周期才能算完，那效率极低。
但如果你把它拆成 4 个小阶段，每个阶段 25 个周期。
虽然单条指令还是 100 个周期，但第二条指令可以在第一条指令执行的同时开始取指。
这就是流水线（Pipeline）。
白中英书中对流水线的讲解，前提就是你必须深刻理解这四个阶段的边界。
2. 控制信号的精简
如果不分阶段，控制单元需要同时控制取指、运算、写回的所有开关，逻辑极其复杂，容易出错。
分阶段后，每个阶段只需要关注局部的控制信号。
取指阶段：只管 PC 和 MAR。
执行阶段：只管 ALU 和寄存器读端口。
这种模块化设计，是硬件工程师的圣经。
3. 寄存器堆的读写冲突
注意上面的代码，我们在 decode 阶段读取了 REG_A 和 REG_B，在 write_back 阶段写入 REG[Destination]。
如果在同一周期内，一条指令要读寄存器，另一条指令要写同一个寄存器，怎么办？
这就是著名的数据冒险（Data Hazard）。
在简单的 CPU 设计中，我们会插入气泡（Stall），让流水线停顿一个周期，等待数据准备好。
在更高级的设计中（如乱序执行），会有更复杂的机制，但根源都在于寄存器是共享资源。
理解这一点，你就理解了为什么“写回”是一个独立的阶段，而不是和执行混在一起。
手写简化版：用 Python 模拟单周期 CPU
为了让你彻底搞懂，我们写一个更简化的版本，模拟单周期 CPU。
单周期 CPU 的特点是：一条指令在一个时钟周期内完成所有阶段。
这意味着，时钟周期必须足够长，能容纳下最慢的路径（通常是内存访问）。
class SingleCycleCPU:def __init__(self):self.PC = 0self.MEM = {} # 模拟内存self.REG = [0] * 32def set_memory(self, addr, val):self.MEM[addr] = valdef execute(self):# 1. 取指 (PC - MEM - IR)# 注意：单周期中，这一步和后面的步骤是并行的，但逻辑上我们先取ir = self.MEM.get(self.PC, 0)# 2. 译码 (并行于取指，但在逻辑上依赖 IR)# 解析指令opcode = (ir 26) 0x3Frd = (ir 21) 0x1Frs1 = (ir 16) 0x1Frs2 = (ir 11) 0x1F# 3. 执行 (ALU 运算)# 假设只支持 ADD 指令if opcode == 0x0B: # ADDalu_result = self.REG[rs1] + self.REG[rs2]elif opcode == 0x0A: # LUI (Load Upper Immediate)alu_result = (ir 0x03FFFF) 16else:alu_result = 0# 4. 访存/写回 (Memory Read/Write or Register Write)# 如果是 ADD，直接写回寄存器if opcode == 0x0B:self.REG[rd] = alu_result# 5. PC 更新self.PC += 4 # 假设每条指令 4 字节return self.REG# 测试
cpu = SingleCycleCPU()
cpu.REG[1] = 5
cpu.REG[2] = 10# 设置指令：ADD R0, R1, R2
# Opcode 0x0B, Rd 0, Rs1 1, Rs2 2
instr = (0x0B 26) | (0 21) | (1 16) | (2 11)
cpu.set_memory(0, instr)cpu.execute()
print(fR0 = {cpu.REG[0]}) # 输出: 15对比多周期和单周期：特性
单周期 CPU
多周期 CPU (流水线基础)时钟周期
很长 (需覆盖最慢路径)
很短 (仅覆盖最快路径)控制复杂度
简单 (组合逻辑)
复杂 (时序逻辑/状态机)面积
大 (需要全速 ALU 和内存)
小 (可复用部件)适用场景
教学、验证
实际商用 CPU白中英教材中，通常会先讲单周期，因为它直观；再讲多周期，因为它高效。
你在学习时，要明白：单周期是“慢但简单”，多周期是“快但复杂”。
应用场景：从考试到项目
回到开头的问题：看了一堆教程还是不会写项目。
现在你知道了，“写项目”在计算机底层，就是构建数据通路和控制逻辑。
1. 嵌入式开发
如果你做嵌入式（如 STM32、RISC-V），你需要理解寄存器映射。
当你修改一个 GPIO 寄存器时，你实际上是在执行一条写指令。
你理解指令周期，就能明白为什么有时候读取寄存器需要等待（因为总线仲裁），为什么有时候需要双缓冲（因为流水线冲突）。
2. 编译器优化
如果你写编译器，你需要知道 CPU 的流水线深度。
如果你生成的代码中有依赖链（如 a = b + c; d = a + e;），你就无法利用流水线的并行性。
理解指令周期，你就能写出更友好的汇编代码，减少流水线停顿。
3. 性能分析
当你发现程序变慢时，不要只怪“代码写得烂”。
去查处理器手册（Developer Documentation），看看你的指令在流水线中是否产生了Cache Miss 或 Branch Misprediction。
例如，Intel 的开发者文档会详细列出每条指令的 Latency（延迟）和 Throughput（吞吐）。
这些数据，都是基于指令周期的微操作统计出来的。
避坑指南不要死记硬背指令格式：要理解每个字段的作用。操作码告诉 CPU“做什么”，地址字段告诉 CPU“对谁做”。
关注数据通路：画图！画数据从哪里来，到哪里去。白中英书里的图，要自己手画一遍，标上箭头。
区分“逻辑”与“物理”：逻辑上，加法是一步；物理上，加法可能需要几十个门电路的延迟。总结：
计算机组成原理不是玄学，它是电子学的工程化表达。
白中英的书是地图，指令周期是导航仪，数据通路是道路。
你要做的，不是背地图，而是开车上路。
当你能用 Python 模拟出一个单周期 CPU，并解释清楚每一个信号的变化时，你就真正入门了。
当你能分析一条指令在流水线中的延迟，并优化它时，你就开始精通了。
还有什么不懂的？评论区留言挨个回 计算机组成原理白中英怎么学：从入门到精通的底层逻辑
计算机组成原理白中英怎么学：从入门到精通的底层逻辑
看了一堆视频，背了不少公式，一到真题还是懵？这是很多自学者在啃《计算机组成原理》（白中英版）时的共同噩梦。
你以为你在学计算机，其实你只是在背“死知识”。
真正的入门到精通，不是记住“ALU是什么”，而是理解数据在硬件里是怎么流动的。
今天不聊虚的，直接拆解这门课的“源码级”核心逻辑。
入口定位：别把书当圣经，把它当地图
白中英老师的这本教材，在国内高校里地位很高。但很多学生一上来就死磕第一章的数制转换，觉得那是基础。
错了。
对于想真正搞懂计算机的人，指令系统才是入口。
为什么？
因为指令是软件和硬件的接口。你写的每一行 C 代码，最终都要翻译成 CPU 能听懂的指令。
如果你不理解指令怎么被取出来、怎么被解析、怎么被执行，那你永远只是会做题，不会“造轮子”。
在准备考试或者做项目时，你要建立这样的认知链条：程序（软件层）：你写的 main 函数。
指令（接口层）：CPU 识别的二进制码。
微操作（硬件层）：数据在寄存器、ALU、内存之间的搬运。白中英的书里，关于指令周期的描述，就是这条链的核心。
很多教程只告诉你“指令执行分取指、译码、执行、写回”，但没告诉你为什么要这么分。
这就是痛点。
核心片段：指令周期的“伪代码”解剖
为了讲清楚，我们不看具体的汇编代码，而是看一个通用的指令执行微操作序列。
这段逻辑在《计算机组成原理》中对应着 CPU 的数据通路控制。我们可以用 Python 风格的伪代码来模拟这个过程，帮助你看懂硬件内部的“黑盒”。
假设我们要执行一条简单的加法指令：ADD R1, R2, R3（即 R1 = R2 + R3）。
# 模拟 CPU 执行一条加法指令的微操作流程
# 对应白中英教材中关于“单总线结构”或“多总线结构”的控制信号逻辑class CPU_Simulator:def __init__(self):self.PC = 0 # 程序计数器，指向下一条指令self.IR = 0 # 指令寄存器，存放当前正在执行的指令self.MAR = 0 # 内存地址寄存器self.MDR = 0 # 内存数据寄存器self.REG = {i: 0 for i in range(32)} # 通用寄存器组 R0-R31self.ALU_Result = 0 # ALU 运算结果暂存区def fetch_instruction(self):取指阶段 (Fetch)核心逻辑：PC - MAR - Memory - MDR - IR同时 PC 自增，准备下一条指令# 1. 将 PC 的内容送到 MAR# 硬件动作：PC 输出信号接到 MAR 输入端self.MAR = self.PC# 2. 启动内存读取 (Read)# 硬件动作：控制信号 MEM_R = 1# 模拟内存返回数据到 MDR# 假设内存中 PC 地址处存放的是指令代码 0x1002self.MDR = self.memory_read(self.MAR) # 3. 将 MDR 的内容送到 IR# 硬件动作：MDR 输出信号接到 IR 输入端self.IR = self.MDR# 4. PC 自增 (PC + 1)# 硬件动作：ALU 执行 PC + 1 操作，结果写回 PCself.PC = self.PC + 1return self.IRdef decode_instruction(self):译码阶段 (Decode)核心逻辑：IR - 控制器 (CU)CU 分析指令字段，生成控制信号# 1. 分离操作码 (Opcode) 和 操作数 (Operand)# 假设指令格式：[Opcode: 6 bits] [Rd: 5 bits] [Rs1: 5 bits] [Rs2: 5 bits]opcode = (self.IR 26) 0x3Frd = (self.IR 21) 0x1Frs1 = (self.IR 16) 0x1Frs2 = (self.IR 11) 0x1F# 2. 生成控制信号# 这里模拟控制单元(CU)的判断逻辑# 如果是 ADD 指令 (假设 opcode == 0x0B)if opcode == 0x0B:# 需要读取 Rs1 和 Rs2 的值self.REG_A = self.REG[rs1]self.REG_B = self.REG[rs2]self.Destination_Reg = rdreturn EXECUTE_ADDelse:return UNKNOWNdef execute_operation(self, signal):执行阶段 (Execute)核心逻辑：REG_A, REG_B - ALU - ALU_Resultif signal == EXECUTE_ADD:# 硬件动作：ALU 执行加法运算# 控制信号 ALU_OP = ADDself.ALU_Result = self.REG_A + self.REG_Bdef write_back(self):写回阶段 (Write Back)核心逻辑：ALU_Result - REG[Destination]# 硬件动作：将结果写入目标寄存器self.REG[self.Destination_Reg] = self.ALU_Resultdef run(self, instruction_code):# 模拟内存中只有一条指令self.memory_read_mock = lambda addr: instruction_code# 1. 取指self.fetch_instruction()# 2. 译码sig = self.decode_instruction()# 3. 执行self.execute_operation(sig)# 4. 写回self.write_back()return self.REG# 测试：执行 R0 = R1 + R2
# 假设 R1=10, R2=20
# 指令编码：Opcode(0x0B) Rd(0) Rs1(1) Rs2(2)
cpu = CPU_Simulator()
cpu.REG[1] = 10
cpu.REG[2] = 20# 构造指令：0x0B 00000 00001 00010 ...
# 简化为整数模拟
instr = (0x0B 26) | (0 21) | (1 16) | (2 11)result = cpu.run(instr)
print(fR0 的值是: {result.REG[0]}) # 输出: 30逐行解析这段“源码”背后的硬件真相：self.MAR = self.PC：这行代码对应硬件中的地址总线。CPU 把要取指令的地址发给内存。
self.MDR = self.memory_read(self.MAR)：对应数据总线。内存把取到的指令数据送回 CPU 的临时缓冲区（MDR）。
self.IR = self.MDR：指令进入指令寄存器。CPU 接下来要“读懂”它。
opcode = (self.IR 26) 0x3F：这是译码器的工作。通过移位和掩码，把指令拆成操作码和操作数。
self.ALU_Result = self.REG_A + self.REG_B：这是**运算器（ALU）**的核心任务。它只负责算，不负责存。
self.REG[self.Destination_Reg] = self.ALU_Result：结果写回寄存器堆。关键点：
很多初学者觉得“加法”很简单，但在硬件层面，这是一次多阶段的状态机迁移。
每一个箭头（-）都代表一根数据通路，每一个判断（if）都代表一个组合逻辑电路。
白中英教材里那张经典的“CPU 数据通路图”，其实就是在画这段伪代码的运行轨迹。
设计思想：为什么要分这四个阶段？
你可能会问：CPU 为什么不直接一口气把事做完？为什么要分取指、译码、执行、写回？
这涉及到计算机设计的核心权衡：速度 vs 复杂度。
1. 流水线的基础
如果 CPU 是一个大黑盒，一条指令要 100 个时钟周期才能算完，那效率极低。
但如果你把它拆成 4 个小阶段，每个阶段 25 个周期。
虽然单条指令还是 100 个周期，但第二条指令可以在第一条指令执行的同时开始取指。
这就是流水线（Pipeline）。
白中英书中对流水线的讲解，前提就是你必须深刻理解这四个阶段的边界。
2. 控制信号的精简
如果不分阶段，控制单元需要同时控制取指、运算、写回的所有开关，逻辑极其复杂，容易出错。
分阶段后，每个阶段只需要关注局部的控制信号。
取指阶段：只管 PC 和 MAR。
执行阶段：只管 ALU 和寄存器读端口。
这种模块化设计，是硬件工程师的圣经。
3. 寄存器堆的读写冲突
注意上面的代码，我们在 decode 阶段读取了 REG_A 和 REG_B，在 write_back 阶段写入 REG[Destination]。
如果在同一周期内，一条指令要读寄存器，另一条指令要写同一个寄存器，怎么办？
这就是著名的数据冒险（Data Hazard）。
在简单的 CPU 设计中，我们会插入气泡（Stall），让流水线停顿一个周期，等待数据准备好。
在更高级的设计中（如乱序执行），会有更复杂的机制，但根源都在于寄存器是共享资源。
理解这一点，你就理解了为什么“写回”是一个独立的阶段，而不是和执行混在一起。
手写简化版：用 Python 模拟单周期 CPU
为了让你彻底搞懂，我们写一个更简化的版本，模拟单周期 CPU。
单周期 CPU 的特点是：一条指令在一个时钟周期内完成所有阶段。
这意味着，时钟周期必须足够长，能容纳下最慢的路径（通常是内存访问）。
class SingleCycleCPU:def __init__(self):self.PC = 0self.MEM = {} # 模拟内存self.REG = [0] * 32def set_memory(self, addr, val):self.MEM[addr] = valdef execute(self):# 1. 取指 (PC - MEM - IR)# 注意：单周期中，这一步和后面的步骤是并行的，但逻辑上我们先取ir = self.MEM.get(self.PC, 0)# 2. 译码 (并行于取指，但在逻辑上依赖 IR)# 解析指令opcode = (ir 26) 0x3Frd = (ir 21) 0x1Frs1 = (ir 16) 0x1Frs2 = (ir 11) 0x1F# 3. 执行 (ALU 运算)# 假设只支持 ADD 指令if opcode == 0x0B: # ADDalu_result = self.REG[rs1] + self.REG[rs2]elif opcode == 0x0A: # LUI (Load Upper Immediate)alu_result = (ir 0x03FFFF) 16else:alu_result = 0# 4. 访存/写回 (Memory Read/Write or Register Write)# 如果是 ADD，直接写回寄存器if opcode == 0x0B:self.REG[rd] = alu_result# 5. PC 更新self.PC += 4 # 假设每条指令 4 字节return self.REG# 测试
cpu = SingleCycleCPU()
cpu.REG[1] = 5
cpu.REG[2] = 10# 设置指令：ADD R0, R1, R2
# Opcode 0x0B, Rd 0, Rs1 1, Rs2 2
instr = (0x0B 26) | (0 21) | (1 16) | (2 11)
cpu.set_memory(0, instr)cpu.execute()
print(fR0 = {cpu.REG[0]}) # 输出: 15对比多周期和单周期：特性
单周期 CPU
多周期 CPU (流水线基础)时钟周期
很长 (需覆盖最慢路径)
很短 (仅覆盖最快路径)控制复杂度
简单 (组合逻辑)
复杂 (时序逻辑/状态机)面积
大 (需要全速 ALU 和内存)
小 (可复用部件)适用场景
教学、验证
实际商用 CPU白中英教材中，通常会先讲单周期，因为它直观；再讲多周期，因为它高效。
你在学习时，要明白：单周期是“慢但简单”，多周期是“快但复杂”。
应用场景：从考试到项目
回到开头的问题：看了一堆教程还是不会写项目。
现在你知道了，“写项目”在计算机底层，就是构建数据通路和控制逻辑。
1. 嵌入式开发
如果你做嵌入式（如 STM32、RISC-V），你需要理解寄存器映射。
当你修改一个 GPIO 寄存器时，你实际上是在执行一条写指令。
你理解指令周期，就能明白为什么有时候读取寄存器需要等待（因为总线仲裁），为什么有时候需要双缓冲（因为流水线冲突）。
2. 编译器优化
如果你写编译器，你需要知道 CPU 的流水线深度。
如果你生成的代码中有依赖链（如 a = b + c; d = a + e;），你就无法利用流水线的并行性。
理解指令周期，你就能写出更友好的汇编代码，减少流水线停顿。
3. 性能分析
当你发现程序变慢时，不要只怪“代码写得烂”。
去查处理器手册（Developer Documentation），看看你的指令在流水线中是否产生了Cache Miss 或 Branch Misprediction。
例如，Intel 的开发者文档会详细列出每条指令的 Latency（延迟）和 Throughput（吞吐）。
这些数据，都是基于指令周期的微操作统计出来的。
避坑指南不要死记硬背指令格式：要理解每个字段的作用。操作码告诉 CPU“做什么”，地址字段告诉 CPU“对谁做”。
关注数据通路：画图！画数据从哪里来，到哪里去。白中英书里的图，要自己手画一遍，标上箭头。
区分“逻辑”与“物理”：逻辑上，加法是一步；物理上，加法可能需要几十个门电路的延迟。总结：
计算机组成原理不是玄学，它是电子学的工程化表达。
白中英的书是地图，指令周期是导航仪，数据通路是道路。
你要做的，不是背地图，而是开车上路。
当你能用 Python 模拟出一个单周期 CPU，并解释清楚每一个信号的变化时，你就真正入门了。
当你能分析一条指令在流水线中的延迟，并优化它时，你就开始精通了。
还有什么不懂的？评论区留言挨个回