1
struct Particle {
2
    float x, y, z;   // 12 字节
3
    int id;           // 4 字节
4
    char padding[48]; // 填充到 64 字节
5
};
6

7
// 遍历所有 x 值
8
for (int i = 0; i < N; i++) {
9
    sum += particles[i].x;  // 步长 = 64 字节
10
}
11
// Stride 预取器检测到步长 64，自动预取后续行

1
// __builtin_prefetch(addr, rw, locality)
2
// rw: 0 = 读预取, 1 = 写预取
3
// locality: 0 = 低（可被驱逐）, 1 = 中, 2 = 高, 3 = 保留
4

5
// 读预取，低局部性（预取到 L2）
6
__builtin_prefetch(&arr[i + 16], 0, 0);
7

8
// 读预取，高局部性（预取到 L1）
9
__builtin_prefetch(&arr[i + 16], 0, 3);
10

11
// 写预取
12
__builtin_prefetch(&dst[i], 1, 0);

1
// 链表遍历：硬件预取无效，软件预取有效
2
struct Node {
3
    int data;
4
    struct Node *next;
5
};
6

7
void traverse_list(struct Node *head) {
8
    struct Node *curr = head;
9
    while (curr) {
10
        __builtin_prefetch(curr->next, 0, 1);  // 预取下一个节点
11
        process(curr->data);
12
        curr = curr->next;
13
    }
14
}

1
// 间接索引：硬件预取无效
2
int *indices = ...;  // 索引数组
3
float *data = ...;   // 数据数组
4

5
for (int i = 0; i < N; i++) {
6
    __builtin_prefetch(&data[indices[i + 8]], 0, 0);  // 预取 8 步之后的数据
7
    sum += data[indices[i]];
8
}

1
// 矩阵乘法分块中的预取
2
void matmul_prefetch(double *C, double *A, double *B, int N) {
3
    for (int i = 0; i < N; i++) {
4
        for (int k = 0; k < N; k++) {
5
            __builtin_prefetch(&B[(k+4) * N], 0, 1);  // 预取 B 的后续行
6
            for (int j = 0; j < N; j++) {
7
                C[i*N+j] += A[i*N+k] * B[k*N+j];
8
            }
9
        }
10
    }
11
}

1
// 假设：
2
// - 内存延迟 = 200 周期
3
// - 每次迭代 = 5 周期（计算密集）
4
// - 预取距离 = 200 / 5 = 40 次迭代
5

6
for (int i = 0; i < N; i++) {
7
    __builtin_prefetch(&arr[i + 40], 0, 0);  // 预取 40 步之后的数据
8
    sum += arr[i] * factor;  // 5 周期计算
9
}

1
// 非临时存储：直接写入内存，不经过缓存
2
void stream_store(float *dst, float *src, int n) {
3
    for (int i = 0; i < n; i += 4) {
4
        __m128 data = _mm_load_ps(src + i);
5
        _mm_stream_ps(dst + i, data);  // 非临时存储
6
    }
7
    _mm_sfence();  // 确保所有非临时存储完成
8
}

1
// 顺序访问：硬件预取器自动工作，无需软件预取
2
for (int i = 0; i < N; i++) {
3
    sum += arr[i];  // Stream 预取器自动预取后续行
4
}
5
// 添加软件预取反而可能降低性能（增加指令开销）

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

5
struct Node { int data; struct Node *next; };
6

7
void traverse_no_prefetch(struct Node *head) {
8
    struct Node *curr = head;
9
    while (curr) {
10
        curr = curr->next;  // 每次都是随机访问
11
    }
12
}
13

14
void traverse_with_prefetch(struct Node *head) {
15
    struct Node *curr = head;
16
    while (curr) {
17
        __builtin_prefetch(curr->next, 0, 1);
18
        curr = curr->next;
19
    }
20
}
21

