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

1.3.5 缓存、多核与超线程

约 1.1 万字 · 6 张图 · 读完你能说清为什么内存访问慢 200 拍还能跑得动、 为什么两个线程各写各的变量会互相拖慢五倍、 并且明白「核心多不等于快」这句话到底卡在哪一层

上一节把「算」压到了极致,这一节讲「等」。 一条 add 从取指到退休大约 20 拍,一次内存访问要 200 拍。 如果每条指令都真的去内存拿数据,前面所有的流水线、旁路、乱序、预测, 全部白搭——处理器 95% 的时间在等一根内存条。 缓存做的就是把这 200 拍变成 4 拍。 而一旦有了缓存,多核就冒出一个新问题:两块缓存里的同一份数据, 谁说了算。MESI 协议、内存屏障、伪共享、NUMA, 这一整串东西都是从「缓存」这两个字里长出来的。 这一节最后会回答标题里的问题:为什么核心多不等于快。

本节的小部分

  1. 1 200 拍与 4 拍:一次未命中的账
  2. 2 缓存凭什么管用:局部性与工作集
  3. 3 一个地址怎么变成一次命中
  4. 4 满了踢谁:替换策略与写策略
  5. 5 三级分工:L1、L2、L3 各管什么
  6. 6 多核的第一道难题:缓存一致性
  7. 7 MESI 的四态:一次写要花多久
  8. 8 内存序:为什么 CPU 会重排你的代码
  9. 9 伪共享:同一行上的两个变量
  10. 10 多核怎么连起来:环形、网格、NUMA
  11. 11 超线程在共享什么
  12. 12 内存墙、预取,以及为什么核心多不等于快

1.3.5-1200 拍与 4 拍:一次未命中的账

先算一笔最朴素的账。假设一颗 3 GHz 的处理器,一条 add 走完五级流水要 5 拍,从取指到退休(算上乱序引擎的各种开销) 实际大约 15~20 拍。20 拍在 3 GHz 上是 6.7 纳秒。 而一次真的去内存拿数据、发现缓存里没有,要先读到 L3、 L3 也没有就去内存控制器、内存控制器去 DRAM 阵列里找那一行, 全程大约 200~300 拍,也就是 70~100 纳秒。

两者差了一个半数量级。假设程序里每 10 条指令就有一次真正的内存访问, 而这次访问每次都落空——那么每 10 条指令要等 250 拍, 平均摊下来每条指令多花 25 拍。IPC 会从 2 掉到 0.04。 这个数字意味着什么?意味着这颗 3 GHz 的处理器跑起来跟一颗 60 MHz 的处理器差不多。所有的流水线、旁路、乱序、分支预测, 在「每次都要去内存」这个前提下加起来只值 60 MHz。

这就是为什么缓存不是「优化」,是「前提」。没有缓存, 现代处理器架构根本立不起来——不是慢一点,是慢两个数量级。 而缓存要做的,就是把 200 拍压到 4 拍:一级缓存命中大约 4~5 拍, 二级 12~14 拍,三级 40~50 拍。这三层合起来, 把「平均访存延迟」(AMAT)压到一个能接受的水平。

AMAT 这个公式值得记住。 AMAT = 命中时间 + 未命中率 × 未命中代价。 一级缓存命中时间 4 拍,未命中率 5%,未命中要花 200 拍—— 那么 AMAT = 4 + 0.05 × 200 = 14 拍。 加一层二级:L1 未命中率 5%,L2 命中时间 12 拍, L2 里有 80% 能找到,剩下 20% 才去内存。 AMAT = 4 + 0.05 × (12 + 0.2 × 200) = 4 + 0.05 × 52 = 6.6 拍。 就这一层缓存,把 14 拍变成 6.6 拍,翻了一倍还多。

这个公式还揭示了一件反直觉的事:优化命中时间比优化未命中率更划算。 上面那个例子里,把 L2 命中时间从 12 拍降到 10 拍,AMAT 从 6.6 降到 6.5; 把 L1 未命中率从 5% 降到 4%,AMAT 从 6.6 降到 6.08。 后者更有效,但前者更容易做——这就是为什么处理器厂商两边都在拼命。

还有一件事必须说清楚:「拍」这个单位在不同处理器上不一样。 同样是「L1 命中 4 拍」,在 3 GHz 的核上是 1.3 纳秒, 在 5 GHz 的核上是 0.8 纳秒。所以跨代比较必须换算成时间, 不能直接比拍数。这也是为什么主频停滞之后, 处理器厂商的宣传重点从「多少 GHz」变成了「IPC 提升多少」, 再变成了「缓存多少 MB」——因为后者是当下真正卡脖子的地方。

存储层次金字塔:寄存器、L1、L2、L3、内存、SSD、磁盘七层的容量与延迟对比
图 1.3.5-1 从寄存器到磁盘的七层。左边是容量(对数轴),右边是延迟(对数轴),两个轴的跨度都是六个数量级。最值得记住的是那条对角线——容量每翻十倍,延迟大致也翻十倍,这不是巧合,是「越小越快」这条物理规律在起作用:小存储可以做得离 ALU 更近、可以用更贵的电路、可以并行比较所有行。这张图也解释了为什么缓存要分级:一级做不大,做大了就慢;要做大,只能慢一点,于是有了二级、三级。

1.3.5-2缓存凭什么管用:局部性与工作集

缓存能起作用,靠的是程序访问内存时的一种统计规律: 刚刚访问过的地址,很可能马上再被访问;刚刚访问过的地址旁边的地址, 很可能马上被访问。前者叫时间局部性,后者叫空间局部性。

