计算机是怎么长出来的
总目录/ 第 1 部/ 1.3 CPU/ 1.3.2

1.3.2 取指、译码、执行、写回:一辈子只做四步

约 1.2 万字 · 6 张图 · 读完你能画出一台最小 CPU 的数据通路、 说清一条 load 为什么比一条 add 慢五十倍、并且明白 「主频 × IPC」这个乘法里,每一项是怎么来的

上一节把一条指令拆成了字节。这一节讲这些字节进来之后发生什么。 不管是最早的 4004 还是今天的 192 核处理器,做的事情都是同一套: 从 PC 指向的地方取一串字节,译出「要干什么」,交给运算器算, 把结果塞回某个寄存器,然后 PC 往前走。 四步。所有复杂度都长在这四步的内部,以及「怎么让四步同时进行」上。 这一节先把单条指令的四步走通,再讲它要花几个周期—— 这两个数字决定了你手机里那颗芯片每秒能做多少事。

本节的小部分

  1. 1 四步:一台机器的最小骨架
  2. 2 取指:PC 是怎么往前走的
  3. 3 译码:把字节变成一排控制信号
  4. 4 执行:运算器其实只会加和选
  5. 5 访存:一次读内存要等多久
  6. 6 写回与退休:结果什么时候才算数
  7. 7 一条指令几个周期:单周期、多周期、流水线
  8. 8 CPI、IPC 与主频:三个数字一台戏
  9. 9 控制单元:硬布线与微码的分界
  10. 10 四步之外的第五件事:被打断
  11. 11 从复位到第一条指令
  12. 12 用真实的延迟感受速度

1.3.2-1四步:一台机器的最小骨架

先看一台能跑程序的最小机器需要哪些零件。不要想高级特性,就想要能执行 add eax, ebx 和 jmp 这两条指令。

零件作用它回答的问题
程序计数器 PC存「下一条指令在哪」我该去哪儿拿指令
指令存储器 / 指令缓存按地址吐出若干个字节那个地址上写着什么
译码器把字节翻译成控制信号这串字节要干什么
寄存器堆一小片能同时读两个、写一个的存储操作数在哪
运算器 ALU做加减、与或、比较算出来是多少
数据存储器 / 数据缓存装变量、数组、堆栈那个地址上存的是什么
控制单元决定每一步谁开谁关这一拍该让哪个门导通
最小 CPU 数据通路:PC、指令存储器、译码器、寄存器堆、ALU、数据存储器与写回通路
图 1.3.2-1 一台最小 CPU 的数据通路。粗线是数据走的路,细虚线是控制信号。注意右下角那条从写回端绕回寄存器堆的线——它让「算出来的结果」变成「下一次能读到的输入」,整个循环才闭合。还要注意 PC 左边那个加法器:它只做一件事,把 PC 加 4。这条看起来最傻的通路,是所有程序能从头跑到尾的原因。

把这张图按时间切开,就是四步:

① 取指 IF    PC → 指令存储器 → 取出这条指令的字节,PC 指向下一条
② 译码 ID    字节 → 译码器 → 「ALU 做加法、读 0 号和 3 号寄存器、结果写 1 号」
③ 执行 EX    寄存器堆读出两个值 → ALU 算 → 同时算出访存地址
   访存 MEM  (只有 load/store 才真的去读或写数据存储器)
④ 写回 WB    结果写进寄存器堆;标志位更新;这条指令「退休」

真实处理器把这四步拆成五级,中间多一级「访存」(MEM), 因为读写数据存储器本身要时间,单独拿出来更好排。 所以教科书里的经典流水线是 IF、ID、EX、MEM、WB 五级。 本节标题写四步,是把访存算在执行里——概念上是四件事,实现上常分五级。

有一点必须现在说清楚:这四步不是「一条指令做完了才做下一步」。 在最早的机器上确实是那样串行的,但现代机器里, 第一条指令在写回的时候,第二条在执行,第三条在译码,第四条在取指。 四步变成了四条并行的流水线工位,每个时钟都有一条新指令进来、一条旧指令出去。

这是理解 CPU 的第一个台阶:它的快不来自「一步做得快」,来自「四步同时在干不同的活」。 后面 1.3.4 讲流水线,讲的就是这条流水线怎么被各种事情打断。 这一节先把单个工位看清楚。

「控制单元」是什么。 它不是一块独立的芯片,是一堆组合逻辑,散在整条通路上。 它的输出就是图里那些细虚线:这一拍寄存器堆要不要写、ALU 做哪种运算、 存储器是读还是写、写回的是 ALU 的结果还是存储器的数据。 这些信号加起来大约几十位,由指令的译码结果和当前状态共同决定。 所谓「执行一条指令」,物理上就是把这几十位信号按正确的时序拉高拉低。

1.3.2-2取指:PC 是怎么往前走的

PC 是一个寄存器,里面存一个地址。取指单元拿这个地址去指令缓存里读, 读出来的字节送去译码,同时把 PC 加上这条指令的长度。 就这么简单,简单到只有一个问题:长度是多少。

ARM64 每条 4 字节,所以取指单元永远做 PC + 4。 x86 的指令 1 到 15 字节,取指单元必须先算出长度才能更新 PC。 这一步在 x86 上叫「指令长度译码」(length decoding), 它和真正的译码是两件事:先要知道这条指令有几个字节, 才能知道下一条从哪开始。

