第 8 章　CPU 内部原理

8.1CPU 的零件清单

把 CPU 拆开，核心零件就这几样，它们都是前几章搭过的东西：

这些零件被 数据通路（datapath）串起来：数据在寄存器、ALU、存储器之间流动，而控制器负责指挥每一拍谁干什么。

深一层：位宽——零件的「口径」有多大？

看懂零件清单后，还有一个决定 CPU 能力的硬指标：位宽（word size），即数据通路一次能搬运、ALU 一次能加工的二进制位数。常见的「32 位 CPU」「64 位 CPU」说的就是它。可以把数据通路想象成一条传送带：32 位就是传送带每一格放 32 个 0/1，寄存器是格子的暂存箱，ALU 是加工机，三者口径必须一致——寄存器存 32 位、ALU 算 32 位、总线传 32 位，任何一处窄了都会成为瓶颈。

位宽为什么重要？因为它一次限定了 CPU 能直接「一口吞下」的整数上限与内存地址范围。32 位 CPU 的寄存器只有 32 位，直接表示的无符号整数最大是 2³²−1，寻址空间最多 2³² 字节 = 4 GB——这就是当年 32 位机器装再多内存也只认得出 4 GB 的原因：地址这串「数字」写不下更大的数。64 位寄存器把上限抬到 2⁶⁴ 字节，足够装下今天任何一台机器的内存。

顺带把 ALU 的「出身」说透：它就是第 5 章全加器的直系后代。一个一位全加器进位串联 32 个，就是 32 位加法器；再加一组与门、或门、非门完成逻辑运算，配一个多路选择器按指令挑出「这次要加法还是与运算」的输出——ALU 就齐了。真实的工程改进在于速度：行波进位加法器要等进位像多米诺一样逐位传过去（32 位要串 32 级门延迟），高频 CPU 用超前进位等结构，让高位进位「提前算出来」，把加法压进一个时钟周期。你看，从第 3 章一个晶体管、到第 4 章一个门、到第 5 章一个加法器、再到本章一个 ALU——每一章都是下一章的零件，这正是「计算机没有魔法」的最好注脚。

这张表是理解后续三章（内存、存储、cache）的地图：越往下越慢、越便宜、越大。每一层的存在，都是为了用便宜弥补上一层的贵，用大容量弥补上一层的小——而这个金字塔能够流畅运转，靠的是下一章要讲的「局部性原理」。

8.2程序计数器：指向下一条指令

程序是一串存放在内存里的指令。CPU 怎么知道「现在该执行哪一条」？答案是一个特殊的寄存器——程序计数器（Program Counter，简称 PC）。

PC 里存的不是数据，而是一个内存地址——指向「下一条要执行的指令」所在的位置。它的工作逻辑极简单：

1. CPU 按 PC 里存的地址，去内存取出那条指令。
2. 取出后，PC 自动加 1（指向下一条）。
3. 如果遇到「跳转」指令，PC 就被强行改写成跳转目标地址，于是程序「拐弯」了。

深一层：PC 加的「1」，到底是什么？

「PC 自动加 1」这句口诀里藏着一个容易被忽略的问题：加的 1 是一个字节，还是一条指令？答案取决于指令集的设定。在定长指令集里，每条指令占的字节数固定（例如经典嵌入式指令集每条固定 4 字节），那么 PC 的新值就是「PC + 4」——注意是 4 个字节地址，而不是 4 条指令。而在变长指令集（如 x86）里，指令短则 1 字节、长则 15 字节，PC 该前进多少要等译码器量出当前指令的实际长度才知道。所以严格地说，「加 1」应读作「前进到下一条指令的起始地址」，定长指令集里这个增量恰好是个常数。

顺着这个思路能看到一个漂亮的硬件结构：PC 的新值有两个候选来源——顺序执行时来自「PC + 固定增量」的小加法器，跳转时来自指令里写明的目标地址（或目标地址的计算电路）。两者之间接一个多路选择器（第 5 章学过的部件）：没有跳转就选前者，译码发现是跳转指令就选后者。所谓「程序拐弯」，在硬件上不过是选择器换了条通路。你看，前面五章搭的积木——加法器、多路选择器、触发器——在这只「手指」上全都用上了。

