计算机是怎么长出来的
总目录/ 第 0 部/ 0.4 两种芯片架构/ 0.4.1

0.4.1 x86 与 ARM:CISC 和 RISC 走的两条路

约 1.1 万字 · 6 张图 · 读完你能看懂「一条指令有多复杂」这件事, 为什么它影响功耗、面积和价格,以及为什么「RISC 更先进」这个说法只对了一半

这一节要拆掉一个流传很广的说法。 「CISC 落后、RISC 先进」「ARM 比 x86 省电,因为它是精简指令集」—— 这两句话在九十年代是对的,在今天只对了一小半。 真正的答案是:x86 芯片的内部,早就在跑 RISC 风格的微操作了。 那为什么还有区别?区别在「翻译」这道工序上, 而这道工序,正在决定一颗芯片有多少晶体管、发多少热。

本节的小部分

  1. 0.4.1-1 一条指令能有多复杂
  2. 0.4.1-2 1978 年的选择题:内存比逻辑贵
  3. 0.4.1-3 CISC 的代价:微码与变长指令
  4. 0.4.1-4 RISC 的四条戒律
  5. 0.4.1-5 反转:x86 内部其实也是 RISC
  6. 0.4.1-6 译码器:x86 最贵的那块电路
  7. 0.4.1-7 定长与变长:取指时差在哪
  8. 0.4.1-8 load-store 与三十一个寄存器
  9. 0.4.1-9 代码密度:ARM 曾经输过的那一局
  10. 0.4.1-10 功耗到底从哪来
  11. 0.4.1-11 生态:真正的护城河
  12. 0.4.1-12 小结与十道自测题

0.4.1-1一条指令能有多复杂

先看两行「汇编」,它们干的是同一件事:把内存里一个数加 1。

x86 的写法:add dword [rbx], 1

ARM64 的写法: ldr w0, [x1] / add w0, w0, #1 / str w0, [x1]

第一条是一条指令:从寄存器 rbx 指向的地址读 4 个字节, 加 1,再写回去。三个动作,一条指令。

第二条是三条指令:读进寄存器、在寄存器里加、写回内存。 每一步都要自己写。

这就是 CISC 和 RISC 最直观的区别: 一条指令里塞多少活。 塞得多的叫复杂指令集(CISC,Complex Instruction Set Computer), 塞得少的叫精简指令集(RISC,Reduced Instruction Set Computer)。

名字听起来像「高级 vs 低级」,其实是一次交易的两种付法: CISC 把复杂度放在硬件里(一条指令干三件事), RISC 把复杂度放在编译器里(三条指令,程序员或编译器自己排)。

先澄清一件事:「RISC 的指令少」这个说法容易误导。 ARM64 的指令数量也有几百条,加上 SIMD、加密、虚拟化扩展,一点不少。 RISC 的关键不是「少」,是「规整」—— 定长、格式统一、寻址方式少。 「精简」这个词指的是规则的复杂度,不是指令的条数。

为什么这件事值得关心

因为它直接决定三件你在乎的事:

一是芯片面积。规则越复杂,译码电路越大。 一颗现代 x86 芯片里,负责「把指令翻译成内部动作」的电路, 占了相当大的面积——这些晶体管不参与计算,只参与「理解」。

二是功耗。晶体管在开关时耗电,不开关时几乎不耗。 译码电路每个周期都在满负荷工作,它是芯片里最「忙」的模块之一。 而功耗,是手机和笔记本的第一约束。

三是软件生态。指令集是软件和硬件之间唯一的契约。 换指令集,所有二进制程序都要重编——这是 x86 活了四十年、 ARM 上不了桌面(直到最近)的根本原因。

把它变成字节看看

汇编只是给人看的。真正存进内存、送进 CPU 的,是字节。

add dword [rbx], 1 编译出来是三个字节: 83 03 01。

注意第二项:一个字节里塞了三件事——寻址方式、目标寄存器、位移长度。 这种「位段复用」在 x86 里到处都是,也是它编码紧凑的原因。

ARM64 的 add w0, w0, #1 是四个字节, 但它是固定位段:哪几位是操作码、哪几位是源寄存器、 哪几位是目标寄存器、哪几位是立即数,全写死在规范里。

这个差别在「人」看来没什么,在「电路」看来是两回事。 x86 的译码器要先判断「这个 03 到底是 ModR/M 还是别的什么」, ARM 的译码器直接按位置切。 前者是一台需要读说明书的机器,后者是一台按模板切的机器。

x86 变长指令与 ARM 定长指令的字节流对比
图 0.4.1-1 同样一段操作,x86 的字节流长短不一,ARM64 每条都是四字节。取指和译码的难度,从这一行就分开了。

0.4.1-21978 年的选择题:内存比逻辑贵

要理解 CISC 为什么长成那样,得回到它诞生的年代。

1978 年,Intel 发布 8086。它有 29000 个晶体管, 主频 5 到 10 MHz,地址空间 1MB。 同年,一 KB 内存的价格大约是 7 到 8 美元。

算一下:8086 能寻址的 1MB,如果全部装满内存, 成本是 1024 × 7.5 ≈ 7680 美元。 而那颗 CPU 本身卖几十美元。

内存比处理器贵两个数量级。这个事实决定了一切。