ARM64:
  PC = 0x1000  →  取 4 字节  →  译码  →  PC = 0x1004
  PC = 0x1004  →  取 4 字节  →  译码  →  PC = 0x1008

x86-64:
  PC = 0x1000  →  取若干字节 →  先扫出「这条 5 字节」 →  PC = 0x1005
  PC = 0x1005  →  取若干字节 →  扫出「这条 3 字节」    →  PC = 0x1008

顺序执行时,PC 是一条直线地往前爬。遇到跳转就断了: jmp 把 PC 直接改成目标地址,call 改成目标地址并把返回地址压栈, 条件跳转则要看标志位决定改不改。

这里出现了一个贯穿后面所有章节的矛盾: 取指是流水线的第一级,但「跳不跳」要到执行阶段才知道。 等知道的时候,取指单元已经按顺序取了四五条指令进来, 这些指令全白取了,还要从流水线里清掉。这就是分支预测要解决的问题 (1.3.4 细讲)。这一节只需要记住:PC 每被改写一次,流水线就要打个嗝。

取指与 PC 前进:顺序执行时 PC 递增,跳转时 PC 被改写,已预取的指令作废
图 1.3.2-2 PC 的两条路径。上半是顺序执行:每条指令占 4 字节(或 n 字节),PC 顺着地址往上爬,取指单元可以毫无顾虑地一直往下取。下半是一次跳转:第 3 条是 jmp 0x2000,但取指单元在执行它之前就已经把 0x100C、0x1010、0x1014 三条指令取进来了——这三条是「按顺序猜的」,跳转一旦成立,它们全部作废,流水线要清空重来。清空的代价不是零,它等于流水线的深度乘以一个时钟周期。

取指这一步看起来只是「按地址读内存」,但它自己也可能错过。 指令不在 L1 指令缓存里,就要去 L2、L3、内存拿, 一次几十到几百个周期。这时候取指单元不是干等,它会做预取: 既然程序大概率是顺序执行的,那就顺便把后面几行也取进来。 预取的准确率直接决定前端能不能喂饱后端, 所以现代处理器会跟踪「最近哪些指令块被连续取过」, 甚至会记住某个分支上次跳去了哪里。

指令缓存和数据缓存是分开的。这个设计叫哈佛结构 (以 1940 年代哈佛 Mark I 命名),和冯·诺依曼结构相对。 分开的理由很实际:取指每个周期都要读一次,访存也经常要读一次, 如果共用一个缓存,两者就会抢端口——这叫结构冒险。 分成两个独立缓存,取指和数据访问可以同时进行,冲突消失。 代价是同一块内存可能在两个缓存里各有一份, 如果程序自己修改了自己的代码,硬件不一定知道要同步 (这就是「自修改代码」在 x86 上必须 jmp 一下、 在 ARM 上必须执行一段缓存维护指令的原因)。

PC 有多宽,决定了程序能有多大。32 位 PC 只能寻址 4 GB, 这是 32 位系统「单个进程最多用 2 GB 或 3 GB 内存」的根源。 64 位 PC 理论上能寻址 16 EB,实际上现在只用了低 48 位(256 TB), 上面那 16 位必须和第 47 位一样(符号扩展),这叫「规范地址」。 你如果在内核里看到一个 0xffff8880... 的指针,那不是负数, 那是高半区地址的正常样子。

取指单元一个周期能取多少。 Intel 的取指单元每周期从指令缓存取 16 字节,AMD 也是 16 或 32 字节; ARM 的高性能核心每周期能取 4 到 6 条指令(16~24 字节)。 这个数字就是「前端宽度」,它决定了机器最多能同时喂饱几个执行单元。 x86 的麻烦在于:16 个字节里可能有 3 条指令,也可能只有 1 条带一堆前缀的指令, 同样是 16 字节,能译出几条完全看运气。

1.3.2-3译码:把字节变成一排控制信号

译码器做的事,说穿了就是查表。输入是操作码那几位,输出是几十根控制线:

控制信号它管什么取值来自哪里
ALU 操作加、减、与、或、异或、移位、比较操作码
源寄存器号从寄存器堆哪两个口读ModRM 里的 reg / r/m 字段
目的寄存器号写回时写到哪个寄存器同上,方向由操作码决定
是否写寄存器这条指令有没有结果要写操作码(cmp 就不写)
是否访存要不要读写数据存储器操作码 + ModRM 的 mod 字段
访存方向读还是写操作码
立即数怎么扩展符号扩展还是零扩展,扩到多宽操作码 + 前缀
下一条 PC 来源PC+4、跳转目标、还是返回地址操作码

这些信号不需要「计算」,只需要「连线」。译码器本质上是一大片与门或门, 把操作码的每一位接到合适的地方。这也是为什么 RISC 的译码只要一级: 32 位定长、字段位置固定,操作码在第 0~6 位,源寄存器在第 5~9 位, 目的寄存器在第 0~4 位,接线一固定,信号立刻就出来了。

x86 做不到这一点。同样是 mov,89 是「寄存器写内存」, 8B 是「内存读寄存器」,方向正好相反;源和目的哪个在 ModRM 的 reg 字段、 哪个在 r/m 字段,要看操作码的第 1 位。译码器得先认出操作码, 再决定「怎么解释这个 ModRM」,两步之间有依赖。 这种依赖链让 x86 的译码级比 ARM 长,也更难并行。

