第4章：处理器体系结构（Processor Architecture）
一、导读
1.1 本章学习目标
第4章从程序员的汇编视角进一步深入到硬件层面，讲解如何设计和实现一个能够执行机器指令的处理器。本章的核心目标是让你理解：处理器是如何一步步执行每条指令的。
本章的学习目标包括：
- 理解 Y86-64 指令集：一个简化的 x86-64 子集，用于教学目的
- 掌握指令执行的各个阶段：取指、译码、执行、访存、写回、更新 PC
- 理解 SEQ 处理器的设计：一个单周期、非流水线的处理器实现
- 理解流水线的基本原理：如何将指令执行分解为多个阶段以提高吞吐量
- 掌握流水线冒险及其解决方案：数据冒险、控制冒险及其处理方法
- 理解乱序执行的基本概念：超越流水线的性能提升手段
1.2 为什么程序员需要了解处理器设计
你可能会问："我是程序员，为什么要了解处理器是怎么设计的？"答案有几个：
理解性能瓶颈：知道处理器的流水线结构，就能理解为什么某些代码模式会导致性能下降（如分支预测失败、缓存未命中）
编写更高效的代码：了解指令级并行（ILP）的原理，可以编写让处理器更高效执行的代码
理解编译器的优化决策：编译器很多优化（如指令调度、循环展开）都是基于对处理器微架构的理解
安全研究：侧信道攻击（如 Spectre、Meltdown）利用了处理器的微架构特性
1.3 从第3章到第4章的过渡
第3章让我们知道了程序在机器级别的表示——一系列二进制编码的指令。第4章则回答了一个更深层的问题：这些指令是如何被硬件执行的？ 如果说第3章是"程序的静态表示"，那么第4章就是"程序的动态执行"。
二、核心概念详解
2.1 Y86-64 指令集
Y86-64 是 CSAPP 教材定义的一个简化指令集，它是 x86-64 的子集，保留了核心概念但去除了复杂的细节。
2.1.1 Y86-64 的指令分类
| 类别 | 指令 | 说明 |
|---|---|---|
| 数据传送 | irmovq、rrmovq、mrmovq、rmmovq | 立即数→寄存器、寄存器→寄存器、内存→寄存器、寄存器→内存 |
| 整数运算 | addq、subq、andq、xorq | 加减与异或 |
| 条件码 | 隐含在运算指令中 | 设置 CC（条件码） |
| 跳转 | jmp、je、jne、jg、jge、jl、jle | 无条件/条件跳转 |
| 过程调用 | call、ret | 调用/返回 |
| 内存操作 | pushq、popq | 压栈/出栈 |
| 特殊 | nop、halt | 空操作/停机 |
2.1.2 Y86-64 指令编码
每条 Y86-64 指令由 1-10 个字节组成。第一个字节是操作码（icode:ifun），高 4 位是指令代码，低 4 位是指令功能：
字节 0: icode:ifun（操作码）
字节 1: rA:rB（寄存器指示符，如果有的话）
字节 2-9: valC/valP（立即数或地址，如果有的话）例如，addq %r8, %r10 的编码：
- 字节 0: 0x60（icode=6 表示整数运算，ifun=0 表示 add）
- 字节 1: 0x8A（rA=8, rB=10）
2.2 指令执行的六个阶段
每条指令的执行可以分为六个阶段（stage）：
2.2.1 取指（Fetch）
从内存中读取指令字节。根据 PC（程序计数器）的值，从内存中取出指令的第一个字节，解码出指令长度，然后计算下一条指令的地址（valP）。
取指阶段的操作：
1. icodes = Mem[PC] 的高 4 位
2. ifuns = Mem[PC] 的低 4 位
3. rA = Mem[PC+1] 的高 4 位（如果指令有寄存器字段）
4. rB = Mem[PC+1] 的低 4 位（如果指令有寄存器字段）
5. valC = Mem[PC+2:PC+9]（如果指令有立即数字段）
6. valP = PC + 指令长度2.2.2 译码（Decode）
从寄存器堆中读取操作数。根据指令类型，确定需要读取哪些寄存器，并从寄存器堆中获取它们的值。
译码阶段的操作：
1. valA = Reg[rA]（或 Reg[%rsp] 对于 push/call/pop）
2. valB = Reg[rB]（或 Reg[%rsp] 对于 push/call）2.2.3 执行（Execute）
ALU 执行运算或计算有效地址。
执行阶段的操作：
1. 对于算术/逻辑指令：valE = valA OP valB
2. 对于内存访问：valE = valB + valC（计算有效地址）
3. 对于跳转：判断条件码，决定是否跳转
4. 设置条件码（对于算术/逻辑指令）2.2.4 访存（Memory）
访问数据内存（读取或写入）。
访存阶段的操作：
1. 对于 load 指令：valM = Mem[valE]
2. 对于 store 指令：Mem[valE] = valA
3. 对于其他指令：不访问内存2.2.5 写回（Write Back）
将结果写入寄存器堆。
写回阶段的操作：
1. 对于需要写两个寄存器的指令：
Reg[rA] = valE（或 valM）
Reg[rB] = valM（或 valE）
2. 对于只需要写一个寄存器的指令：
Reg[rD] = valE（或 valM）
3. 对于不写寄存器的指令：不写回2.2.6 更新 PC（PC Update）
将 PC 设置为下一条指令的地址。
PC 更新：
1. 对于跳转且条件满足：PC = valC（目标地址）
2. 对于 call/ret/jmp：PC = valC 或 valM
3. 对于其他指令：PC = valP（下一条顺序指令）2.3 SEQ 处理器——单周期实现
SEQ 处理器是最简单的实现方式：每条指令在一个时钟周期内完成所有六个阶段。
时钟周期 = 取指 + 译码 + 执行 + 访存 + 写回 + 更新PC2.3.1 SEQ 处理器的硬件结构
SEQ 处理器由以下主要硬件组件构成：
寄存器堆：包含 16 个 64 位寄存器，有两个读端口和一个写端口
ALU：执行算术和逻辑运算
数据内存：存储程序的数据（与指令内存分开，哈佛结构简化）
PC 寄存器：存储当前指令的地址
条件码寄存器：存储 SF、ZF、CF、OF 四个标志位
控制逻辑：根据当前指令的类型，生成各硬件组件的控制信号
2.3.2 SEQ 处理器的局限性
单周期处理器的主要问题是时钟周期由最慢的指令决定。即使简单的 nop 指令也要等待所有阶段完成，而复杂的 mrmovq 指令需要访问内存，耗时最长。
最坏情况时钟周期 = 所有阶段延迟之和
= t_fetch + t_decode + t_execute + t_memory + t_writeback + t_pc_update这导致两个问题：
时钟频率低（因为周期长）
硬件利用率低（每个阶段只在一个周期的一部分时间内工作）
2.4 流水线处理器
2.4.1 流水线的基本思想
流水线将每条指令的执行分解为多个阶段，每个阶段由独立的硬件电路实现。不同指令的不同阶段可以重叠执行，就像工厂的流水线一样。
非流水线（单周期）：
时钟 1: [取指1][译码1][执行1][访存1][写回1][PC1]
时钟 2: [取指2][译码2][执行2][访存2][写回2][PC2]
时钟 3: [取指3]...
流水线：
时钟 1: [取指1]
时钟 2: [译码1][取指2]
时钟 3: [执行1][译码2][取指3]
时钟 4: [访存1][执行2][译码3][取指4]
时钟 5: [写回1][访存2][执行3][译码4][取指5]
时钟 6: [PC1] [写回2][访存3][执行4][译码5][取指6]理想情况下，流水线的吞吐量（单位时间内完成的指令数）可以提高到时钟频率的级别，而不是受限于单条指令的执行时间。
2.4.2 流水线的性能指标
- 吞吐量（Throughput）：单位时间内完成的指令数。理想流水线的吞吐量 = 时钟频率
- 延迟（Latency）：一条指令从开始到完成所需的时间。流水线的延迟 = 阶段数 × 时钟周期
- CPI（Cycles Per Instruction）：平均每条指令需要的时钟周期数。理想流水线 CPI ≈ 1
流水线加速比 = 非流水线执行时间 / 流水线执行时间
≈ (阶段数 × 最长阶段延迟) / (阶段数 × 最长阶段延迟 + 流水线开销)注意：流水线的延迟实际上比单周期更长（因为增加了流水线寄存器的延迟），但吞吐量大幅提高。
2.4.3 流水线寄存器
在相邻阶段之间插入流水线寄存器（pipeline register），用于保存阶段间传递的数据。Y86-64 流水线有五个流水线寄存器：
| 寄存器 | 位置 | 保存内容 |
|---|---|---|
| F | 取指→译码 | 指令字节、valP |
| D | 译码→执行 | valA、valB、控制信号 |
| E | 执行→访存 | valE、valA、控制信号、条件码 |
| M | 访存→写回 | valE、valM、valA、控制信号 |
| W | 写回→更新PC | valE、valM、控制信号 |
2.5 流水线冒险（Pipeline Hazards）
流水线虽然提高了吞吐量，但引入了三类冒险，可能导致流水线无法达到理想性能。
2.5.1 数据冒险（Data Hazard）
当一条指令需要使用前一条指令尚未写回的结果时，就发生了数据冒险。
addq %rax, %rbx # 指令1：计算 %rbx = %rbx + %rax
mrmovq 8(%rbx), %rcx # 指令2：需要 %rbx 的新值指令2在译码阶段读取 %rbx 时，指令1还没有完成写回阶段，因此读到的是旧值。
解决方案一：停顿（Stalling）
检测到数据冒险时，让流水线停顿（插入气泡 bubble），直到数据可用。
时钟 3: [执行1][译码2-停顿]
时钟 4: [访存1][译码2-停顿]
时钟 5: [写回1][执行2] # 数据可用，继续执行停顿会导致性能下降，因为流水线中有"气泡"（空操作）。
解决方案二：转发/旁路（Forwarding/Bypassing）
将 ALU 或内存的输出直接送回到前面阶段需要的地方，而不必等待写回阶段完成。
时钟 3: [执行1][译码2] # 不需要停顿
时钟 4: [访存1][执行2] # 使用执行阶段的结果（从E流水线寄存器转发）转发可以消除大部分数据冒险，但不能消除所有情况。
Load-Use 冒险：
mrmovq (%rax), %rbx # 指令1：从内存加载到 %rbx
addq %rbx, %rcx # 指令2：使用 %rbx这种情况下，指令2在译码阶段需要 %rbx，但指令1要到访存阶段结束后才能得到数据。即使使用转发，也需要停顿一个周期。
2.5.2 控制冒险（Control Hazard）
当处理器遇到条件跳转或过程调用/返回指令时，无法确定下一条要执行的指令，导致流水线无法继续取指。
je target # 条件跳转：不知道下一条是 target 还是下一条顺序指令
addq %rax, %rbx # 这条指令该不该取？解决方案一：停顿直到确定
等待跳转条件计算完成后再取下一条指令。简单但性能差。
解决方案二：预测分支（Branch Prediction）
猜测分支方向，继续取指和执行。如果猜错了，清空流水线（flush）并重新从正确的地址取指。
预测 taken（跳转）：
时钟 1: [取指 jmp]
时钟 2: [译码 jmp][取指 target] # 预测跳转到 target
时钟 3: [执行 jmp][译码 target] # 如果预测正确，继续
# 如果预测错误，清空 target 指令
预测 not taken（不跳转）：
时钟 1: [取指 jmp]
时钟 2: [译码 jmp][取指 next] # 预测不跳转，取下一条顺序指令现代处理器使用复杂的分支预测器（如两级自适应预测器、Tournament 预测器），准确率可达 95% 以上。
2.5.3 结构冒险（Structural Hazard）
当两条指令在同一阶段需要使用同一个硬件资源时，就发生了结构冒险。
例如：如果指令内存和数据内存共享同一个存储体，
那么当一条指令在访存阶段读取数据时，
下一条指令无法同时在取指阶段读取指令。解决方案：
增加硬件资源（如分离指令缓存和数据缓存——哈佛结构）
停顿等待资源释放
2.6 流水线 Y86-64 处理器的详细设计
2.6.1 取指阶段
取指阶段的逻辑：
1. 从指令内存读取指令字节
valP = PC
byte_0 = Mem[PC]
icode = byte_0 的高 4 位
ifun = byte_0 的低 4 位
2. 根据 icode 确定指令长度
need_regids = (icode 属于需要寄存器字段的指令)
need_valC = (icode 属于需要立即数的指令)
len = 1 + (need_regids ? 1 : 0) + (need_valC ? 8 : 0)
3. 读取寄存器字段（如果需要）
rA = Mem[PC+1] 的高 4 位
rB = Mem[PC+1] 的低 4 位
4. 读取立即数（如果需要）
valC = Mem[PC+need_regids+1 : PC+len-1]
5. 计算 valP
valP = PC + len
6. 将结果写入 F 流水线寄存器2.6.2 译码阶段
译码阶段的逻辑：
1. 从 D 流水线寄存器读取指令信息
2. 确定需要读取的寄存器
srcA = 根据 icode 确定（通常是 rA 或 %rsp）
srcB = 根据 icode 确定（通常是 rB 或 %rsp）
3. 从寄存器堆读取
valA = Reg[srcA]
valB = Reg[srcB]
4. 确定写回的目标寄存器
dstE = 根据 icode 确定（写回 ALU 结果的目标）
dstM = 根据 icode 确定（写回内存数据的目标）
5. 将结果写入 E 流水线寄存器2.6.3 执行阶段
执行阶段的逻辑：
1. ALU 运算
alufun = 根据 ifun 确定（add/sub/and/xor）
valE = alu(valA, valB) # 对于算术指令
valE = valB + valC # 对于内存访问指令（计算有效地址）
2. 设置条件码（对于算术/逻辑指令）
if (icode 属于设置条件码的指令) {
SF = valE < 0
ZF = (valE == 0)
CF = 无符号进位
OF = 有符号溢出
}
3. 判断跳转条件
Cnd = 根据条件码和 ifun 计算
4. 将结果写入 M 流水线寄存器2.6.4 访存阶段
访存阶段的逻辑：
1. 根据指令类型访问内存
if (icode 属于 load 指令) {
valM = Mem[valE]
} else if (icode 属于 store 指令) {
Mem[valE] = valA
}
2. 将结果写入 W 流水线寄存器2.6.5 写回阶段
写回阶段的逻辑：
1. 根据指令类型写回寄存器
if (icode 需要写 dstE) {
Reg[dstE] = valE
}
if (icode 需要写 dstM) {
Reg[dstM] = valM
}
2. 更新 PC
if (跳转且条件满足) {
PC = valE # 跳转目标地址
} else if (call) {
PC = valE # 跳转目标地址（call 的目标在 valC，经执行阶段传递）
} else {
PC = valP # 下一条顺序指令
}2.7 转发逻辑的详细分析
转发（Forwarding）是流水线处理器中最复杂但也最关键的部分。它需要在正确的时机将正确的值传递到正确的地方。
2.7.1 需要转发的情况
以 addq %rax, %rbx 后跟 mrmovq (%rbx), %rcx 为例：
指令1 (addq): F → D → E(valE = %rax + %rbx) → M → W(写回 %rbx)
指令2 (mrmovq): F → D(读 %rbx) → E(valE = %rbx + valC) → M(valM = Mem[valE]) → W(写回 %rcx)指令2在 D 阶段需要 %rbx 的值，但指令1要到 W 阶段才写回 %rbx。
转发方案：将指令1在 E 阶段计算出的 valE 直接送到指令2的 D 阶段输入端。
2.7.2 转发路径
Y86-64 流水线中有多条转发路径：
E 阶段到 D 阶段：ALU 结果转发给下一条指令的译码
M 阶段到 D 阶段：内存读取结果转发（用于 load-use 冒险的转发）
M 阶段到 E 阶段：内存读取结果转发给执行阶段
W 阶段到 D 阶段：写回值转发给译码阶段
转发逻辑的核心判断：
如果 dstE（M 阶段）== srcA（D 阶段），且 M 阶段的指令会写 dstE：
valA 转发为 M 阶段的 valE
如果 dstM（M 阶段）== srcA（D 阶段），且 M 阶段的指令会写 dstM：
valA 转发为 M 阶段的 valM2.8 异常处理
在流水线处理器中，异常（Exception）的处理变得复杂，因为多条指令同时处于不同的执行阶段。
2.8.1 异常的类型
陷阱（Trap）：有意引发的异常，如系统调用。返回到下一条指令。
故障（Fault）：可修复的异常，如缺页异常。返回到当前指令重新执行。
终止（Abort）：不可修复的异常，如硬件错误。终止程序。
2.8.2 流水线中的异常问题
当多条指令同时在流水线中时，异常可能由不同阶段的指令引发。关键问题是：应该以哪条指令的异常为准？
假设流水线中有 5 条指令：
F: 指令5
D: 指令4
E: 指令3
M: 指令2
W: 指令1
如果指令3在执行阶段引发了异常，但指令1在写回阶段也有问题，
应该以哪个为准？解决方案：以流水线中最深的（最接近完成的）指令的异常为准。即 W 阶段的异常优先于 M 阶段，M 阶段优先于 E 阶段。
三、重要知识点
3.1 指令级并行（ILP）
指令级并行是指程序中不相关的指令可以被同时执行。现代处理器通过各种技术挖掘 ILP：
// 有数据依赖的循环——ILP 低
for (int i = 0; i < N; i++) {
sum += a[i]; // 每次迭代依赖上一次的 sum
}
// 无数据依赖的循环——ILP 高
for (int i = 0; i < N; i++) {
c[i] = a[i] + b[i]; // 每次迭代独立
}编译器通过指令调度来最大化 ILP：
// 原始代码
x = a + b;
y = c + d;
z = x * y;
// 编译器调度后（a+b 和 c+d 可以并行计算）
temp1 = a + b; // 与下一条独立
temp2 = c + d; // 与上一条独立
z = temp1 * temp2;3.2 超标量处理器
超标量（Superscalar）处理器可以在每个时钟周期发射（issue）多条指令到不同的功能单元。
典型的超标量处理器结构：
┌─────────────────────────────────────────┐
│ 指令取指单元 │
│ （每周期取多条指令） │
├─────────────────────────────────────────┤
│ 指令分发单元 │
│ （动态调度、寄存器重命名） │
├──────────┬──────────┬──────────────────┤
│ 整数ALU │ 浮点ALU │ Load/Store 单元 │
│ #1 │ #1 │ │
├──────────┼──────────┼──────────────────┤
│ 整数ALU │ 浮点ALU │ 分支单元 │
│ #2 │ #2 │ │
└──────────┴──────────┴──────────────────┘3.3 乱序执行（Out-of-Order Execution）
乱序执行允许指令不按照程序中的顺序执行，只要最终结果与顺序执行一致。
原始程序顺序：
1. x = a + b; // 需要 a, b
2. y = c + d; // 需要 c, d
3. z = x * e; // 需要 x, e（x 依赖指令1）
4. w = y * f; // 需要 y, f（y 依赖指令2）
顺序执行：1 → 2 → 3 → 4
乱序执行的可能顺序：
1. x = a + b; // 立即执行
2. y = c + d; // 立即执行（与1并行）
3. w = y * f; // y 已就绪，可以执行
4. z = x * e; // x 已就绪，可以执行乱序执行的关键技术：
- Tomasulo 算法：使用保留站（Reservation Station）动态调度指令
- 寄存器重命名（Register Renaming）：消除假依赖（WAW 和 WAR 冒险）
- 重排序缓冲区（ROB）：保证指令按程序顺序提交（commit），维持精确异常
3.4 分支预测的高级技术
现代处理器使用复杂的分支预测算法：
3.4.1 两位饱和计数器
每个分支有一个 2 位计数器，状态转换如下：
强预测不跳转(00) ←→ 弱预测不跳转(01) ←→ 弱预测跳转(10) ←→ 强预测跳转(11)只有连续两次预测错误才会改变预测方向，这提供了对短暂偏差的容忍。
3.4.2 相关预测器（Correlating Predictor）
利用最近 n 个分支的历史来提高预测准确率。例如，使用最近 2 个分支的历史（4 种组合），每种组合使用一个两位计数器。
历史模式 → 预测器
00 → 计数器 A
01 → 计数器 B
10 → 计数器 C
11 → 计数器 D3.4.3 Tournament 预测器
结合全局预测器和局部预测器，使用一个选择器来决定信任哪个预测器的结果。这种"锦标赛"结构可以针对不同分支选择最合适的预测策略。
3.5 内存子系统与处理器的交互
处理器与内存子系统的交互对性能有巨大影响：
3.5.1 缓存一致性
在多处理器系统中，每个核心都有自己的 L1/L2 缓存。当多个核心访问同一内存位置时，需要缓存一致性协议来保证数据一致性。
常见的缓存一致性协议（如 MESI）：
- Modified（已修改）：缓存行已被修改，与内存不一致
- Exclusive（独占）：缓存行与内存一致，且只有一个副本
- Shared（共享）：缓存行与内存一致，可能有多个副本
- Invalid（无效）：缓存行无效
3.5.2 非阻塞缓存
现代处理器的 L1 缓存支持"未命中时继续"（miss under miss），即在一个缓存行等待内存返回时，可以继续处理其他缓存命中。这大大减少了内存延迟对性能的影响。
四、常见误区与难点
4.1 误区一："流水线让每条指令都变快了"
流水线实际上可能让单条指令的延迟更长（因为增加了流水线寄存器的延迟）。流水线的优势在于提高吞吐量——单位时间内完成更多指令，而不是让单条指令更快。
4.2 误区二："分支预测错了也没关系"
分支预测错误的代价非常高。在现代处理器上，一次预测失败可能导致 15-20 个时钟周期的损失，因为流水线需要被清空并从正确的地址重新取指。这就是为什么编写"分支友好"的代码很重要：
// 分支不可预测——性能差
for (int i = 0; i < N; i++) {
if (a[i] > threshold) { // 随机数据，预测准确率约 50%
sum += a[i];
}
}
// 消除分支——性能好
for (int i = 0; i < N; i++) {
int mask = a[i] > threshold ? -1 : 0; // 编译器可能生成 CMOV
sum += a[i] & mask;
}4.3 误区三："转发可以解决所有数据冒险"
转发不能解决 Load-Use 冒险。当一条 load 指令后面紧跟一条使用 load 结果的指令时，即使使用转发，也需要停顿一个周期，因为 load 的数据要到访存阶段结束后才能得到。
4.4 难点：理解流水线时序图
画出流水线时序图是理解流水线行为的最有效方法。关键要点：
- 每条指令占据一行（或一列），每个阶段占据一个时钟周期
- 气泡（bubble）用空白表示
- 转发用箭头表示
- 注意区分"指令在某个阶段"和"数据在某个阶段"
4.5 难点：理解乱序执行的可见性
乱序执行对程序员是不可见的——程序的外部行为必须与顺序执行完全一致。处理器通过重排序缓冲区（ROB）保证指令按程序顺序提交，从而维持这种一致性。理解这一点对于理解侧信道攻击（如 Spectre）非常重要。
五、实践应用
5.1 编写流水线友好的代码
// 避免长依赖链——使用多个累加器
// 差：单依赖链
double sum = 0;
for (int i = 0; i < N; i++) {
sum += a[i]; // 每次加法依赖上一次的结果
}
// 好：多条独立依赖链
double sum1 = 0, sum2 = 0, sum3 = 0, sum4 = 0;
for (int i = 0; i < N; i += 4) {
sum1 += a[i];
sum2 += a[i + 1];
sum3 += a[i + 2];
sum4 += a[i + 3];
}
double sum = sum1 + sum2 + sum3 + sum4;5.2 减少分支预测失败
// 排序数据使分支更可预测
// 如果经常查询某个范围，使用二分查找而不是线性查找
// 使用条件传送替代条件分支
// 编译器通常会自动做这个优化（-Og 或 -O1 以上）
int max(int a, int b) {
return a > b ? a : b; // 编译器可能生成 CMOV 而不是条件跳转
}
// 使用查表法消除分支
// 差：多个 if-else
if (x == 0) result = func0();
else if (x == 1) result = func1();
else if (x == 2) result = func2();
// 好：函数指针数组
typedef int (*FuncPtr)();
FuncPtr table[] = {func0, func1, func2};
result = table[x]();5.3 使用性能分析工具
# 使用 perf 分析性能瓶颈
perf stat ./program
perf record ./program
perf report
# 使用 perf 查看缓存未命中
perf stat -e cache-misses,cache-references ./program
# 使用 perf 查看分支预测失败
perf stat -e branch-misses,branch-loads ./program5.4 理解编译器优化报告
# 查看编译器优化决策
gcc -O2 -fopt-info-vec-optimized example.c
# 查看向量化信息
gcc -O2 -fopt-info-vec-missed example.c
# 查看内联决策
gcc -O2 -fopt-info-inline example.c六、本章小结
第4章深入讲解了处理器体系结构的设计原理：
Y86-64 指令集：一个简化的教学用指令集，保留了 x86-64 的核心概念。
指令执行阶段：取指、译码、执行、访存、写回、更新 PC 六个阶段构成了指令执行的完整流程。
SEQ 处理器：单周期实现简单但效率低，时钟周期受限于最慢的指令。
流水线处理器：通过将指令执行分解为多个重叠阶段，大幅提高吞吐量。
流水线冒险：数据冒险、控制冒险和结构冒险是流水线性能的主要威胁，需要通过转发、停顿和分支预测来解决。
高级技术：超标量、乱序执行和高级分支预测进一步提升了处理器性能。
核心要点：理解处理器的微架构设计，可以帮助你编写更高效、更可预测的代码。现代处理器的复杂性（流水线、缓存、分支预测、乱序执行）意味着程序员不能简单地假设每条指令执行时间相同——代码的编写方式会显著影响实际性能。
从第1章的全局概览到第4章的处理器内部细节，我们已经建立了一个从宏观到微观的计算机系统知识框架。这个框架将帮助你在学习后续章节（存储器层次结构、链接、异常控制流、虚拟内存、I/O、网络编程等）时，将新知识有机地融入已有的知识体系中。