时间局部性来自循环和反复调用的函数。一个 for 循环体里 的计数器 i,每个迭代都要读一次、写一次; 一个被调用一千次的函数,它的代码在每次调用时都要被取指。 这些数据如果每次都去内存拿,光是 i 一个人就能把流水线拖死。

空间局部性来自数据结构和顺序执行。数组 a[0] 被访问之后, a[1]、a[2]、a[3] 几乎肯定接着被访问; 指令是一条接一条放的,取了一条指令,后面几条就在它旁边。 这就是为什么缓存和内存之间不是按字节搬,而是按行(cache line)搬—— 一次搬 64 字节,代价和搬 1 字节差不多(因为 DRAM 的访问粒度就是一行, 而且总线的传输时间远小于寻址时间)。

这两个局部性合起来,就产生了一个关键概念:工作集(working set)。 程序在一段时间内真正频繁访问的那部分数据,叫它的工作集。 如果工作集能装进缓存,程序就跑得快;装不进,缓存就开始颠簸—— 每次访问都把上一次刚装进来的东西挤掉,命中率断崖式下跌。 这个现象叫抖动(thrashing),和操作系统里的页面抖动是同一回事, 只是尺度小了一千倍。

一个能实测的例子。 遍历一个 int 数组并求和,数组大小从 1 KB 一路加到 1 GB。 在 1 KB~32 KB 区间,每次加一倍的耗时几乎线性增长,说明全在 L1 里; 过了 32 KB 出现一个明显的台阶,耗时突然跳 3 倍——那是掉出 L1 进了 L2; 过了 512 KB 再跳一次,进 L3;过了几十 MB 再跳一次,进内存。 这条「阶梯曲线」是测缓存层级最经典的方法, 每一级台阶的位置就是那一级缓存的容量。

值得注意的是,缓存对顺序访问和随机访问的态度完全不同。 顺序访问时,一次未命中会把整行 64 字节都装进来, 后面 15 个 int 全部命中,等效未命中率只有 1/16。 随机访问时,装进来的 64 字节里只用 4 字节,剩下 60 字节全是浪费, 有效带宽只剩 1/16。这就是为什么链表遍历比数组遍历慢那么多—— 不是因为指针跳转本身慢,是因为链表把空间局部性彻底破坏了。

有一组数字能把这件事说透。假设内存延迟 80 纳秒、缓存行 64 字节。 顺序遍历数组时,硬件预取器能提前把后面的行拉进来, 实际吞吐可以接近内存带宽(双通道 DDR5 大约 70 GB/s)。 随机遍历时,每次访问都要等满 80 纳秒, 单线程每秒只能做 1250 万次访问,每次拿 64 字节——算下来 0.8 GB/s。 差了将近一百倍,全在「下一行在哪」这件事上。 这是数据结构课上说「数组比链表快」时从来不提的那个真实原因。

1.3.5-3一个地址怎么变成一次命中

缓存在硬件上就是一块 SRAM 加一套比较电路。问题是:怎么在几千行里 快速找到「我要的那一行在不在」?最直接的办法是拿地址去逐行比对, 但那是几千次比较,慢得没法用。真实的做法是把地址切成几段, 用其中一段当索引直接定位——这就是组相联(set associative)。

一个 64 位虚拟地址,在缓存看来是三段:

段宽度作用
行内偏移 offset6 位(64 字节行)定位行内的哪个字节,缓存查找时不用它
组索引 index取决于组数,如 6 位 = 64 组直接选中一行「候选组」,一步到位
标记 tag剩下的高位和组内每一路的 tag 并行比较,判断是不是我要的那行

以 Intel Skylake 的 L1 数据缓存为例:48 KB、12 路组相联、64 字节行。 48 KB / 64 B = 768 行,768 / 12 路 = 64 组。 所以 index 是 6 位,offset 是 6 位。 一次查找的过程是:拿地址的 6 位 index 选中 64 组里的一组, 这一组有 12 路,把 12 个 tag 同时取出来,和地址的 tag 段并行比较, 12 个比较器同时出结果。命中就是「某一路的 tag 相等且 valid 位为 1」。 整个过程是组合逻辑,4 拍就能出结果——因为它只有一级比较, 不需要遍历。

为什么是 12 路,不是 1 路也不是 768 路? 这是三个因素拉扯的结果。路数越多,冲突越少—— 如果只有 1 路(直接映射),两个地址恰好 index 相同就会互相踢, 哪怕缓存里还有大片空地。但路数越多,比较器和选择器越贵—— 12 路就要 12 套比较器加一个 12 选 1 的多路器, 而且每一路都要接读出放大器,面积和功耗都上去了。 而且路数多了之后,命中时间也会变长(多路器的级数增加)。

实际的选择是:L1 用 8~12 路,L2 用 8~16 路,L3 用 12~16 路。 这个数字不是随便定的,是「冲突未命中率」和「命中时间」的曲线交点。 从 1 路加到 2 路,冲突未命中率能降一半;从 2 路到 4 路再降一半; 从 8 路到 16 路,只降几个百分点,但面积翻倍。 所以大家在 8~16 路之间停下。

还有一个更根本的问题:用虚拟地址还是物理地址查缓存? 程序用的是虚拟地址,但缓存必须是物理地址索引的——否则两个进程 用同一个虚拟地址访问不同的物理页,缓存会串。可虚拟地址转物理地址 要走页表(TLB 命中 1 拍,未命中要几十上百拍), 如果先转换再查缓存,光是地址翻译就把 L1 的 4 拍吃光了。

