① 二进制是工程必然，不是数学偏好

• 晶体管本质是电控开关，只需可靠地处于通/断两态，制造偏差与噪声都不影响判断；把开关组合起来得到逻辑门，一种 NAND 就能搭出所有数字电路；
• 关键在于信号每过一级门都被掰回标准的 0 或 1，噪声不累积——这就是芯片能塞几百亿个晶体管还能工作的原因。

这一摞层，以及那条分界线

高级语言      Python / C / Rust        ← 人的思维
    ↓ 编译 / 解释
汇编语言      mov, add, jmp            ← 指令的助记符
    ↓ 汇编器
机器码 (ISA)  0x48 0x01 0xd8           ← 软硬件的契约 ★
    ↓ 微架构实现
微架构        流水线、Cache、乱序引擎   ← 厂商的自由发挥
    ↓ 数字电路 / 物理
门电路 → 晶体管  NAND、MOSFET 开关      ← 布尔逻辑与电子

ISA 是软硬件的分界线：写明的部分永不轻易改动，没写的部分（流水线几级、Cache 多大）厂商随便换——所以 2005 年编译的 x86 程序能跑在 2025 年的 CPU 上。但性能问题会穿透抽象层，这正是学这门课的理由。

这条语句走过的站

• 编译期：翻成三条指令（02 章数据怎么表示、03 章指令怎么编码）再变成机器码字节；
• 取指：地址先过虚拟内存翻译（06 章）、再查 Cache（05 章），未命中才访问 DRAM；
• 执行：ALU 做加法，而它会和前后几十条指令乱序、并行地跑（04 章）；写回时多核同碰一块内存还有缓存一致性（08 章）。

基本量

CPU 时间 = 指令数 × CPI × 时钟周期
         = 指令数 × CPI / 主频

CPI = 平均每条指令花的时钟周期数（越小越好，乱序 CPU 可 < 1）
IPC = 1/CPI，每周期执行的指令数（现代高性能核 IPC 可达 4~6）

• 这个乘积说明性能是三方合作：编译器影响指令数，微架构影响 CPI/IPC，工艺和电路影响主频。只盯主频是九十年代的思维——如今两颗同主频的 CPU 性能可以差一倍，差距全在 IPC。
• 跨指令集比「每秒执行多少条指令」毫无意义：一条 x86 指令可能顶三条 RISC-V 指令的活。比性能只能比真实负载的完成时间，这就是 SPEC、Geekbench 这类基准测试存在的原因（以及它们被厂商「应试优化」的原因）。

Amdahl 定律：优化的天花板

加速比 S = 1 / ( (1−f) + f/s )    // f=可优化部分占比, s=该部分的加速倍数

例: 程序 80% 可并行，用无穷多核 → S = 1/0.2 = 最多 5 倍

• 直觉版本：你没法优化的那部分，决定了你的上限。串行部分占 20%，哪怕并行部分加速无穷倍，整体也只有 5 倍。
• 它不只关于并行：做任何性能优化前先测量「这段代码占总时间的比例」——占 3% 的函数优化到零，整体也只快 3%。先 profile 再动手，是 Amdahl 定律在日常工程里的形态。

godbolt.org：看指令

• 浏览器里写 C/C++/Rust，右侧实时出汇编，可切换编译器版本、优化等级、目标架构（x86 / ARM64 / RISC-V）。学 02 章时看 x / 8 被编成移位、x / 10 被编成「乘一个魔数再移位」；学 03 章时对比同一函数在三种 ISA 下的样子。

perf stat：数周期

$ perf stat -e instructions,cycles,branches,branch-misses,cache-misses ./a.out

       428 405 329      instructions      #  1.82  insn per cycle
       235 243 356      cycles
       131 623 330      branches
         1 627 336      branch-misses     #  1.24% of all branches
         2 845 966      cache-misses

• WSL2 里 perf 可用（部分计数器受限），macOS 用 Instruments，Windows 原生用 VTune。工具不重要，「拿数字验证直觉」的习惯才重要。
• 用法上只有一条纪律：先写下预测，再看输出。猜「这个循环 IPC 大概多少、cache-miss 率大概多少」，然后对照。猜错的地方就是你对硬件的误解所在——这比读十页讲解有效。

① 排一下序就快一倍　② 用 stride 量出「行」

3.3 万个随机数扫 2000 遍：if (a[i] < 128) sum += a[i];
              耗时     branch-misses      IPC
未排序      0.053 s   1 627 336 (1.24%)   1.82
排序后      0.026 s     179 393 (0.13%)   3.66

扫 64 MB 数组，每隔 stride 字节访问一次：
stride   访问次数     总耗时    每次访问
    32   2 097 152    1.7 ms   0.83 ns
    64   1 048 576    1.7 ms   1.63 ns  ← 总耗时与 stride=32 完全相同

• ①数据一个字节没变、指令一条没少，只是顺序变了：分支变得可预测，流水线不再被冲刷（04 章）。必踩的坑是编译器会把它编成条件传送（cmov）让效应消失，要显式 -fno-if-conversion；
• ②stride 32 的访问次数是 64 的两倍而总耗时一样，因为取回的 cache 行数相同——决定耗时的是行数不是访问次数（05 章）。

③ 列遍历　④ 假共享　⑤ 依赖链

4096² int 数组，关向量化：行遍历 0.005 s ／ 列遍历 0.220 s（慢 48×）
                          cache-misses 多 ~900×，dTLB-misses 多 ~340×
4 线程各加自己的计数器：同一 cache 行 0.042 s ／ 各占独立行 0.009 s（快 5×）
4 亿次浮点加：1 个累加器 0.269 s ／ 4 个独立累加器 0.067 s（恰好快 4.0×）

• ③耗时差 48 倍是结果，cache-misses 差 900 倍是原因，而 dTLB 差 340 倍说明列遍历把 TLB 也一起打穿了（06 章）；
• ④四个线程逻辑上毫无共享，却因挤在同一条 64 B 行里被一致性协议来回收发所有权（08 章）；
• ⑤浮点加有延迟但完全流水，串成一条链时每次都等上一次结果；拆成 4 条独立链就能同时在流水线里，上限 ≈ 延迟 ÷ 发射间隔（04 章）。

四段结构

• 02 数据的机器表示 → 03 指令集：地基。补码与浮点不过关，后面所有「为什么结果不对」都解释不了；
• 04 CPU 微架构：本页主线也最厚——流水线、分支预测、乱序全在里面，上手章那个分支预测实验在这里得到解释；
• 05 存储层次与 Cache → 06 虚拟内存：性能的真正大头，上手章另外三个实验的答案都在这两章；
• 07 I/O → 08 并行 → 09 显示子系统走到整机，10 用代码造一台机器把前面九章变成能跑的模拟器，11 是路线图。

读法与换算

0xDEADBEEF = 1101 1110 1010 1101 1011 1110 1110 1111
               D    E    A    D    B    E    E    F   // 逐 4 位对照，无需计算

常见数字的直觉: 0xFF=255(一字节全1)  0x400=1024  0x1000=4096(一页)

• 为什么不用十进制读内存：255 和 256 看不出任何结构，0xFF 和 0x100 一眼看出「进位边界」。地址、掩码、颜色值、权限位都天然是 2 的幂结构。

位运算：对比特的直接操作

x & 0xFF        // 取低 8 位（掩码：AND 留下想要的位）
x | (1 << 3)    // 把第 3 位置 1
x & ~(1 << 3)   // 把第 3 位清 0
x ^ (1 << 3)    // 把第 3 位翻转
x & (x - 1)     // 消掉最低位的 1（判 2 的幂、数 1 个数的基础）
(x + 7) & ~7    // 向上对齐到 8 的倍数（内存分配器天天在用）

• 这些不是竞赛技巧，而是系统代码的日常：权限标志（O_RDWR | O_CREAT）、页表项、网络协议头的字段拆装，全是位运算。

从里程表推导

• 想象 3 位数的里程表，只能显示 000~999。从 000 往回倒 1 格显示 999——所以在这个「模 1000」的世界里，999 的行为和 −1 一模一样：任何数加 999，效果等于减 1（进位溢出被丢掉）。
• 二进制同理：8 位寄存器是模 256 的世界，11111111（255）的行为等于 −1，11111110（254）等于 −2。补码就是「用 2ⁿ − |x| 代表 −x」：[−x] = 2ⁿ − x，如此而已。
• 于是减法免费获得：a − b = a + (2ⁿ − b)，硬件里就是「b 逐位取反再 +1，然后照常加」。一套加法器通吃加减、通吃正负，这是补码淘汰原码/反码的根本原因。

随之而来的性质（都能从定义推出）

• 最高位天然充当符号位（不需要特殊电路对待它）；0 只有一种表示。
• n 位范围 −2ⁿ⁻¹ ~ 2ⁿ⁻¹−1，负端多一个：−128 存在而 +128 不存在（8 位）。所以 abs(INT_MIN) 溢出——这是真实世界的 bug 来源。
• 符号扩展：8 位的 0xFF（−1）扩到 32 位要填成 0xFFFFFFFF 才还是 −1——「负数补 1、正数补 0」，这就是指令集里 movsx（符号扩展）和 movzx（零扩展）并存的原因。

溢出

int mid = (lo + hi) / 2;          // 经典 bug：lo+hi 可能溢出 int
int mid = lo + (hi - lo) / 2;     // 修复：JDK 的二分搜索曾栽在上一行

• 硬件层面溢出只是「进位丢掉、结果回绕」，CPU 会如实设置溢出标志；但 C/C++ 把有符号溢出定义为未定义行为（UB），编译器会按「不可能溢出」优化，产生比回绕更诡异的结果（如死循环、检查被删除）。无符号溢出则是良定义的回绕。
• 怎么防：Rust 在 debug 模式下溢出直接 panic；C 用 __builtin_add_overflow；安全关键代码先判再算。

有无符号混用

std::vector<int> v;
for (int i = 0; i < v.size() - 1; i++)   // v 为空时: size()-1 = 巨大无符号数
    ...                                   // 循环失控 → 越界崩溃