所以现代 x86 干脆不在执行阶段用「x86 指令」这个概念。 它把每条 x86 指令译成一到几个定长的微操作(μop), 之后所有阶段只认 μop:

一条 x86:add eax, [rbx+rcx*4+8]
译成 μop:
  μop1  load   tmp ← [rbx + rcx*4 + 8]      ; 访存
  μop2  add    eax ← eax + tmp              ; 运算

每条 μop 大约一百位宽,里面装着:做什么、两个源操作数在哪(物理寄存器编号)、 目的在哪、立即数、以及一堆标志。它是定长的、字段规整的—— 等于在芯片内部把 x86 翻译成了一套 RISC。

μop 有几个实际后果值得知道。第一,解码后的指令会被塞进一个「μop 缓存」, 下次再执行同一段代码可以直接从缓存取 μop,跳过译码—— 所以循环体跑第二遍比第一遍快。第二,微码指令(cpuid、 rep movsb)其实是「一串 μop 的模板」,由一个微码定序器逐条吐出来。 第三,一个 x86 指令最多能被拆成四个 μop;超过四个的走微码。

那 x86 的译码器到底怎么算长度?没有捷径,只能扫。它按顺序检查: 先吃掉所有前缀(最多 4 个),看到 0F 就读第二字节, 再看到 38 或 3A 就读第三字节; 然后看这个操作码有没有 ModRM,有的话读 ModRM; ModRM 的 mod 和 r/m 字段又决定后面有没有 SIB、有没有位移、位移是 1 字节还是 4 字节; 最后加上可能的立即数。整个过程是一串「看前一个字节再决定读几个」的判断, 没法并行,只能一级一级往下推。

这条链有多长?最坏情况下要过六七级判断,每级都是几个门延迟。 这就是 x86 译码速度上不去的根本原因:不是工艺问题, 是编码格式让「读下一个字节」这件事依赖于「刚读到的这个字节」。 相比之下 ARM64 的译码没有这种依赖——字段位置全写在规范里, 32 位一进来,操作码、源寄存器、目的寄存器同时就位,几个门延迟就出结果。

译码是最难并行的一步。 取指可以一次取 16 字节,执行可以有四个 ALU 同时算, 但译码必须知道每条指令的边界。x86 的顺序译码器一次只能完整译一条, 想并行就要多开几个译码器,而每个译码器都要自己扫一遍长度—— 这就是为什么 x86 的前端宽度长期卡在 4 到 6 条, 不是不想加,是加了也喂不饱。

1.3.2-4执行:运算器其实只会加和选

ALU 是 CPU 里最像「计算」的部件,但它能做的运算少得出奇。真正的核心只有两种: 加法和选择(多路选择器)。其余都是它们的组合。

减法?a − b = a + (~b) + 1,用同一加法器,把 b 取反、进位输入置 1。 这就是 1.2.3 讲过的补码加法器,一条都不用改。

比较?也是减法,只是不把结果写回去(1.3.1 §9 讲过)。 与、或、异或?一位一位的独立操作,用一排门就行,不涉及进位,比加法还快。

移位?这里有个技巧值得看:桶形移位器(barrel shifter)。 如果要移 0 到 63 位,最笨的办法是串 63 级「移一位」, 延迟 63 个门。桶形移位器把它变成 6 级: 第一级决定移不移 32 位,第二级决定移不移 16 位,依次到 1 位。 6 个二进制位正好能表示 0~63,所以 6 级就够。 从 63 级压到 6 级,代价是每级都要一个 64 选 1 的多路器—— 面积换延迟,这是数字设计里最常见的交易。

ALU 内部结构:加法器、逻辑单元、桶形移位器与结果选择
图 1.3.2-3 一个 64 位 ALU 的内部。左边两个操作数进来,兵分四路:加法器(减法也走它)、逻辑单元(与或异或非)、桶形移位器(6 级,每级移 32/16/8/4/2/1 位)、以及直接旁路。右边一个多路选择器按操作码挑一路送出去,同时把标志位写进标志寄存器。注意移位器的画法:六级串起来,但每级只需要一个「移或不移」的决定,这就是把一个 63 级的长链压成 6 级的方法。

乘法比加法贵得多。两个 64 位数相乘,最笨的做法是加 64 次; 实际用的是华莱士树(Wallace tree):先把 64 个部分积排成树, 用保留进位的加法器一层层压缩,大约 6 到 7 层就能压成两个数,最后做一次加法。 延迟大约 3 到 5 个周期,面积是加法器的几十倍。 这就是为什么编译器宁愿用移位和加法代替小常数乘法 (1.3.1 §12 那个 lea 的例子)。

除法更贵。它没有「一次算完」的电路,只能迭代: 每次试商一位,64 位就要 64 次迭代。硬件上常用 SRT 算法一次试出几位, 但仍然是几十个周期。开方、三角函数、超越函数更慢, 通常靠查表加多项式逼近,用专门的浮点单元算,几十到上百周期。