真实的解法是VIPT(virtual indexed, physically tagged): 用虚拟地址的 index 段去选组(因为页大小 4 KB = 12 位, 而 index + offset 只有 12 位时,这段虚拟地址和物理地址完全相同), 同时并行地做 TLB 翻译;等物理地址出来,再用物理 tag 段去比较。 两条路并行跑,谁也不等谁。这个技巧成立的前提是 index + offset 的位数不超过页内偏移的位数—— 一旦缓存大到超过这个限制(比如 32 KB 以上的 L1), 厂商就得改设计:要么提高相联度(让 index 变窄), 要么干脆改成物理索引(PIPT,多花几拍)。Skylake 的 L1 用 12 路正是为了这个:48 KB / 64 B / 12 = 64 组,index 只要 6 位, 加 offset 6 位正好 12 位,卡在 4 KB 页的边界上。 一个缓存的相联度,居然是被页大小逼出来的。

缓存地址拆分与组相联查找:64 位地址切成 tag、index、offset,index 选中一组后 8 路 tag 并行比较
图 1.3.5-2 一个地址怎么变成一次命中。上面是地址的三段拆分,下面是缓存的组织:组是行,路是列,index 直接选中一行,然后这一行的 8 个 tag 并行比较。注意右边那个「同一行里 8 个格子的 tag 全都不同」——这正是组相联的意思:同一组里的 8 路可以装 8 个不同的地址,只要它们的 index 相同。直接映射就是「只有一路」,那 8 个候选变成 1 个,冲突未命中率立刻上去。

1.3.5-4满了踢谁:替换策略与写策略

组里的 8 路都满了,新来一行要踢掉谁?这个问题和操作系统换页是同一个问题, 答案也类似:踢最不可能再被用的那个。 理论最优是 Belady 算法(踢未来最晚被访问的), 但那要求预知未来,硬件做不到。实际用的是三种近似。

策略怎么选代价用在哪
LRU踢最久没被访问的每路要记时间戳,8 路要 8 套计数器小相联度时可行,实际很少真用
伪 LRU(树形)用一棵二叉树记录「哪半边更近被用过」n 路只要 n−1 个状态位L1、L2 的主流选择
随机随便挑一个几乎零成本大相联度(16 路以上)反而够用
NRU(未用优先)每行一个「最近用过」位,先踢没被标记的每行 1 位早期处理器、TLB

伪 LRU 的具体做法值得看一眼:8 路用 7 个位,组成一棵完全二叉树。 每次访问某一路,就把从根到那个叶子的路径上所有位都指向「另一边」。 要踢人的时候,从根开始,每次看当前节点指向哪边就往哪边走,走到叶子就是受害者。 这个结构的好处是更新和查询都只要 3 步(log₂8), 而且只需要 7 个位,而不是 8 个时间戳。它不精确—— 可能踢掉一个刚用过但路径被覆盖的行——但实测命中率和真 LRU 只差 1~2 个百分点。

比替换策略更容易被忽略的是写策略。写操作有两种处理方式: 写的时候只改缓存(write-back,写回),还是同时改缓存和内存(write-through,写通)? 写通简单,但每次写都要发一次内存事务,带宽受不了。 写回只在缓存行被踢出时才写回内存,省带宽,但需要给每行加一个 脏位(dirty bit)。

现代处理器全部用写回。这带来一个连锁反应:一个被写过但还没写回的行, 在缓存里是「最新的」,内存里是「旧的」。如果别的核来读这一行, 必须由持有它的那个核把数据递过去,不能直接从内存读。 这就是下一节 MESI 协议要处理的核心问题——写回策略直接把「缓存」 从「内存的副本」变成了「内存的部分真相」。

写未命中还有第二种选择:写的时候要不要把这一行先读进来? 写分配(write-allocate)是先读进来再改, 不写分配(no-write-allocate)是直接写进内存、不进缓存。 前者适合「写了还会再读」的场景(绝大多数),后者适合「写了就不管」的场景 (比如 memset 大块内存、图形渲染里的深度缓冲)。 处理器和编译器都在做这个判断:非临时存储指令 (x86 的 movnti、ARM 的 stnp) 就是明确告诉硬件「这一行别进缓存」。 用对了能省一半带宽,用错了(写完马上读)会慢两倍。

1.3.5-5三级分工:L1、L2、L3 各管什么

为什么不分一级,分三级?因为「大」和「快」不可兼得, 而程序对两者的需求分布是分层的:绝大多数访问集中在很小的一块数据上, 少部分访问散布在很大的范围里。一级缓存服务前者,三级缓存兜住后者。

层级典型容量相联度命中延迟归属
L1 指令32~64 KB8 路3~4 拍每核私有
L1 数据32~48 KB8~12 路4~5 拍每核私有
L2512 KB~2 MB8~16 路12~14 拍每核私有
L38~256 MB12~16 路40~50 拍多核共享(或分片)
内存8 GB~2 TB—200~300 拍全机共享

这张表里有三个设计决定值得说。

第一,指令和数据分开。这叫哈佛结构,和冯·诺依曼结构 相对。分开的理由不只是「取指和取数同时发生」——流水线里 IF 和 MEM 确实同时在工作,共用一块缓存就要抢端口。更重要的理由是 两者的访问模式完全不同:指令是纯顺序读(除了分支), 几乎从不写;数据是读写混合、随机得多。分开之后, 指令缓存可以做成只读、可以用更激进的预取、可以不做写回逻辑, 数据缓存则要照顾写。混在一起,两边的优化都做不了。

第二,L2 私有,L3 共享。L2 私有是因为它离核太近, 延迟只有 12 拍,做成共享的话光是走线就要几十拍,还不如不设。 L3 共享是因为它是「兜底」的那一层——如果每个核各有一块独立的 L3, 那么两个核要交换数据时只能通过内存,来回 160 纳秒。 共享 L3 让核间数据交换变成 40 拍(虽然还是要走一致性协议), 而且能避免「同一个库被四个核各缓存一份」的浪费。