• C 的转换规则：有符号与无符号相遇，有符号被转成无符号。−1 变成 4294967295，比较、减法全部失真。size_t 是无符号的，这让上面的坑遍布 C++ 代码。
• 移位的暗雷：负数右移是实现定义（多数编译器算术移位）；移位数 ≥ 位宽是 UB（1 << 32 在 x86 上实际只移 0 位，因为硬件只取移位数低 5 位）。

格式

值 = (−1)^S × 1.M × 2^(E − bias)

float  (32位): S 1位 | E 8位(bias=127)  | M 23位   ≈ 7 位十进制精度
double (64位): S 1位 | E 11位(bias=1023)| M 52位   ≈ 16 位十进制精度

• 尾数首位恒为 1（规格化），所以不存，白赚一位精度——这是隐藏位。
• 阶码用移码（真实指数 + bias）存储，好处是非负浮点数的比特模式可以直接当无符号整数比大小；负数一侧顺序相反，需先翻转才能比——排序浮点数仍可以用整数比较器。

0.1 的真相

0.1 (十进制) = 0.000110011001100...(二进制, 无限循环)
存进 double  = 0.1000000000000000055511151231257827...
所以: 0.1 + 0.2 == 0.3   → false
      0.1 + 0.2          → 0.30000000000000004

• 和 1/3 在十进制里写不尽是同一回事：分母含 2 以外因子的分数，二进制写不尽。0.5、0.25、0.125 精确，0.1、0.2、0.3 全部不精确。
• 钱为什么不能用 float：分单位的累加误差会攒出真实的账目差。正确做法是整数存最小单位（以分计）或十进制类型（Java BigDecimal、Python decimal、SQL NUMERIC）。

特殊值：编码里预留的暗门

E 全 0, M = 0   → ±0          // 正负零，== 判相等但 1/x 符号不同
E 全 0, M ≠ 0   → 非规格化数   // 填补 0 附近的空隙，运算极慢(软件辅助)
E 全 1, M = 0   → ±∞          // 1.0/0.0 = inf（不崩溃！）
E 全 1, M ≠ 0   → NaN         // 0.0/0.0、sqrt(-1)；NaN != NaN 恒真

• NaN 会传染：任何与 NaN 的运算结果还是 NaN，一路污染到输出。判断方法只有 isnan(x) 或利用 x != x。
• 浮点除零不崩溃（得到 inf），整数除零才崩溃——很多人的直觉恰好相反。

比较与误差纪律

fabs(a - b) < 1e-9              // 绝对误差：量级大时失效
fabs(a - b) < eps * max(|a|,|b|) // 相对误差：通用但 0 附近失效

• 浮点加法不满足结合律：(big + small) − big 可能把 small 整个吃掉（大数吃小数）。求和顺序影响结果——这是并行归约结果不可复现的根源；高精度求和用 Kahan 补偿算法。
• 误差会在相近数相减时灾难性放大（catastrophic cancellation）：sqrt(x+1)−sqrt(x) 在 x 很大时几乎全是噪声，改写成 1/(sqrt(x+1)+sqrt(x)) 则稳定——数值稳定性的入门直觉。

字节序

int x = 0x12345678;  地址从低到高:
小端 (x86, ARM默认):  78 56 34 12    // 低位字节在低地址
大端 (网络字节序):    12 34 56 78    // 高位字节在低地址，像人的书写

• 小端的好处：取一个数的低 8 位/低 16 位，地址不变（指针强转截断天然正确）；大端的好处是十六进制 dump 顺着读。没有对错，只有约定。
• 什么时候必须在意：数据跨机器边界时——网络协议（TCP/IP 头一律大端，所以有 htonl/ntohl）、二进制文件格式、直接 memcpy 结构体到 socket。同一台机器内永远感知不到。

对齐与 struct padding

struct A { char c; int x; };      // sizeof = 8, 不是 5！
内存布局: [c][pad][pad][pad][x x x x]   // int 要求地址是 4 的倍数

struct B { int x; char c; };      // sizeof 仍是 8: 尾部补齐到对齐边界
struct C { char a; int x; char b; }  // 12 字节; 调序成 {x,a,b} → 8 字节

• 为什么要对齐：让一个 int 落在 4 的倍数地址上，保证它不跨越硬件的自然访问边界。x86 容忍非对齐访问（跨 Cache 行时变慢），ARM 的原子指令遇到非对齐直接异常。
• 实战影响：结构体按成员从大到小排列可以消掉 padding；序列化时不要直接 memcpy 结构体（padding 内容是垃圾，且对端布局可能不同）。

加法：1 个周期（64 位约 0.2~0.3 纳秒，即三十~五十亿分之一秒）

• 朴素方案「行波进位」——每一位等低位的进位传上来——64 位要串行等 64 级门延迟，太慢。
• 超前进位（CLA）的洞察：第 i 位是否产生进位，其实可以直接从输入算出来，不必等。定义「生成 G=AB、传播 P=A⊕B」，每一位的进位都展开成只含输入的表达式，并行计算。代价是电路面积换时间——硬件设计的永恒交易。

乘法：约 3 个周期

• 本质是「移位相加」的并行化：把 64 个部分积用压缩树（Wallace tree）并行归约。现代 CPU 的 64 位乘法延迟约 3 周期，已经很便宜。
• Booth 编码的洞察值得一记：乘数里一串连续的 1（如 0111111）等于「高一位的 1 减最低位的 1」，一串加法变成一加一减——减少部分积数量，还顺带自动处理了补码符号。

除法：20~40+ 个周期，且难以流水

• 除法本质是「试商」的串行循环——每一步依赖上一步的余数，无法像乘法那样并行展开。这是三种运算里唯一的本质串行。
• 所以编译器不遗余力地消除除法：除以常数 8 变移位；除以常数 10 变「乘 magic number 再移位」；除以变量则没救。热点循环里的整数除法值得手动消除（比如用累减、查表或换成乘法）。

三档方案

• 奇偶校验（1 bit 冗余）：让 1 的个数恒为偶数，任何 1 位翻转立刻暴露。只能发现、不能定位、两位同错则漏网——用在串口、老式内存这类低成本场景。
• 海明码/ECC（log n 级冗余）：多组奇偶位交叉覆盖，出错时各组的「报警模式」恰好拼出出错位置——能定位就能纠正（翻回来即可）。服务器内存的 ECC 就是它的扩展版（SECDED：纠 1 位、检 2 位）。
• CRC（固定几十 bit 冗余）：把整段报文当多项式做模 2 除法，余数作校验值。对突发错误（连续多位损坏，正是传输线的典型错法）检测能力极强，硬件实现只是移位加异或——以太网帧、ZIP、PNG、磁盘扇区全在用。

亲眼看一次

int add(int a, int b) { return a + b; }

$ gcc -O1 -fcf-protection=none -c add.c && objdump -d -M intel add.o
0000000000000000 <add>:
   0:  8d 04 37     lea    eax,[rdi+rsi]     // 3 个字节就是这个函数的全部
   3:  c3           ret

• 8d 04 37 这三个字节里编码了：操作（lea 计算地址）、目的寄存器（eax）、两个源寄存器（rdi、rsi）。指令 = 操作码 + 操作数说明，所有 ISA 概莫能外。
• 指令大致分五类：算术逻辑（add/and/shl）、数据搬运（load/store/mov）、控制流（jmp/branch/call/ret）、系统（syscall、特权指令）、SIMD（向量运算）。任何语言的任何程序，最终都摊平成这五类的序列。

寄存器：指令的工作台

• 运算不直接发生在内存上（RISC 中严格如此）：数据先 load 进寄存器，算完再 store 回去。寄存器只有十几个，但访问不产生额外周期——它们就在 ALU 旁边。
• 编译器的一大核心工作就是寄存器分配：让最热的变量常驻寄存器。寄存器不够用时变量「溢出」到栈上，性能立降——这就是局部变量比全局变量快的底层原因之一。

契约的两侧

• 契约内（架构状态）：通用寄存器、PC、标志位、每条指令的语义、异常行为。程序只依赖这些，所以 2005 年的 exe 在 2025 年的 CPU 上行为分毫不差。
• 契约外（微架构）：流水线深度、Cache 大小、乱序窗口、分支预测器。Intel 从 Pentium 到今天换了十几代微架构，ISA 契约始终向后兼容——这是 x86 帝国的护城河，也是它背着几十年历史包袱的原因。

契约思维解释的现象

• 为什么 Apple 从 x86 迁到 ARM 需要 Rosetta 2（二进制翻译）：换契约必须翻译或重编译。而 macOS 应用商店里的 app 多数「直接就能跑」，因为分发的是中间格式或双架构包。
• 为什么 CPU 漏洞分两种修法：ISA 层的 bug（指令行为错）必须换硬件或禁用指令；微架构层的问题（Spectre 类）可以用微码更新缓解——因为微码在契约之下。
• 为什么 RISC-V 令人兴奋：它是第一个开放、免版税、模块化的主流 ISA 契约，任何人可以照着造芯片——契约的所有权本身就是产业权力。

两派

RISC-V: 所有指令恒 32 位，字段位置固定
        [funct7|rs2|rs1|funct3|rd|opcode]   // 寄存器号永远在同一位置
x86:    1~15 字节可变长
        [前缀...][操作码][ModRM][SIB][位移][立即数]  // 每段都可有可无

• 定长：取指时不用解析就知道下一条在哪，可以并行译码任意多条；代价是简单操作也占 32 位，代码体积大（RISC-V 用 C 扩展的 16 位压缩指令补救）。
• 变长：常用指令编得短（ret 只占 1 字节），代码密度高、省指令 Cache；代价是找到第二条指令之前必须先译完第一条的长度——x86 译码器为此付出巨大的晶体管和功耗，是它在低功耗场景吃亏的真实原因之一。

编码空间是稀缺资源