22
int main() {
23
    // 构建链表
24
    struct Node *head = NULL, *prev = NULL;
25
    for (int i = 0; i < 10000000; i++) {
26
        struct Node *node = malloc(sizeof(struct Node));
27
        node->data = i;
28
        node->next = NULL;
29
        if (prev) prev->next = node;
30
        else head = node;
31
        prev = node;
32
    }
33

34
    clock_t start = clock();
35
    traverse_no_prefetch(head);
36
    clock_t end = clock();
37
    printf("无预取: %.3f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
38

39
    start = clock();
40
    traverse_with_prefetch(head);
41
    end = clock();
42
    printf("有预取: %.3f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
43

44
    return 0;
45
}

1
# Intel CPU：通过 MSR 寄存器控制预取器
2
# 需要安装 msr-tools
3
sudo modprobe msr
4

5
# 禁用 L2 硬件预取器（bit 0 = prefetch enable）
6
sudo wrmsr 0x1a4 0x0  # 禁用所有预取器
7

8
# 查看当前预取器状态
9
sudo rdmsr 0x1a4
10

11
# 重新启用
12
sudo wrmsr 0x1a4 0xf

1
# 对比有无硬件预取的性能
2
# 正常模式（预取器启用）
3
perf stat -e L1-dcache-loads,L1-dcache-load-misses,LLC-loads ./sequential_test
4

5
# 禁用预取器后
6
sudo wrmsr 0x1a4 0x0
7
perf stat -e L1-dcache-loads,L1-dcache-load-misses,LLC-loads ./sequential_test
8
sudo wrmsr 0x1a4 0xf  # 重新启用

1
# 编译链表遍历测试
2
gcc -O2 -o prefetch_test prefetch_test.c
3

4
# 对比有无软件预取
5
perf stat -e L1-dcache-loads,L1-dcache-load-misses ./prefetch_test

1
// 测试不同预取距离的效果
2
for (int dist = 4; dist <= 64; dist *= 2) {
3
    start = clock();
4
    for (int i = 0; i < N; i++) {
5
        __builtin_prefetch(&arr[i + dist], 0, 0);
6
        sum += arr[i];
7
    }
8
    end = clock();
9
    printf("预取距离 %d: %.3f 秒\n", dist, (double)(end - start) / CLOCKS_PER_SEC);
10
}

1
置信度计数器示例：
2
访问 1: 置信度 0 → 不预取
3
访问 2: 置信度 1 → 不预取（可能只是巧合）
4
访问 3: 置信度 2 → 开始预取 1 行
5
访问 4: 置信度 3 → 预取 2 行
6
访问 5+: 置信度 4+ → 预取 4 行（最大预取距离）

1
// ARM 预取 intrinsics
2
// PRFM (Prefetch Memory) 指令的编码格式
3
// PRFM <prfop>, [<Xn|SP>{, #<pimm>}]
4

5
// 读预取到 L1
6
__builtin_prefetch(addr, 0, 3);  // GCC 内建
7

8
// ARM NEON intrinsics 中的预取
9
// v64int8 *ptr;
10
// __asm__ __volatile__("prfm pldl1strm, [%0]" : : "r"(ptr));

1
// 未对齐：预取可能需要加载 2 个缓存行
2
struct BadAlign {
3
    int data;  // 偏移 60，跨越缓存行边界！
4
};
5
// 如果结构体起始地址 % 64 = 60，则 data 跨越两个缓存行
6

7
// 缓存行对齐：一次预取正好一个缓存行
8
struct GoodAlign {
9
    int data;
10
} __attribute__((aligned(64)));
11

12
// 检查对齐
13
assert(((uintptr_t)&arr[0] & 63) == 0);  // 确保缓存行对齐

1
// B+ 树节点查找：预取下一个节点
2
struct btree_node {
3
    int keys[ORDER-1];
4
    struct btree_node *children[ORDER];
5
    int num_keys;
6
    int is_leaf;
7
};
8

9
int btree_search(struct btree_node *root, int key) {
10
    struct btree_node *node = root;
11
    while (node) {
12
        int i = 0;
13
        while (i < node->num_keys && key > node->keys[i]) i++;
14

15
        if (i < node->num_keys && key == node->keys[i]) return 1;
16

17
        if (node->children[i]) {
18
            // 预取下一层节点——B+ 树遍历是链式依赖
19
            // 不预取的话，每次都要等缓存未命中
20
            __builtin_prefetch(node->children[i], 0, 1);
21
        }
22
        node = node->children[i];
23
    }
24
    return 0;
25
}

1
// BFS 图遍历：预取邻居节点
2
void bfs_prefetch(int *graph, int *visited, int start, int n) {
3
    int queue[n], head = 0, tail = 0;
4
    queue[tail++] = start;
5
    visited[start] = 1;
6

7
    while (head < tail) {
8
        int node = queue[head++];
9
        int neighbor = graph[node * 2];      // 邻居列表偏移
10
        int degree = graph[node * 2 + 1];    // 度数
11

12
        // 预取邻居节点的数据
13
        for (int i = 0; i < degree && i < 8; i++) {
14
            __builtin_prefetch(&graph[(neighbor + i) * 2], 0, 0);
15
            __builtin_prefetch(&visited[neighbor + i], 0, 0);
16
        }
17

18
        for (int i = 0; i < degree; i++) {
19
            int nb = graph[neighbor + i];
20
            if (!visited[nb]) {
21
                visited[nb] = 1;
22
                queue[tail++] = nb;
23
            }
24
        }
25
    }
26
}