当时的程序要装进很小的内存里,而指令存在内存里、占内存空间。 所以有一个非常实际的目标:让每条指令尽量多干活,让程序尽量短。

一条 add [bx], 1 只占 3 到 4 个字节, 换成「读、加、写」三条就是 8 到 10 个字节。 在内存按 KB 算钱的年代,这个差别是真金白银。 复杂指令不是为了「高级」,是为了「省内存」。

还有第二个理由:省编译器的活

1970 年代的编译器很弱。让它去分配寄存器、安排指令顺序、优化循环, 它做不好。而 CISC 的指令「一条顶三条」, 编译器只要一条条翻译过去就行,不用做复杂的优化。

换句话说:CISC 把「聪明」放在了硬件和指令设计里, 因为那时候软件还不够聪明。 而 RISC 的赌注正好相反——赌编译器会变聪明。

年代DRAM每 KB当时的选择
197816 Kbit$7.5CISC · 指令要短
1985256 Kbit$2RISC 出现,内存仍贵
199516 Mbit$0.3缓存变大,RISC 赢工作站
2010DDR3$0.02内存不再是瓶颈
2026DDR5$0.000003差两百多万倍

看最后一行和第一行的比值:四十八年,内存单价跌了两百五十万倍。 当年「一条指令要省几个字节」的理由,今天已经完全消失了。 但指令集没有跟着改——因为改了,所有软件都要重写。

另一边:三个人同时想到了同一个答案

1975 年,IBM 的 John Cocke 在做一件当时看来很奇怪的事: 他统计了程序里实际执行的指令,发现大部分指令很少被用到。 于是他做了一个实验性的机器,叫 801—— 指令少、定长、寄存器多。这个项目没商用,但它是最早的 RISC 雏形。

五年后,两条独立的路线同时走通了:

伯克利:David Patterson 带队做了 RISC I 和 RISC II(1980–1982), 第一次用「RISC」这个词。他们的贡献不只是设计,还有公开的量化分析—— 用真实程序统计指令使用频率,用数据说话。

斯坦福:John Hennessy 带队做了 MIPS(1981), 重点是流水线:让每条指令都恰好五个阶段,这样流水线永远不会堵。 这个设计后来商业化成了 MIPS 公司。

1985 年,英国的 Acorn 公司做出了 ARM1—— 25000 个晶体管,6 MHz。他们选 RISC 的理由很朴素: 小团队做不出复杂的 CISC 芯片,只能做简单的。 今天统治手机的架构,最初是「没能力做复杂」的产物。

一个容易忽略的事实:RISC 不是「理论推导出来的更优解」, 是在内存变便宜、编译器变强之后,重新算了一遍账。 1978 年 CISC 是对的,1985 年 RISC 开始对,1995 年 RISC 明显更优—— 因为那三个前提(内存价格、编译器能力、芯片面积成本)一直在变。
1978 到 2026 年每 KB 内存价格的对数曲线,以及当年的 1MB 成本
图 0.4.1-2 内存单价的对数曲线。CISC 诞生在曲线最左边那个点上——那时候省一个字节,真的等于省钱。

0.4.1-3CISC 的代价:微码与变长指令

「一条指令干三件事」听起来很美,但硬件要怎么实现它?

答案是一种叫微码(microcode)的东西: 每条复杂指令,在芯片内部对应一小段「微程序」, 由一串更简单的微操作组成。

add [bx], 1 到了芯片里,会被拆成: 算出地址 → 发读信号 → 等内存 → 取回数据 → 送进 ALU → 加 1 → 发写信号 → 写回, 七八个步骤,每一步占一个或几个时钟周期。

这套做法在 1978 年是合理的:硬件简单(一个微码 ROM 加一个执行单元), 指令灵活(想加新指令,改微码就行)。

但代价随时间变得越来越重:

一、指令变长,取指变难。x86 指令长度是 1 到 15 个字节,不固定。 处理器取指时不知道这一条有多长——它得先读几个字节, 看前缀、看操作码、再看 ModR/M 字节,才能算出来。 这叫「串行译码」:第二条指令的起点,取决于第一条的长度。

二、并行变难。现代处理器想一个周期译码四条、六条指令, 但 x86 的指令长短不一,你不能简单地「每 4 字节切一刀」。 必须一条条算长度,这就把并行卡住了。

三、微码很慢。走微码的指令,一条要花好几个周期。 而简单指令(比如 mov)可以硬布线直接执行,一个周期搞定。 所以 x86 内部其实分两条路:简单指令直通,复杂指令走微码。

那些几乎没人用的指令

x86 的指令表里有不少奇怪的东西,是历史的沉积。举几个例子:

这些指令的存在,本身就是「兼容性成本」的具象化: 它们占着译码表的空间,占着验证的工作量,占着硅片的面积, 但几乎没有程序在用。 而你不能删——删了某些1998 年的软件就崩了。

一个很实际的后果:某些 x86 指令慢得离谱,就是因为它们走微码。 比如字符串操作、某些形式的 loop、跨页的内存访问。 在性能敏感的代码里,一条这样的指令可能顶几十条简单指令的时间。 这也是为什么编译器宁愿生成多条简单指令,也不用那些「高级」指令。

0.4.1-4RISC 的四条戒律