• 操作码位数有限，设计者用前缀码思想分配：高频指令给短码，低频指令用长码逐级扩展（教材里的「扩展操作码」就是这件事）——和 Huffman 编码同一个直觉。
• ISA 会长满补丁：x86 的前缀字节层层叠加（REX、VEX、EVEX），每次扩展（64 位、AVX、AVX-512）都要在旧编码的缝隙里找地方。对比之下 RISC-V 从第一天就预留了扩展编码空间——设计的先见之明体现在二十年后。

谱系（每种都标了它服务的语言结构）

立即数     add rax, 42        // 常量 42
寄存器     add rax, rbx       // 局部变量（已分配到寄存器）
直接/绝对  mov rax, [0x601040] // 全局变量（地址链接期定死）
寄存器间接 mov rax, [rbx]      // 指针解引用 *p
基址+偏移  mov rax, [rbp-16]   // 栈上局部变量、结构体成员 p->field
基址+变址×比例 mov rax, [rbx+rcx*8]  // 数组下标 a[i]（i 乘元素大小）
PC 相对    lea rax, [rip+0x2f]  // 位置无关代码：共享库的全局访问

调用的机械过程（x86-64 System V 为例）

caller:                          callee:
  mov edi, 42     // 参数1→rdi      push rbp        // 序言:存旧帧基
  call foo        // 压返回地址      mov  rbp, rsp   // 立新帧
                                   sub  rsp, 32    // 给局部变量留空间
                                   ...
                                   leave; ret      // 尾声:撤帧,弹地址跳回

• 栈向低地址生长；每层调用压一个栈帧：返回地址、保存的寄存器、局部变量。递归深度过深 → 栈耗尽 → stack overflow，此名即由此来。
• 调用约定的分工：前 6 个整型参数走寄存器（rdi/rsi/rdx/rcx/r8/r9），返回值在 rax；寄存器分「调用者保存」（callee 可随便用）和「被调用者保存」（callee 用前必须存、返回前必须还）。约定是 per-平台的：Windows x64 与 Linux 不同，跨约定调用必然崩。

当年的分歧

• CISC（x86、VAX）的逻辑：内存又贵又慢，指令应该「浓缩」——一条指令干一串事（VAX 甚至有多项式求值指令），代码密度至上。
• RISC（MIPS、SPARC，源于 Patterson/Hennessy 的观察）的逻辑：测量显示编译器根本不用那些复杂指令，80% 的执行是 20% 的简单指令。不如只留简单指令：定长编码、只有 load/store 碰内存、大寄存器堆——一切为流水线让路。

终局：表面 CISC，内芯 RISC

• Pentium Pro（1995）起，x86 CPU 在译码级把每条 CISC 指令拆成 1~4 个 RISC 风格的微操作（μops），后端流水线、乱序引擎处理的全是 μops。从此「x86 是 CISC」只在译码器里成立。
• 反方向同样发生：ARM 加入了越来越多复杂指令（一条指令载入多寄存器、加密轮函数），RISC-V 靠扩展堆功能。纯粹主义两边都放弃了。
• 真正剩下的差异：译码功耗与并行度。变长的 x86 译码又费电又难并行（这是 Apple M 系列每周期能译 8+ 条而 x86 长期 4~6 条的原因之一）；以及契约的商业属性——x86 双寡头授权、ARM 收费授权、RISC-V 免费开放。

三个概念

• 组合逻辑：输出只由当前输入决定的电路（加法器、译码器、多路选择器 MUX）。信号穿过需要时间——门延迟，路径越长越慢。它没有记忆。
• 时序逻辑：加上触发器/寄存器——只在时钟边沿把输入「拍照」存下来的元件。有了它电路才有状态，才能记住「现在执行到哪了」。
• 时钟：全芯片统一的节拍器。每个时钟周期做同一件事：寄存器输出 → 穿过一片组合逻辑 → 结果在下一个边沿存进寄存器。周期必须长过最慢的那条组合路径（关键路径），否则存进去的是没算完的垃圾。

数据通路：指令流过的管道

PC → 指令存储器 → 译码/读寄存器堆 → ALU → 数据存储器 → 写回寄存器
 ↑___________________ PC+4 或分支目标 ____________________|

• 每条指令都流经这条通路，不同指令用到不同的段：加法跳过数据存储器；load 用满全程；分支用 ALU 算比较、结果改 PC。MUX（多路选择器）+ 控制信号决定每一站的数据从哪来、到哪去。
• 控制器就是「看操作码、拉控制线」的组合逻辑：见到 load 就拉起「存储器读」「写回选存储器」；见到分支就拉起「PC 选分支目标」。教材说的「硬布线控制器」即此——一张真值表而已。

经典五段

       周期:  1    2    3    4    5    6    7
指令1:       IF → ID → EX → MEM → WB
指令2:            IF → ID → EX  → MEM → WB
指令3:                 IF → ID  → EX  → MEM → WB

IF 取指 | ID 译码读寄存器 | EX 执行 | MEM 访存 | WB 写回

• 把单周期的长通路切成五段，段间插寄存器：关键路径变成五分之一，主频立刻能提五倍；稳态下每周期完成一条指令（CPI→1），尽管每条指令仍要走 5 拍。
• 延迟没变（一条指令还是 5 拍），吞吐变了（每拍出一条）——回忆第 00 章：这是典型的「牺牲的延迟为零、吞吐纯赚」的设计，所以从 1980 年代起没有任何严肃 CPU 不用流水线。

结构冒险：抢硬件

• IF 要读内存取指、MEM 也要读写内存——同一拍抢同一个存储器。解法简单粗暴：把资源复制一份——指令和数据分开的 L1 Cache（哈佛式 L1）就是这么来的。

数据冒险：等结果

add x1, x2, x3    // x1 在第5拍才写回
sub x4, x1, x5    // 但它第3拍就要读 x1 → 读到旧值!

• 关键观察：结果其实第 3 拍末尾（EX 出口）就算出来了，只是还没写回寄存器堆。那就别绕寄存器堆——直接从 ALU 出口拉一根线到 ALU 入口：转发（forwarding）。多数数据冒险由此零代价化解。
• 唯一转发救不了的：load-use——load 的数据 MEM 段末尾才到，下一条指令的 EX 等不到，必须硬插一个气泡（stall）。所以编译器会把 load 和使用它的指令隔开（指令调度），你在 -O2 的汇编里看到的「怪异顺序」多半是这个。

控制冒险：不知道下一条是谁

• 分支要到 EX 段才知道跳不跳，可 IF 每一拍都得取新指令——取哪条？等答案就是每个分支浪费两三拍；程序平均每 5~7 条指令一个分支，等不起。
• 解法是赌：猜一个方向继续取，猜错再冲掉重来——分支预测，下一张卡。它重要到值得单独一张。

预测器的进化

• 2 位饱和计数器：每个分支记一个 4 状态计数（强跳/弱跳/弱不跳/强不跳），跳则加、不跳则减。妙处是连错两次才改主意：循环末尾那一次「不跳」不会毁掉「这个分支基本总跳」的判断。
• 历史模式：很多分支的行为取决于「前几个分支怎么走的」（如交替跳/不跳）。把最近分支结果串成位串作为索引，同一条分支在不同「上下文」里可以有不同预测——两级自适应预测。
• 现代 TAGE 类预测器：多张表用不同长度的历史，长历史命中优先——本质是自动学习「这个分支依赖多远的过去」。数万比特的状态、95~99% 的准确率，是 CPU 里最像机器学习的部件。

写代码时它真实存在

// 对随机数组: if (a[i] < 128) sum += a[i];
未排序: 预测器五五开瞎猜 → 每次错猜罚十几个周期 → 慢
排序后: 前半全不跳后半全跳 → 预测几乎全对 → 快       // 著名的 StackOverflow 问题

• 规避手段：热路径消除难预测分支——用条件传送（cmov）、位技巧、查表替代 if（branchless 编程）；把可预测性还给硬件（排序、分离冷热路径）。perf stat 的 branch-misses 一栏直接告诉你赌输了多少。

数字比论证有用（AMD Zen 4，3.3 万元素扫 2000 遍）

                    耗时     branch-misses      IPC
未排序（随机数据）   0.053 s   1 627 336 (1.24%)   1.82
排序后               0.026 s     179 393 (0.13%)   3.66
                    ↑ 快约 2 倍   ↑ 少约 9 倍      ↑ 翻倍

• 三个数字要一起看：耗时只是结果，branch-misses 是原因，IPC 才是机制——预测对了流水线不断流，同样的指令数在一半的周期里跑完（1.82 → 3.66）。这就是「分支预测是现代性能支柱」的可测量形态。
• 但那个流传的「快 5~6 倍」已经过时了。那是 2012 年提问时的硬件；本机只差约 2 倍——现代 TAGE 类预测器连相当随机的数据也能学出些规律（随机数据上仍只错 1.24%）。方向恒定、倍数缩小：预测器越强，这个经典演示的效果就越弱。自己跑一遍看你的机器是多少。
• 测这个实验有个必踩的坑：编译器会把 if (a[i] < 128) sum += a[i] 编成条件传送（cmov），分支根本不存在、效应随之消失。要看到分支效应必须显式关掉：gcc -O2 -fno-if-conversion -fno-tree-loop-if-convert，并用 objdump -d | grep cmov 确认真的没有 cmov。这恰好从反面证明了 branchless 化的威力。

两个部件：BTB 与返回地址栈

• BTB（分支目标缓冲）：取指阶段手里只有 PC，指令还没译码，CPU 甚至不知道这条是不是分支——BTB 就是「按 PC 索引、告诉你上次这条分支跳去了哪」的表。直接分支的目标恒定，一学就准；间接分支学不学得会，全看目标序列有没有规律。
• 返回地址栈（RAS）：ret 也是间接跳转（目标在栈上），但它有完美的结构规律——call 时把返回地址压进一个十几层的小硬件栈，ret 时弹出来当预测，准确率接近满分。代价是call/ret 必须配对：手写汇编用 jmp 冒充返回、协程切换栈、setjmp/longjmp 跳出深层调用，都会把这个栈弄错位，之后连续多次返回全部错判。

