False Sharing 해결 — Cache Line Padding·SoA 적용

1
hot 공유 변수 사이에 padding을 넣어 *다른 line*에 두기

1
struct counters {
2
    std::atomic<long> a;       /* 8 byte */
3
    std::atomic<long> b;       /* 8 byte — a와 같은 line */
4
};
5
counters g;
6

7
void thread_a(void) {
8
    for (int i = 0; i < N; i++) g.a.fetch_add(1, std::memory_order_relaxed);
9
}
10

11
void thread_b(void) {
12
    for (int i = 0; i < N; i++) g.b.fetch_add(1, std::memory_order_relaxed);
13
}

1
struct counters {
2
    alignas(64) std::atomic<long> a;
3
    char pad_a[64 - sizeof(std::atomic<long>)];
4
    alignas(64) std::atomic<long> b;
5
    char pad_b[64 - sizeof(std::atomic<long>)];
6
};
7

8
static_assert(sizeof(counters) == 128, "padded counters");

1
#include <new>
2

3
struct counters {
4
    alignas(std::hardware_destructive_interference_size) std::atomic<long> a;
5
    char pad[std::hardware_destructive_interference_size - sizeof(std::atomic<long>)];
6
    alignas(std::hardware_destructive_interference_size) std::atomic<long> b;
7
};

1
constexpr int N_CPU = 8;
2

3
struct alignas(64) shard {
4
    std::atomic<long> v;
5
    char pad[64 - sizeof(std::atomic<long>)];
6
};
7
shard counters[N_CPU];
8

9
void inc(int cpu) {
10
    counters[cpu].v.fetch_add(1, std::memory_order_relaxed);
11
}
12

13
long total(void) {
14
    long s = 0;
15
    for (int i = 0; i < N_CPU; i++)
16
        s += counters[i].v.load(std::memory_order_relaxed);
17
    return s;
18
}

1
thread_local long my_counter;
2
std::vector<long *> all_counters;
3
std::mutex mu;
4

5
void register_thread(void) {
6
    std::lock_guard g(mu);
7
    all_counters.push_back(&my_counter);
8
}
9

10
long total(void) {
11
    long s = 0;
12
    std::lock_guard g(mu);
13
    for (auto *p : all_counters) s += *p;
14
    return s;
15
}

1
template <typename T, size_t N>
2
struct spsc_ring {
3
    alignas(64) std::atomic<size_t> head;
4
    char pad_h[64 - sizeof(std::atomic<size_t>)];
5

6
    alignas(64) std::atomic<size_t> tail;
7
    char pad_t[64 - sizeof(std::atomic<size_t>)];
8

9
    alignas(64) T buf[N];
10
};

1
#include <linux/cache.h>
2

3
struct foo {
4
    int a;
5
    int b ____cacheline_aligned;    /* 새 line */
6
};
7

8
static struct bar g_bar ____cacheline_aligned;
9
DEFINE_PER_CPU(unsigned long, counters);   /* per-CPU는 자동 분리 */

1
Intel Xeon 8-core 비교
2
같은 line                   5.2 s
3
padded                      0.4 s     (13x)
4
per-CPU                     0.07 s   (74x)

1
struct foo {
2
    alignas(64) std::atomic<int> a;
3
    std::atomic<int> b;    /* a와 같은 line — alignas 의미 없음 */
4
};

1
alignas(64) int x;    /* Cortex-M7 line = 32 B → 메모리 두 배 낭비 */

1
struct shard { std::atomic<long> v; };
2
shard arr[8];      /* 8 byte씩 — 한 line에 8개 모두 있음 */

1
void f(void) {
2
    alignas(64) std::atomic<int> x;    /* stack은 16/32 B만 보장 */
3
}

1
char pad[64 - sizeof(std::atomic<long>)];   /* sizeof 바뀌면 깨짐 */