第2章 计算机体系结构

CPU 的工作原理

章节导读

如果把计算机比作一座城市，那么 CPU 就是这座城市的市政厅——所有指令都在这里被解读和执行。但 CPU 的内部世界远比大多数人想象的复杂：一颗现代桌面处理器包含上百亿个晶体管，每秒钟执行数百亿条指令，而这些指令的执行方式早已不是「一条接一条」那么简单。本章将打开 CPU 这个黑盒子，看看里面到底发生了什么。

一切从一个最基本的循环开始：取指（Fetch）、解码（Decode）、执行（Execute）、写回（Write Back）。这是 1945 年冯·诺依曼在 EDVAC 报告草案中描述的计算模型，八十年来所有计算机的骨架都没有变过：程序和数据一起存放在存储器中，CPU 按顺序取出指令并执行。早期的 CPU 确实就是这样工作的——取一条指令，执行完，再取下一条。但这种方式有一个巨大的浪费：取指单元、解码单元、执行单元在大部分时间里都在互相等待。1960 年代的 IBM Stretch 和 CDC 6600 率先引入了流水线的思想：把指令执行拆成多个阶段，让不同的指令同时处于不同的阶段，就像工厂的装配流水线一样。流水线不减少单条指令的延迟，但成倍提高了吞吐量——这是计算机体系结构史上第一个伟大的思想。

流水线一旦引入，新的问题随之而来。当一条加法指令的结果还没写回，下一条依赖它的指令就已经进入执行阶段，怎么办？这是数据冒险。当一条分支指令还没算出跳转方向，后面的指令该不该继续取？这是控制冒险。当两条指令同时需要使用同一个硬件单元？这是结构冒险。为了解决控制冒险，工程师发明了分支预测器——现代处理器的两级自适应预测器准确率高达 95% 以上，预测错误的代价是清空流水线的十几个周期。为了解决数据冒险并进一步挖掘并行性，1967 年 Robert Tomasulo 在 IBM System/360 Model 91 的浮点单元中提出了划时代的乱序执行算法：指令不必按程序顺序执行，只要操作数就绪就可以开工，通过保留站和寄存器重命名消除假依赖，再用重排序缓冲区保证对外呈现顺序执行的结果。乱序执行加上超标量设计（每个周期发射多条指令），让现代 CPU 的指令级并行度达到每周期 4-6 条指令。

但 CPU 再快，也快不过内存的鸿沟。这就是著名的「内存墙」问题：过去四十年 CPU 主频增长了上千倍，而内存访问延迟只改善了几倍。今天一次 L1 缓存命中约 1 纳秒，而访问主存需要约 100 纳秒——如果按人类感知比例缩放，L1 命中相当于拿起桌上的一本书，主存访问则相当于睡了一整夜。为了填平这道鸿沟，计算机体系结构构建了精密的内存层次：寄存器、L1、L2、L3 缓存、主存、SSD、磁盘，每一层都是上一层的缓存，利用程序访问的时间局部性和空间局部性，让 CPU 在绝大多数时候不必直面缓慢的主存。理解缓存的组织方式（直接映射、组相联、全相联）、缓存行、写策略，是写出高性能代码的必修课——矩阵乘法按行遍历和按列遍历的性能可以相差十倍，原因全在缓存。

最后，2005 年前后，单核 CPU 撞上了功耗墙：频率提升带来的功耗按超线性增长，散热无法承受，「免费午餐」结束了。处理器厂商转向多核，把频率停在 3-5GHz，用核心数量换取算力。这一转变深刻改变了软件行业——从此性能提升不再自动获得，程序员必须显式地思考并行。本章将带你走完这条从单条指令到多核处理器的完整认知路径，这正是「from the bottom up」方法论的核心：理解了 CPU 如何工作，你才能理解操作系统的调度、编译器的优化，以及你的代码为什么快或为什么慢。

核心概念

• CPU
• 流水线
• 分支预测
• 乱序执行
• 超标量
• 内存层次
• 缓存
• 多核

要点精析