1980 年代,Berkeley 的 David Patterson 和 Stanford 的 John Hennessy 各自带队做了实验:如果指令集设计得极端简单,会怎样?

他们发现,当时 CISC 芯片上跑的典型程序里, 大约 20% 的指令承担了 80% 的执行次数, 而很多「高级」指令几乎没人用。

于是有了 RISC 的四条设计原则。这四条要一起看,它们是互相支撑的。

第一条:指令定长

ARM64 的每条指令都是 32 位(4 字节),没有例外。 RISC-V 的基础指令集也是 32 位。

好处是取指和译码可以并行: 一次取 16 字节,就是 4 条指令,边界清清楚楚, 译码器可以四个通道同时开工。 这一条直接决定了「一个周期能译码几条」。

第二条:加载/存储分开(load-store)

RISC 规定:只有 load 和 store 能访问内存,其他指令只碰寄存器。

所以「内存加 1」要三条指令。看起来笨,但带来了一个巨大的好处: 每条指令的执行时间可以固定。 add 不访问内存,就不会因为缓存没命中而卡住, 流水线可以一直往前推。

而 x86 的 add [rbx], 1 要访问内存, 它到底要花几个周期,取决于数据在不在缓存里。 这种「时间不确定」的指令,是流水线最难处理的东西。

第三条:指令格式统一

在 ARM64 里,源寄存器和目标寄存器的位置是固定的那几个位段。 译码器不需要「先看看是什么指令,再决定去哪几个位取寄存器号」。 它可以在读到指令的那一瞬间,同时把寄存器号送到寄存器堆。

x86 不是这样。同样是 add,操作数可以在寄存器里、 可以在内存里、可以是立即数,编码方式完全不同, 要读完整个 ModR/M 字节才知道。

第四条:寄存器要多

x86 在 32 位时代只有 8 个通用寄存器(eax、ebx、ecx、edx、esi、edi、ebp、esp), 64 位扩到 16 个。

ARM64 有 31 个通用 64 位寄存器(x0 到 x30), 再加一个栈指针和一个零寄存器。 RISC-V 是 32 个。

为什么寄存器多重要?因为寄存器是「手边的抽屉」。 抽屉多,编译器就能把更多变量放在手边, 不用频繁地存回内存、再取出来。 x86 只有 8 个抽屉,编译器经常被迫「腾地方」——这就是它指令条数多的一个原因。

附赠的一条:条件执行

ARM 还有一个别的架构没有的特色:每条指令都可以带一个条件码。

比如 ADDEQ w0, w0, #1 的意思是「如果上一次比较的结果是相等,才执行这个加」。 条件不成立,这条指令就当作空操作,不改变任何状态。

这解决了一个很烦的问题:小分支。 如果一个 if 里面只有一条语句, 用跳转实现就要「判断 → 跳 → 执行 → 跳回来」, 而跳转会让流水线猜错——猜错就要清空重来,损失十几个周期。

用条件执行,这段代码变成「判断 → 一条可能不执行的加法」, 没有跳转,流水线不会断。 在分支密集的代码里,这一招能省不少。

代价是指令编码:条件码占了 4 位,挤掉了别的字段。 ARM64 干脆把这条取消了——因为现代的分支预测已经足够准, 条件执行省下的那点,不如把 4 位还给立即数和寄存器号。 这是一个「当年的优势,后来被别的技术进步抵消」的典型例子。

x86、ARM64、RISC-V 的通用寄存器数量与指令格式对比
图 0.4.1-3 抽屉的数量:x86-64 有 16 个,ARM64 有 31 个,RISC-V 有 32 个。抽屉越多,编译器越不需要来回搬东西。

0.4.1-5反转:x86 内部其实也是 RISC

讲到这里,很容易得出一个结论:「那 x86 不是很笨吗」。

实际情况是:从 1995 年的 Pentium Pro 开始,x86 芯片内部就把指令翻译成了 RISC 风格的微操作(micro-op,简称 uop),然后在一个 RISC 核心上执行。

也就是说,今天的 x86 是「两层结构」:

  1. 外层:兼容几十年的 x86 指令,变长、复杂、带各种历史包袱。
  2. 内层:一个定长、load-store、寄存器多的执行核心,和 ARM 的核心思路一样。

中间那层「翻译」,就是译码器。它把一条 add [rbx], 1 拆成 load、add、store 三个 uop。

所以「CISC vs RISC」这个对立,在芯片内部已经消失了。 两者都在跑 RISC 风格的核心,区别只剩下「外面裹了多厚的一层壳」。

x86 指令被译码器拆成多条微操作,再送进 RISC 风格执行核心
图 0.4.1-4 x86 的两层结构:外面是历史,里面是现在。一条复杂指令进门前,先被拆成三条简单指令。

那为什么还有性能差别?因为这层壳有成本。 成本不在执行,在「理解」。

拆开看:一条 x86 指令要过几道关

假设译码器收到一段字节流,它要做这些事:

  1. 找前缀。x86 指令前面可以有 0 到 4 个前缀字节(锁、重复、段覆盖、操作数大小)。要先扫一遍。
  2. 读操作码。一到三个字节,决定这是什么指令。
  3. 读 ModR/M。一个字节,说明操作数在寄存器还是内存、用哪种寻址方式。
  4. 读 SIB。如果是复杂寻址(基址 + 索引 × 比例),还要一个字节。
  5. 读位移和立即数。长度从 0 到 8 字节不等。