同一个调用点，五种目标序列

5000 万次间接调用，四个候选函数，只改「每次调哪个」的序列（AMD Zen 4，gcc -O2）：

• 最反直觉的是那两行「轮转」：完全规则的 0,1,2,3,0,1,2,3… 反而比随机更慢、错判率顶到 100%。
• 五行数字与一个极简模型逐条吻合：「预测这次的目标 = 上次的目标」。永远同一个 → 全中；两个交替 → 每次都错；两个随机 → 对一半；四个轮转 → 每次都错；四个随机 → 错四分之三。五个比例（0 / 100 / 50 / 100 / 75）没有一个是估出来的，都是这个模型的直接推论。
• 为什么这么规则的轮转学不会？因为这段循环里除了循环回边没有任何别的条件分支，全局分支历史是一串常量。现代间接预测器靠「历史 + PC」区分同一条间接跳转的不同上下文，历史退化成常数时，四次调用在预测器眼里完全一样。规律藏在数据里而不是控制流里，预测器就看不见。
• 错判一次多花多少：永远同一个是 1.26 ns/次，两个交替是 8.4 ns/次——每次错判约 7 ns，本机 4.2 GHz 下约 30 个周期，比上一张卡说的方向错判（15~20 周期）更贵。合理：目标错判要等地址算出来才发现，发现得更晚，冲掉的指令更多。

三个机制，一台机器

• 寄存器重命名：两条指令用了同一个寄存器名但数据无关（WAR/WAW，「名相关」），给它们各发一个物理寄存器别名，假冲突消失。ISA 的 16 个寄存器名背后是 200+ 个物理寄存器。剩下的 RAW（真数据依赖）无法消除——只能转发和等待。
• 保留站/发射队列（Tomasulo 的遗产）：译码后的指令带着「我在等谁的结果」进队等待；每个执行结果广播到所有等待者，操作数凑齐的指令立即发射——数据流驱动取代程序顺序。
• 重排序缓冲 ROB：乱序算完 ≠ 乱序生效。所有指令按程序顺序进入 ROB，执行完打上「完成」标记，但只有排到队头才允许提交（真正改寄存器/内存）。于是异常发生时，未提交的后续指令全部一笔勾销——对外呈现的永远是「精确的、按序的」状态，契约得以维持。

超标量：把机器加宽

• 取指、译码、发射、执行、提交全部并行化：现代大核每拍可译码 4~8 条、发射 6~12 个 μop 到十来个执行端口（几个 ALU、几个访存单元、几个向量单元）。
• 宽度的收益递减：程序里天然的指令级并行（ILP）有限——真依赖链、分支、访存把可并行的指令隔开。这就是为什么没有 20 发射的 CPU：不是造不出，是喂不饱。
• VLIW（超长指令字）是另一条路：让编译器提前打包并行指令，硬件只管照单执行。通用市场上败了（Itanium——编译器猜不准运行时行为），但在 DSP（数字信号处理器）/AI 加速器里活得很好（负载规则、编译期可知）。

SMT/超线程：两个线程填一台机器

• 一个线程停顿（cache miss、依赖链）时，它占的执行端口全在空转。SMT 给一个物理核配两套架构状态（寄存器、PC），两个线程的指令混在同一个乱序引擎里争抢执行端口——空隙被另一个线程填上。
• 收益视负载而定：两个访存密集线程 +20~30% 吞吐；两个算力密集线程互相踩踏，可能负收益。所以 HPC 集群常关超线程，Web 服务器常开。
• 它是「一核当两核报」的营销来源：OS 看到 2 个逻辑 CPU，但执行资源只有一份。

前端（按序）→ 后端（乱序）→ 提交（按序）

前端: 分支预测 → 取指 → 译码(x86: 变长切分+μop转换, 带μop缓存)
         ↓ 每拍 4~8 μops
后端: 重命名 → 发射队列 → 执行端口×10~20(ALU/AGU/向量/访存)
         ↓ 乱序完成
提交: ROB 按序退休(每拍 4~8 条) → 架构状态更新

• 旗舰核的数量级（2020s）：ROB 300~600 条、物理寄存器 300+、L1 32~192KB、L2 1~3MB、乱序窗口能藏住一次 DRAM miss 的大部分延迟。
• IPC 差距的来源：Apple M 系列宽前端（8 译码）+ 巨大 ROB + 巨大 L1，同频性能领先——「宽而稳」路线；传统 x86 走「窄一点但频率冲 5~6 GHz」路线。两者本质是在功耗曲线上选了不同的点：频率的功耗代价是超线性的（P∝CV²f，提频还得提压），宽度的代价是面积。

大小核：一颗芯片上的两种哲学

• 性能核（宽、深、乱序、耗电）跑冲刺负载，能效核（窄、浅、省电）跑常驻后台——因为性能的最后 20% 要花 3 倍功耗，混搭比全大核能效高得多（下表是同一颗芯片上的两种哲学）

  	性能核 P-core	能效核 E-core
  设计取向	宽、深、乱序，能冲高频	窄、浅，省电
  面积 / 功耗	大 / 高	小 / 低（同面积可塞多个）
  该跑什么	前台冲刺负载、单线程敏感任务	常驻后台、批量并行任务
  放错核的代价	后台任务霸占大核 → 费电发热、逼着降频拖累全局	前台任务困在小核 → 直接卡顿

  。手机十年前就这么干（ARM big.LITTLE），Intel 2021 年跟进，OS 调度器为此专门改造（联动 OS 页调度章）。

延迟的数量级（换算成人类时间）

寄存器      ~0.3ns    「1 秒」     手边的东西
L1 Cache    ~1ns      「4 秒」     桌上翻笔记
L2 Cache    ~4ns      「15 秒」    书架上找书
L3 Cache    ~15ns     「1 分钟」   隔壁房间拿资料
DRAM 主存   ~80ns     「5 分钟」   楼下便利店
NVMe SSD    ~50µs     「2 天」     跨城快递
机械磁盘    ~5ms      「6 个月」   海运
网络往返    ~0.5ms+   「2 周起」   国际邮件

• 结论自己浮现：miss 到下一层的代价是数量级的。程序快慢往往不取决于算了多少，而取决于数据在金字塔哪一层。

本机真实参数（getconf -a / lscpu，AMD Ryzen 7 8845H）

• 组数可以当场验算：组数 = 容量 ÷（行大小 × 路数）——32 KB ÷ (64 × 8) = 64 组，index 恰好 6 位。拿你自己机器的 getconf -a | grep -i cache 代进去算一遍，「组」和「路」就再也不会混。
• 顺带看见「口径不统一」这个坑的实物：同一台机器上 getconf 报 LEVEL1_DCACHE_SIZE 32768（单核视角），lscpu 报 L1d cache: 64 KiB (2 instances)（所有实例之和），而产品页会宣传 L3「16 MB 大缓存」（全核共享总量）。三个数字都对，说的不是同一件事。

金字塔为什么可行：局部性

• 快的存储必然小（SRAM 一个 bit 要 6 个晶体管、还得离核近），大的必然慢——物理定律，没有两全。层次结构的赌注是程序行为的两条经验律：时间局部性（刚用过的很快再用——循环变量）、空间局部性（用了这个就会用旁边的——数组遍历、顺序取指）。
• 只要局部性成立，「小而快的层」就能拦截绝大多数访问，整个金字塔用 5% 的成本呈现出 95% 的快。局部性差的程序（随机指针追逐）则跌穿金字塔，直面 DRAM 的真实延迟——快慢差距可达百倍，这就是数据结构选择背后的硬件真相。

SRAM：静态，即「通电就稳」

• 一个 bit = 6 个晶体管锁成的双稳态（两个反相器咬住对方）。读写快（亚纳秒）、不需要刷新；代价是面积大、贵——所以只用来做 Cache 和寄存器堆，容量以 KB/MB 计。

DRAM：动态，即「会漏电、要续命」

• 一个 bit = 1 个晶体管 + 1 个电容，有电荷=1。密度是 SRAM 的 6 倍以上，便宜——所以主存用它，容量以 GB 计。
• 电容漏电，几十毫秒就丢数据 → 必须周期性刷新（逐行读出再写回），内存控制器自动做，代价是几个百分点的带宽和读写间隙。「动态」之名即由此来。
• 读取是破坏性的：读一行会放掉整行电荷，读完必须写回。这行数据读出后暂存在行缓冲（row buffer）里——连续访问同一行（行命中）快，跳到别的行要先关旧行再开新行（行冲突）慢好几倍。DRAM 也有「局部性」，顺序访问快于随机访问在 DRAM 层面又应验一次。

非易失存储：断电不忘的底层

• SRAM 和 DRAM 都断电即失忆（易失性），所以金字塔底还得有一个非易失层兜底，和上面拼速度的两位分工完全不同——它换来的是「掉电还在」。
• Flash/SSD：按块擦写、读快写慢，负责数据的长期落盘；主板上那颗存固件的 ROM/Flash 则保证开机瞬间 CPU 手里就有代码可取（只能预先固化）。层层易失、最终落到非易失，存储金字塔到此闭环。

基本单位：Cache 行（64 字节）

• Cache 不缓存单个字节，而是按64 字节的行整块搬运——赌空间局部性：你要了第 1 个字节，大概率马上要第 2~64 个。「碰一个字节 = 搬 64 字节」是本章后面所有优化的公理。

放哪、怎么找：三种方案

地址切三段:  [ Tag | 索引 index | 行内偏移 offset ]
                      ↓              ↓ log2(64)=6 位
              选中某一组         定位行内字节
组内比较 Tag → 相等即命中

• 直接映射：每个地址只有一个坑（index 直接定行）。查找快、电路省，但两个热点地址若撞坑会互相踢——冲突 miss。
• 全相联：任何行进任何坑，冲突最少，但每次查找要并行比较所有 Tag——只有 TLB 这种几十项的小结构用得起。
• 组相联（现实答案）：index 选组、组内 4~16 路全相联。冲突率接近全相联、成本接近直接映射。现代 L1 典型 8 路、L3 典型 16 路。