CPU 的基本工作循环——取指、解码、执行、写回。指令集架构（ISA）定义了软硬件的契约：程序员可见的寄存器、指令格式、内存模型。以 x86 为例，一条指令的执行分为几个阶段：取指阶段由程序计数器（PC，x86 中叫 RIP）给出地址，从指令缓存中取出指令字节；解码阶段把变长的 x86 指令（1 到 15 字节）翻译成内部微操作（μops）——现代 x86 CPU 是 CISC 外壳 RISC 内核，复杂指令被拆解为简单的微操作；执行阶段由算术逻辑单元（ALU）、浮点单元（FPU）或加载/存储单元完成实际计算；写回阶段把结果写入寄存器文件或内存，并更新标志位。x86 的复杂解码是历史包袱：为了兼容 1978 年的 8086，指令长度可变、寻址模式繁多，解码成为流水线瓶颈，因此 Intel 引入了 μop 缓存（Decoded Stream Buffer）直接缓存解码结果。相比之下 RISC-V 和 ARM 的定长或半定长指令解码简单得多，这也是 RISC 哲学在移动和嵌入式领域胜出的原因之一。理解这个循环是理解一切微架构优化的起点。

流水线设计——用并行换吞吐量。流水线的核心思想是把指令执行划分为 k 个阶段，每个阶段由独立的硬件单元负责，理想情况下每个时钟周期完成一条指令（吞吐率提升 k 倍），而单条指令的延迟仍是 k 个周期。经典的五级流水线是 IF（取指）、ID（解码/读寄存器）、EX（执行）、MEM（访存）、WB（写回）。流水线的性能受「最慢阶段」制约——木桶效应，因此现代 CPU 把流水线切得越来越细：Pentium 4 的 NetBurst 架构达到 20-31 级流水线，每级做的事很少，从而允许更高的主频；但超长流水线的代价是分支预测失败时要清空更多级，恢复成本巨大，Pentium 4 的失败让 Intel 在 Core 架构中退回到 14-19 级的平衡设计。流水线还要求每个阶段都能独立工作，这推动了寄存器堆多端口、分离的指令/数据缓存（哈佛结构）等设计。衡量流水线效率的指标是 CPI（Cycles Per Instruction），理想流水线 CPI=1，而现代乱序超标量处理器的实际 CPI 可以低于 0.25——意味着平均每个周期完成 4 条以上指令。

流水线冒险——数据、控制、结构三类冲突及解决方案。数据冒险发生在后一条指令需要前一条指令尚未写回的结果，例如 add 之后紧跟使用其结果的 mul。解决方案有三种：停顿（Stall，插入气泡等待结果，简单但损失性能）；数据前递/旁路（Forwarding，把 EX 阶段的计算结果直接旁路给下一条指令的输入，不必等写回，可消除大部分停顿）；编译器指令调度（重排指令把无关操作填入延迟槽）。load-use 冒险（load 的结果立即被使用）即使有前递也必须停顿一个周期。控制冒险来自分支指令：分支结果在 EX 或 MEM 阶段才确定，而 IF 阶段早已取入了后续指令。解决方案包括静态预测（总是预测不跳转或向后跳转预测跳转）、动态预测（见下一要点）、分支延迟槽（MIPS 的做法，把分支后一条指令设为无论如何都执行的槽位）以及推测执行加恢复。结构冒险是两条指令争用同一硬件资源，例如统一缓存下取指和访存冲突，解决方案是资源复制——分离指令缓存和数据缓存、多端口寄存器堆、多个执行单元。三类冒险的处理水平直接决定了流水线的实际效率。

