一、CPU 执行指令的本质
CPU(Central Processing Unit,中央处理器)的核心任务是执行机器指令。
程序员编写的 C、Java、Python 等高级语言代码,最终需要通过编译、解释或运行时执行机制,转化为处理器能够执行的操作。
以 C 语言为例:
int a = 10;
int b = 20;
int c = a + b;
这段代码表达了三个基本操作:
- 定义变量 a。
- 定义变量 b。
- 将 a 和 b 相加,结果保存到 c。
但 CPU 并不直接理解 int、+ 或变量名称。
在机器层面,这些操作会被表示为一系列机器指令。
例如,某种假设性的指令序列:
MOV R1, #10
MOV R2, #20
ADD R3, R1, R2
STORE [ADDR], R3
其中:
MOV:数据传送。ADD:整数加法。STORE:将数据写入内存。R1、R2、R3:通用寄存器。#10、#20:立即数。[ADDR]:内存地址操作数。
以上是便于理解的伪汇编,不对应某一款真实处理器的完整指令编码。
CPU 执行指令的过程,本质上是:
获取指令、解析指令、读取操作数、执行运算、保存结果。
这个过程通常称为指令周期(Instruction Cycle)。
二、指令执行的基本阶段
传统计算机组成原理通常将一条指令的执行划分为几个阶段:
- 取指(Fetch)。
- 译码(Decode)。
- 执行(Execute)。
- 访存(Memory Access)。
- 写回(Write Back)。
不同指令不一定经过所有阶段。例如,寄存器之间的整数加法通常不需要访问数据内存,而加载指令需要访存。
2.1 指令执行流程
flowchart TD
A["取指 Fetch"] --> B["译码 Decode"]
B --> C["读取操作数"]
C --> D["执行 Execute"]
D --> E{"是否需要访存?"}
E -->|是| F["访存 Memory Access"]
E -->|否| G["写回 Write Back"]
F --> G
G --> H["更新处理器状态"]
H --> I["继续执行后续指令"]
classDef stage fill:#E8F1FF,stroke:#3973C6,color:#17365D
classDef decision fill:#FFF4E5,stroke:#D99A35,color:#704510
classDef result fill:#EAF7F0,stroke:#39966B,color:#174D35
class A,B,C,D,F,G stage
class E decision
class H,I result
这是传统的指令执行抽象模型。现代 CPU 通常会将指令进一步拆分成微操作,并通过流水线、乱序执行等机制并行处理多条指令。
三、第一阶段:取指(Fetch)
取指是 CPU 执行指令的第一个阶段。
CPU 需要知道下一条应该执行的指令位于什么位置。
这个位置由程序计数器(Program Counter,PC)记录。
3.1 什么是 PC?
PC 是 CPU 中用于保存下一条待取指令地址的寄存器。
在不同处理器架构中,PC 的具体语义和更新时机可能存在差异。
例如:
PC = 0x1000
表示处理器当前需要从对应地址获取指令。
取指阶段的基本过程:
- 根据 PC 确定指令地址。
- 从指令缓存或更低层存储层级获取指令。
- 将指令送入后续处理逻辑。
- 更新取指地址,通常继续取下一条顺序指令。
3.2 PC 如何变化?
假设程序指令位于连续地址:
| 指令地址 | 指令 |
|---|---|
| 0x1000 | MOV R1, #10 |
| 0x1004 | MOV R2, #20 |
| 0x1008 | ADD R3, R1, R2 |
| 0x100C | STORE [ADDR], R3 |
如果每条指令长度固定为 4 字节,那么顺序执行时,PC 通常按 4 递增。
flowchart TD
A["PC = 0x1000"] --> B["取出 MOV R1, #10"]
B --> C["PC = 0x1004"]
C --> D["取出 MOV R2, #20"]
D --> E["PC = 0x1008"]
E --> F["取出 ADD R3, R1, R2"]
F --> G["PC = 0x100C"]
G --> H["取出 STORE 指令"]
classDef address fill:#E8F1FF,stroke:#3973C6,color:#17365D
classDef fetch fill:#EAF7F0,stroke:#39966B,color:#174D35
class A,C,E,G address
class B,D,F,H fetch
需要注意:
并不是所有 CPU 的指令长度都是 4 字节。
例如:
- x86/x86-64 指令长度可变。
- ARM A32 指令通常为 4 字节。
- ARM Thumb 指令可以采用 16 位或 32 位编码。
- AArch64 指令通常为 4 字节。
因此,PC 的更新方式取决于具体指令架构。
3.3 指令从哪里读取?
CPU 并不是每次都直接访问主存获取指令。
现代 CPU 通常具有指令缓存(Instruction Cache,I-Cache)。
取指逻辑优先从 I-Cache 获取指令。
如果 I-Cache 未命中,则需要从更低层缓存或主存获取对应数据。
flowchart TD
A["PC 提供指令地址"] --> B["查询 L1 I-Cache"]
B --> C{"缓存命中?"}
C -->|是| D["获取指令"]
C -->|否| E["查询更低层缓存"]
E --> F{"是否命中?"}
F -->|是| G["获取指令缓存行"]
F -->|否| H["访问主存"]
H --> I["加载指令缓存行"]
G --> D
I --> D
D --> J["送入指令处理前端"]
classDef access fill:#E8F1FF,stroke:#3973C6,color:#17365D
classDef decision fill:#FFF4E5,stroke:#D99A35,color:#704510
classDef result fill:#EAF7F0,stroke:#39966B,color:#174D35
class A,B,E,H,I access
class C,F decision
class D,G,J result
3.4 指令预取(Instruction Prefetch)
为了减少等待,现代 CPU 还会使用预取机制。
预取器尝试提前获取可能即将执行的指令数据,使指令在真正需要时已经进入缓存或前端缓冲结构。
预取通常基于程序执行规律,例如顺序取指和分支预测结果。
预取并不保证每次都准确。如果预取的数据没有被使用,就可能浪费缓存空间和内存带宽。
四、第二阶段:译码(Decode)
取指阶段获取的是机器指令编码。
CPU 还需要解析这些编码,确定具体执行什么操作。
这个过程称为指令译码。
4.1 什么是机器指令?
机器指令是处理器指令集架构(ISA)定义的二进制编码。
例如,某条指令可能表示:
ADD R3, R1, R2
它表达的语义是:
将寄存器 R1 和 R2 的值相加,并将结果写入 R3。
但真实机器指令并不是直接保存字符串 ADD R3, R1, R2,而是使用二进制位表示操作码、寄存器编号、寻址方式等信息。
4.2 指令通常包含哪些信息?
一条机器指令可能包含以下信息:
| 字段 | 作用 |
|---|---|
| Opcode | 操作码,表示执行什么操作 |
| Source Operand | 源操作数 |
| Destination Operand | 目标操作数 |
| Addressing Mode | 寻址方式 |
| Immediate | 立即数 |
| Condition | 条件执行或条件判断相关信息 |
具体字段由 ISA 和指令格式决定,不是所有指令都包含全部字段。
4.3 译码器做什么?
译码器根据机器指令编码识别指令类型和操作数信息,并生成后续执行所需的控制信息。
例如:
ADD R3, R1, R2
译码后,处理器需要明确:
- 操作类型:整数加法。
- 源操作数:R1、R2。
- 目标寄存器:R3。
- 执行资源:整数运算单元。
- 结果处理:将加法结果写入目标寄存器。
flowchart TD
A["机器指令编码"] --> B["指令译码器"]
B --> C["识别操作码"]
B --> D["解析源操作数"]
B --> E["解析目标操作数"]
B --> F["解析寻址方式"]
C --> G["生成控制信息"]
D --> G
E --> G
F --> G
G --> H["进入后续执行流程"]
classDef input fill:#E8F1FF,stroke:#3973C6,color:#17365D
classDef decode fill:#FFF4E5,stroke:#D99A35,color:#704510
classDef output fill:#EAF7F0,stroke:#39966B,color:#174D35
class A input
class B,C,D,E,F,G decode
class H output
4.4 x86 指令与微操作(μops)
现代 x86 CPU 的指令集复杂,部分指令可能包含多个操作。
为了提高执行效率,许多处理器会将复杂的 x86 指令解码为更简单的微操作(Micro-operations,μops)。
例如,一条具有内存操作数的复杂指令,内部可能拆分成加载、运算和存储等多个微操作。
flowchart TD
A["x86 机器指令"] --> B["指令译码"]
B --> C["生成一个或多个 μops"]
C --> D["调度与执行"]
D --> E["执行单元"]
E --> F["结果处理"]
classDef instruction fill:#E8F1FF,stroke:#3973C6,color:#17365D
classDef decode fill:#FFF4E5,stroke:#D99A35,color:#704510
classDef execute fill:#EAF7F0,stroke:#39966B,color:#174D35
class A instruction
class B,C decode
class D,E,F execute
需要注意:
- 并不是所有 x86 指令都会拆分成多个 μops。
- 有些简单指令可以直接对应一个微操作。
- 某些处理器还支持微操作融合(Micro-op Fusion)。
- 不同 CPU 微架构的译码和微操作实现可能不同。
ISA 定义的是软件可见的指令语义,μops 属于具体处理器微架构的内部实现。
五、第三阶段:读取操作数
译码完成后,CPU 需要获取执行指令所需的数据。
操作数可能来自:
- 寄存器。
- 指令中的立即数。
- 内存。
5.1 寄存器操作数
寄存器是 CPU 内部高速存储单元。
例如:
ADD R3, R1, R2
CPU 需要读取 R1 和 R2 的值,再执行加法。
flowchart TD
A["读取指令 ADD R3, R1, R2"] --> B["读取寄存器 R1"]
A --> C["读取寄存器 R2"]
B --> D["获得操作数 A"]
C --> E["获得操作数 B"]
D --> F["送入整数执行单元"]
E --> F
classDef source fill:#E8F1FF,stroke:#3973C6,color:#17365D
classDef result fill:#EAF7F0,stroke:#39966B,color:#174D35
class A,B,C source
class D,E,F result
寄存器访问通常比访问主存快得多,因此编译器会尽可能合理地利用寄存器。
5.2 立即数操作数
立即数是直接编码在指令中的常量。
例如:
MOV R1, #10
其中 10 就是立即数。
CPU 不需要额外访问内存读取这个常量,而是从指令编码中解析得到。
5.3 内存操作数
某些指令需要访问内存。
例如:
LOAD R1, [0x1000]
表示从指定内存地址读取数据到 R1。
真实处理器可能通过地址生成单元(Address Generation Unit,AGU)计算有效地址,再由加载/存储单元(Load/Store Unit,LSU)完成内存访问。
flowchart TD
A["内存访问指令"] --> B["解析地址表达式"]
B --> C["地址生成单元 AGU"]
C --> D["计算有效地址"]
D --> E["访问数据缓存"]
E --> F{"L1 D-Cache 命中?"}
F -->|是| G["读取数据"]
F -->|否| H["访问更低层缓存或主存"]
H --> G
G --> I["将数据送入执行流程"]
classDef address fill:#E8F1FF,stroke:#3973C6,color:#17365D
classDef decision fill:#FFF4E5,stroke:#D99A35,color:#704510
classDef result fill:#EAF7F0,stroke:#39966B,color:#174D35
class A,B,C,D,E,H address
class F decision
class G,I result
注意:
内存操作数并不意味着 CPU 每次都访问主存。数据可能已经存在于 L1、L2 或 L3 Cache 中。
六、第四阶段:执行(Execute)
执行阶段是真正完成指令操作的阶段。
CPU 会根据指令类型,选择相应的执行单元。
现代 CPU 通常具有多个不同功能的执行单元。
6.1 整数运算单元(ALU)
ALU(Arithmetic Logic Unit,算术逻辑单元)负责整数算术运算和逻辑运算。
常见操作包括:
- 加法。
- 减法。
- 与运算。
- 或运算。
- 异或运算。
- 比较。
- 移位。
例如:
ADD R3, R1, R2
执行逻辑可以抽象为:
6.2 浮点运算单元(FPU)
FPU(Floating Point Unit,浮点运算单元)用于执行浮点数运算。
例如:
float a = 1.5f;
float b = 2.5f;
float c = a * b;
浮点运算通常遵循 IEEE 754 等浮点数标准,但具体指令支持和执行细节取决于处理器架构。
6.3 SIMD 执行单元
SIMD(Single Instruction Multiple Data,单指令多数据)允许一条指令对多个数据元素执行相同类型的操作。
例如:
A = [1, 2, 3, 4]
B = [5, 6, 7, 8]
A + B = [6, 8, 10, 12]
在支持相应 SIMD 指令的处理器中,可以利用向量寄存器和向量执行单元并行处理多个数据元素。
常见技术包括:
- x86 SSE。
- x86 AVX。
- ARM NEON。
- ARM SVE。
6.4 分支执行单元
分支指令会改变程序执行顺序。
例如:
if (a > b) {
c = a;
} else {
c = b;
}
CPU 需要判断条件是否成立,并确定后续应该执行哪条指令。
现代处理器通常使用分支预测机制,提前预测分支方向,减少流水线等待。
6.5 不同执行单元的关系
flowchart TD
A["指令调度器"] --> B["整数 ALU"]
A --> C["浮点 FPU"]
A --> D["SIMD 向量单元"]
A --> E["加载与存储单元 LSU"]
A --> F["分支执行单元"]
B --> G["执行结果"]
C --> G
D --> G
E --> G
F --> G
classDef dispatch fill:#E8F1FF,stroke:#3973C6,color:#17365D
classDef unit fill:#FFF4E5,stroke:#D99A35,color:#704510
classDef result fill:#EAF7F0,stroke:#39966B,color:#174D35
class A dispatch
class B,C,D,E,F unit
class G result
不同处理器的执行端口和执行单元数量不同,同一类型的指令也可能由多个执行单元处理。
七、第五阶段:访存(Memory Access)
访存阶段主要针对需要读取或写入内存的指令。
例如:
LOAD R1, [0x1000]
STORE [0x2000], R1
第一条指令从内存读取数据。
第二条指令将寄存器数据写入内存。
7.1 Load 操作
Load 表示从内存读取数据。
LOAD R1, [ADDR]
基本过程:
- 计算有效地址。
- 查询数据缓存。
- 如果缓存命中,获取数据。
- 如果缓存未命中,向更低层存储请求数据。
- 将读取结果提供给后续执行逻辑。
7.2 Store 操作
Store 表示将数据写入内存。
STORE [ADDR], R1
CPU 需要:
- 计算有效地址。
- 获取待写入的数据。
- 执行缓存写入及一致性相关操作。
- 根据缓存策略处理下级存储更新。
现代处理器通常具有 Store Buffer 等结构,用于暂存尚未完成下级存储处理的写操作。
因此,指令执行完成和数据最终写入 DRAM,并不一定发生在同一时刻。
八、第六阶段:写回(Write Back)
写回阶段负责将执行结果保存到目标位置。
例如:
ADD R3, R1, R2
执行完成后,结果需要写入 R3。
如果是加载指令:
LOAD R1, [ADDR]
则需要将读取的数据写入 R1。
如果是存储指令,数据写入缓存或存储系统的过程则由相应的内存访问机制处理,不一定经过传统意义上的寄存器写回阶段。
8.1 指令执行结果
flowchart TD
A["执行单元完成运算"] --> B["产生结果"]
B --> C{"目标位置是什么?"}
C -->|寄存器| D["写入目标寄存器"]
C -->|内存| E["进入 Store 处理流程"]
C -->|状态标志| F["更新相关状态"]
D --> G["完成对应结果处理"]
E --> G
F --> G
classDef execute fill:#E8F1FF,stroke:#3973C6,color:#17365D
classDef decision fill:#FFF4E5,stroke:#D99A35,color:#704510
classDef result fill:#EAF7F0,stroke:#39966B,color:#174D35
class A,B execute
class C decision
class D,E,F,G result
九、现代 CPU 为什么不能简单地一条指令执行完再执行下一条?
前面介绍的是传统指令执行过程。
如果 CPU 必须严格按照以下方式工作:
取指完成后才译码,译码完成后才执行,执行完成后才取下一条指令,那么大量硬件资源可能处于空闲状态。
例如,执行一条需要等待内存的数据加载指令时,CPU 的其他执行单元可能无法充分利用。
为提高处理器吞吐量,现代 CPU 引入了流水线、乱序执行、分支预测等技术。
9.1 指令流水线(Pipeline)
流水线的核心思想是:
将指令执行过程拆分为多个阶段,让多条指令同时处于不同阶段。
可以将其理解为一条生产流水线:
- 第一条指令正在执行。
- 第二条指令正在译码。
- 第三条指令正在取指。
不同指令可以同时占用不同的流水线阶段。
flowchart TB
subgraph C1["周期 1"]
A1["指令 1:取指"]
end
subgraph C2["周期 2"]
A2["指令 1:译码"]
B2["指令 2:取指"]
end
subgraph C3["周期 3"]
A3["指令 1:执行"]
B3["指令 2:译码"]
C3I["指令 3:取指"]
end
subgraph C4["周期 4"]
A4["指令 1:访存"]
B4["指令 2:执行"]
C4I["指令 3:译码"]
D4["指令 4:取指"]
end
subgraph C5["周期 5"]
A5["指令 1:写回"]
B5["指令 2:访存"]
C5I["指令 3:执行"]
D5["指令 4:译码"]
end
classDef stage fill:#E8F1FF,stroke:#3973C6,color:#17365D
class A1,A2,B2,A3,B3,C3I,A4,B4,C4I,D4,A5,B5,C5I,D5 stage
上图展示的是理想化的五阶段流水线。
实际处理器可能采用更多流水线阶段,也可能同时处理多个指令、微操作和执行线程。
流水线主要提高的是指令吞吐量,不意味着单条指令的执行延迟一定减少。
9.2 流水线冲突
流水线并不总是能够顺利运行。
常见冲突有三类:
| 类型 | 英文 | 含义 |
|---|---|---|
| 结构冲突 | Structural Hazard | 多条指令竞争同一硬件资源 |
| 数据冲突 | Data Hazard | 指令之间存在数据依赖 |
| 控制冲突 | Control Hazard | 分支指令导致后续执行路径不确定 |
数据冲突
例如:
ADD R1, R2, R3
SUB R4, R1, R5
第二条指令需要使用 R1。
如果第一条指令尚未产生结果,第二条指令就不能直接使用该值。
这种情况属于数据依赖。