替换：踢谁

• 理想答案是「踢最久之后才会用的」（Belady 最优）——但那需要预知未来。可实现的近似是 LRU（踢最久没用过的）：赌时间局部性，最近没用的以后多半也不用。
• 真实硬件连精确 LRU 都嫌贵（16 路要维护全序），用伪 LRU（树状近似）或动态插入策略（DRRIP 等，抗扫描污染：一次性流过的大数组不该把常驻热数据踢光）。方向是一致的：用最少的记账位数逼近「保热踢冷」。

写：何时告诉下层

• 写直达（write-through）：每次写同步写穿到下层。数据永远一致、掉电不怕，但写带宽被放大——配写缓冲吸收突发。
• 写回（write-back）：只写 Cache、标记「脏」位，被替换时才写回下层。同一行写一百次只回写一次，省带宽——现代 CPU Cache 的普遍选择，代价是「内存里的值可能是旧的」，多核一致性因此复杂化（第 08 章 MESI 的 M 态就是「脏」的多核版本）。
• 写 miss 时：写回配「写分配」（先把行搬上来再写），写直达配「非写分配」（直接写下层）——搭配逻辑：会反复写的才值得搬上来。

  	写直达 write-through	写回 write-back
  何时写下层	每次写都穿透	被替换时才写（脏位标记）
  写带宽	被放大（要配写缓冲吸收突发）	省（同一行写一百次只回写一次）
  下层数据是否最新	永远最新	可能是旧的
  多核一致性	简单	复杂（MESI 的 M 态就是「脏」的多核版）
  写 miss 搭配	非写分配（直接写下层）	写分配（先把行搬上来）
  现代 CPU	少用	普遍选择

① 按内存布局的方向遍历

// C 的二维数组按行存储
for (i...) for (j...) sum += a[i][j];   // 行遍历: 顺着内存走,每行 64B 用满 → 快
for (j...) for (i...) sum += a[i][j];   // 列遍历: 每次跳 N×4 字节,行行 miss → 慢很多

• （4096×4096 int，64 MB，关掉向量化以隔离纯 Cache 效应）：

  	耗时	cache-misses	miss 率	dTLB-load-misses
  行遍历	0.005 s	11 843	0.33%	50 478
  列遍历	0.220 s	10 846 758	14.31%	17 084 757
  倍数	慢 48×	多 约 900×	—	多 约 340×

  三列一起看才是完整的故事：耗时差 48 倍是结果，cache-misses 差 900 倍是直接原因，而 dTLB-load-misses 差 340 倍说明列遍历同时把 TLB 也打穿了（每跳 16 KB，几乎每次访问都换页）。课本只讲 Cache，告诉你 TLB 一起在受害。
• 倍数会因机器而异（内存带宽、Cache 大小、TLB 项数都不同），但方向恒定、且三个指标必然同向恶化。自己跑一遍：perf stat -e cache-misses,cache-references,dTLB-load-misses ./prog。

② 数据结构决定局部性

• 数组顺序扫 = 空间局部性满分 + 硬件预取器全速（它识别顺序模式、提前搬后面的行）；链表/树的指针追逐 = 每步一次不可预取的随机访问。N 不大时，O(n) 的数组常胜 O(log n) 的指针结构——复杂度分析假设访存等价，现实里差两个数量级。
• AoS（结构体数组，struct 的数组）vs SoA（数组结构体，把各字段拆成平行数组）：只用到 x 字段却遍历 struct{x,y,z,w} 数组，每 64B 行里 3/4 是无用数据；拆成四个平行数组（SoA），带宽利用率 ×4 且可向量化——游戏引擎 ECS（实体-组件-系统架构）、列式数据库（比如分析型数仓）都是这一个想法。

③ 分块（tiling）：让工作集塞进 Cache

• 大矩阵乘法直接三重循环，B 矩阵每一列都要重新从 DRAM 读；把矩阵切成能装进 L1/L2 的小块、块内算完再换块，同一块数据被复用几十次——高性能 BLAS（基础线性代数子程序库）快出朴素实现 10 倍以上的第一功臣。

④ 多线程：false sharing 假共享

int counter[4];              // 4 个线程各自累加 counter[tid]
// 看似无共享,实则 4 个 int 挤在同一个 64B 行里:
// 每次写都让其他核的该行失效 → 行在四个核间弹跳 → 比单线程还慢
struct alignas(64) { int v; } counter[4];   // 每人独占一行 → 线性加速

• （4 线程各自 +1 两千万次，先用 &P[0]^&P[1] >> 6 == 0 确认真在同一行）：

  同一 cache 行（false sharing）  0.042 s
  各占独立一行（64 B 对齐）      0.009 s   → 快约 5 倍

  四个线程各改各的变量、逻辑上毫无共享，却因为挤在同一条 64 B 行里而被一致性协议来回收发所有权——这是「性能问题可以完全不在算法里」最典型的一个例子。
• 测它有个必踩的坑：累加器必须自己是 volatile。否则 -O2 看出「循环两千万次自增」有闭式解，一步算完，两个版本都是 0.000 s——第一次跑就是这样，差点当成「false sharing 不存在」。凡是拿循环计时的实验，先确认循环真的跑了。

三级的分工（典型参数，2020s）

L1i/L1d  32~192KB/核   4~5 周期    指令/数据分开(消结构冒险)
L2       1~3MB/核      12~16 周期  私有,统一
L3       数十MB 共享    40~60 周期  全核共享,切片分布
DRAM     数十GB         ~300 周期

• L1 拼延迟（必须跟上流水线节拍，所以小）；L3 拼命中率（拦住去 DRAM 的漏网之鱼，所以大而慢）；L2 是缓冲带。
• 平均访问时间 = 命中时间 + miss 率 × miss 代价，逐级嵌套。改善性能的三个着力点一目了然：降 miss 率（容量/相联度/软件局部性）、降 miss 代价（多级、预取）、降命中时间（小而近）。

同一个思想的三代形态

• 多体交叉（教材经典）：把主存分成多个独立「体」，连续地址轮流落在不同体上（低位交叉），顺序访问时各体流水错峰工作，带宽 ×体数。若高位选体则连续地址挤在一个体里，白分——「怎么切地址」决定并行度。
• 现代 DRAM 的内部并行：一根内存条上有多个 bank/bank group，内存控制器把请求交织派发，掩盖每个 bank 的行操作延迟——低位交叉活在每根内存条里。
• 多通道（channel）：CPU 引出 2/4/8 个独立内存通道，双通道≈带宽×2。装两根内存条快于一根大条的原因就在这——这是普通人最常接触的「多体并行」。服务器/HBM（高带宽内存）把通道堆到极致：GPU 的 HBM 上千 bit 位宽，为的就是喂饱几千个核。

三个问题 → 一个机制

• 保护：物理地址人人可算，进程 A 一个野指针就能改写进程 B 的数据、甚至内核。加了翻译层，A 的页表里根本没有映到 B 内存的条目——访问不到 = 绝对隔离，越权访问在翻译时被硬件拦下（段错误的来源）。
• 重定位：程序编译时不可能知道自己会被装到物理内存哪里。有了虚拟地址，每个程序都从固定布局开始（代码在低址、栈在高址），装哪儿由页表决定——编译器、链接器从此不关心物理内存。
• 超额分配：所有进程的虚拟空间总和远超物理内存也没关系——没访问的页不占物理页，冷页可以换出到磁盘。物理内存变成了「所有进程虚拟空间的缓存」——金字塔思想再次登场，DRAM 之下又垫了一层。

x86-64 的四级页表

虚拟地址 48 位: [ 9位 | 9位 | 9位 | 9位 | 12位页内偏移 ]
                  ↓     ↓     ↓     ↓
                PML4 → PDPT → PD → PT → 物理页框
每级 512 项×8B = 恰好一个 4KB 页

• 树的妙处：没用到的子树整棵不存在。普通进程只用几百 MB 地址空间，页表只需几十 KB——稀疏地址空间的存储代价趋近于零。这也是 64 位机器敢给每个进程 256TB 虚拟空间的底气。
• 页表项（PTE）不只存页框号，还带一排权限位：present（在不在内存）、R/W（可写吗）、U/S（用户态可访问吗）、NX（可执行吗）、dirty/accessed（写过/访问过——给 OS 的置换算法当线索）。只读段、W^X、写时复制，全是在这几个 bit 上做文章。

参数与代价

• 典型规模：L1 TLB 64~128 项（全相联/高相联度），L2 TLB 1~3K 项。覆盖范围 = 项数 × 页大小：128 项 × 4KB 只罩得住 512KB——工作集超过它就开始 TLB miss，每次 miss 由硬件页表行走器做多次访存补课（几十周期）。
• 所以有大页（huge page）：2MB/1GB 的页让每个 TLB 项覆盖 512/26 万倍的地址范围。数据库、JVM 大堆、虚拟化场景收益立竿见影——这是「调大页」这个运维操作背后的全部原理。

用什么地址索引：三种方案

• 现代 CPU 的分工很整齐：L1 用 VIPT（它跟流水线抢每一个周期），L2/L3 用 PIPT（它们本来就要几十个周期，翻译早就完成了，多等一拍无所谓）。

VIPT 的隐藏约束：解释了一个你可能一直觉得奇怪的参数

• 能这么并行的前提是：用来选组的位必须全部落在页内偏移里——页内偏移那 12 位翻译前后原样不变，用它选组，虚拟地址和物理地址选出来的是同一组。写成公式就是 index 位数 + 行内偏移位数 ≤ 12，等价于每一路的容量 ≤ 页大小。
• 代进本机参数（getconf -a：L1d 32 KB、8 路、行 64 B）：每路 = 32 KB ÷ 8 = 4 KB，恰好一个页；组数 64 → index 6 位 + 偏移 6 位 = 12 位，顶格用满、一位不剩。
• 于是「L1d 为什么十几年一直卡在 32 KB」有了硬答案：4 KB 页 + VIPT 之下，想扩容只能加路数，而路数一多比较器和功耗又扛不住。Apple 换了个前提——16 KB 页，每路就能到 16 KB，L1d 一口气做到 128 KB 还保持 VIPT。这是「参数不是拍脑袋定的」最好的一个例子：第 05 章那张真实参数表里的每个数字背后，都压着这类约束。