分支预测——从静态到动态到两级自适应。分支预测的目标是在分支结果确定之前猜测跳转方向，让流水线不中断地继续取指。静态预测用固定规则：早期简单实现「预测不跳转」，后来发现循环通常向后跳转，于是「向后取跳转、向前取不跳转」的静态策略能达到 60-70% 准确率。动态预测记录历史行为：1 位预测器记住上次分支的方向，但循环中会错两次（进入和退出各一次）；2 位饱和计数器预测器需要连续两次错误才改变预测，循环场景只需错一次，准确率提升到 85-90%。两级自适应预测器（Tournament Predictor，McFarling 1993 提出）是里程碑：用全局历史寄存器（GHR）记录最近 n 次分支的结果作为索引，查一张模式历史表（PHT），不同的历史模式对应不同的 2 位计数器——「如果最近三次都是跳转，这次大概率也跳转」。Alpha 21264 和 Pentium Pro 采用此设计，准确率达 93-97%。现代处理器更进一步：Intel 从 Haswell 开始使用基于感知机（Perceptron）的预测器，用机器学习方法对多个历史特征加权求和，配合循环缓冲器和间接分支目标预测（BTB，预测跳转目标地址而不仅是方向），综合准确率超过 98%。预测失败的代价是清空流水线重新取指，现代深流水线下约损失 15-20 个周期——这就是为什么「分支友好」的代码（如用 CMOV 代替短分支、排序数据让分支更规律）能显著提速。

乱序执行——Tomasulo 算法、保留站与重排序缓冲区。程序顺序不等于最优执行顺序：只要数据依赖满足，指令可以提前执行。1967 年 Robert Tomasulo 为 IBM System/360 Model 91 的浮点单元设计的算法是乱序执行的奠基之作，其核心是寄存器重命名：架构寄存器（程序员可见的 16 个）被映射到数量大得多的物理寄存器（现代 CPU 有 150-250 个），从而消除 WAR（写后读）和 WAW（写后写）这两类「假依赖」，只保留真正的 RAW（读后写）数据依赖。实现机制包括：保留站（Reservation Station，每条已解码指令在此等待操作数就绪，通过公共数据总线 CDB 监听其他指令的结果）；重排序缓冲区（ROB，按程序顺序记录所有在途指令，只有位于 ROB 头部且已完成的指令才能「退休」提交结果，保证对外呈现顺序执行的语义）；物理寄存器堆与空闲列表管理重命名资源。乱序执行还带来精确异常的能力：任何指令出错时，ROB 保证它之前的指令全部完成、之后的指令全部丢弃，异常状态与顺序执行完全一致。现代 CPU 的调度窗口可达数百条指令，能在等待缓存缺失的几百个周期里继续执行后续无关指令，这是单核性能的重要来源。代价是硬件复杂度和 Spectre/Meltdown 类推测执行安全漏洞——2018 年曝光的这些漏洞本质上是攻击者读取了推测执行期间被临时加载到缓存中的数据。

超标量设计——多发射与指令级并行。超标量（Superscalar）指 CPU 在每个时钟周期内发射（Issue）多条指令，前提是这些指令之间无依赖且硬件资源充足。实现超标量需要复制硬件：多个解码器（Intel Golden Cove 有 6 个解码器）、多个执行端口（典型配置是 4 个整数 ALU、2 个加载单元、1-2 个存储单元、2-4 个浮点/向量单元）、多端口寄存器堆。发射策略分为静态多发射（编译器负责找出可并行的指令，如 VLIW 架构 Intel Itanium，商业上失败了）和动态多发射（硬件在运行时判断，现代 CPU 全部采用）。与超标量互补的是超长指令字（VLIW）和显式并行指令计算（EPIC），它们把调度负担交给编译器，硬件简单但依赖编译器质量，最终只在 DSP 和 GPU（某种程度上）领域存活。衡量超标量效率的指标仍是 IPC（每周期指令数）：理论峰值可能是 6，实际程序通常只有 1-3，差距来自依赖链、缓存缺失和分支预测失败。程序员能做的：减少长依赖链（循环展开、多累加器）、使用 SIMD 向量化（一条指令处理 4-16 个数据，是另一种「更宽」的并行）、避免不可预测的分支。超标量 + 乱序 + 分支预测 + 缓存层次的组合，构成了现代单核性能的完整拼图。