浮点单元在结构上是独立的。整数 ALU 和浮点乘加器排在两个不同的执行端口上, 所以一条整数加法和一条浮点乘法可以同一拍发射、同一拍算完, 互不干扰。这也是「一条指令几个周期」这个问题必须分指令类型回答的原因: add 一个周期,imul 三个周期,div 二十到四十个周期, 浮点除法四十到八十个周期,开方更长。 如果一条除以零的除法卡在流水线里,后面的指令能不能先走,就取决于机器有没有乱序能力。

浮点加法看起来和整数加法差不多,其实复杂得多:要先对齐阶码 (把小的那个数的尾数右移,让两个数的指数一样),再相加, 再规格化(把结果左移直到最高位是 1),最后舍入。 三步里任何一步出错都会让结果差一位。IEEE 754 规定的五种舍入模式、 NaN 和无穷的传播规则,让浮点单元的控制逻辑比整数 ALU 复杂一个数量级。

1.3.2-5访存:一次读内存要等多久

访存这一步听起来简单:给个地址,读一个数。但它是整个四步里唯一可能慢上百倍的一步。

地址从哪来?x86 的寻址方式允许「基址 + 变址 × 比例 + 偏移」, 这个加法由一个专门的地址生成单元(AGU)算。 现代处理器有好几个 AGU,所以一个周期能同时算出好几个地址。 算完地址,先查缓存:

在哪典型容量命中延迟相当于多少个时钟
寄存器几百字节00
L1 数据缓存32~64 KB约 4 周期4
L2 缓存256 KB~2 MB约 12 周期12
L3 缓存8~128 MB约 40 周期40
内存(DRAM)GB 级约 60~100 纳秒200~400
固态硬盘TB 级约 100 微秒40 万
机械硬盘TB 级约 10 毫秒4000 万

最后两行不是 CPU 能直接访问的,它们要经过缺页异常和驱动, 但放在一张表里才能看出数量级的跨度:从寄存器到内存差两个数量级, 从内存到硬盘又差三个数量级。这个跨度是所有存储层次设计的理由, 也是 1.3.5 的主题。

在真的去访问内存之前,还有一个环节几乎所有程序都会碰到:地址翻译。 程序里用的地址是虚拟地址,硬件要先查页表把它翻成物理地址。 页表在内存里,每查一次都要读内存,那还怎么快? 所以有一个专门的小缓存叫 TLB(translation lookaside buffer), 存最近用过的「虚拟页 → 物理页」映射,通常只有几十到几百项。

TLB 命中时,地址翻译几乎不要时间,和缓存查找并在一起做。 TLB 不命中就要走「页表遍历」(page walk):x86-64 是四级页表, 最坏要读四次内存,才能拿到物理地址。四乘两百个周期, 接近一千拍——一次 TLB 未命中的代价,比一次缓存未命中还贵四倍。

这解释了两件在性能分析里很常见的事。第一,为什么「随机访问一个大数组」 比「顺序访问同一个数组」慢得多:顺序访问一页里的 4096 字节只需要一次 TLB 查找, 随机访问每跳一次就可能换一页,TLB 被踢爆。 第二,为什么虚拟机和高并发服务器会用「大页」(2 MB 甚至 1 GB 一页): 一页装的东西多了,同样的数据量需要的 TLB 项就少,未命中自然少。 大页不是什么高深优化,它就是在省 TLB 这一层。

访存还有一个容易被忽略的细节:对齐。 x86 允许非对齐访问(一个 4 字节整数放在不被 4 整除的地址上), 但硬件要拆成两次总线访问再拼起来,慢一倍。 ARM 默认也允许,但某些配置下会直接触发异常。 C 语言里 struct 的成员会被自动填充对齐, 就是为了避免这种拆分——你在 sizeof(struct) 里看到的那几个"空隙", 买的就是这个。

更麻烦的是访存和运算在时间上的错位。 add eax, [rbx] 这一条指令既要读内存又要算加法, 而且加法必须等内存读回来才能做。如果那个地址不在缓存里, 这条指令就要卡两百个周期,后面的指令(如果它们不依赖这个结果) 本来可以先做——这就是乱序执行的起点。

load 和 store 的区别不只是方向。 load 有明确的「结果什么时候到」,可以给一个预期的延迟; store 没有结果,它是「把值扔出去」,但要保证别的核看到它的顺序。 所以 store 在硬件里通常是「先写进 store buffer,等条件合适再真正落地」, 这个缓冲让 store 看起来很快,代价是内存顺序变得难以推理。 1.3.5 讲内存序时,所有反直觉的例子都源于这个缓冲。

1.3.2-6写回与退休:结果什么时候才算数

写回是四步里最不起眼的一步:把结果写进寄存器堆的目标寄存器。 寄存器堆有两个写口(能同时写两个结果,给双发射用)和两个以上的读口。 写口一开,值就进去了,下一个周期就能读到。

但在现代处理器里,写回和「生效」是两件事。 一条指令算完、结果写进了物理寄存器,这件事叫完成(complete); 它真正被承认、对程序状态产生影响,叫退休(retire / commit)。 两者之间隔着一段排队:

指令进来 → 译码 → 派发到执行单元 → 执行完(complete)
        → 进入重排序缓冲(ROB)排队
        → 轮到自己、且前面全部退休了 → 退休(retire)
        → 结果写进「架构寄存器」,此时才对程序可见

为什么要多这一层?因为异常。 假设第 5 条指令发生除零,而第 6、7 条已经算完了。 如果它们的结果已经写进寄存器,异常处理程序看到的机器状态就是错的—— 它会看到「第 5 条没做完,但第 6、7 条做完了」这种现实中不存在的中途状态。

