返回专栏
· 13 分钟阅读

CPU 如何执行一条指令?


一、CPU 执行指令的本质

CPU(Central Processing Unit,中央处理器)的核心任务是执行机器指令。

程序员编写的 C、Java、Python 等高级语言代码,最终需要通过编译、解释或运行时执行机制,转化为处理器能够执行的操作。

以 C 语言为例:

int a = 10;
int b = 20;
int c = a + b;

这段代码表达了三个基本操作:

  1. 定义变量 a。
  2. 定义变量 b。
  3. 将 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)。

二、指令执行的基本阶段

传统计算机组成原理通常将一条指令的执行划分为几个阶段:

  1. 取指(Fetch)。
  2. 译码(Decode)。
  3. 执行(Execute)。
  4. 访存(Memory Access)。
  5. 写回(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

表示处理器当前需要从对应地址获取指令。

取指阶段的基本过程:

  1. 根据 PC 确定指令地址。
  2. 从指令缓存或更低层存储层级获取指令。
  3. 将指令送入后续处理逻辑。
  4. 更新取指地址,通常继续取下一条顺序指令。

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

执行逻辑可以抽象为:

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]

基本过程:

  1. 计算有效地址。
  2. 查询数据缓存。
  3. 如果缓存命中,获取数据。
  4. 如果缓存未命中,向更低层存储请求数据。
  5. 将读取结果提供给后续执行逻辑。

7.2 Store 操作

Store 表示将数据写入内存。

STORE [ADDR], R1

CPU 需要:

  1. 计算有效地址。
  2. 获取待写入的数据。
  3. 执行缓存写入及一致性相关操作。
  4. 根据缓存策略处理下级存储更新。

现代处理器通常具有 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。

如果第一条指令尚未产生结果,第二条指令就不能直接使用该值。

这种情况属于数据依赖。