第三,L3 是分片的,不是一整块。这一点最容易被误解。 现代的 L3 不是一块大的 SRAM 挂在中轴上,而是切成很多片 (slice),每片 2~4 MB,用一条环形总线或网格连起来。 一个地址属于哪一片,由地址的哈希决定——通常是取地址的某几位做异或。 所以一个核访问 L3 时,如果目标片在芯片的另一头, 延迟会比在隔壁那片高 10~20 拍。 这就是为什么「L3 延迟」在同一个处理器上不是一个固定数字, 而是一个分布。厂商标的是平均值或者最坏值。

还有一个技术细节叫包含性(inclusion)。 L3 是「包含」L1/L2 的所有内容(inclusive),还是「不包含」(non-inclusive / exclusive)?包含性的好处是一致性协议好做——要查某行在不在任何核里, 只看 L3 就够了;坏处是浪费容量,一行数据在 L1、L2、L3 各存一份。 Intel 长期用包含性,AMD Zen 用非包含性(L3 只装被踢出 L2 的行, 叫 victim cache 模式)。 非包含性省容量,但一致性探测要广播到所有核, 协议复杂得多。这是容量和协议复杂度之间的一次交换, 没有绝对的对错。

1.3.5-6多核的第一道难题:缓存一致性

现在把两个核放进来,每个核都有自己的 L1 和 L2,共享一个 L3。 考虑这样一段代码:

// 核 0
x = 1;
while (flag == 0) {}
print(x);

// 核 1
x = 2;
flag = 1;

这段代码在单核上是对的:核 1 先写 x 再写 flag, 核 0 看到 flag 变 1 时 x 一定是 2。 在多核上,它可能打印 1,也可能永远循环下去。 原因有两层,第一层就是缓存一致性: 核 1 写了 x = 2,这个 2 可能只写进了核 1 自己的 L1, 核 0 的 L1 里还是旧的 1。两块缓存各说各话,谁对?

解决办法只有一条:让所有核看到的内存是同一个内存。 这句话的正式说法叫「一致性」(coherence),它有三个必须满足的条件, 合起来叫 coherence 的三条要求:

  1. 程序顺序:同一个核先写 A 再写 B,别的核不能先看到 B 再看到 A。
  2. 写传播:一个核写了某地址,别的核最终要能看到这个写。
  3. 写串行化:所有核对同一个地址的写,必须有一个全局一致的顺序—— 不能核 0 看到的是「先 1 后 2」,核 1 看到的是「先 2 后 1」。

硬件上实现这三条有两大类方案。一类是总线监听 (snooping):所有核挂在同一条总线上,每次写都广播出去, 每个核自己检查「我这儿有没有这一行,有就失效」。简单、快, 但广播的开销随核数线性增长,超过 8 个核就撑不住了。 另一类是目录(directory):在 L3 里为每一行记一个 「谁有这一行」的位图,写的时候只通知位图里列出的那些核。 核数多时省带宽,但要额外存目录,而且查目录本身有延迟。

现实中的处理器大多是混合的:片内 8 个核以内用监听(因为 L3 是共享的, 共享的 L3 天然就是一个广播点),跨 socket 用目录。 「监听 vs 目录」这个选择,本质上是「广播便宜还是查表便宜」, 取决于核数。核少时广播赢,核多时查表赢,交叉点大约在 8~16 核。

最容易搞混的一点是:一致性(coherence)和一致性(consistency) 是两个不同的词。前者说的是「同一地址的多份副本怎么保持一致」, 后者说的是「不同地址的访问顺序怎么保证」。 中文都译成「一致性」,英文里一个是 coherence 一个是 consistency, 读论文时要看清是哪个。前者靠 MESI 这类协议,后者靠内存序模型—— 就是 1.3.5-8 要讲的东西。

1.3.5-7MESI 的四态:一次写要花多久

监听协议里最有名的是 MESI。它给每个缓存行四个状态:

状态含义内存里是最新的吗别的核有副本吗
M(Modified)本核改过,独占不是,我这儿才是没有
E(Exclusive)本核独占,没改过是没有
S(Shared)多核共享,都没改过是有,可能好几个
I(Invalid)这一行作废——

E 和 S 的区别看着很细微——都是干净的,都跟内存一致。 但它是整个协议的效率关键:如果一行处于 E(独占), 本核要写它时可以直接改成 M,一句话都不用广播。 如果只有 S 和 I 两个状态,那么每次写都要先广播一声 「你们把副本作废」,哪怕实际上根本没有别的核有副本。 程序中大量变量是「一个核写、别人不碰」的,E 状态把这些写全部变成了静默操作。

状态转移的关键几条:

现在可以算一算「一次写」的代价了。假设变量 x 在两个核之间 被反复写,缓存行在核 0 和核 1 之间来回弹——这个现象叫 缓存行乒乓(cache line ping-pong)。

乒乓的账单。 核 0 写:命中 M,1 拍。
核 1 写:未命中,发 BusRdX,核 0 递数据并降级,核 1 进 M, 这一趟大约 40~70 拍(取决于 L3 的物理距离)。
核 0 再写:又一次 BusRdX,又 40~70 拍。
两个核交替写同一个变量,每次写都要 40~70 拍, 而单核写只要 1 拍。慢了五十倍。 这就是为什么「多线程计数器」要用原子操作或者分片累加, 而不是简单地 counter++。

MESI 之后还有 MOESI(AMD 用,加了 O 状态:Owner, 表示「我这份是脏的,但别人也可以读,写回由我负责」, 省掉「M 降级到 S 时必须先写回内存」这一趟)、 MESIF(Intel 用,加了 F 状态:Forward, 多核共享时指定一个核负责应答,避免所有核同时回数据)。 名字越来越长,核心思路是一样的:用更多的状态编码更多的信息, 从而在常见场景下少发广播、少传数据。

