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

5
#define N 100000000
6

7
// 伪共享版本
8
struct Counters {
9
    int count_a;  // 线程 A 修改
10
    int count_b;  // 线程 B 修改
11
    // 两个变量在同一缓存行中！
12
};
13

14
struct Counters counters = {0, 0};
15

16
void *thread_a(void *arg) {
17
    for (int i = 0; i < N; i++) {
18
        counters.count_a++;  // 使线程 B 的缓存行无效
19
    }
20
    return NULL;
21
}
22

23
void *thread_b(void *arg) {
24
    for (int i = 0; i < N; i++) {
25
        counters.count_b++;  // 使线程 A 的缓存行无效
26
    }
27
    return NULL;
28
}
29

30
// 修复版本：缓存行对齐
31
struct CountersFixed {
32
    int count_a;
33
    char pad_a[60];  // 填充到 64 字节
34
    int count_b;
35
    char pad_b[60];  // 填充到 64 字节
36
} __attribute__((aligned(64)));
37

38
struct CountersFixed counters_fixed = {0, {0}, 0, {0}};

1
# 使用 perf 检测缓存一致性流量
2
perf stat -e cache-misses,LLC-load-misses,cycles ./your_program
3

4
# 高 cache-misses + 高 LLC-load-misses 可能是伪共享
5

6
# 使用 perf c2c（Cache-to-Cache）专门检测伪共享
7
perf c2c record ./your_program
8
perf c2c report
9
# 查找 "Shared Data Cache Line Table" 中的高冲突缓存行

1
// 方法 1：手动填充
2
struct AlignedCounter {
3
    int count;
4
    char padding[60];
5
};
6

7
// 方法 2：编译器属性
8
struct AlignedCounter2 {
9
    int count;
10
} __attribute__((aligned(64)));
11

12
// 方法 3：C++11 alignas
13
struct alignas(64) AlignedCounter3 {
14
    int count;
15
};
16

17
// 方法 4：Linux 内核的 __cacheline_aligned
18
#define ____cacheline_aligned __attribute__((__aligned__(SMP_CACHE_BYTES)))
19
#define __cacheline_aligned ____cacheline_aligned
20

21
struct Counters {
22
    int count_a ____cacheline_aligned;
23
    int count_b ____cacheline_aligned;
24
};

1
// 核心 A
2
data = 42;       // 写入 Store Buffer
3
flag = 1;        // 写入 Store Buffer
4

5
// 核心 B
6
while (flag != 1);  // 可能读到 flag=1 但 data 还是 0！
7
print(data);        // 可能打印 0！

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

5
#define N 500000000
6

7
// 伪共享版本
8
struct Bad {
9
    int a;
10
    int b;
11
};
12

13
// 对齐版本
14
struct Good {
15
    int a;
16
    char pad1[60];
17
    int b;
18
    char pad2[60];
19
} __attribute__((aligned(64)));
20

21
struct Bad bad = {0, 0};
22
struct Good good = {0, {0}, 0, {0}};
23

24
void *inc_a_bad(void *arg) {
25
    for (int i = 0; i < N; i++) bad.a++;
26
    return NULL;
27
}
28
void *inc_b_bad(void *arg) {
29
    for (int i = 0; i < N; i++) bad.b++;
30
    return NULL;
31
}
32
void *inc_a_good(void *arg) {
33
    for (int i = 0; i < N; i++) good.a++;
34
    return NULL;
35
}
36
void *inc_b_good(void *arg) {
37
    for (int i = 0; i < N; i++) good.b++;
38
    return NULL;
39
}
40

41
int main() {
42
    pthread_t t1, t2;
43
    clock_t start, end;
44

45
    // 伪共享
46
    start = clock();
47
    pthread_create(&t1, NULL, inc_a_bad, NULL);
48
    pthread_create(&t2, NULL, inc_b_bad, NULL);
49
    pthread_join(t1, NULL);
50
    pthread_join(t2, NULL);
51
    end = clock();
52
    printf("伪共享: %.3f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
53

54
    // 对齐
55
    start = clock();
56
    pthread_create(&t1, NULL, inc_a_good, NULL);
57
    pthread_create(&t2, NULL, inc_b_good, NULL);
58
    pthread_join(t1, NULL);
59
    pthread_join(t2, NULL);
60
    end = clock();
61
    printf("对齐: %.3f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
62

63
    return 0;
64
}

1
# 使用 perf c2c 检测伪共享
2
perf c2c record -- ./false_sharing_test
3
perf c2c report
4

5
# 查看缓存一致性相关事件
6
perf stat -e \
7
  offcore_response.demand_data_rd.any_response,\
8
  offcore_response.demand_rfo.any_response \
9
  ./your_program
10
# demand_rfo = Read For Ownership = 获取独占权的请求

1
// 利用 E 状态优化：先读再写
2
// 如果数据只在本核心缓存中（E 状态），写入几乎免费
3
int value = shared_data;  // 读 → 如果其他核心没有副本，状态为 E
4
shared_data = value + 1;  // 写 → E→M，无需 Invalidate！
5
// vs. 如果其他核心有副本（S 状态）：
6
shared_data = shared_data + 1;  // S→M，需要广播 Invalidate

1
┌──────────────┬──────────────────────────────────────┐
2
│ 缓存行地址    │ 位向量（Sharers）                      │
3
├──────────────┼──────────────────────────────────────┤
4
│ 0x1000       │ [1, 0, 0, 1, 0, 0, 0, 0]            │ ← Core 0, 3 有副本
5
│ 0x2000       │ [0, 0, 1, 0, 0, 0, 0, 0]            │ ← Core 2 独占（E 状态）
6
│ 0x3000       │ [0, 0, 0, 0, 0, 0, 0, 0]            │ ← 无缓存副本
7
└──────────────┴──────────────────────────────────────┘

1
// NUMA 系统上的伪共享更加致命
2
// 解决方案：不仅缓存行对齐，还要 NUMA 感知分配
3

4
struct alignas(64) NumaAwareCounter {
5
    std::atomic<int> count;
6
};
7

8
// 每个线程在本地 NUMA 节点分配计数器
9
void* local_counter = numa_alloc_onnode(sizeof(NumaAwareCounter),
10
                                         numa_node_of_cpu(sched_getcpu()));
11
// 线程只更新本地计数器，定期汇总到全局
12
// 避免跨插槽的缓存行弹跳