重排序缓冲解决了这个问题:所有指令按程序顺序排队退休, 第 5 条出异常时,它后面的指令虽然算完了,但一条都没退休, 结果全部丢弃。于是异常处理程序看到的是一个精确的现场: 第 5 条之前全部完成,第 5 条之后全部没发生。 这个性质叫「精确异常」(precise exception),是所有能跑操作系统、 能调度的处理器的必备条件。

这也解释了一个调试时的困惑:崩溃时 rip 指向的指令, 可能不是真正出问题的那条,而是「最后退休的那条」。 因为乱序执行时,出问题的那条可能早就完成了, 但它退休时被判定为异常,于是 rip 记的是它—— 在程序顺序上它是「第一条没完成的」,这正是异常处理程序需要的。

精确异常的时间线:指令乱序完成但按序退休,异常发生时后续结果全部丢弃
图 1.3.2-4 精确异常是怎么保证的。上半是执行顺序:第 6 条比第 5 条先算完(它不依赖前面的结果),第 5 条在做除法时除了零。下半是退休顺序:严格按 5、6、7 排。第 5 条一退休就触发除零异常,第 6 条虽然早就算完了,也得跟着被丢弃——它的结果一个字都没写进架构寄存器。异常处理程序接手时,看到的现场是「第 1~4 条做完,第 5 条没做,第 6 条以后不存在」,干净得像什么都没发生过。

退休还有一个副作用:它是性能瓶颈之一。即使执行单元很闲, 如果退休宽度只有每周期 4 条,那 IPC 就永远超不过 4。 这就是为什么现代处理器的「发射宽度」「执行宽度」「退休宽度」三个数字要一起看, 只提高其中一个没有用。

1.3.2-7一条指令几个周期:单周期、多周期、流水线

同样这四步,有三种实现方式,对应 CPU 设计史的三个阶段。

单周期实现。一条指令在一个时钟里走完四步。 时钟周期必须容纳最慢的那条路径——通常是 load: 取指、译码、算地址、读数据存储器、写回,一条长链。 假设这条链要 800 皮秒,时钟就只能跑 1.25 GHz。 而简单的 add 可能只要 300 皮秒,剩下的 500 皮秒它就在干等。 一条慢指令拉低了所有指令的速度,这就是单周期的致命缺点。

多周期实现。把一个时钟拆成几个,每条指令用几个时钟走完。 好处是时钟可以快得多(每步只要 200 皮秒), 而且简单指令能用更少的周期。坏处是要在每步之间加锁存器保存中间结果, 而且同一条指令还是串行的——总时间没变,只是切碎了。

流水线实现。把四步做成四个工位,每个周期四个工位各干一条指令的活。 时钟周期取最慢那一级的时间,但吞吐量变成「每周期完成一条」。 它不减少单条指令的延迟(还是四拍),但把吞吐提高了四倍。

单周期、多周期、流水线三种执行方式的时间对比
图 1.3.2-5 三种实现的时间表。左边单周期:每条指令占满一整格,格子宽度由最慢的 load 决定,add 在里面大半时间是空的。中间多周期:一条指令拆成几小格串行走完,格子变窄了,但同一时刻只有一条指令在跑。右边流水线:格子宽度和多周期一样,但格子沿对角线排开,四个工位同时装满——第 4 拍之后,每拍都出一条结果。延迟没变(都是四拍),吞吐变了四倍。

流水线不是免费的。它带来三个新问题,后面的 1.3.4 全在讲它们:

问题怎么来的名字
下一条指令可能要用这一条的结果写回在第五拍,下一条第三拍就要读数据冒险(data hazard)
跳转要不要跳还不知道取指早就按顺序取了几条控制冒险(control hazard)
两条指令抢同一个部件一个周期只能访问一次存储器结构冒险(structural hazard)

结构冒险值得单独看一眼,因为它最容易理解、也最容易被低估。 假设只有一块存储器,既放指令又放数据:取指要读它,load 也要读它, 两者撞在同一拍,只能让一个等。早期的冯·诺依曼机器就是这样, 每拍最多只能做一件事,吞吐被硬件卡死。

解法不是让存储器变快,而是把它拆成两块—— 指令缓存和数据缓存分开(上一节讲过的哈佛结构), 再加上寄存器堆的双端口设计(同时读两个、写一个)。 这样一来,取指、读操作数、写结果三件事可以在同一拍里并行, 结构冒险基本消失。这个例子说明:流水线的很多问题不是靠更聪明的控制解决的, 是靠把资源复制一份解决的——而复制资源要花面积和电。

数据冒险的常用解法是旁路(forwarding / bypass): 不等结果写回寄存器,直接从执行单元的出口接到下一条的入口。 这样「写回」这一步在数据上可以被跳过,只保留在「退休」的意义上。 旁路能把大部分数据冒险的代价从两拍降到零拍,它是流水线能真正跑起来的关键。

流水线深度不是越深越好。 Pentium 4 的 Prescott 核心把流水线拉到 31 级,主频冲到了 3.8 GHz, 但分支预测失败的代价也变成了 30 多个周期, 而且每级之间的锁存器开销让「每级真正干活的电」占比下降。 结果是同频性能差、功耗高,被 AMD 的短流水线打得很惨。 今天的处理器回到 14~20 级,这是「主频」与「罚金」之间的最优解。

