1
LD   r1, [mem1]     ; 加载，缓存未命中，~200 周期
2
ADD  r2, r3, r4     ; 不依赖 r1，可以立即执行
3
MUL  r5, r6, r7     ; 不依赖 r1，可以立即执行
4
ADD  r8, r1, r9     ; 依赖 r1，必须等待

1
周期:  1    2    ...  200  201  202  203  204
2
LD:    IF   ID   ...  MEM  WB
3
ADD:        IF   ●●●  ●●●  ID   EX   MEM  WB
4
MUL:             ●●●  ●●●  ●●●  ID   EX   MEM  WB
5
ADD(r1):              ●●●  ●●●  ●●●  ●●●  ID   EX
6
                     ↑ 200 周期气泡！

1
周期:  1    2    3    4    ...  200  201  202  203
2
LD:    IF   ID   EX   MEM  ...  MEM  WB
3
ADD:        IF   ID   EX   MEM  WB              ← 提前执行！
4
MUL:             IF   ID   EX   MEM  WB         ← 提前执行！
5
ADD(r1):                             ID   EX   MEM  WB

1
; 重命名前（有 WAR 依赖）
2
ADD  r1, r2, r3     ; r1 = r2 + r3
3
SUB  r4, r1, r5     ; r4 = r1 - r5  (RAW: 依赖 r1)
4
MUL  r1, r6, r7     ; r1 = r6 * r7  (WAR: r1 被 r4 读取后又写入)
5

6
; 重命名后（WAR 消除）
7
ADD  p5, p2, p3     ; r1 → p5
8
SUB  p8, p5, p5     ; r4 → p8, 读取 p5（r1 的物理寄存器）
9
MUL  p9, p6, p7     ; r1 → p9（新的物理寄存器！不再与 p5 冲突）

1
┌──────────────┬──────────────┐
2
│ 架构寄存器    │ 物理寄存器    │
3
├──────────────┼──────────────┤
4
│ r0           │ p23          │
5
│ r1           │ p9           │  ← 最近一次写入 r1 的物理寄存器
6
│ r2           │ p2           │
7
│ r3           │ p3           │
8
│ ...          │ ...          │
9
│ r31          │ p45          │
10
└──────────────┴──────────────┘

1
┌─────┬──────────┬─────────┬──────────┬─────────┬──────────┐
2
│ Seq │ 指令     │ 状态     │ 目标寄存器│ 结果值   │ 异常标志 │
3
├─────┼──────────┼─────────┼──────────┼─────────┼──────────┤
4
│  1  │ ADD r1   │ 完成  │ p5       │ 42      │ 无       │
5
│  2  │ LD r2    │ ⏳ 等待  │ p8       │ —       │ 无       │
6
│  3  │ MUL r3   │ 完成  │ p9       │ 100     │ 无       │
7
│  4  │ SUB r4   │ 异常  │ p10      │ —       │ 除零！   │
8
│  5  │ ADD r5   │ 完成  │ p11      │ 7       │ 无       │ ← 推测执行
9
└─────┴──────────┴─────────┴──────────┴─────────┴──────────┘
10
                              ↑
11
                    指令 2 阻塞了退休
12
                    指令 1 可以退休
13
                    指令 3-5 必须等指令 2

1
// 假设指令 4 触发除零异常
2
// ROB 状态：
3
// 指令 1: 已完成 → 退休
4
// 指令 2: 已完成 → 退休
5
// 指令 3: 已完成 → 等待退休
6
// 指令 4: 异常！→ 触发回滚
7
// 指令 5: 已完成 → 被丢弃（推测执行的结果）
8
// 指令 6: ⏳ 执行中 → 被丢弃
9

10
// 精确异常保证：
11
// - 指令 1-3 的结果被提交（已退休）
12
// - 指令 4 触发异常，寄存器状态回滚到指令 3 之后
13
// - 指令 5-6 的结果被丢弃（虽然在 ROB 中但未退休）

1
周期:    1         2         3         4
2
ADD:    [执行中]  [完成] ──→ 广播结果
3
                          ↓
4
SUB:    [等待 r1] [等待 r1] [r1 就绪!] [发射执行]

1
// 受害者代码
2
if (x < array1_size) {
3
    y = array2[array1[x] * 64];
4
}
5
// 攻击者：训练分支预测器，使其预测 x < array1_size 为 true
6
// 然后传入恶意 x 值（超出边界）
7
// CPU 推测执行了越界读取，虽然结果被丢弃，但缓存副作用保留

1
// 攻击者代码（用户态）
2
// 读取内核地址的数据
3
char data = *(char *)kernel_address;  // 应该触发段错误
4
// 但在段错误之前，CPU 已经推测执行了后续指令
5
// 后续指令将 data 作为索引访问数组，留下缓存痕迹

1
Store Buffer:
2
┌──────────┬──────────┬─────────┐
3
│ 地址      │ 数据      │ 大小    │
4
├──────────┼──────────┼─────────┤
5
│ 0x1000   │ 42       │ 4 字节  │ ← Store 写入
6
│ 0x2000   │ 99       │ 8 字节  │
7
└──────────┴──────────┴─────────┘
8

9
LD r1, [0x1000]  →  直接从 Store Buffer 读取 42
10
                    不需要等 Store 写入 L1 缓存！