快慢分岔的完整决策树

虚拟地址
 ├─ TLB 命中(99%+) ──────────→ 物理地址   // ~1 周期
 └─ TLB miss → 页表行走(4次访存,查表本身也走Cache)
      ├─ PTE present ─────────→ 物理地址,填TLB  // 几十周期
      └─ PTE 缺失/无权限 → 缺页异常 → 陷入内核(OS 接管)
            ├─ 合法但没装载: 分配页/从磁盘读入 → 重执行  // 微秒~毫秒
            └─ 非法访问: SIGSEGV → 进程崩溃

物理地址 → L1 命中(~4周期) / L2(~14) / L3(~50) / DRAM(~300)

• 同一条指令的耗时从 1 周期到几毫秒，跨越六个数量级——全看数据落在哪条分支。性能工程的大部分工作就是把访问从慢分支挪到快分支。
• 注意软硬分工的界线：TLB 与页表行走全是硬件自动的；只有缺页才惊动操作系统——机制（翻译）在硬件，策略（缺了怎么办、换谁出去）在 OS。这条界线也是本页与 OS 页的分界：置换算法、工作集、COW、mmap 的精彩内容在 OS 页虚拟内存章。

两种编址，一个胜者

• 内存映射 I/O（MMIO，现代主流）：把设备寄存器映射进物理地址空间的保留区段。读写设备 = 普通的 load/store，无需专用指令，C 代码里一个 volatile 指针就能驱动硬件——嵌入式开发的日常。
• 独立编址（port I/O，x86 遗产）：专用 in/out 指令访问独立的 64K 端口空间。地址空间不占内存的份额，但指令专用、只有 x86 有——如今仅剩键盘控制器等古董设备在用。

三种方式

• 轮询：CPU 循环读状态寄存器直到就绪。实现最简单，但慢设备会把 CPU 空转烧光——键盘每秒几次按键，轮询等于全职保安盯一扇几乎不开的门。
• 中断：设备就绪时主动拉信号，CPU 暂停当前程序跳进处理函数。CPU 平时干正事，「门铃响了才去开门」——中低速、事件稀疏的设备的标准答案。
• DMA（直接内存访问）：连「搬数据」本身也外包——CPU 只说「把这 4KB 从设备搬到内存地址 X」，DMA 引擎自己占用总线搬运，完成后发一个中断汇报。CPU 的参与从「每字节」降到「每批次」。

从引脚到消息

• 经典模型：设备连到中断控制器的物理引脚，控制器按优先级仲裁后打断 CPU；CPU 拿着中断号查中断向量表跳到对应处理函数。线是稀缺的、共享线还要逐个问「是你吗」。
• 现代 MSI/MSI-X（消息信号中断）：中断变成一次内存写——设备往特定地址写一个值，就算发了中断。不占引脚、一个设备可有上千个独立向量、还能指定送到哪个核——多队列网卡给每个 CPU 核配独立收包队列+独立中断，并行收包互不干扰（irqbalance/RSS 调优的原理）。

软硬件的接力（与 OS 页衔接）

• 硬件负责：保存最小现场（PC、标志）、切内核栈、跳向量入口——「中断隐指令」说的就是这段自动动作。
• 内核负责：上半部尽快应答硬件、登记工作；下半部（softirq 等）延后做重活——「关中断的时间必须极短」这条纪律贯穿所有 OS 的中断设计（细节在 OS 页中断卡）。
• 异常（除零、缺页）与中断走同一套向量机制，区别只在来源：异常是当前指令同步产生的，中断是外设异步插入的——所以异常可精确归因到指令，中断不行。

NVMe：DMA 设计的教科书

内核在内存里维护: 提交队列 SQ + 完成队列 CQ（都在主存,SSD 靠 DMA 读写）
① CPU 把读写命令填进 SQ, 写一下设备的 doorbell 寄存器(唯一的 MMIO)
② SSD 自己 DMA 取命令 → 执行 → 数据直接 DMA 进目标内存
③ SSD 把完成状态 DMA 写进 CQ → 发中断(或被轮询发现)

• 每核可配独立队列对、队列深度上万——对比一次只能一个请求的老 SATA 协议，NVMe 的性能优势一半来自闪存、一半来自这套为 DMA 和多核而生的队列协议。io_uring 把同样的「共享内存双队列」思想搬进了系统调用接口（OS 页）——好设计会传染。

设备侧的那一套页表

• IOMMU（Intel VT-d / AMD-Vi / ARM SMMU）坐在设备与内存控制器之间：设备发出的地址叫 IOVA（I/O 虚拟地址），先查 IOMMU 的页表翻译成物理地址，才真正落到内存上。和第 06 章 CPU 侧的 MMU 是同一套思想——页表 + 一个叫 IOTLB 的缓存，只是服务对象从进程换成了设备。
• 驱动的动作随之变成：先建立映射拿到 IOVA、把 IOVA 交给设备，用完再解除映射。设备只碰得到被显式映射过的那几页，其余内存对它根本不存在——这就是「设备也进沙箱」。

三个用途，正好对应第 06 章虚拟内存的三个理由

• 保护：固件有 bug 的网卡、恶意的外接设备，都不能再随手读走整个内存（这类攻击有个专名：DMA 攻击）。
• 重定位与直通：虚拟机里的驱动直接编程物理设备，设备发出的是 guest 眼中的物理地址，由 IOMMU 翻译成宿主的真实物理地址——没有 IOMMU 就没有 GPU/网卡直通。
• 扩展寻址：只能寻址 4 GB 以下的老设备，可以由 IOMMU 把任意高位物理页映射到它够得着的窗口，省掉「先拷到低端内存再 DMA」的中转缓冲。

共享并行总线的两宗罪

• 共享 = 排队：同一时刻只能一对设备通信，设备越多、争用越凶，还需要仲裁机制裁决谁先用（当年链式查询/独立请求那些方案解决的就是这个排队问题——如今问题本身被消灭了）。
• 并行 = 齐步走：64 根数据线的信号必须同时到达，频率一高，线间的长度差异和串扰让「同时」不可能维持——共享式多驱动的并行总线（PCI/FSB 一类）频率天花板在几百 MHz 就到了（点对点、严格等长布线的 DDR 内存接口是例外，能跑到数千 MT/s）。

现代答案：串行 + 点对点 + 交换

• 串行差分对把时钟嵌进数据流，单对线可跑 16~64 GT/s——没有对齐问题，速度靠提升单线速率和堆 lane（通道）：PCIe x1/x4/x16 就是 1/4/16 对收发线的并联。
• 点对点 + 交换芯片取代共享：每个设备独享到交换节点的链路，多对设备同时全速通信，仲裁问题消解为交换机的路由问题——和以太网从同轴总线进化到交换机是同一个故事。
• USB、SATA、以太网、片间互连（NVLink、Infinity Fabric）全走了同一条路：高速世界里，串行点对点是唯一答案。「并行口比串行口快」的直觉在 2005 年后已反转。

版图

• PCIe：机箱内的主干——显卡、NVMe、网卡都挂它。分层协议（物理/链路/事务层），支持 DMA、MSI-X、IOMMU，代际翻倍（3.0 约 1GB/s/lane → 6.0 约 8GB/s/lane）。CPU 与芯片组之间、芯片组与设备之间是一棵 PCIe 树——lspci -tv 能看到你机器的这棵树。
• USB：机箱外的万金油——即插即用、热插拔、供电。USB4 融合了雷电，本质是「把 PCIe/DP 隧道化跑在 USB 线上」——线缆世界也在走「一条高速串行链路承载多种协议」的路。
• NVMe over PCIe / 网络化存储：NVMe-oF 把 NVMe 队列协议跑在 RDMA/TCP 上，存储彻底脱离机箱——协议与介质解耦的范例。

物理账本

动态功耗 P ∝ C × V² × f    // 电容 × 电压平方 × 频率
提频需要提压 → 功耗随频率近似立方增长 → 散热撞死在 ~100W/cm²

• 过去的免费午餐叫 Dennard 缩放：晶体管变小，电压同步降低，单位面积功耗不变——频率年年白涨。2005 年前后电压逼近物理下限（漏电流失控），缩放终结：晶体管还在变多（摩尔定律苟着），但不能全部同时全速跑（暗硅）。
• 同样的功耗预算，两个 3GHz 核的吞吐远超一个 4.5GHz 核——于是工业界集体转向：多核、大小核、SIMD、专用加速器，全是「把功耗花在刀刃上」的不同刀法。软件的免费午餐同时结束：单线程程序再也不会自动变快，并发编程从此是必修课（OS 页并发同步章的存在理由）。

频率是从预算里挤出来的

• DVFS（动态电压频率调节）：负载轻就同时降压降频。因为 P ∝ C×V²×f，降频还能顺带降压，省下的功耗是超线性的——这就是手机待机时能把频率压到几百 MHz 的原因。
• 睿频（Turbo/Boost）是反向操作：只要功耗、温度、电流三条预算还有余量就往上冲。所以同一颗芯片有一整条频率曲线——单核冲刺够得着标称峰值，全核持续负载被功耗预算压低一档，散热跟不上再被温度墙压一档。笔记本插不插电、垫不垫散热，是两套完全不同的预算。
• 宽向量指令（AVX-512 一类）功耗密度特别高，某些处理器为它单独降一档频率——「改用向量指令反而更慢」是真实存在的现象（按公开资料写，本机未验证）。

同一个程序连跑 12 次

4 线程、完全相同的计算，连跑 12 次:
  耗时      0.967 ~ 1.141 s     ← 相差 18%
  周期数    16.19G ~ 16.47G     ← 只差 1.7%
  实际频率  3.82 ~ 4.25 GHz     ← 抖的全在这里