走完这五步,才知道这条指令一共多长、下一条从哪开始。 而这一步是串行的——第二条的起点依赖第一条的长度。

ARM64 呢?读 4 个字节,位段是固定的,同一时刻所有字段一起解析。 没有「先看看多长」这个过程。

0.4.1-6译码器:x86 最贵的那块电路

上一步说的「串行找长度」,是 x86 最大的结构性负担。Intel 和 AMD 花了很多年、 用了很多晶体管来绕开它。

办法一:多个译码器并联,各自猜起点

现代 x86 有 4 到 6 个译码器。它们的做法是: 第一个译码器算出长度后,立刻把「下一条的起点」告诉第二个, 第二个开始工作;同时第一个已经去处理第三条了。

这是一个「流水化的串行」:虽然每一步依赖前一步, 但可以把不同指令的不同阶段叠起来。 代价是延迟——第一个译码器算完,第二个才能动,所以启动有先后。

办法二:干脆不译了,把译好的存起来

这是更聪明的办法,叫 uop cache(微操作缓存)。 Sandy Bridge 在 2011 年引入,思路很直接:

程序里的循环会反复执行同一段代码。第一次译码后,把结果(uop 序列)存进一个专门的缓存;下次再执行到这段,直接取 uop,跳过译码器。

命中率能到 80% 以上。也就是说,大部分时候 x86 芯片 根本不在译码——它在执行上次译好的结果。

这就把「变长指令」的代价压到了很小的比例。 但代价是:这块缓存要占面积(几万个 uop,每个几十位), 而且要额外的控制逻辑来判断「这段代码译过没有」。

环节x86 要做的事ARM64 要做的事
取指按字节流取,边界未知按 4 字节对齐取
找长度串行扫描前缀、操作码、ModR/M不需要,固定 4 字节
译码4–6 路,且要处理各种格式4–8 路,格式统一
转 uop必须(复杂指令要拆)不需要(本身就是简单指令)
省事的办法uop cache,命中率 80%不太需要

看清楚最后一行:ARM 不需要 uop cache 也能跑得很好, 因为它没有「翻译」这道工序。 而 x86 必须用一块额外的缓存来弥补。 这些额外的电路,就是「同一工艺下 x86 核心更大」的一个原因。

代价的第二笔:乱序执行

变长指令带来的是「译码难」,还有一笔账在更后面:乱序执行。

x86 的指令可以直接访问内存,所以一条指令要花多久,事先不知道。 如果处理器严格按顺序执行,一条卡在内存上的指令就会堵住后面所有人。

解决办法是乱序:把后面的指令提前拿进来执行, 只要它们不依赖前面那条的结果。 实现这件事需要一个重排序缓冲(ROB,Re-order Buffer)—— 一个能装几百条指令的队列,记录每条指令的状态, 最后再按原始顺序「提交」结果。

现代 x86 的 ROB 有 500 多项(比如 Golden Cove 是 512)。 ARM 的顶级核心也差不多(Firestorm 是 630)。 所以这一项,两者已经趋同了——只要想做高性能,都得付这笔钱。

真正的差别还是在前端:x86 要先把变长指令变成定长 uop,才能进 ROB; ARM 可以直接进。 同样的 ROB 大小,x86 前端每周期能送进来的指令更少。

一句话总结这段:x86 不是「不会做 RISC」, 是「必须先把 CISC 翻译成 RISC,才能开始做 RISC」。 翻译这道工序,就是它多付的那笔钱。 这笔钱在台式机上无所谓(有电源、有风扇),在手机上就是致命的。

0.4.1-7定长与变长:取指时差在哪

上一节反复提到「取指」,值得单独讲清楚,因为它是整个流程的第一道关。

处理器执行一条指令分几步:取指(fetch)→ 译码(decode)→ 执行(execute)→ 访存(memory)→ 写回(writeback)。 取指是第一步:从指令缓存里把字节读进来。

定长:切蛋糕

ARM64 的指令缓存像一盒整齐的方块。一次取 16 字节, 就是 4 条指令,第一条从 0 开始,第二条从 4 开始,清清楚楚。

这带来三个好处:

变长:拆盲盒

x86 的指令缓存像一条没有分隔符的字符流。 处理器必须先「读懂」这一条,才知道下一条从哪个字节开始。

更麻烦的是跨缓存行:一条指令可能前半截在这一行、 后半截在下一行。这时候要等两行都到齐才能译码。 这种情况不常见,但一旦发生,就是几个周期的停顿。

还有一个隐蔽的成本:预取不准。 定长指令可以精确预取到「第 N 条」, 变长指令只能说「大概在这个范围」,取多了浪费带宽,取少了要补。

还有一个隐藏成本:对齐

定长指令有一个很细的好处,平时没人提,但在紧密的循环里能感觉到: 循环的起点可以对齐到缓存行的边界。

假设一个循环体是 5 条 ARM64 指令,正好 20 字节。 编译器可以让它从 64 字节缓存行的开头开始,整段不跨行——一次取指就够。