还有一个初学者常问的问题：刚上电时 PC 是多少？程序还没跑，谁给 PC 第一个值？答案在芯片设计时就定了：复位电路会把 PC 强制置为一个固定初值（例如全零或地址空间的最高处）。于是上电瞬间 CPU 就「天然知道」该去哪里取第一条指令——那里通常放着一小段开机引导程序，它的任务是把真正的系统软件从外存搬进内存，然后把控制权交出去。这个「上电 → 引导 → 加载系统」的链条，第 10 章讲外存时还会再见到它。

8.3指令周期：取指→译码→执行→写回

CPU 执行每一条指令，都固定地重复一个四步循环，叫 指令周期（instruction cycle）。理解了它，就理解了 CPU 的「一生」。

四步分别做什么：

• 取指（Fetch）：控制器按 PC 的地址，从内存把指令取出来，放进指令寄存器 IR，同时 PC +1。
• 译码（Decode）：控制器「读懂」这条指令——它是什么操作、要用哪几个寄存器。
• 执行（Execute）：控制器发出信号，让 ALU 或数据通路真正完成这个操作（加、减、读内存……）。
• 写回（Write back）：把运算结果写回某个寄存器（或内存）。

然后回到第一步，处理下一条。CPU 每秒要跑这个循环几十亿次。

四步不只是名词，让我们把一条指令的完整旅程逐拍拆开看。设程序里有一条加法指令 ADD R1, R2, R3（含义：R1 ← R2 + R3，当前 R2 = 12、R3 = 8），指令本身存放在内存地址 0x100，每条指令 4 字节。若 CPU 采用「每步一拍」的五级流水线，这条指令的前半生如下表——注意 PC 的变化与 IR 的交接：

这张表有三处值得多看一眼：其一，PC 与 IR 是并行的两条线——PC 在拍 1 就指向了下一条，IR 管的是本条，互不干扰；其二，拍 4 的「空过」揭示了 CPI 因指令而异的根源：加法不必访存，访存指令不必计算，各自吃拍不同；其三，指令的「可见效果」（R1 变成 20）直到拍 5 才落定——此前 R1 还是旧值，这正是流水线数据冒险的温床（8.5 节会算这笔账）。

还有一个「隐形第五步」值得知道：中断检查。CPU 在每条指令周期的边界上，都会瞥一眼「有没有更紧急的事」——外部设备发来的请求（比如传感器数据就绪）、计时器到点、电源异常告警。若有，CPU 就在完成当前指令后保存 PC、把 PC 改写为一段中断服务程序的入口，先去处理急事，回来再恢复现场接着跑。飞机上分布着大量需要「及时应答」的设备，航电计算机的运转节奏正是「指令周期为主干、中断处理为旁支」交织而成——理解指令周期，才能理解中断为何只能在指令与指令的间隙插入，而不是打断一条指令的半截。

深一层：每一步占多少「拍」？——CPI 的由来

四步说起来整齐，但每一步占多少个时钟周期，不同 CPU 设计差别很大。最朴素的单周期设计：一个时钟周期干完一整条指令（四步压缩为一拍）——听起来爽快，但周期必须迁就最慢的那类指令，快的指令也被拖着白白等，就像全班统一按最慢同学的速度跑步。改进的多周期设计：把四步拆成几拍，一拍干一步，周期可以做得短。到了现代主流的流水线设计，四步各占一拍、四条指令错开跑（8.5 节）。可见「四步」是逻辑上的骨架，「几拍」是物理上的节奏，两者不必一一对应。

于是需要一把统一的尺子，衡量平均每条指令吃掉几个时钟周期——这就是 CPI（Clock cycles Per Instruction，每条指令时钟周期数）。有了它，程序执行时间可以一次算清：