• 结论直接摆在脸上：「秒」不是硬件的量具，它是「周期数 ÷ 当时的频率」。同一段代码干的活一模一样、周期数几乎是常量，耗时却抖了 18%——抖的不是程序，是频率。
• 线程数怎么影响频率（同一份工作负载）：1 线程 4.258 GHz、2 线程 4.243、4 线程 4.150。本机在 WSL2 里只看得到 4 个逻辑核，真正全核满载时跌幅会更大。
• 怎么读出实际频率：perf stat 输出里 cycles 那行末尾的 GHz，就是 cycles ÷ task-clock 算出来的——这是「刚才真的跑了多快」的唯一可靠读数。

MESI：每行一个状态机

M odified   独占且已改(脏) —— 全芯片唯一真本
E xclusive  独占且干净 —— 只有我有,可静默改成 M
S hared     多核共享只读 —— 想写?先广播让别人失效
I nvalid    无效 —— 读写都得重新获取

• 核间靠嗅探/目录互相监听：写一个共享行之前，必须先发「使无效」消息收回所有副本（写失效策略）——保证任意时刻要么多读者、要么单写者，和读写锁同构。
• 硬件保证的是单地址的一致：你永远不会读到「一半新一半旧」的缓存行。它不保证多个地址间的顺序——那是内存模型的事（下一张卡），两者常被混为一谈。

两大流派

• x86：lock 前缀 + 读改写指令。lock add、lock xchg、lock cmpxchg 让这条读-改-写在内存系统看来不可分割：早期真的锁住总线，现在是把目标 cache 行拉到独占态、改完才放手（上一张 MESI 卡）。其中 CAS（compare-and-swap，cmpxchg）最关键：比较内存与「期望值」，相等才写入新值并报告成功——一条指令完成一次「乐观更新」。
• ARM / RISC-V（弱序 RISC）：LL/SC。load-linked 读一个地址时给它挂上监视，store-conditional 只有在这期间没有别的核碰过它才写成功，否则失败、让你重试。它不锁任何东西，靠「监视 + 失败重试」达成原子性——更契合弱序内存模型，也更好扩展到多核。

CAS 是无锁编程的原子

• 用一个 CAS 循环（读旧值 → 基于它算新值 → CAS 写回，失败就整段重来）可以不用锁实现计数器、栈、队列——这就是 lock-free。好处是没有「持锁线程被调度器换出、结果所有人干等」的问题（联动 OS 页）。
• 代价是它极难写对：ABA 问题（值从 A 变 B 又变回 A，CAS 只看值、以为从没变过，酿成 bug）、活锁、以及和内存序的纠缠。所以日常请用现成的 std::atomic 或锁；手写 lock-free 数据结构是专家运动，不是常规操作。

鬼故事的机制

核A:  data = 42;        核B:  while (!flag);
      flag = 1;               print(data);    // 可能打出 0 !

• 为什么：核 A 的写先进写缓冲（store buffer）再择机刷出，两条写到达「全局可见」的顺序可能颠倒；核 B 侧的乱序执行也可能把读提前。单线程内硬件保证「看起来按序」，跨线程的可见顺序没人默认担保。
• 各 ISA 担保的强度不同：x86-TSO 较强（只有「写后读」会乱），ARM/RISC-V 弱序（读读、读写、写写都可乱）——所以并发 bug 常在 ARM 上必现、x86 上潜伏，迁移到 Apple Silicon/服务器 ARM 时集中爆雷。

把顺序买回来

• 硬件提供屏障指令（fence/dmb）：屏障前的访存全局可见之后，才允许屏障后的访存进行。
• 程序员的正确姿势不是手插屏障，而是用语言级原子类型：C/C++ 的 atomic 带 acquire/release 语义——release 写（发布 flag）与 acquire 读（看见 flag）配对，编译器自动在正确位置插屏障，data 的写入保证先于 flag 可见。「用锁和 atomic，不要用裸变量传递信号」这条纪律的硬件依据就在这。

SIMD：CPU 里的向量车道

• x86 的 SSE/AVX（128/256/512 位）、ARM 的 NEON/SVE：一条指令对 4~16 个 float 同时运算。图像、音频、字符串处理（memchr 用 SIMD 一次扫 32 字节）、AI 推理的 CPU 路径全靠它。
• 用法优先级：先让编译器自动向量化（规整循环 + -O3，godbolt 验证）；不行再用 intrinsics 手写。数据布局决定成败——第 05 章的 SoA 布局正是为了让数据「一行行喂进向量车道」。

GPU：把整颗芯片押给吞吐

• 设计哲学与 CPU 相反：砍掉分支预测、乱序、大 Cache（那些为延迟服务的一切），换成几千个简单核 + 超宽显存带宽，用海量线程轮转来掩盖访存延迟——一批线程等内存时，另一批顶上，执行单元永不空闲。
• SIMT（单指令多线程）执行模型：32 个线程为一组（warp，线程束）踏同一条指令；组内分支分歧则两条路径串行各走一遍——GPU 代码「怕 if」的原因。适合的负载一句话：规整、海量、算术密集（图形、矩阵乘、深度学习）；指针追逐和复杂分支请留在 CPU。

  	CPU（含 SIMD）	GPU
  为什么服务而设计	延迟——让单条依赖链尽快跑完	吞吐——让总完成量最大
  核的性质	少而宽（乱序、大 Cache、分支预测）	多而简（砍掉这些，换执行单元）
  怎么掩盖访存延迟	乱序窗口 + 多级 Cache	海量线程轮转（一批等内存，另一批顶上）
  分支分歧	预测器处理，代价可控	同一 warp 内两条路径串行各走一遍
  适合的负载	逻辑复杂、分支多、延迟敏感	规整、海量、算术密集

为什么专用能赢几个数量级

• 通用 CPU 执行一次加法，90%+ 的能量花在「取指、译码、调度、预测」这些管理开销上，真正的运算只占零头。专用架构把管理开销摊薄：TPU 的脉动阵列让数据在数万个乘加单元间直接流动，一次取指驱动上万次运算——能效比 CPU 高两个数量级，原理不神秘，就是砍掉灵活性、摊薄开销。
• 代表：AI 的 TPU（张量处理单元）/NPU、视频编解码的固定单元（手机录 4K 不烫手的原因）、网络的 DPU（数据处理单元）、加密的 AES-NI（x86 的 AES 加密指令扩展）。判断某负载会不会「硬化」：足够普遍 + 算法足够稳定 + 数据并行度高。

攻击的两块积木

• 积木一（第 04 章）：分支预测错误时，推测执行的指令被回滚——架构状态完美还原，但推测期间的访存已经改变了 Cache 的冷热，而 Cache 状态不回滚。
• 积木二（第 05 章）：命中与 miss 的时间差可以精确测量——Cache 的冷热是一条侧信道。
• 组合（Spectre v1）：训练分支预测器让越界检查被预测为通过 → CPU 推测执行 array2[secret*4096]（用越权读到的秘密值当下标）→ 回滚后逐项测量 array2 哪一行变热 → 秘密值泄露。没有任何一条指令「真正」违规执行过，秘密却出来了。

算一笔确定性的账

• 一个像素常见是 32 位（RGBA 各 8 位，其中 8 位常常不用，纯粹为了对齐）；
• 1920 × 1080 一帧 = 2,073,600 像素 × 4 字节 ≈ 7.9 MiB；
• 60 Hz 下扫描输出的带宽 = 7.9 MiB × 60 ≈ 475 MiB/s（约 3.98 Gbit/s）；
• 换成 4K@120Hz：3840 × 2160 × 4 × 120 ≈ 3.8 GiB/s。这两个数字只取决于算术，谁算都一样——它解释了为什么高分辨率高刷新率的设备对内存带宽敏感，也解释了显示接口（HDMI / DisplayPort）为什么要一代代提速。

三个相关概念

• stride（行距）：一行实际占的字节数常常大于「宽 × 每像素字节」，因为要对齐到 64 / 256 字节边界。逐行拷贝时用 stride 而不是宽度，是图形代码里最经典的一条；
• 色深与色域：8 bit/通道是主流，HDR 内容用 10 bit（每像素 30 位），带宽随之上升；
• 消隐期（blanking）：扫描输出在每帧之间有一小段不传像素的间隙，这段时间就是「换缓冲区」的安全窗口——下一卡的 VSync 正是踩在这里。

三种现象

• ① 撕裂（tearing）：屏幕上半部分是新一帧、下半部分是旧一帧，中间一条明显的错位线。成因是扫描输出正读到一半时，帧缓冲的内容被改了；
• ② 卡顿 / 掉帧（stutter）：某一帧算得太久，错过了扫描输出的窗口，于是同一帧被显示了两次。60 Hz 下每帧预算约 16.7 ms，超一点点就掉一整帧；
• ③ 输入延迟（latency）：画面流畅但操作「跟手感差」。成因是缓冲层数太多——每多一层缓冲，就多一帧的延迟。

双缓冲与 VSync

• 双缓冲：画在后台缓冲区，画完再整体切换。切换动作（page flip）只是改一个「当前显示哪块内存」的指针，代价极低；
• VSync（垂直同步）：把切换动作对齐到消隐期，于是撕裂被彻底消除。代价是渲染要等待——如果一帧只超时一点点，帧率会从 60 直接掉到 30（因为必须等下一个窗口）；
• 三缓冲：多一块后台缓冲，让渲染不必等待切换完成，缓解「掉一半帧率」的问题，代价是多一帧延迟；
• 可变刷新率（VRR / FreeSync / G-Sync）：反过来让显示器等 GPU——帧准备好了就扫描输出。这是今天最优的方案，同时解决撕裂与半帧率问题。

GPU 擅长什么

• 大规模并行的同类操作：几百万像素各自独立地做同一套计算，正好是 GPU 的形态（这与第 07、08 章讲的 SIMD 与并行是同一条思路，只是规模大了两个量级）；
• 纹理采样与混合：缩放、旋转、透明度叠加在 GPU 上几乎是免费的，在 CPU 上是逐像素的乘加；
• 代价是「过去一趟」：数据要传到显存、命令要提交、结果要同步。小批量、频繁往返的用法会让 GPU 比 CPU 还慢——这就是「批处理（batching）」在图形编程里被反复强调的原因。