x86 的循环体长度是浮动的,编译器只能尽量凑: 插入几个 nop 把起点挪到对齐位置。 但循环体本身多长,编译器控制不了——它由指令的选择决定。 所以 x86 的循环更容易「跨缓存行」,一次取指变成两次。

这个损失不大,通常几个百分点。但在热点循环里 (比如一个跑十亿次的图像滤波),几个百分点就是实打实的时间。 所以高性能编译器会专门做「循环对齐」优化——这几乎是 x86 独有的需求。

一个能感觉到的差别:同样的代码,ARM 版本的指令缓存命中率通常更高。 不是因为它缓存大,是因为它的指令排布更紧凑、更可预测。 这在手机这种缓存很小的设备上,影响比在台式机上大得多。

0.4.1-8load-store 与三十一个寄存器

这一节讲 RISC 的第二条和第四条戒律,它们是一对。

为什么「只有 load/store 能碰内存」是好事

表面上看,这条规矩让程序变长了:一条变三条。但它换来了一件极重要的事—— 每条指令的时间可以预测。

流水线最怕「不确定」。如果一条 add 可能在 1 个周期完成(数据在寄存器), 也可能在 300 个周期完成(数据在内存里,缓存没命中), 那流水线就没法安排后面的工作。

RISC 的做法是:把不确定性集中到 load/store 上, 其他指令全部固定周期。这样流水线可以放心地往前冲, 只在遇到 load 时才需要等。

而 x86 的做法是:让每条指令都可能访问内存, 然后用复杂的硬件去处理这种不确定性(重排序缓冲、乱序执行)。 这又是一笔「用晶体管换兼容」的交易。

三十一个寄存器解决了什么问题

编译器的一个核心任务是「寄存器分配」:把程序里的变量安排到寄存器里, 让它们尽量待在手边。

寄存器越多,能同时放在手边的变量越多,需要「存回内存再取出来」的次数越少。 这个次数有个专门的指标,叫溢出(spill)。

x86 在 32 位时代只有 8 个寄存器,其中 esp 是栈指针、ebp 常常被帧指针占用, 真正能自由用的只有 6 个左右。 稍微复杂一点的循环,变量就不够放了,编译器只能往内存里塞。

ARM64 有 31 个,其中 x30 是返回地址、x29 常作帧指针,还有 29 个可用。 接近五倍的差距。

这就是为什么同一个算法,ARM64 编译出来的指令条数往往比 x86-64 少—— 不是因为它指令更强,是因为它不用频繁地「腾抽屉」。

一个能直接看到的好处:参数怎么传

函数调用时,参数要传给被调用的函数。传参靠什么?靠寄存器,或者靠栈。

x86-64 的约定(System V ABI,Linux 和 macOS 用): 前 6 个参数放寄存器(rdi、rsi、rdx、rcx、r8、r9), 第 7 个开始压栈。

ARM64 的约定(AAPCS64): 前 8 个参数放寄存器(x0 到 x7),第 9 个开始压栈。

看起来只差两个。但压栈不只是「少用一个寄存器」—— 每次压栈是一次内存写,每次读参数是一次内存读。 一个七参数的函数,x86 上要写一次内存,ARM 上不用。

更深的影响在叶子函数(不再调用别的函数的小函数)。 ARM64 上,一个只用 x0–x7 的小函数可以不碰栈——不建栈帧、不保存、不恢复。 这类函数在程序里占大多数,它们的开销直接决定了「函数调用有多便宜」。

但寄存器多也有代价:保存和恢复。函数调用时,被调用的函数如果要改寄存器,就得先把原值存到栈上。 31 个寄存器意味着上下文切换、中断处理时要保存的状态更多。 所以 ARM 的调用约定把寄存器分成「调用者保存」和「被调用者保存」两类, 就是为了控制这个成本。

0.4.1-9代码密度:ARM 曾经输过的那一局

讲到这里,ARM 好像处处占优。但历史上它在一个关键指标上输过,而且输得很难看。

这个指标叫代码密度:同样的程序,编译出来的机器码有多大。

定长的代价:每条都占满 4 字节

ARM 的定长 4 字节设计,在 32 位时代带来了一个尴尬: 一条只有「寄存器加 1」的简单指令,也要占 4 个字节。 而 x86 的对应指令可能只要 2 个字节。

在手机上,这个问题很严重:代码要占内存,内存要占空间和电。 当年 ARM 的芯片常常只有几十 KB 的存储, 代码密度直接决定了「能不能装下」。

Thumb:一半长度的指令集

1994 年,ARM 推出了 Thumb 指令集:一套 16 位的「压缩版」指令。 只保留最常用的操作,格式更紧,代价是功能受限(不能条件执行、立即数范围小)。

处理器可以在两种模式间切换,或者(在后来的版本里)混着用。 结果很实在:代码体积减少 30% 到 40%,性能只掉 10% 到 15%。 对当时的手机来说,这笔买卖太划算——所以 Thumb 成了标配。

RISC-V 也走了这条路

RISC-V 的基础指令是 32 位,但它有一个可选的 C 扩展 (Compressed),把常用指令压到 16 位。 加了 C 扩展的 RISC-V,代码密度接近 x86。