这个公式值得盯着看一分钟，它是整章的「计算总纲」：想让程序更快，只有三条路——① 减少指令条数（换更好的算法、让编译器生成更精简的代码）；② 降低 CPI（改进微架构，比如流水线、更聪明的电路）；③ 提高频率（受 8.4 节那两堵墙的限制）。三条路互相牵制：有的设计 CPI 低但每拍做得多、频率上不去；有的频率高但每条指令要拍数多。所以比较两颗 CPU 绝不能只看频率，三个因子乘起来才是真相。

8.4时钟频率：快慢的物理限制

上一章说，时钟是 CPU 的心跳。每个时钟周期，CPU 推进指令周期的一步。所谓 时钟频率（clock frequency），就是这个心跳每秒跳多少次，单位是赫兹（Hz）。

• 1 Hz = 每秒 1 次；1 MHz = 每秒 100 万次；1 GHz = 每秒 10 亿次。
• 一颗「3.5 GHz」的 CPU，每秒心跳 35 亿次。

频率越高，CPU 越快——但不能无限提升，物理上有两道墙：

1. 传播延迟：电信号在芯片里从一处传到另一处需要时间。一个时钟周期必须长到足以让信号稳稳地走完该走的路。频率提太高，周期太短，信号还没到位就「变拍」了，电路就会算错。
2. 发热：晶体管每开关一次都消耗一点能量、发出一点热。频率越高，开关越频繁，芯片越烫。热散不掉，芯片就烧坏。

深一层：一个「心跳」究竟有多短？

频率与周期互为倒数，f = 1/T。把常见频率换算成周期，能建立精确的数量级直觉：

那么这「心跳」最初从哪来？答案是主板上一枚不起眼的石英晶体振荡器（晶振）。石英晶体有个奇特的物理性质——压电效应：给它加电压它就形变，形变后又反过来生电，接上电路便稳定振荡。石英振荡的频率几乎不随温度漂移，精度可达百万分之一量级，远胜任何电阻电容拼凑的振荡电路。但晶振直接震出来的频率通常只有几十 MHz，远低于 CPU 主频——CPU 内部再用一个锁相环（PLL）电路把它「倍频」上去：例如基准 100 MHz 倍频 35 倍得 3.5 GHz。这也解释了为什么「超频」常常从换晶振、调 PLL 倍率下手：心跳的源头与分频倍率，都在这条链上。

「发热」这堵墙也有公式可依。晶体管开关一次，本质是对一小段导线电容充放电，每次耗能约为 E = ½CV²（C 是等效电容，V 是电压）；每秒开关 f 次、活动比例 α，得动态功耗 P ≈ αCV²f。注意 V 带着平方：电压降到 0.7 倍，功耗几乎减半。这解释了两件行业大事——为什么每一代新工艺都拼命降电压，以及为什么频率翻一倍功耗也几乎翻一倍、散热系统迟早吃不消。2000 年代中期以后，单核频率停在 3～4 GHz 附近不再狂飙，厂商转向「一芯片塞多核」，正是撞上这堵功耗墙后的集体转向。

8.5流水线：让指令「排队」并行

既然频率提不动，能不能让同一时刻多做几件事？这就引出了 流水线（pipeline）技术。

回忆指令周期的四步：取指、译码、执行、写回。如果不做流水线，CPU 是一条指令完整做完四步，才开始下一条——每一步时，其他硬件大多闲着。这就像洗车，一辆车要冲完、擦干、打蜡全做完才放下一辆进站，工位大部分时间空着。

流水线的想法是：把四步拆成四个「工位」，让多条指令同时在不同工位推进。当第 1 条指令在执行时，第 2 条已经在译码，第 3 条正在取指，第 4 条排队等候……

流水线的效果是显著的：理想情况下，吞吐量（每秒完成的指令数）能提升接近「级数」倍。但它也有代价——如果一条指令的下一步依赖上一条的结果（这叫 数据冒险），就得停下来等，流水线会「断流」；跳转指令也会打乱排队（控制冒险）。现代 CPU 用「乱序执行」「分支预测」等技巧来缓解，但底层思想始终是这条流水线。

深一层：流水线靠什么「记住进度」？