MESI 四态转移图:I、E、S、M 四个状态之间的读写转移与总线事务
图 1.3.5-3 MESI 的四个状态与主要转移。绿色是本地操作(不需要总线),橙色是要发总线事务的,红色是「别人动了我的行」——被动降级。图里最值得看的是 E→M 那条绿色箭头:它没有对应的总线事务,这就是 Exclusive 状态的全部价值。如果只有 S 和 I,这条边就不存在,每次写都得走橙色的 BusUpgr。真实程序里大量的变量是「一个核写、别人不读」的,这条静默升级的边省下的广播量相当可观。

1.3.5-8内存序:为什么 CPU 会重排你的代码

MESI 解决了「同一地址的多个副本」。但开头那段代码还有第二个问题: 就算 x 和 flag 的缓存都同步了, 核 1 的写也可能以相反的顺序被核 0 看到—— 核 0 看到 flag = 1 的时候,x 还是 1。

为什么?因为写不是立刻生效的。每个核都有一个 存储缓冲(store buffer):写指令退休时, 值先进缓冲,然后慢慢发总线事务。缓冲的存在是为了不让 CPU 停下来等—— 写一个变量要 40 拍,如果每条写指令都等,流水线就废了。 但缓冲带来的后果是:后一条写可能比前一条先离开缓冲 (如果前一条的地址正在被别人占用,后一条可以先走)。 于是别的核看到的顺序和你写的顺序不一样。

还有失效队列(invalidate queue):收到「你那一行作废」的 消息时,不必立刻执行,先塞进队列,等有空再处理。 后果是:本核可能还在用一行已经「逻辑上作废」的数据读了一会儿。 这两个缓冲加起来,就允许了四种重排里的两种。

重排类型x86(TSO)ARM / RISC-V(弱序)说明
Load → Load不允许允许两次读,可能后发先至
Load → Store不允许允许读之后写,写可能先被别人看到
Store → Store不允许允许两次写,可能顺序颠倒
Store → Load允许允许写还在缓冲里,读已经拿到旧值

x86 用的是 TSO(Total Store Order,全序存储)。 它只允许一种重排:store 后面跟 load,load 可能先执行。 这条口子正是 store buffer 造成的——写进了缓冲但还没发出去, 后面的读不必等它。其他三种 x86 都保证顺序, 所以 x86 的程序员相对幸福,很多在 ARM 上会炸的代码在 x86 上跑得好好的。 这也造成了一个流传很广的误解:「我的代码在 x86 上测了十年没问题」。 它的意思往往是「x86 帮我掩盖了十年」。

要修这段代码,需要一个屏障(barrier / fence)。 x86 上写 asm volatile("mfence" ::: "memory"), C11 之后有标准写法 atomic_thread_fence(memory_order_seq_cst), 或者更细的 memory_order_release / acquire 配对。 release 的作用是「我前面所有的写,都必须在我这一次写之前被看到」, acquire 的作用是「我后面所有的读,都必须在我这一次读之后才发」。 两个配对,就构成了一条单向的墙。

x86 上还有一个著名的事实:mfence 很贵, 几十到上百拍。但如果你只是要实现「写数据、再置标志」这个模式, 不需要 mfence,只需要一条 xchg—— 因为 x86 的 xchg 隐含 lock 前缀,而带 lock 的指令 本身就是全屏障。这就是为什么很多无锁队列里写的是 __atomic_exchange_n(&flag, 1, __ATOMIC_SEQ_CST), 而不是 flag = 1; mfence;。后者慢三倍,效果一样。

ARM 那边的情况更糟:默认全是弱序,几乎什么都能重排。 ARMv8 提供了 dmb(数据内存屏障)、dsb(更重的、 还要等所有未完成的内存操作)、isb(指令同步屏障, 用于修改代码后的场景)。C++ 的 std::atomic 在 ARM 上会编译成 ldar / stlr (load-acquire / store-release 语义的单指令), 比一整条 dmb 便宜得多。 这就是为什么「用标准原子操作」比「手写汇编屏障」好—— 编译器知道目标平台哪条指令最便宜。

1.3.5-9伪共享:同一行上的两个变量

现在讲本节最实用的一个坑。假设要统计两个计数器,分别由两个线程更新:

struct Counters {
    long a;
    long b;
};
struct Counters c;

// 线程 0
for (long i = 0; i < N; i++) c.a++;

// 线程 1
for (long i = 0; i < N; i++) c.b++;

直觉上这两个线程毫不相干:一个只碰 a,一个只碰 b, 没有任何数据依赖。但实测下来它比单线程还慢,可能慢五到十倍。

原因是 a 和 b 在内存里是紧挨着的, 两个 long 共 16 字节,落在同一个 64 字节的缓存行里。 线程 0 写 a,要拿到这一行的独占权(M 状态), 于是线程 1 手里的副本被作废;线程 1 接着写 b, 又要抢独占权,线程 0 的副本被作废。缓存行在两个核之间来回弹, 每次弹都要 40~70 拍。这就是伪共享 (false sharing)——两个线程共享的不是数据,是缓存行。

这个坑最阴的地方在于:它在单核上完全不存在,在双核上才爆发, 而且 profiler 里看不出来。你只会看到两个线程都变慢, CPU 占用率很高,但没有锁竞争,没有 IO,没有任何可疑的地方。 用 perf 看会看到一个奇怪的指标: HITM(hit modified)事件特别多——意思是「我读的这一行, 在别的核里是脏的」,这正是乒乓的证据。

修法有三种,从粗到细:

一是填充(padding):在 a 和 b 之间塞足够的空字节,让它们落在不同的行里。C++11 起有 alignas(64),C 里有 _Alignas(64), GCC 有 __attribute__((aligned(64)))。 用 alignas(64) 修饰整个结构体,或者给每个字段单独对齐, 都能把两个字段推到不同的行。

二是按线程分片:每个线程用自己的一份计数器 (counters[thread_id].a),最后汇总。 这既消除了伪共享,又消除了真共享,是无锁编程里最常见的做法。 注意数组元素本身也要按 64 字节对齐,否则 counters[0] 和 counters[1] 又会在同一行。

三是把只读数据和可写数据分开。一个常见的设计是 「结构体里前面放一堆只读配置,后面放热字段」, 这样多个核读配置时都在 S 状态(共享是允许的,不冲突), 写热字段时才抢独占。反过来,如果把一个频繁写的字段 放在一堆只读字段中间,每次写都会把整行抢走, 连带把别人正在读的只读字段也作废掉。 Linux 内核里大量的 ____cacheline_aligned 就是在干这件事。

一个真实的量级。 两个线程各做一亿次 ++,变量相邻:约 4.2 秒。 变量各占一行(alignas(64)):约 0.6 秒。 单线程做两亿次:约 0.55 秒。 伪共享把并行变成了「比串行还慢七倍」。 这个数字在不同机器上会变,但「慢一个数量级」是稳定的。
伪共享:两个变量落在同一缓存行,两个核各自写各自的变量却反复抢夺同一行的独占权
图 1.3.5-4 伪共享是怎么发生的。上面两个核各写各的变量,逻辑上毫无关系;下面那条缓存行在两边各有一份,被写一次就在两个核之间搬一次。关键在中间那条红色的来回箭头:它搬的不是数据,是「独占权」。每一次搬都要几十拍,而真正有用的工作只有一条 inc。右边是修法:把两个变量推到不同的行里,两条线立刻各走各的。

1.3.5-10多核怎么连起来:环形、网格、NUMA

前面一直默认「所有核共享一个 L3」。核少的时候这是对的, 核多起来就不是了——一个 L3 挂 64 个核,走线和端口都做不出来。 于是有了各种拓扑。

环形总线(ring)是 Intel 从 Nehalem 到 Skylake 的方案。 所有组件(每个核的 L2、每个 L3 分片、内存控制器、IO 控制器) 排成一个环,数据在环上单向流动。要访问环对面的东西, 得一站一站传过去。这个方案的优点是简单、可扩展, 缺点是环越长延迟越高——Skylake-SP 的环上挂 28 个核, 最远两点的延迟是最邻近的几倍。

网格(mesh)是 Intel 从 Skylake-SP 开始用的。 核排成二维网格,每个交叉点是一个路由器,数据走 XY 路由 (先横向再纵向)。网格的延迟随距离线性增长, 比环形好一些,而且布线规整、面积利用率高。 代价是每个路由器都要缓存和仲裁,功耗不低。

CCX / CCD 是 AMD 的方案。它不追求一个大 L3, 而是把 4~8 个核加一块 L3 组成一个 CCX,多个 CCX 再拼起来。 Zen 2 之后叫 CCD(core chiplet die),一个 CCD 8 个核共享 32 MB L3。 跨 CCD 通信要经过 Infinity Fabric,延迟比 CCX 内部高 3~4 倍。 这就是为什么 AMD 的处理器上「线程绑核」特别重要—— 同一进程的两个线程落在不同 CCD 上,通信延迟能差三倍。

再往上一层就是 NUMA(non-uniform memory access, 非一致内存访问)。一台双路服务器有两个 socket,每个 socket 有自己的 内存控制器和自己的内存条。核访问自己 socket 的内存要 80 纳秒, 访问对面 socket 的要 140 纳秒——因为要经过 socket 之间的互联 (Intel 的 UPI、AMD 的 Infinity Fabric)。

NUMA 给软件带来的麻烦是:内存分配的位置决定了性能。 如果进程跑在 socket 0 上,但它的内存是在 socket 1 上分配的 (因为分配时恰好在那个核上跑),那么它每次访存都要跨 socket。 操作系统提供了 numactl、mbind、 set_mempolicy 来控制这件事, 也有「首次触碰」(first touch)策略——哪块内存第一次被哪个核写, 就分配在哪个核的本地。首次触碰这条策略是很多 NUMA 性能问题的根源: 一个线程分配了大数组、另一个线程去用它,全部跨 socket。

这些拓扑差异最后都落到一个数字上:核间通信延迟。 同一个 CCX 内 20 拍,同 socket 跨 CCX 60 拍,跨 socket 200 拍以上。 这个数字直接决定了「多线程程序能扩展多少个核」—— 如果一个算法每做 100 条指令就要同步一次,那么同步开销 在 8 核时就吃掉了全部收益。

三种多核拓扑:环形总线、二维网格、CCX 加跨片互联,以及双路 NUMA 的本地与远端内存
图 1.3.5-5 四种把核连起来的办法。环形最省线但延迟随环长线性增长;网格延迟随距离线性增长但布线规整;CCX 把「近」做到极致,代价是跨 CCX 变远;NUMA 把「远」推到 socket 之间。看这四张图要看的不是形状,是「任意两点之间要走几跳」——那个跳数就是同步的代价。同一段多线程代码在四种拓扑上跑,扩展性可以差出好几倍,原因全在这些线上。

1.3.5-11超线程在共享什么

超线程(Intel 叫 Hyper-Threading,AMD 叫 SMT)经常被误解成 「一个核当两个核用」。它不是。它是让两个线程轮流用同一个核的执行资源, 目的是把核里闲置的部分填满。

