1
// 顺序访问 vs 随机访问
2
#include <stdio.h>
3
#include <stdlib.h>
4
#include <time.h>
5

6
#define SIZE (64 * 1024 * 1024)  // 64M integers = 256MB
7

8
int main() {
9
    int *arr = malloc(SIZE * sizeof(int));
10
    clock_t start, end;
11

12
    // 顺序访问
13
    start = clock();
14
    long long sum1 = 0;
15
    for (int i = 0; i < SIZE; i++) {
16
        sum1 += arr[i];
17
    }
18
    end = clock();
19
    printf("顺序访问: %.3f 秒, sum=%lld\n",
20
           (double)(end - start) / CLOCKS_PER_SEC, sum1);
21

22
    // 随机访问（指针追逐）
23
    // 预先构建一个随机排列的链
24
    for (int i = 0; i < SIZE; i++) arr[i] = (i + 1) % SIZE;
25
    // Fisher-Yates 洗牌，构建随机跳转链
26
    for (int i = SIZE - 1; i > 0; i--) {
27
        int j = rand() % (i + 1);
28
        int tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp;
29
    }
30

31
    start = clock();
32
    long long sum2 = 0;
33
    int idx = 0;
34
    for (int i = 0; i < SIZE; i++) {
35
        sum2 += idx;
36
        idx = arr[idx];
37
    }
38
    end = clock();
39
    printf("随机访问: %.3f 秒, sum=%lld\n",
40
           (double)(end - start) / CLOCKS_PER_SEC, sum2);
41

42
    free(arr);
43
    return 0;
44
}

1
// 伪共享示例
2
struct Counters {
3
    int count_a;  // 线程 A 修改
4
    int count_b;  // 线程 B 修改
5
};
6

7
// count_a 和 count_b 在同一缓存行（64 字节）中
8
// 线程 A 修改 count_a → 使线程 B 的缓存行失效
9
// 线程 B 修改 count_b → 使线程 A 的缓存行失效
10
// 结果：两个线程反复互相使对方的缓存行失效

1
// 修复：将变量放在不同缓存行
2
struct Counters {
3
    int count_a;
4
    char padding_a[60];  // 填充到 64 字节
5
    int count_b;
6
    char padding_b[60];  // 填充到 64 字节
7
} __attribute__((aligned(64)));
8

9
// 或使用编译器内置宏
10
struct Counters {
11
    int count_a __attribute__((aligned(64)));
12
    int count_b __attribute__((aligned(64)));
13
};

1
# 查看基本性能指标
2
perf stat ./your_program
3

4
# 输出示例：
5
#   3,452,678,901  instructions              # 1.52 insn per cycle
6
#   2,273,156,789  cycles                    # 2.543 GHz
7
#     456,789,012  cache-references          # 200.123 M/sec
8
#      12,345,678  cache-misses              # 2.70% of all cache refs
9
#      34,567,890  branch-misses             # 1.23% of all branches

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

5
#define SIZE (32 * 1024 * 1024)  // 32M 元素 = 128MB
6

7
int main() {
8
    int *arr = calloc(SIZE, sizeof(int));
9
    clock_t start, end;
10

11
    // 不同步长遍历
12
    for (int stride = 1; stride <= 64; stride *= 2) {
13
        start = clock();
14
        long long sum = 0;
15
        for (int i = 0; i < SIZE; i += stride) {
16
            sum += arr[i];
17
        }
18
        end = clock();
19
        printf("步长 %2d: %.3f 秒, 每元素 %.1f ns\n",
20
               stride,
21
               (double)(end - start) / CLOCKS_PER_SEC,
22
               (double)(end - start) / CLOCKS_PER_SEC * 1e9 / (SIZE / stride));
23
    }
24

25
    free(arr);
26
    return 0;
27
}

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

5
int main() {
6
    // 测试不同工作集大小下的访问延迟
7
    for (int size_kb = 4; size_kb <= 16384; size_kb *= 2) {
8
        int size = size_kb * 1024 / sizeof(int);
9
        int *arr = malloc(size * sizeof(int));
10

11
        // 初始化
12
        for (int i = 0; i < size; i++) arr[i] = (i + 16) % size;
13

14
        clock_t start = clock();
15
        int idx = 0;
16
        for (int i = 0; i < 10 * 1024 * 1024; i++) {
17
            idx = arr[idx];  // 指针追逐
18
        }
19
        clock_t end = clock();
20

21
        double ns_per_access = (double)(end - start) / CLOCKS_PER_SEC * 1e9
22
                              / (10 * 1024 * 1024);
23
        printf("工作集 %6d KB: %.1f ns/access\n", size_kb, ns_per_access);
24

25
        free(arr);
26
    }
27
    return 0;
28
}

1
# Linux 下查看 CPU 缓存信息
2
lscpu | grep -i cache
3
# L1d cache:                       32 KiB
4
# L1i cache:                       32 KiB
5
# L2 cache:                        256 KiB
6
# L3 cache:                        12288 KiB
7

8
# 查看缓存行大小
9
getconf LEVEL1_DCACHE_LINESIZE
10
# 64
11

12
# 查看 NUMA 拓扑
13
numactl --hardware
14

15
# 查看详细 CPU 信息
16
cat /proc/cpuinfo | head -30

1
# perf stat：统计硬件性能计数器
2
perf stat ./your_program
3

4
# 关注的几个关键指标：
5
#   cycles          — 总时钟周期
6
#   instructions    — 总指令数（IPC = instructions / cycles）
7
#   cache-references — 缓存访问次数
8
#   cache-misses    — 缓存未命中次数
9
#   branch-misses   — 分支预测失败次数
10

11
# 只看缓存和分支事件
12
perf stat -e cache-misses,cache-references,branch-misses ./your_program
13

14
# 用 objdump 查看编译器生成的汇编
15
objdump -d your_program | head -50