合成器做的事

• 每个窗口画到自己的一块缓冲区（离屏），合成器把它们按层级、透明度、变换叠加成最终一帧；
• 于是「移动窗口」「淡入淡出」「桌面切换」不需要应用重画——合成器拿现成的纹理做变换即可，这就是这类动画总是很流畅的原因；
• 反过来，只要动画涉及「内容本身变化」（文字重排、列表重新布局），就绕不开应用重画，流畅与否取决于应用自己的帧时间预算。

模拟器有三档精度，别一上来就挑最难的

• 本章做的是第一档，外加第二档最有价值的两个零件：一个 Cache 模型、一个分支预测器。它们各只有几十行，却能把第 04、05 章的说法全部变成可以数出来的数字。

为什么模拟器里的数字比真机上的更适合学习

• 真机测量要跟三样东西搏斗：频率在动（第 08 章：同一程序连跑 12 次耗时差 18%）、后台进程在抢、编译器会把你要测的代码整段优化掉（第 01 章五个实验里踩了两次）。
• 模拟器里没有这些：miss 多少次、错判多少次是确定的，换台机器、换个编译器、隔一年再跑，数字一个不差。本章下面每个数字你都能一字不差地复现出来——这是真机实验给不了的东西。
• 更重要的是可观测性：真机的 perf 只给你一个总数，模拟器里你可以问「是哪一条分支错的、错在第几次、这次访存落在哪一组」——想插什么计数器就插什么。

三个必踩的坑（都是静默出错，不会报错）

• 写 x0 必须作废：RV32I 规定 0 号寄存器恒为零，而 li t0, 0 这类伪指令、比较结果都会往它上面写。漏了 reg[0] = 0 这一行，程序不会崩，只会算出莫名其妙的结果。
• 立即数要符号扩展：(int32_t)insn >> 20 里那个强制转换是关键——有符号数的右移是算术右移，高位补符号位，正好就是符号扩展。写成无符号右移，所有负偏移全错。
• 分支和跳转的目标是相对「本条指令」的 PC，不是相对 PC+4。写反了循环会少跑或多跑一圈，而且往往还能「跑完」，只是结果不对。

怎么产出可以喂给它的机器码

• 不需要交叉编译器，一套 binutils 就够（Ubuntu 上包名 binutils-riscv64-linux-gnu）。三步：as -march=rv32i -mabi=ilp32 汇编 → ld -m elf32lriscv -Ttext=0x1000 链接 → objcopy -O binary 拍平成裸镜像。
• 本卡的代码就是这么跑通的：一段 7 条指令的求和汇编（sum += i 循环到 100），模拟器输出 a0=5050，执行了 303 条指令——3 条初始化 + 100 圈 × 3 条，一条不多一条不少。指令数能对上，说明控制流也对了，这比只看结果强得多。

模型比想象中简单

• 三个数组就够：tag[组][路]、valid[组][路]、lru[组][路]（存一个时间戳）。给定地址：行号 = 地址 ÷ 行大小、组号 = 行号 % 组数、tag = 行号 ÷ 组数——正是第 05 章那张「地址切三段」的图，写成两个除法。
• 组内挨个比 tag，中了就更新时间戳；没中就挑时间戳最小的换出去。只统计命中率的话，Cache 模型里不需要存一个字节的真实数据——这也解释了 Cache 的本质：它是一张「谁在里面」的账本。

256×256 的 int 矩阵（256 KB），模拟 32 KB / 8 路 / 64 B

• 6.25% 就是 1/16：一条 64 B 的行装 16 个 int，第一次未命中把后面 15 个一起带上来。第 05 章「碰一个字节 = 搬 64 字节」的精确形态。
• 列遍历那 100% 不是容量不够——同样 32 KB、只把相联度换成全相联，miss 立刻掉回 4096。差别全在冲突：列步长 1024 B = 16 条行，组号每次 +16 再模 64，整个 Cache 只有 4 个组在干活，8 路 × 4 组 = 32 条行，装不下一列需要的 256 条。第 05 章那句「2 的幂步长是性能玄学事故的高发区」，这就是它的实物。
• 最后一行是解药：每行多留一个 int（步长 1024 → 1028 B），组号不再原地打转，miss 从 6.5 万掉到 4336——一个 int 的填充换来 15 倍。数组填充（padding）这个老技巧的全部原理就在这三个数字里。
• 这五行数字与机器无关：不管你用什么 CPU、什么编译器，跑出来一模一样。

四行的预测器

• idx = (pc >> 2) & 1023：用 PC 索引一张 1024 项的表（右移 2 位是因为指令四字节对齐，低两位恒为零）。
• guess = bp[idx] >= 2：状态 0~3 分别是强不跳 / 弱不跳 / 弱跳 / 强跳。
• 猜错就计数；然后 taken ? bp[idx]++ : bp[idx]--（夹在 0~3 之间）。
• 再加一个「每个分支点单独计数」的小表，你就有了一个 perf 给不了的 profiler：能精确到哪条分支错了几次。

第 01 章那个经典实验，这次数得清清楚楚

程序是 if (a[i] >= 128) sum += a[i]; 扫 32768 字节数组、跑 100 遍（数组用固定 LCG 生成，所以人人可复现）：

• 同一份代码、同一条指令，只换了数据，错判从 163 万次降到 400 次。这就是第 01 章那个实验的机理——真机的 perf 只会告诉你「branch-misses 少了 9 倍」，模拟器直接指出是哪一条分支、错了几次。
• 数据分支的 49.90% 说明：2 位计数器对随机数据毫无办法，等于瞎猜。对照第 04 章的—现代 TAGE 类预测器在同样随机的数据上只错 1.24%——这两个数字之间就是三十年预测器进化的距离。
• 1 位与 2 位的差别要在循环上才看得出来：上一张卡的行遍历里，内层循环回边执行 65 536 次，2 位错 261 次、1 位错 514 次——正好是「每次退出内层循环，1 位错两次（出去一次、回来一次），2 位只错一次」，256 次退出。教科书那句「连错两次才改主意」，就是这两个数。

先说「对吗」：三级验证

• 自检程序：跑一个你能手算出答案的程序（求和到 100 得 5050），并且核对指令条数——结果对而条数不对，说明控制流走了另一条路，只是恰好殊途同归。
• 官方测试集：RISC-V 的 riscv-tests 每条指令一组用例，失败时把用例编号留在寄存器里，直接告诉你哪条指令实现错了。
• 差分测试（最强）：同一个程序在你的模拟器和一个黄金模型（Spike）上同时跑，每执行一条指令就比对全部 32 个寄存器和 PC，第一处不一致就是 bug 现场。写这个对比框架的成本，远低于你为一个静默错误熬的夜。

再说「为什么慢」：本机数字

• 跑那个 2130 万条指令的程序，模拟器用 0.06~0.09 秒，约 230~360 MIPS。用 perf 看宿主这一侧：执行了 13.37 亿条 x86 指令——每模拟一条 RV32I 指令要花约 63 条宿主指令，宿主 IPC 4.06。「功能级模拟慢几十倍」这句话，具体形态就是这个 63。
• 开销的大头是那个 switch：它被编成一张跳转表，也就是每模拟一条指令都要走一次间接跳转——正是第 04 章 BTB 卡讲的那种分支。有意思的是本机 perf 显示这条 dispatch 只错 0.90%：因为这个测试程序的 opcode 序列高度规则，宿主的预测器把它学会了。换成 opcode 杂乱的真实负载，它就会变成解释器最大的一笔开销。
• 解释器界的标准解法是 computed goto：每条指令执行完，直接跳向下一条指令的处理代码，把一个「什么目标都可能」的跳转点拆成几百个各自有规律的跳转点——第 04 章那张卡的结论在这里直接兑现（本机未做 A/B 对照，别把网上流传的倍数当定论，自己测）。
• 再快就得换路线：动态二进制翻译（QEMU 把一段客户机指令翻译成宿主指令、缓存起来反复执行），代价是失去「每条指令都能插桩」的能力。精度、速度、可观测性，三样里挑两样——这是模拟器领域的基本取舍。

动手项目（难度递进）

• ① nand2tetris：从 NAND 门搭到能跑俄罗斯方块的完整计算机。做完它，第 00、02~04 章从「懂了」变成「造过」。（约 2~4 周业余时间，前 6 章硬件部分对应本页）
• ② 写一个 RISC-V 模拟器：几百行 C/Rust 实现 RV32I 的取指-译码-执行循环，跑通官方测试集。ISA、寻址、调用约定从此刻进肌肉。第 10 章已经把这条路铺到能跑——核心循环、Cache 模型、分支预测器、验证办法都在那一章，接着往上加 M 扩展、CSR、页表、流水线模型即可。（配合汇编页 RISC-V 章）
• ③ 性能实验集：用 perf 复现本页每个可测现象——分支预测（排序 vs 未排序）、Cache 行遍历、false sharing、TLB miss、内存带宽上限。每个实验写下「预测值 vs 值」，对不上就深挖——这是性能工程师的日常训练。
• ④ 进阶选修：给 QEMU/gem5 加个简单设备模型；用 Verilog 在 FPGA 上跑一个五段流水线核（如「一生一芯」计划）。

书与资料（按阶段）

• 入门起步：CS:APP（深入理解计算机系统）——程序员视角的体系结构，配套 lab（bomb lab、cache lab）质量极高，本页多章与之呼应。
• 系统学习：Patterson & Hennessy《计算机组成与设计》（RISC-V 版）——单周期到流水线的标准教材。
• 登堂入室：Hennessy & Patterson《计算机体系结构：量化研究方法》——乱序、多核、DSA 的研究生级正典。
• 保持更新：Agner Fog 优化手册、uops.info、Chips and Cheese 架构分析、ISCA/MICRO 会议的获奖论文。