为什么要填满?因为一个线程在乱序核里跑的时候,执行单元经常是空的。 分支猜错要清空、缓存未命中要等 200 拍、依赖链卡住要等前面的结果。 有研究统计过,一个宽度 4 的乱序核跑单线程, 平均只有 1.5~2 个执行端口在工作。一半以上的执行资源在闲着。 超线程就是在这些空隙里塞进另一个线程的指令。

具体怎么塞?把一个物理核的硬件分成两份:

资源超线程怎么处理原因
通用寄存器、PC、标志位复制一份(架构状态双份)两个线程各有自己的上下文
重命名表、ROB、保留站分区共享它们是「在飞指令」的容器,必须按线程隔离
ALU、乘法器、浮点单元完全共享这是真正干活的部分,谁用都行
L1、L2、TLB完全共享复制不起,面积翻倍。代价是两个线程互相挤
分支预测器共享(有的设计加线程标记)两个线程的分支会互相污染历史

从这个表就能看出超线程的收益和代价都不小。 收益是:单线程跑的时候,闲置的执行单元被填上了,吞吐能提高 15~30%。 代价是:两个线程抢同一块 L1、同一份 ROB、同一个分支预测器, 单线程的性能反而会下降几个百分点。 所以超线程不是「免费的两倍」,是「用一点单线程性能换不少吞吐」。

什么时候收益最大?两个线程都在等内存的时候。 一个线程卡在缓存未命中上,另一个线程正好可以用这段时间执行—— 这是超线程最理想的场景,实测能到 1.6 倍甚至更高。 什么时候收益最小?两个线程都在做密集计算的时候。 两个线程抢同一个 FPU,谁也没快,总吞吐几乎不变, 甚至因为抢 L1 变慢。

这就解释了一个常见的困惑:为什么服务器 CPU 开超线程跑数据库能快 30%, 而跑科学计算几乎没变化?因为数据库的瓶颈在访存和 IO 等待上(适合超线程), 科学计算的瓶颈在浮点吞吐上(不适合)。 「要不要关超线程」这个问题没有统一答案, 它取决于你的程序在等什么。

还有一件事值得说:超线程让「核数」这个数字变得不可比了。 一个 8 核 16 线程的处理器,物理执行资源只有 8 份, 不是 16 份。云厂商卖 vCPU 的时候,一个 vCPU 往往就是一个超线程, 所以「4 vCPU」可能只对应 2 个物理核。 这就是为什么同样的 vCPU 数,不同实例类型的性能能差一倍—— 差别不在核数,在物理资源怎么切。

超线程的资源划分:两份架构状态与分区共享的重排缓冲,共用同一组执行单元和一级缓存
图 1.3.5-6 超线程到底复制了什么、共享了什么。上面两份是各自独立的架构状态(寄存器、PC),中间的重排缓冲和保留站按线程分区,下面那排执行单元和 L1 缓存是两家共用的。看这张图要抓住一个比例:复制的那部分很小(大约占核面积的 5%),共享的那部分很大。这就是超线程「花 5% 面积换 20% 吞吐」的全部秘密,也是它收益上限的来源——共享的部分一旦成为瓶颈,再加线程也没用。

1.3.5-12内存墙、预取,以及为什么核心多不等于快

最后把这一节收起来。先补上「内存墙」这件事的完整图景。

从 1980 年到 2005 年,处理器主频每年涨 50%~60%, 而 DRAM 的访问延迟每年只降 7%。两条曲线越拉越开, 这个差距叫内存墙(memory wall)。 1980 年,一次内存访问大约等于 1 条指令的时间; 2000 年是 100 条;2020 年是 300 条。 处理器快了三百倍,内存几乎没快。

硬件对付内存墙的手段有三类。第一类是缓存, 就是把数据搬到近处,前面讲的都是这个。第二类是预取: 在数据被用到之前就把它拉进来。

硬件预取器的工作方式是观察访问模式。如果它发现你连续访问了 0x1000、0x1040、0x1080 (每次加 64 字节),它就推测你要顺序遍历,主动把 0x10c0、0x1100……往后拉。 一个 L2 预取器通常能维持 8~16 个「在飞的预取」, 这正好把「一次只能等一个未命中」变成「同时等十几个」—— 这个能力叫 MLP(memory level parallelism,内存级并行)。

有了 MLP,顺序访问的实际带宽就能拉满:单次访问 80 纳秒, 但同时有 12 个在飞,等效每 6.7 纳秒拿一行 64 字节, 约 9.5 GB/s。再加上多核并行,才能接近内存条的物理带宽 (双通道 DDR5-5600 理论 89.6 GB/s)。 所以「内存带宽」这个指标只有在访问模式对的时候才拿得到, 随机访问时你拿到的是延迟,不是带宽。

软件预取是第三条路:编译器或程序员显式插入 __builtin_prefetch。它适合「硬件看不出来」的模式, 比如链表、树、哈希表——这些结构的下一站在哪,只有程序自己知道。 用对了能把随机访问的延迟藏起来,用错了(预取太早被踢掉、 或预取太多挤掉有用的数据)反而更慢。

现在可以正面回答标题了:为什么核心多不等于快? 有四层原因,一层比一层深。

第一层:Amdahl 定律。 如果程序有 10% 的部分必须串行,那么 100 核也只能快 10 倍。 这不是硬件的问题,是问题本身的结构。1.3.4 结尾已经说过一次, 这里再强调一次,因为它是所有并行优化的天花板。

第二层:同步的代价。 并行部分要协作,协作就要同步(锁、原子操作、屏障)。 每次同步都是一次缓存行抢夺加上内存屏障,几十到几百拍。 如果一个任务本身只有几千拍,同步开销就吃掉了一大半。 这就是粒度问题:任务切得太细,同步比干活还贵; 切得太粗,负载又不均衡。