内存层次结构——从寄存器到磁盘的性能鸿沟。局部性原理是内存层次的理论基石：时间局部性（刚访问的数据很可能再次访问，如循环变量）和空间局部性（访问了某地址，其邻近地址很可能被访问，如数组遍历）。基于局部性，计算机构建了金字塔式的存储层次，每层容量更大、速度更慢。以典型 3GHz 桌面 CPU 为参照的延迟数据：寄存器访问 0.3ns（1 周期）；L1 缓存 1-1.3ns（4-5 周期），容量 32-64KB；L2 缓存 4-5ns（12-15 周期），容量 512KB-2MB；L3 缓存 12-15ns（40-50 周期），容量 16-64MB，多核共享；主存（DDR4/DDR5）80-100ns（250-300 周期），容量 16-128GB；NVMe SSD 随机读 20-100μs（数万到数十万周期）；机械磁盘寻道 5-10ms（千万周期以上）；跨数据中心网络往返 数十 ms。从 L1 到主存延迟差 100 倍，从主存到 SSD 又差 1000 倍。Jeff Dean 著名的「程序员应知的延迟数字」把这些数据拟人化：L1 命中是 0.5 秒，主存引用是睡 4 分钟，SSD 随机读是睡 4 天，磁盘寻道是睡 4 年。理解这个数量级差异，你就理解了为什么「缓存友好」是性能优化的第一原则，也理解了操作系统为什么如此设计虚拟内存和页面置换。

缓存的组织方式——直接映射、组相联、全相联。缓存把内存划分为固定大小的块（Cache Line，通常 64 字节）作为搬运单位。直接映射缓存中，每个内存块只能放到唯一确定的缓存行（行号 = 块地址 mod 行数），硬件最简单（一次比较），但两个频繁访问的地址若映射到同一行会互相驱逐，产生「冲突缺失」甚至颠簸（thrashing）。全相联缓存中，块可以放到任意行，冲突最少，但每次查找要并行比较所有行的标签，硬件成本随行数平方增长，只适合小容量结构如 TLB。组相联是两者的折中：缓存被分成若干组，每组 k 行，块先按地址定位到组，再在组内 k 行中任选（k 路组相联）。k=8 或 16 是现代 L1/L2 的典型值，兼顾命中率和硬件成本。替换策略常用 LRU 近似（如树形伪 LRU）。写策略分写直达（Write-Through，同时写缓存和内存，简单但流量大）和写回（Write-Back，只写缓存，脏位标记，替换时才写回，现代 CPU 的标准做法），配合写缓冲吸收存储流量。缓存缺失分三类（3C 模型）：强制缺失（首次访问，无法避免）、容量缺失（工作集超过缓存容量）、冲突缺失（映射冲突）。程序员可控的部分：让数据结构紧凑（结构体字段排序、避免指针追逐）、按缓存行顺序访问（行优先遍历矩阵）、对齐关键数据到缓存行边界、多核下避免伪共享（不同核写同一缓存行的不同变量，会触发缓存一致性流量，可用填充对齐解决）。

缓存一致性与多核架构——从单核到多核的必然性。2004 年前后，单核频率提升撞上功耗墙：动态功耗 P = C·V²·f，提频必须提压，功耗按超线性增长，风冷散热到达极限（Pentium 4 高达 130W 仍只有 3.8GHz），「频率竞赛」宣告终结。厂商转向多核：把两个、四个乃至上百个核心封装在一起，每个核心保持适中频率，用并行度换取总吞吐。多核带来缓存一致性问题：每个核心有私有 L1/L2，同一内存块可能在多个缓存中存在副本，一个核心写入后其他核心的副本必须失效或更新。解决方案是一致性协议，最经典的是 MESI（Modified、Exclusive、Shared、Invalid 四状态）：核心写数据前先通过总线广播 Invalidate 消息让其他副本失效，读共享数据时若有 Modified 副本则由其提供最新值。MOESI 增加了 Owned 状态允许脏数据共享，减少写回流量。一致性流量通过目录（Directory）或监听（Snooping）机制管理，核数越多开销越大，这是众核扩展的瓶颈之一。多核还引入了内存一致性模型问题：x86 采用较强的 TSO（Total Store Order）模型，ARM 采用弱内存模型，跨核共享数据必须使用内存屏障或原子操作，否则重排序会导致数据竞争。对程序员而言，多核时代意味着：性能不再随时间自动提升（Amdahl 定律限制了加速比），必须显式并行化；线程间通信成本高昂（跨核缓存传输几十纳秒，伪共享更糟）；无锁编程需要深刻理解内存模型。从单核到多核的转变，是过去二十年软件行业最重要的硬件背景。