1.3.2-8CPI、IPC 与主频:三个数字一台戏

到这里可以算性能了。最常用的公式:

程序执行时间 = 指令数 × CPI × 时钟周期
             = 指令数 ÷ (IPC × 主频)

CPI = cycles per instruction,每条指令平均花几个周期
IPC = instructions per cycle,每周期平均完成几条指令
两者互为倒数(严格说,IPC = 1 / CPI)

举一个具体例子。一颗 4 GHz 的处理器,IPC 是 4:

每秒指令数 = 4 × 10⁹ × 4 = 160 亿条
每条指令平均时间 = 1 / (4 × 10⁹) = 0.25 纳秒

0.25 纳秒里发生了什么?光在真空里走 7.5 厘米。 在硅里,信号传播速度大约是真空中光速的三分之一, 所以只能走 2.5 厘米——这差不多就是一颗大芯片的对角线长度。 换句话说,一个时钟周期里,信号勉强能从芯片一头跑到另一头。 这就是为什么芯片不能无限做大,也是为什么缓存要一层层贴着核心放。

公式里三个量互相牵制,动一个会带坏另外两个:

你改了什么指令数CPI主频结果
流水线加深不变变差(冒险罚金变大)变高通常净亏,看具体深度
加宽发射(一次发 4 条)不变变好略降(面积功耗)净赚,但受限于程序并行度
加指令(如 SSE 一条算 4 个浮点)减少略差不变数据并行时赚很多
改进编译器减少略好不变白赚,但天花板低
换更快的存储器不变明显变好不变赚,尤其在访存密集的程序里

这张表解释了为什么「主频高就快」是错的。老式的 Pentium 4 跑到 3.8 GHz, 却被 2 GHz 的 Core 2 打得没脾气——因为后者的 IPC 高出近一倍。 性能是乘法,不是加法,只看一个因子一定会判断错。

还有一个更隐蔽的问题:IPC 不是常数,它随程序变。 纯计算的循环可以跑到 IPC 4 以上,一个指针追逐的链表遍历可能只有 0.5—— 因为每次 load 都要等上一次 load 的结果,缓存全不命中。 所以「这颗 CPU 的 IPC 是多少」这个问题本身就不严谨, 应该说「在某某基准测试上 IPC 是多少」。 厂商宣传的 IPC 提升 15%,通常是在一堆精心挑选的测试上取的平均。

1.3.2-9控制单元:硬布线与微码的分界

前面那些控制信号是谁产生的?两种做法,分界很清楚。

硬布线(hardwired):用组合逻辑直接译出信号。 输入是指令的操作码和当前流水级的状态,输出是那几十根控制线。 速度快(信号只过几个门),占面积小,但一旦流片就改不了。 ARM、RISC-V、MIPS 的主体都是硬布线。

微码(microcode):芯片里有一小块只读存储器,叫控制存储器。 每条机器指令对应一段「微程序」,微程序里每条微指令就是一组控制信号。 执行一条机器指令,就是按顺序取出几条微指令、依次驱动总线。 慢(要多读一次存储器),占面积(控制存储器不小),但可以改。

微码的历史很有意思。它本来是 1950 年代 IBM 为了让「改指令集不用重新设计硬件」 发明的,后来被 RISC 运动当成落后技术批判。 但 x86 一直用它,因为 x86 的指令太复杂——rep movsb、 字符串比较、BCD 运算、任务切换,用硬布线实现会疯掉。

更关键的是:微码可以打补丁。 主板 BIOS 里存着一份微码更新,开机时写进 CPU。 2018 年熔断(Meltdown)和幽灵(Spectre)漏洞爆发后, 全球的服务器和 PC 都是靠微码更新撑过来的—— 在硬件不变的情况下,改掉推测执行的行为,代价是性能掉几个百分点。 如果这些逻辑是硬布线的,那些机器就只能报废。

一个著名的微码 bug。 1997 年 Pentium 的 F00F 漏洞:指令 F0 0F C7 C8 (一个带 LOCK 前缀的非法指令)会让处理器的微码定序器进入死循环, 取指单元被锁死,连「取异常处理程序」这件事都做不到,整机死机。 修复办法是操作系统在缺页处理里加一段检测代码—— 因为硬件已经坏了,只能从软件绕。 这件事说明:微码是软件,软件就有 bug,而 bug 在已售出的芯片里改不了。

1.3.2-10四步之外的第五件事:被打断

如果世界很美好,指令会一条条顺利走完四步。但机器要能响应外部事件: 键盘按了、网卡收到包、定时器到点、程序除了零、访问的页不在内存里。 这些事都会打断流水线。

打断分两类,区别在于「是谁引起的」:

类别来源例子什么时候被处理
异常(exception)当前指令自己除零、非法指令、缺页、断点、对齐错误同步:执行到这条才发现
中断(interrupt)外部设备或定时器键盘、网卡、时钟节拍、核间消息异步:随时可能来
陷阱(trap)程序自己故意触发int 3、syscall、ud2执行到这条时

处理流程是固定的一套,硬件和操作系统分工:

① 硬件:把当前 PC、标志位、出错码压栈(或存进专用寄存器)
② 硬件:按异常号查「中断向量表」,跳到对应的处理程序
③ 软件:处理程序保存现场、做该做的事(比如把缺的页读进来)
④ 软件:执行「从中断返回」指令,硬件恢复 PC 和标志位,继续跑

关键在于第一步:压进去的 PC 必须是「出问题的那条」, 而不是「流水线里正在跑的那条」。乱序执行时这两个不是一回事, 所以硬件必须保证「所有比它早的指令都已完成、所有比它晚的都没生效」—— 这就是上一节讲的精确异常。

缺页是最常见也最贵的一种。程序访问一个不在物理内存的页, CPU 触发缺页异常,操作系统去硬盘读 4 KB,把页表补上, 再返回重新执行那条指令。整个过程几万到几十万个周期, 期间这个进程什么都不干。所谓「内存不够就卡」,卡的就是这个。

中断还涉及优先级和嵌套。硬件给每个中断源一个号码,号码小的优先级高; 高优先级的来了,可以打断正在执行的低优先级处理程序,这叫中断嵌套。 操作系统在处理关键数据结构时会短暂关中断(cli), 这段时间里外设的事件不会丢——它们会挂在「待处理」寄存器里, 等开中断(sti)后一起送进来。但如果关得太久, 事件就会积压甚至溢出,表现为「网卡丢包」「鼠标卡顿」。

系统调用走的是另一条路。它不是外部事件,是程序主动触发的一条指令 (x86 的 syscall、ARM64 的 svc), 硬件把它当成一种异常来处理:保存现场、提高特权级、跳到内核预先登记好的入口。 所以「调用内核」这件事在硬件层面和「除零」是同一套机制, 只是异常号不同。这也是为什么系统调用那么贵—— 一次特权级切换要保存几十个寄存器、切换栈、刷新 TLB 的一部分, 代价是几千个周期,相当于一次内存访问的十几倍。

中断则引入了另一个问题:原子性。 一条指令执行到一半被中断,处理程序如果改了同一条指令用到的数据, 回来继续执行就会出错。所以硬件必须保证「指令是原子的」—— 要么完整执行,要么完全不执行。这在单核时代靠「中断只在指令边界响应」就能做到, 多核时代就麻烦了,因为另一个核可能正在改同一块内存(1.3.5 讲缓存一致性)。

1.3.2-11从复位到第一条指令

把前面的东西串起来,看一台机器开机那一瞬间发生了什么。 这是四步第一次真正跑起来,也是最干净的一次。

按下电源键,CPU 的 PC 被硬件强制设成一个固定值,叫复位向量。 x86 是 0xFFFFFFF0(实模式的 F000:FFF0), ARM64 通常由芯片厂商定,树莓派是 0x80000,很多嵌入式是 0x0。 这个地址上放的是一段固件(BIOS 或 UEFI),烧在主板上的闪存里。

0xFFFFFFF0:  jmp  far ptr start      ; 只有 16 字节空间,先跳走
start:
    cli                              ; 关中断,现在还不能被打断
    xor  eax, eax
    mov  ds, ax                      ; 段寄存器清零,进入平坦模式
    lgdt [gdt_desc]                  ; 装全局描述符表
    mov  cr0, ...                    ; 置 PE 位,切到保护模式
    jmp  code32                      ; 远跳,清掉流水线里的旧指令
code32:
    mov  esp, 0x7C00                 ; 建立栈,没有栈就没法调函数
    call kernel_entry                ; 终于可以调 C 函数了

每一步都在解决一个具体的硬件限制:cli 是因为此时中断向量表还没建好, 来了中断没处跳;lgdt 是因为保护模式需要段描述符; jmp code32 是一条远跳转,它同时做两件事——跳到 32 位代码、 并清空流水线里那些按 16 位译码的指令(这是 1.3.4 里「流水线清空」的最早用例); mov esp 是因为 C 函数要用栈,而复位时栈指针是垃圾值。

多核机器上这段流程还要更绕一点。复位时并不是所有核都跑同一段代码: 硬件选一个核当引导核(BSP),其余的核(AP)先停在一个等待状态里, 等引导核把内存、页表、中断控制器都准备好,再逐个发「启动」信号, 告诉它们「从某个地址开始执行」。这个地址就叫 AP 的启动向量。 所以你在一台多核机器上电时看到的是:一个核在跑固件, 其他核都在睡觉,直到被叫醒。

这段代码的每一行,都能对应到前面讲的某一步: jmp 改 PC,mov esp 写寄存器, lgdt 写一个特殊的控制寄存器, call 把返回地址压栈再改 PC。 没有魔法,全是四步的组合。

为什么复位向量在那么高的地址。 0xFFFFFFF0 是 4 GB 往下 16 字节。这个位置有个好处: 不管后面怎么设计内存布局,它总在地址空间的顶端, 不会和任何可能的内存区域冲突。而且它离顶端只有 16 字节, 放不下一条完整的跳转,所以第一件事一定是跳走—— 这 16 字节是「硬件强制规定」和「软件自由安排」之间的一道缝。

1.3.2-12用真实的延迟感受速度

最后把数字摆在一起,建立一点直觉。所有数字以「一个时钟周期」为单位, 取 4 GHz(一拍 0.25 纳秒):