第三层:带宽和缓存的争抢。 四个核一起跑,共享的 L3 和内存带宽就被四家分。 如果程序是内存密集型的,四个核可能一个都跑不满, 总吞吐只比单核高一点点——因为瓶颈从「算」变成了「搬」。 这就是「扩展性差」的最常见原因: 以为加核能加算力,实际上加的是对同一个带宽的竞争者。

第四层:NUMA 和拓扑。 核多了之后,「哪个核访问哪块内存」开始影响性能。 一个没考虑 NUMA 的程序在双路服务器上可能只有单路的一半性能, 因为它的一半访存都在跨 socket。

把这四层折成一个数字。 假设程序 95% 可并行,单核跑 1 秒。 8 核理论加速 1 / (0.05 + 0.95/8) = 5.9 倍。 扣掉同步开销(假设 15%),实际 5 倍。 再扣掉带宽争抢(假设内存密集,扩展性打七折),实际 3.5 倍。 再扣掉 NUMA 跨片(假设一半访存跨 socket),实际 2.8 倍。 8 核跑出 2.8 倍,这就是现实中「加核」的典型收益。 这和 1.3.4 里说的「16 核实际 6~8 倍」是同一件事。

所以「核心多不等于快」不是一句抱怨,是一条可以算出来的结论。 它由四层折扣叠加而成,每一层都有对应的解法: Amdahl 靠改算法,同步靠减少共享,带宽靠提高局部性,NUMA 靠绑核和本地分配。 而这四层解法,本质上都在做同一件事——让数据离计算更近, 让计算之间的耦合更松。这句话也是整个第 1 部的主题: 从晶体管到缓存,所有的设计都在跟「距离」较劲。

1.3 章到这里就结束了。五节走下来,从一条指令的字节, 到取指译码执行写回,到栈和寄存器,到流水线和乱序, 再到缓存和多核。这一章讲的是「机器怎么执行人给它的指令」。 下一章换个方向:这些指令是谁写的、怎么从人写的文字变成机器能执行的字节。 那就是 1.4 章,从汇编到编译器、链接器、解释器和 JIT。

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

  1. AMAT 的公式是什么?为什么说「优化命中时间」和「优化未命中率」是两条不同的路?
  2. 时间局部性和空间局部性各来自程序的什么特征?各举一个例子。
  3. 一个 32 KB、8 路组相联、64 字节行的缓存,有几组?index 几位?
  4. 为什么 L1 的相联度会被「页大小」限制住?VIPT 成立的前提是什么?
  5. MESI 里 E 状态和 S 状态都是干净的,为什么要区分?
  6. 什么叫「缓存行乒乓」?为什么两个线程各写各的变量也会乒乓?
  7. x86 的 TSO 允许哪一种重排?它是被什么硬件结构造成的?
  8. release 和 acquire 各保证什么?为什么它们比全屏障便宜?
  9. 超线程复制了什么、共享了什么?为什么它对数据库有效、对科学计算效果差?
  10. 「核心多不等于快」的四层原因是什么?每一层对应的解法是什么?
点开看答案(先自己想,别急着点)
  1. AMAT = 命中时间 + 未命中率 × 未命中代价。前者是每次访问都要付的固定成本,后者只在落空时付。优化命中时间对整条路径都有效但空间有限(受电路限制);降低未命中率收益更大但需要更大的容量或更好的替换策略,而容量又会推高命中时间。
  2. 时间局部性来自循环和反复调用的函数(循环计数器、热点函数代码);空间局部性来自数组和顺序执行的指令(a[i] 后面接 a[i+1],取了一条指令后面几条就在旁边)。
  3. 32 KB / 64 B = 512 行,512 / 8 路 = 64 组,index 6 位,offset 6 位。
  4. VIPT 要用虚拟地址的 index 段选组,条件是 index + offset 的位数不超过页内偏移(4 KB 页是 12 位)。一旦缓存超过这个限制,index 会伸进页号里,虚拟地址和物理地址不再相同,VIPT 就不成立。要么提高相联度让 index 变窄,要么改成物理索引。
  5. 因为 E 状态下本核写可以直接静默升级到 M,不需要发任何总线事务;S 状态下写必须发 BusUpgr 作废别人的副本。区分 E 和 S,就把「一个核独占的写」这个最常见的情况变成了零开销。
  6. 同一缓存行在两个核之间反复被抢夺独占权,每次抢都要几十拍。两个线程写不同变量但变量落在同一行(比如结构体里相邻的两个 long),就构成伪共享——共享的不是数据,是行。
  7. 只允许 Store → Load 重排。原因是 store buffer:写指令退休时值先进缓冲,后面的读不必等它发出去就能执行,于是读可能拿到旧值。
  8. release 保证「之前的读写都在这次写之前可见」,acquire 保证「之后的读写都在这次读之后」。它们只需要单向的墙,可以用一条指令实现(ARM 的 stlr/ldar),而全屏障要两个方向都堵,成本高得多。
  9. 复制架构状态(寄存器、PC),分区共享 ROB 和保留站,完全共享执行单元、L1/L2、TLB、分支预测器。数据库的瓶颈在访存等待上,一个线程等内存时另一个可以用执行单元;科学计算的瓶颈在浮点吞吐上,两个线程抢同一个 FPU,没有空隙可填。
  10. Amdahl 定律(串行部分封顶,解法是改算法)、同步代价(解法是减少共享、加大粒度)、带宽与缓存争抢(解法是提高局部性)、NUMA 与拓扑(解法是绑核与本地分配)。四层的共同点是「让数据离计算更近、让计算之间耦合更松」。
← 1.3.4 流水线、分支预测与乱序执行 1.4.1 汇编:给机器码起个人能念的名字 · 尚未动笔