代码示例

/* 缓存友好性实验：矩阵遍历顺序对性能的影响 */
#include <stdio.h>
#include <time.h>

#define N 4096
static int matrix[N][N];

long long sum_row_major(void) {
    long long s = 0;
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            s += matrix[i][j];
    return s;
}

long long sum_col_major(void) {
    long long s = 0;
    for (int j = 0; j < N; j++)
        for (int i = 0; i < N; i++)
            s += matrix[i][j];
    return s;
}

int main(void) {
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            matrix[i][j] = i + j;

    clock_t t0 = clock();
    volatile long long a = sum_row_major();
    clock_t t1 = clock();
    volatile long long b = sum_col_major();
    clock_t t2 = clock();

    printf("row-major: %.3f s\n", (double)(t1 - t0) / CLOCKS_PER_SEC);
    printf("col-major: %.3f s\n", (double)(t2 - t1) / CLOCKS_PER_SEC);
    return 0;
}

/* 4096x4096 的 int 矩阵占 64MB，远超 L3 缓存。
   行优先遍历按内存地址顺序访问，每次缓存缺失
   搬入 64 字节（16 个 int），随后 15 次访问全部命中，
   缺失率约 1/16。列优先遍历每次访问间隔 16KB
   （一行的大小），落在不同的缓存行甚至不同的页上，
   每次访问都缺失，且会把行优先刚建立的缓存全部冲掉。
   实测列优先通常慢 5-15 倍。这个实验是理解
   「空间局部性决定性能」的最直观教材。
   注意 volatile 防止编译器把整个循环优化掉。
   延伸实验：用 perf stat 观察两种遍历的
   cache-misses 计数，用分块（tiling）技术改写
   列优先版本，验证分块后性能可以逼近行优先。 */

/* 分支预测的威力：可预测与不可预测分支的性能对比 */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define SIZE 32768
static int data[SIZE];

long long sum_filtered(void) {
    long long s = 0;
    for (int i = 0; i < SIZE; i++)
        if (data[i] >= 128)
            s += data[i];
    return s;
}

int cmp(const void *a, const void *b) {
    return *(const int *)a - *(const int *)b;
}

int main(void) {
    for (int i = 0; i < SIZE; i++)
        data[i] = rand() % 256;

    clock_t t0 = clock();
    volatile long long r1 = sum_filtered();
    clock_t t1 = clock();
    qsort(data, SIZE, sizeof(int), cmp);
    volatile long long r2 = sum_filtered();
    clock_t t2 = clock();

    printf("unsorted: %.4f s\n", (double)(t1 - t0) / CLOCKS_PER_SEC);
    printf("sorted:   %.4f s\n", (double)(t2 - t1) / CLOCKS_PER_SEC);
    return 0;
}

/* 这就是 Stack Overflow 史上票数最高的问题
   「Why is processing a sorted array faster than an
   unsorted array」的核心代码。数据随机时，
   if (data[i] >= 128) 的跳转方向完全不可预测，
   分支预测器准确率约 50%（等于抛硬币），
   每次预测失败清空流水线损失约 15-20 周期。
   数据排序后，前半段全不跳转、后半段全跳转，
   预测器轻松学会模式，准确率接近 100%。
   实测未排序版本慢 2-6 倍。消除该分支的
   无分支写法：用位运算代替 if，
   例如 int t = (data[i] - 128) >> 31;
   s += (~t & data[i]);
   这样无论数据如何分布性能都稳定。
   本实验直观展示了控制冒险与分支预测
   对实际程序性能的巨大影响。 */

/* 观察 CPU 缓存层次：指针追逐测延迟 */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

static inline long long ns_now(void) {
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return (long long)ts.tv_sec * 1000000000LL + ts.tv_nsec;
}