四条指令同时推进，谁来保证它们不互相踩脚？答案是每两级之间的一排 流水线寄存器（pipeline register）：每拍结束时，各级把自己的中间成果（指令码、操作数、计算结果……）锁进这排触发器，下一拍再由下一级取走。这正是第 6 章 D 触发器的大规模列队应用——流水线的本质，是「用一排排触发器把时间切成段」。级分得越多，每级干的活越薄，拍子就可以越短、频率就越高；代价是寄存器更多、前后依赖更碎、断流损失更大。没有免费的午餐，只有精算后的折中。

这里必须澄清一个高频误区：流水线并没有让「单独一条指令」变快。一条指令该走四步还是四步，五级流水线甚至因为每级多了锁存动作而略慢一点。流水线提升的是吞吐率（单位时间出口的指令条数），不是单条延迟（一条指令从头到尾的时间）。回到洗车类比：单车洗完的时间一点没缩短，但每小时洗完的车数翻了接近四倍。日常说「CPU 更快了」，绝大多数场景关心的正是吞吐率——批量任务源源不断，出口才重要。

把这两点写成公式：设流水线有 k 级、每级 1 拍、共执行 n 条指令。不做流水线：一条占 k 拍，共 nk 拍。做流水线：第一条指令独走全程要 k 拍，此后每拍「出货」一条，再出 n−1 条——总拍数 = k + (n−1)。于是理想加速比：

注意两条指令会碰车的情形，统称「冒险」（hazard，直译「危险」）。原文已点了数据冒险与控制冒险，这里补全三兄弟并说明工程对策：

• 结构冒险：两条指令在同一拍想用同一件硬件。典型如「这条要取指令、那条要取数据，都涌向同一块内存」。对策：把指令与数据分开存取（指令缓存/数据缓存分设，正是第 7 章哈佛结构的现实回声）、把部件加多份。硬件冲突，用硬件解决。
• 数据冒险：后一条指令要用前一条还没写回的结果——上一步的答数还在流水线里没落账，下一步就伸手要。两条对策：停顿（等一拍，把流水线「气泡」塞进去，简单但费吞吐）与转发（结果算出来的一瞬间，直接从中间级抄近道递给需要它的级，不必等写回，又叫前递 forwarding）。
• 控制冒险：跳转指令「拍板」之前，后面已经按顺序取进流水线的指令属于「押错宝」。对策：分支预测（赌它跳还是不跳，赌对零代价、赌错冲刷重来）与延迟槽等技巧。预测器如今准确率可达 95% 以上——这是一场用统计规律与硬件胆量换速度的豪赌。

硬件设旁路之外，软件也在帮流水线「排雷」：编译器知道哪两条指令前后依赖，指令调度会故意在依赖指令之间插进几条无关指令垫背，把停顿的空拍填满——在不改变程序语义的前提下重排顺序，是编译器与 CPU 微架构多年养成的默契。软硬协同，正体现在这些看不见的细节里。

n = 1000            # 指令条数
k = 5               # 流水级数
stall_data = n * 0.20 * 1   # 20% 的指令因数据冒险各停 1 拍
flush_branch = n * 0.10 * 3 # 10% 的跳转预测失败各冲刷 3 拍
serial = n * k              # 不用流水线：每条 5 拍
pipe = k + (n - 1) + stall_data + flush_branch
print("串行总拍数:", serial)      # 5000
print("流水总拍数:", pipe)        # 1504.0
print("实际加速比:", round(serial / pipe, 2))  # 3.32

三兄弟之外，再补一句现代 CPU 的进阶棋：既然指令 B 在等指令 A 的结果，那排在后面的无关指令 C、D 何不先跑？——这正是乱序执行（out-of-order execution）的思路。CPU 在译码后把指令拆成一队「待办」，谁的操作数齐了就先放行谁，只在最终写回时按程序原本的顺序交账，保证结果与老老实实排队完全一致。可以把硬件想象成一位手快的厨房主管：炖汤的锅在慢熬（等结果的指令），他绝不让整个后厨干等，而是先把凉菜、摆盘这些不依赖炖汤的活干完。代价是控制逻辑的复杂度飙升——现代主流 CPU 的晶体管相当大一部分都花在这类「调度智慧」上，但换来的，就是你在跑大型软件时感受到的行云流水。