这说明一件事:「定长」是一个工程上的取舍,不是一个教条。 定长让译码简单,但浪费空间;变长省空间,但译码复杂。 现代设计的选择是「主指令定长 + 常用指令压缩」——两头的好处都拿一点。

方案指令长度代码密度译码难度
x86-641–15 字节最高最难
ARM64(A64)固定 4 字节中等简单
ARM Thumb-22 或 4 字节高中等
RISC-V + C 扩展2 或 4 字节高中等

注意第一行和第四行的对比:x86 的密度优势是靠「极端变长」换来的, 而 RISC-V 用「两种长度」就拿到了接近的效果。 这是后发优势——它不用兼容四十年的历史。

同一段 C 代码编译成 x86-64 与 ARM64 的指令序列对比
图 0.4.1-6 同一段循环,两种编译结果。x86 版本更短(代码密度高),ARM64 版本更规整(每条定长、寄存器够用)。

0.4.1-10功耗到底从哪来

这一节要拆掉第二个流行的说法:「ARM 省电是因为 RISC」。

这句话有一半对,但它把因果关系搞反了顺序。

功耗的三个来源

芯片的功耗分三块,比例随设计差别很大:

一、动态功耗。晶体管开关时给电容充放电。 公式是 P = C × V² × f。 这一项占大头,而且对电压极其敏感——电压降 10%,功耗降 19%。

二、静态功耗(漏电)。晶体管关不严,一直有微小电流漏过去。 工艺越先进,漏电占比越高。

三、短路功耗。开关瞬间,上下管同时导通的极短时间。 占比小,但频率越高越明显。

指令集影响的是哪一块

指令集主要影响「C」——等效电容,也就是晶体管数量和翻转次数。

回到上一节的结论:x86 要多一套译码器、多一块 uop cache、 多一堆处理「不确定」的电路。这些晶体管的电容,每次开关都要耗电。 所以同样的工作,x86 核心要翻转更多的晶体管。

但这个差距有多大?在同等微架构、同等工艺下,大概是 10% 到 30% 的量级—— 不是「几倍」。

真正造成「手机几瓦、笔记本几十瓦」这个巨大差距的,是另外三件事:

  1. 工艺。手机芯片用最先进的制程(3nm、2nm),台式机芯片往往落后一到两代。同一颗设计,换一代工艺,功耗能差 30% 到 40%。
  2. 频率。手机大核跑 2.5–3.5 GHz,台式机冲 5–6 GHz。而功耗随频率是超线性的(第 0.3.2 节算过,大致三次方)。频率高 60%,功耗可能翻倍。
  3. 电压。高频必须高压。手机芯片在 0.7–0.9V 工作,台式机在 1.1–1.3V。电压高 40%,动态功耗高 96%——几乎翻倍。

把这三件事乘起来,才是「几瓦 vs 几十瓦」的来源。 指令集只是其中一个不太大的因子。

所以正确的说法是:ARM 省电,主要是因为它设计给手机用—— 低频率、低电压、小核心、先进工艺。 「RISC 所以省电」这个因果链,中间少了好几环。 反过来,如果把 x86 限制到 15 瓦、2.5 GHz,它也能很省电(笔记本上就是这样做的), 只是它在那个功耗点上,性能不如专门为低功耗设计的 ARM 核心。

一个思想实验

假设让 Intel 用 3nm 工艺,做一个 15 瓦、2.5 GHz 的 x86 核心。 它会比同条件的 ARM 核心费电吗?

会,但差距不是十倍,大概是百分之十几到三十。 这百分之几十,来自译码器和那套「兼容性开销」。 而这百分之几十,在手机那种「每毫瓦都要算」的场景里,就足以决定成败了。

这就是为什么 ARM 能统治手机,而 x86 统治 PC: 不是谁更先进,是谁更适合那个功耗窗口。

一个反面案例:x86 手机为什么没成

2012 年,Intel 认真做过手机芯片,叫 Atom。 它的功耗已经压到可以和同期 ARM 芯片比的程度,性能甚至更好。 结果四年后退出,一台主流手机都没站住。

失败的原因不是「x86 太费电」,是两件更实际的事:

一是生态。Android 的应用大部分是用 Java/Kotlin 写的, 跑在虚拟机里,理论上可以跨架构。但大量应用带 native 库(游戏引擎、图像处理、音视频编解码), 这些库只编了 ARM 版本。 Intel 只能自己做二进制翻译,性能和兼容性都打折。

二是成本结构。手机芯片是「按百万片算成本」的生意, 而 x86 芯片的研发成本要靠 PC 的销量摊。 用做 PC 的成本结构去打手机的价格战,怎么算都不划算。

这件事的教训很清楚:架构的胜负,很少是「谁的技术更好」决定的。 它取决于生态、成本、时机——三者缺一不可。 而这三样,恰恰是最难改变的。

0.4.1-11生态:真正的护城河

最后一节讲一个技术之外的因素,但它比技术更重要。

如果只看技术,x86 早就该被替换了。但它没有,原因只有一个: 全世界几十年积累的软件,都是 x86 的二进制。

二进制兼容是什么意思

一个程序编译成机器码之后,里面是具体的指令序列。 这些指令是 x86 的,就只能跑在 x86 上。

想换指令集,有两条路:

一是重新编译。有源代码的程序可以,但大量商业软件没有源码。 而且重新编译意味着要重新测试、重新认证——成本极高。

二是模拟/翻译。在 ARM 上跑一个 x86 翻译层,把 x86 指令实时翻成 ARM 指令。 苹果的 Rosetta 2 就是这么做的,效率相当高(大概原生的 70% 到 80%)。 但它是「补救」,不是「原生」——而且只对应用有效,对驱动、内核模块无效。

Wintel 联盟:一个自我强化的循环

Windows 只跑 x86,所以软件都为 x86 写; 软件都为 x86 写,所以没人愿意做 ARM 的 PC; 没人做 ARM 的 PC,所以 Windows 不必支持 ARM。

这个循环持续了三十年。打破它需要一件事: 有人能同时提供「硬件 + 系统 + 翻译层」,而且体验足够好。 苹果在 2020 年做到了——因为它同时控制芯片、系统和应用商店。 这就是 M1 的意义,下一节细讲。

为什么全世界只有两家能造 x86

这件事很少有人问,但答案很能说明问题。

1976 年,Intel 和 AMD 签了第二供应商协议:AMD 可以生产 Intel 的处理器, 条件是必须用 Intel 的指令集。1982 年又续了一次。 从那时起,x86 就只有这两家在做。

后来有人试过:Cyrix、Centaur、Transmeta、VIA,都做过 x86 兼容芯片。 结局是要么被收购,要么退出,要么只做低端嵌入式。 不是因为技术做不出来,是因为专利和授权。

2009 年,AMD 拆分出 GlobalFoundries,Intel 一度想收回授权, 最后以反垄断和解收场——AMD 保留 x86 授权,但要交叉授权给 Intel。

结果是:x86 是一个封闭的双寡头市场。 好处是兼容性极好(两家必须完全对齐), 坏处是没有第三家能用「同样的指令集、更好的设计」来竞争。 ARM 正好相反:谁都能买授权,谁都能设计。 一个赢在统一,一个赢在开放——这是两种不同的生态策略。

第三条路:RISC-V 想做什么

2010 年,伯克利的团队开始做 RISC-V。 它的目标不是「更快」,是「谁都能用,不用交钱」。

ARM 的授权是要收费的(一次性授权费 + 每片提成),而且 你不能改它的指令集。RISC-V 反过来了: 规范完全公开,谁都能实现,谁都能加自己的扩展, 而且不需要付版税。

这带来一个很现实的好处:小公司也能做自己的 CPU。 一个团队想做专用芯片(比如 AI 加速、存储控制器), 用 RISC-V 做核心,不用谈授权、不用等审批、不用按片付费。

目前的短板是生态:编译器、操作系统、调试工具都在补,但还没到 ARM 的成熟度。 不过它已经在中低端嵌入式和部分服务器上站住了脚—— 这条路和 ARM 当年走过的路,几乎一模一样。

ARM 的另一个问题:碎片化

ARM 不是一家公司卖芯片,它是卖指令集授权。 高通、联发科、苹果、三星各自设计核心,各自加不同的扩展。

结果是:同样是 ARM64,不同厂家的芯片,某些指令的行为可能不一样, 某些扩展有的有、有的没有。 所以在 ARM 上做底层软件,比在 x86 上麻烦——x86 只有两家(Intel、AMD), 而且它们必须保持完全兼容。

x86ARM
谁做芯片Intel、AMD(还有少量授权厂)几十家,各自设计
指令集来源两家各自扩展,但互相兼容ARM 公司授权,版本众多
软件生态几十年 PC 软件,二进制兼容移动端极强,PC 端薄弱
优势场景桌面、服务器、游戏手机、平板、嵌入式、部分服务器

看第三行:「移动端极强,PC 端薄弱」——这不是技术问题,是历史问题。 ARM 在手机上积累了二十年,那里是它的主场; 而 PC 上的软件,从操作系统到驱动到游戏,都是围绕 x86 长出来的。 换指令集,等于换一整个生态,这个成本比设计一颗新芯片高得多。

主要指令集家族的时间线与分支:x86、ARM、RISC-V、MIPS、Power
图 0.4.1-5 五条支线,同一个起点(1970 年代的微处理器)。注意 ARM 那条线在 2011 年之后突然加速——那是手机时代的推力。

四个常见的误解

这一节的内容,网上流传着不少简化版。有四个说法值得专门纠正一下。

误解一:「RISC 一定比 CISC 快。」 九十年代确实如此——RISC 的流水线简单,能跑更高频率。 但今天两者的性能已经在同一个区间,差别更多来自微架构(几路译码、多大的 ROB、缓存多大) 和工艺,而不是指令集本身。 同样的工艺和面积预算,谁的设计更好,谁就更快——和 CISC/RISC 的标签关系不大。

误解二:「x86 是 CISC,所以内部很落后。」 前面讲过:x86 内部跑的是 RISC 风格的 uop。 它落后的地方只有一处——前端要翻译。 这一处确实要花晶体管和电,但不是「整个架构落后」。

误解三:「ARM 一定省电。」 ARM 也有 200 瓦以上的服务器芯片(比如各类云厂商的自研 CPU)。 省电的不是指令集,是「为低功耗窗口做的设计」—— 低频率、低电压、小核心、先进工艺。 把 ARM 拉到 5 GHz 去跑,它一样费电。