double chase(size_t array_bytes, size_t stride) {
    size_t n = array_bytes / sizeof(void *);
    void **arr = malloc(array_bytes);
    for (size_t i = 0; i < n; i++)
        arr[i] = &arr[(i + stride / sizeof(void *)) % n];
    long long t0 = ns_now();
    void **p = &arr[0];
    size_t steps = 0;
    while (ns_now() - t0 < 200000000LL) {
        p = (void **)p;
        steps++;
    }
    double ns = 200000000.0 / steps;
    free(arr);
    return ns;
}

int main(void) {
    size_t sizes[] = { 16UL<<10, 64UL<<10, 256UL<<10,
                       1UL<<20, 4UL<<20, 16UL<<20,
                       64UL<<20, 256UL<<20 };
    for (size_t i = 0; i < sizeof(sizes)/sizeof(sizes[0]); i++)
        printf("array %6zu KB, stride 64B: %6.2f ns/access\n",
               sizes[i] >> 10, chase(sizes[i], 64));
    return 0;
}

/* 指针追逐（pointer chasing）是测量内存延迟的经典方法：
   每次访问的地址依赖上一次访问的结果，
   形成严格的数据依赖链，CPU 的乱序执行和预取器
   都无法提前工作，测出的就是真实的存储层次延迟。
   步长取 64 字节（一个缓存行）避免同一行内的命中干扰。
   随着数组从 16KB 增大到 256MB，你会看到延迟呈阶梯状跳变：
   数组在 L1 内约 1ns，进入 L2 约 4ns，进入 L3 约 15ns，
   超出 L3 进入主存约 80-100ns，超过物理内存触发交换后
   延迟暴涨到微秒级。把实测数据画成对数坐标图，
   就是教科书上内存层次金字塔的实证版本。
   编译时加 -O1 即可，注意不要开 LTO 让循环被消除；
   更严谨的做法是把结果累加到 volatile 变量。 */

/* 伪共享（False Sharing）：多核性能的隐形杀手 */
#include <stdio.h>
#include <pthread.h>

struct Counters {
    long a;
    long b;
};

struct PaddedCounters {
    long a;
    char pad1[56];
    long b;
    char pad2[56];
};

static struct Counters shared;
static struct PaddedCounters padded;
static volatile int go = 0;

void *worker_shared(void *arg) {
    long which = (long)arg;
    while (!go) { }
    for (long i = 0; i < 100000000L; i++) {
        if (which == 0) shared.a++;
        else shared.b++;
    }
    return NULL;
}

void *worker_padded(void *arg) {
    long which = (long)arg;
    while (!go) { }
    for (long i = 0; i < 100000000L; i++) {
        if (which == 0) padded.a++;
        else padded.b++;
    }
    return NULL;
}

int main(void) {
    pthread_t t1, t2;
    clock_t s = clock();
    pthread_create(&t1, NULL, worker_shared, (void *)0);
    pthread_create(&t2, NULL, worker_shared, (void *)1);
    go = 1;
    pthread_join(t1, NULL); pthread_join(t2, NULL);
    printf("shared  (same line): %.3f s\n",
           (double)(clock() - s) / CLOCKS_PER_SEC);

    go = 0; s = clock();
    pthread_create(&t1, NULL, worker_padded, (void *)0);
    pthread_create(&t2, NULL, worker_padded, (void *)1);
    go = 1;
    pthread_join(t1, NULL); pthread_join(t2, NULL);
    printf("padded (diff lines): %.3f s\n",
           (double)(clock() - s) / CLOCKS_PER_SEC);
    return 0;
}

/* shared.a 和 shared.b 位于同一个 64 字节缓存行内，
   两个核心各自高频写入时，MESI 协议迫使该缓存行
   在两核的缓存之间不断「乒乓」：每次写入都要
   先让对方副本失效，缓存行以独占状态来回迁移，
   这就是伪共享——逻辑上毫无关系的数据因为
   物理上共享缓存行而产生巨大同步开销。
   padded 版本用 56 字节填充把两个计数器
   隔到不同缓存行，两核可以各自在本地缓存中
   高速累加，实测通常快 3-10 倍。
   工程对策：热点计数器按核分离（per-CPU 变量）、
   结构体按缓存行对齐（C11 的 alignas(64)、
   C++17 的 std::hardware_destructive_interference_size）、
   Linux 内核中大量使用 ____cacheline_aligned 宏。
   用 perf c2c 工具可以直接检测伪共享热点。 */