1
// Store Forwarding 失败的典型模式
2
void bad_pattern(int *arr) {
3
    // Store 4 字节
4
    arr[0] = 42;      // ST 4 字节到地址 arr
5

6
    // Load 8 字节（包含 arr[0] 和 arr[1]）
7
    long val = *(long*)arr;  // LD 8 字节 → 大小不匹配！
8
    // CPU 无法从 4 字节 Store 转发到 8 字节 Load
9
    // 必须等 Store 写入缓存后再读取
10
}
11

12
// 大小匹配的 Store Forwarding
13
void good_pattern(int *arr) {
14
    arr[0] = 42;
15
    int val = arr[0];  // 同为 4 字节 → 转发成功！
16
}

1
# 测量 Store Forwarding 失败
2
perf stat -e ld_blocks.store_forward ./your_program
3
# 值越高，说明 Store-to-Load 转发失败越频繁

1
#include <stdio.h>
2
#include <time.h>
3

4
#define N 100000000
5

6
int main() {
7
    int *arr = aligned_alloc(64, N * sizeof(int));
8
    for (int i = 0; i < N; i++) arr[i] = 1;
9

10
    // 模式 1：独立加载（乱序执行完美重叠）
11
    clock_t start = clock();
12
    int sum = 0;
13
    for (int i = 0; i < N; i += 4) {
14
        sum += arr[i] + arr[i+1] + arr[i+2] + arr[i+3];
15
    }
16
    clock_t end = clock();
17
    printf("独立加载: %.3f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
18

19
    // 模式 2：指针追逐（依赖链，乱序执行无效）
20
    int *next = arr;
21
    start = clock();
22
    for (int i = 0; i < 10000; i++) {
23
        next = (int*)(uintptr_t)next[0];  // 每次依赖上一次
24
    }
25
    end = clock();
26
    printf("指针追逐: %.3f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
27

28
    // 模式 3：Store 后立即 Load（Store Forwarding）
29
    start = clock();
30
    for (int i = 0; i < N; i++) {
31
        arr[i] = i;         // Store
32
        sum += arr[i];      // Load 同一地址 → Store Forwarding
33
    }
34
    end = clock();
35
    printf("Store-Load 转发: %.3f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
36

37
    free(arr);
38
    return 0;
39
}

1
// 乱序执行能隐藏多少延迟？
2
// 假设 L1 命中 3 周期，L2 命中 12 周期，L3 命中 36 周期，DRAM 200 周期
3

4
// 场景 1：独立加载（乱序执行可以完美重叠）
5
for (int i = 0; i < N; i++) {
6
    sum += arr[i];  // 每次加载独立，乱序执行可以重叠
7
}
8

9
// 场景 2：依赖加载（乱序执行无法帮助）
10
for (int i = 0; i < N; i++) {
11
    idx = arr[idx];  // 每次加载依赖上一次的结果
12
    sum += idx;
13
}

1
#include <stdio.h>
2
#include <time.h>
3

4
#define N 100000000
5

6
int main() {
7
    int *arr = malloc(N * sizeof(int));
8
    for (int i = 0; i < N; i++) arr[i] = i;
9

10
    // 场景 1：独立操作（乱序执行有效）
11
    int a = 0, b = 0, c = 0, d = 0;
12
    clock_t start = clock();
13
    for (int i = 0; i < N; i += 4) {
14
        a += arr[i];     // 4 个独立累加
15
        b += arr[i+1];   // 乱序执行可以重叠
16
        c += arr[i+2];
17
        d += arr[i+3];
18
    }
19
    clock_t end = clock();
20
    printf("独立操作: %.3f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
21

22
    // 场景 2：依赖链（乱序执行无效）
23
    int sum = 0;
24
    start = clock();
25
    for (int i = 0; i < N; i++) {
26
        sum += arr[sum % N];  // 每次依赖上一次结果
27
    }
28
    end = clock();
29
    printf("依赖链: %.3f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
30

31
    free(arr);
32
    return 0;
33
}

1
# 查看乱序执行相关的硬件事件
2
perf stat -e \
3
  instructions,\
4
  cycles,\
5
  uops_issued.any,\
6
  uops_executed.any,\
7
  uops_retired.any,\
8
  int_misc.recovery_cycles \
9
  ./your_program
10

11
# uops_issued > uops_retired 说明有推测执行被丢弃
12
# int_misc.recovery_cycles 高说明分支预测失败频繁

1
// 通过制造长依赖链来测试 ROB 容量
2
#include <stdio.h>
3
#include <time.h>
4

5
int main() {
6
    // 创建一条长依赖链
7
    double x = 1.0;
8
    clock_t start = clock();
9
    for (int i = 0; i < 100000000; i++) {
10
        x = x + 1.0;  // 每次迭代依赖上一次
11
        x = x * 0.999;
12
    }
13
    clock_t end = clock();
14
    printf("长依赖链: %.3f 秒, x=%.6f\n",
15
           (double)(end - start) / CLOCKS_PER_SEC, x);
16

17
    // 短依赖链（4 条独立链）
18
    double a = 1.0, b = 1.0, c = 1.0, d = 1.0;
19
    start = clock();
20
    for (int i = 0; i < 25000000; i++) {
21
        a = a + 1.0; a = a * 0.999;
22
        b = b + 1.0; b = b * 0.999;
23
        c = c + 1.0; c = c * 0.999;
24
        d = d + 1.0; d = d * 0.999;
25
    }
26
    end = clock();
27
    printf("短依赖链: %.3f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
28

29
    return 0;
30
}