误解四:「指令集决定了性能上限。」 决定性能上限的是三件事:工艺(能放多少晶体管)、微架构(怎么组织这些晶体管)、 以及散热供电(能跑多高频率)。 指令集影响的是「同样工艺下,要多花多少晶体管去做同一件事」。 它是一个系数,不是天花板。

0.4.1-12小结与十道自测题

把这一节收成一张对照表

维度x86(CISC)ARM64 / RISC-V(RISC)
指令长度1–15 字节,变长4 字节定长(可加 2 字节压缩)
一条指令干几件事可以访问内存、算、写回只能干一件,访存靠 load/store
寄存器16 个(64 位)31–32 个
译码难,要串行找长度,靠 uop cache 补救简单,可以宽并行
代码密度高中等(Thumb / C 扩展可提高)
内部执行核心其实也是 RISC 风格本来就是
生态PC 与服务器,几十年积累移动端统治,PC 端在建

把这一节压缩成六句话:

  1. CISC 和 RISC 的区别,不是「先进 vs 落后」,是「复杂度放在硬件还是编译器」。
  2. CISC 诞生在内存比 CPU 贵两个数量级的年代,目标是「让程序短」,不是为了性能。
  3. RISC 的四条戒律互相支撑:定长、load-store、格式统一、寄存器多。
  4. 现代 x86 内部早就是 RISC 核心了,差别在于它必须先「翻译」——这道工序要花晶体管和电。
  5. 功耗的差距主要来自工艺、频率、电压,指令集只占其中百分之十几到三十。
  6. 真正挡住 ARM 上桌面的不是技术,是几十年积累的 x86 二进制生态。
下一节的入口:这一节留了一个悬念——苹果在 2020 年用 M1 打破了 Wintel 循环。 它凭什么做到?不是因为它用了 ARM(ARM 的 PC 早就有人做过,都失败了)。 它做对的是另外几件事:把内存焊在芯片旁边、把 CPU 和 GPU 放进同一个功耗池、 用 Rosetta 2 兜住旧软件、以及一个别人学不来的东西——它同时控制芯片、系统和商店。 下一节把 M1 拆开看。

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

  1. CISC 和 RISC 最本质的区别是什么?为什么说「RISC 指令少」这个说法不准确?
  2. 1978 年,1MB 内存大约多少钱?这个数字如何影响了 8086 的指令设计?
  3. 微码是什么?为什么复杂指令要走微码,而简单指令可以硬布线?
  4. x86 指令的长度范围是多少?「变长」给取指带来什么具体麻烦?
  5. RISC 的四条设计原则分别是什么?它们之间怎么互相支撑?
  6. 什么是微操作(uop)?从哪一代 x86 开始,内部改成「翻译后执行」?
  7. uop cache 解决什么问题?命中率大概多少?它自己有什么代价?
  8. ARM64 和 x86-64 各有多少个通用寄存器?寄存器多有什么好处、什么代价?
  9. Thumb 是什么?它为什么会出现,代价是什么?
  10. 「ARM 省电是因为 RISC」这个说法哪里不准确?真正的三个主因是什么?
点开看简答(先自己想,别急着点)

1. 本质是「复杂度放在哪」:CISC 放硬件里(一条指令干多件事),RISC 放编译器里(多条简单指令)。RISC 的指令条数并不少(加 SIMD、加密扩展后也有几百条),关键是「规整」——定长、格式统一。
2. 约 7680 美元(1024 KB × 7.5)。内存比 CPU 贵两个数量级,所以指令要尽量短、一条干多件事,好让程序装得下。
3. 微码是芯片内部的一小段「微程序」,把复杂指令拆成一串微操作。走微码要多个周期,所以慢;简单指令可以硬布线,一个周期完成。
4. 1 到 15 字节。麻烦在于「不知道下一条从哪开始」——必须串行扫描前缀、操作码、ModR/M,才能算出长度,这卡住了并行译码。
5. 定长、load-store(只有 load/store 访存)、格式统一、寄存器多。定长让并行译码成为可能,格式统一让字段可以同时解析,寄存器多减少溢出,load-store 让每条指令时间可预测。
6. uop 是 x86 指令被译码后生成的内部简单指令。从 1995 年的 Pentium Pro 开始。
7. 它缓存「译好的 uop 序列」,让循环第二次执行时跳过译码。命中率 80% 以上。代价是占面积(几万个 uop)和额外的控制逻辑。
8. x86-64 有 16 个,ARM64 有 31 个(加 SP 和零寄存器),RISC-V 有 32 个。好处是减少寄存器溢出(不用频繁存回内存);代价是函数调用和上下文切换时要保存更多状态。
9. Thumb 是 ARM 的 16 位压缩指令集,1994 年推出。因为定长 4 字节在存储昂贵的年代太浪费,Thumb 能把代码缩小 30%–40%,性能只掉 10%–15%。代价是功能受限(条件执行、立即数范围)。
10. 不准确。省电的主因是工艺更先进、频率更低、电压更低(P=C×V²×f,电压和频率都是超线性影响)。指令集带来的差异大约 10%–30%,是其中一个因子,不是全部。

← 0.3.2 笔记本为什么贵