实验笔记

本章实验围绕「观察看不见的微架构」展开，需要 Linux 环境和 perf 工具（sudo apt install linux-tools-common）。实验一「缓存延迟阶梯」：完成代码示例中的指针追逐程序，分别用 64B、512B、4KB 三种步长测试，绘制数组大小-延迟曲线，标出 L1/L2/L3/主存的边界，与 lscpu 输出的缓存容量对照验证；思考为什么大步长测出的主存延迟更高（TLB 缺失与预取失效的影响）。实验二「分支预测代价」：运行排序数组实验，用 perf stat -e branch-misses,branches 分别统计排序与未排序两种情况的分支预测失败率，验证未排序时失败率接近 50%；然后实现无分支版本（位运算技巧），确认其性能不受数据分布影响；延伸：构造「每 8 次跳转一次」的规律模式，观察预测器能否学会周期性模式。实验三「矩阵乘法优化三部曲」：实现朴素三重循环矩阵乘法，记录 GFLOPS；第一步交换循环顺序（六种排列都测一遍，找出最优）；第二步做分块（block size 分别取 16/32/64，找出与 L1/L2 容量匹配的最优值）；第三步开启编译器自动向量化（-O3 -march=native）对比手工分块。记录每一步的加速比，用 perf stat 观察 cache-misses 和 IPC 的变化，写一页报告解释每个优化起效的微架构原因。实验四「伪共享与并行扩展」：运行伪共享示例，再用 1/2/4/8 线程做并行求和的扩展性测试（每线程独立累加局部变量最后合并 vs 所有线程原子加同一个全局变量），绘制加速比曲线，用 Amdahl 定律和缓存一致性开销解释曲线形状。所有实验要求先写下预测结果再运行验证，预测与实测的差异往往正是最有价值的学习点。

延伸阅读

• 《计算机组成与设计：硬件/软件接口》（Patterson & Hennessy）——计算机体系结构入门的标准教材，用 RISC-V/MIPS 讲清流水线与冒险，比本章更系统，配套实验丰富。
• 《计算机体系结构：量化研究方法》（Hennessy & Patterson）——体系结构领域的「圣经」，深入乱序执行、缓存一致性、多处理器与领域专用架构，图灵奖得主的代表作，适合进阶阅读。
• Ulrich Drepper《What Every Programmer Should Know About Memory》——从程序员视角详解缓存层次、NUMA、伪共享与优化技巧，长达百页但字字珠玑，是本章内存层次部分的最佳延伸。
• Agner Fog 的《The microarchitecture of Intel, AMD and VIA CPUs》系列手册——免费公开的五卷本微架构资料，逐代分析流水线宽度、延迟表和吞吐量，做底层性能优化的必备参考。
• Robert Tomasulo 的原始论文《An Efficient Algorithm for Exploiting Multiple Arithmetic Units》（1967）——乱序执行的源头，篇幅短小，理解保留站和寄存器重命名思想的第一手材料。
• CMU 15-213/18-213 课程讲义与 CS:APP3e 第 5、6 章——处理器体系结构与存储器层次的经典教学内容，配套的 Cache Lab 和 Shell Lab 与本章实验互补。
• 《深入理解计算机系统》第 6 章「存储器层次结构」及 Cache Lab——通过编写缓存模拟器亲手实现直接映射缓存的命中/缺失/驱逐逻辑，是内化缓存原理的最佳实践。
• Spectre 与 Meltdown 原始论文（Kocher et al. 2018; Lipp et al. 2018）——推测执行如何变成安全漏洞的开创性研究，读后可深刻理解分支预测与乱序执行的双刃剑性质。