各类操作的延迟阶梯:寄存器、L1、L2、L3、内存、固态硬盘、机械硬盘
图 1.3.2-6 延迟的阶梯(横轴是对数刻度)。最左边是寄存器,零拍;往右每一级都跳一个数量级。注意最右两格:固态硬盘和机械硬盘的延迟已经不能用「周期」来数了,它们的单位是毫秒,而 CPU 在这段时间里能执行几千万条指令。这就是为什么「等 IO」的程序看起来像卡死——不是它慢,是它等的那个东西和它不在一个时间尺度上。

换个角度看这张图。假设一个时钟周期是一秒(把 0.25 纳秒放大到 1 秒, 放大了 40 亿倍),那么:

操作真实延迟放大后的感受
寄存器访问0伸手就拿到
L1 命中4 周期走到隔壁房间拿本书,4 秒
L2 命中12 周期下楼取个快递,12 秒
L3 命中40 周期去隔壁楼借个东西,40 秒
内存访问200 周期开车去另一个城市拿份文件,3 分多钟
分支预测失败18 周期走错路再折回来,18 秒
固态硬盘读约 40 万周期等一天多
机械硬盘寻道约 4000 万周期等三个多月

这张表能解释很多工程决策。为什么数据库要把索引放在内存里? 因为一次随机磁盘读相当于三个月。为什么 CPU 要花一半的晶体管做缓存和预测? 因为一次内存访问相当于三分钟,而它本可以零成本。 为什么程序员要关心「缓存友好」?因为一次未命中就抵得上几百条指令。

反过来说,也能解释为什么「优化算法复杂度」比「优化常数」重要得多。 把一次 O(n²) 的循环改成 O(n log n),省下的是几百万条指令; 把循环里的一个乘法改成移位,省下的是一条指令。 在 4 GHz 的机器上,一条指令的时间你根本感知不到,一百万条才是一毫秒。

下一节讲这四步里的数据都放在哪:寄存器为什么只有十几个、 函数调用时参数和返回地址怎么传、栈帧是怎么长出来的。 那是「四步」在软件层面的投影。

自测:能答上 8 题,这一节就算过了

  1. 四步是哪四步?为什么真实处理器常分五级?
  2. 顺序执行时 PC 怎么变?遇到跳转时呢?为什么跳转对流水线是坏消息?
  3. 「指令长度译码」和「译码」为什么是两件事?哪类架构需要前者?
  4. μop 是什么?它解决 x86 的什么问题?
  5. ALU 的核心只有哪两种运算?减法和比较是怎么做出来的?
  6. 桶形移位器为什么 6 级就能移 0~63 位?代价是什么?
  7. 单周期实现的最大缺点是什么?举例说明。
  8. 「完成」和「退休」有什么区别?为什么必须有这个区别?
  9. 写出执行时间的公式,并解释为什么「主频高就快」是错的。
  10. 4 GHz 的一个时钟周期里,光在硅里能走多远?这个数字说明了什么?
点开看答案(先自己想,别急着点)
  1. 取指、译码、执行、写回,访存算在执行里。真实处理器把访存单独拆成一级(MEM),变成 IF、ID、EX、MEM、WB 五级,因为读写存储器本身耗时,单独一级更好排流水。
  2. 顺序执行时 PC 加上当前指令的长度(定长加 4,变长要先算长度)。跳转时 PC 被直接改写成目标地址。跳转是坏消息,因为取指单元早已按顺序取了几条指令进来,跳转一成立这些全作废,流水线要清空重来。
  3. 因为译码要按指令边界进行,得先知道这条指令有几个字节、下一条从哪开始。x86 这类变长架构必须做,ARM64 定长则永远加 4。
  4. 微操作,是 x86 指令在芯片内部被译成的定长内部控制格式(约一百位宽),字段规整、便于后端调度。它让变长的 x86 在后端表现得像一台 RISC,也让 μop 缓存可以跳过重复译码。
  5. 加法和选择(多路器)。减法用补码加法做(取反加一),比较也是减法,只是不写回结果。
  6. 因为 6 个二进制位正好能表示 0~63,每一级决定「移不移 2^k 位」,六级组合出任意移位数。代价是每级都要一个宽度等于操作数的多路选择器,面积比串行移位链大得多。
  7. 时钟周期必须按最慢的那条路径(通常是 load)来定,于是简单指令大部分时间在空等。比如 load 要 800 皮秒、add 只要 300 皮秒,时钟只能定 800 皮秒,add 浪费了 500 皮秒。
  8. 完成是「算完了、结果在物理寄存器里」;退休是「按程序顺序被承认、写进架构寄存器」。区别是为了精确异常:出异常的指令之后那些已经算完的指令必须能全部丢弃,让处理程序看到「之前全做完、之后全没发生」的干净现场。
  9. 执行时间 = 指令数 × CPI × 时钟周期 = 指令数 ÷ (IPC × 主频)。主频只是三个因子之一,流水线加深能提主频但会让 CPI 变差(冒险罚金变大),Pentium 4 的 31 级流水线就是例子:3.8 GHz 却输给 2 GHz 的 Core 2。
  10. 约 2.5 厘米(硅中信号速度约为真空中光速的三分之一)。这差不多是一颗大芯片的对角线长度,所以一个时钟周期内信号勉强能从芯片一头走到另一头,芯片不能无限做大,缓存必须贴着核心放。
← 1.3.1 指令与机器码:0xB8 0x01 到底是什么意思