CPU 캐시 & 메모리 계층 완전 가이드 2025: L1/L2/L3, Cache Line, False Sharing, 성능 최적화

메모리 접근 = 비용
캐시 hit = 저렴
캐시 miss = 비쌈

RAM에서 1 byte 읽으면?
→ 64 bytes를 캐시 라인 단위로 가져옴

// 컴파일러/CPU가 자동
for (int i = 0; i < n; i++) {
    process(arr[i]);
    // CPU가 arr[i+1], arr[i+2]를 미리 가져옴
}

// 블로킹 없이 (캐시 미스 많음)
for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
        for (int k = 0; k < n; k++)
            C[i][j] += A[i][k] * B[k][j];

// 블로킹 (캐시에 맞춤)
for (int ii = 0; ii < n; ii += BLOCK)
    for (int jj = 0; jj < n; jj += BLOCK)
        for (int kk = 0; kk < n; kk += BLOCK)
            for (int i = ii; i < ii + BLOCK; i++)
                for (int j = jj; j < jj + BLOCK; j++)
                    for (int k = kk; k < kk + BLOCK; k++)
                        C[i][j] += A[i][k] * B[k][j];

// Array - 캐시 친화적
int arr[1000];
for (int i = 0; i < 1000; i++)
    sum += arr[i];  // 연속 메모리, prefetch 효과

// LinkedList - 캐시 적대적
struct Node {
    int value;
    struct Node* next;
};

Node* curr = head;
while (curr) {
    sum += curr->value;
    curr = curr->next;  // 어디 있을지 모름, cache miss
}

struct Point {
    float x, y, z;
    int color;
};

Point points[1000];

// x만 처리하고 싶을 때
for (int i = 0; i < 1000; i++)
    sum += points[i].x;
// 매번 16 bytes (Point 크기) 가져옴, 그 중 4 bytes만 사용

struct Points {
    float x[1000];
    float y[1000];
    float z[1000];
    int color[1000];
};

// x만 처리
for (int i = 0; i < 1000; i++)
    sum += points.x[i];
// 4 bytes만 가져옴, 100% 활용

struct Bad {
    char a;     // 1 byte + 7 padding
    double b;   // 8 bytes
    char c;     // 1 byte + 7 padding
};
// sizeof(Bad) = 24 bytes (16 wasted!)

struct Good {
    double b;   // 8 bytes
    char a;     // 1 byte
    char c;     // 1 byte + 6 padding
};
// sizeof(Good) = 16 bytes

struct Counters {
    atomic<int> a;  // 4 bytes
    atomic<int> b;  // 4 bytes
};
// 같은 cache line (64 bytes)에 위치

perf c2c record ./my_program
perf c2c report

struct Counters {
    alignas(64) atomic<int> a;
    alignas(64) atomic<int> b;
};

#include <new>
struct Counters {
    alignas(std::hardware_destructive_interference_size) atomic<int> a;
    alignas(std::hardware_destructive_interference_size) atomic<int> b;
};

thread_local int a;
thread_local int b;

// AtomicLong - false sharing 가능
AtomicLong counter = new AtomicLong();
counter.incrementAndGet();  // 모든 스레드가 같은 메모리

// LongAdder - false sharing 회피
LongAdder counter = new LongAdder();
counter.increment();  // 스레드별로 분산된 셀에

Core 1: cache line X = 5 (수정)
Core 2: cache line X = 3 (옛 값)

[I] → 읽기 → [E] (혼자) 또는 [S] (공유)
[E] → 쓰기 → [M]
[S] → 쓰기 → [M] (다른 코어에 invalidate 신호)
[M] → 다른 코어 읽기 → [S] + writeback

[Socket 1]      [Socket 2]
   ↓               ↓
[Memory 1]    [Memory 2]
   ↓               ↓
   └─── Bus ───────┘

Thread on Socket 1 → Memory on Socket 1: 빠름
Thread on Socket 1 → Memory on Socket 2: 느림 (2배)

# 메모리를 특정 노드에 할당
numactl --cpunodebind=0 --membind=0 ./my_program

# 정보 확인
numactl --hardware

#include <numa.h>

void* mem = numa_alloc_local(size);  // 로컬 노드에 할당

// 잘못 - false sharing
class BadCounter {
    long count;
}

// 좋음 - padding
class GoodCounter {
    long p1, p2, p3, p4, p5, p6, p7;  // padding
    long count;
    long p9, p10, p11, p12, p13, p14, p15;  // padding
}

@sun.misc.Contended
class Counter {
    long count;
}

# 캐시 미스 측정
perf stat -e cache-misses,cache-references ./my_program

# 결과
   1,234,567   cache-misses    #   12.345 % of all cache refs
  10,000,000   cache-references

perf stat -e L1-dcache-load-misses,L1-dcache-loads ./my_program

valgrind --tool=cachegrind ./my_program
cg_annotate cachegrind.out.PID

static void BM_Array(benchmark::State& state) {
    int arr[1000];
    for (auto _ : state) {
        long sum = 0;
        for (int i = 0; i < 1000; i++)
            sum += arr[i];
        benchmark::DoNotOptimize(sum);
    }
}
BENCHMARK(BM_Array);

for (i = 0; i < N; i++)
    for (j = 0; j < N; j++)
        for (k = 0; k < N; k++)
            C[i][j] += A[i][k] * B[k][j];

for (i = 0; i < N; i++)
    for (k = 0; k < N; k++)
        for (j = 0; j < N; j++)
            C[i][j] += A[i][k] * B[k][j];

for (ii = 0; ii < N; ii += T)
    for (kk = 0; kk < N; kk += T)
        for (jj = 0; jj < N; jj += T)
            for (i = ii; i < ii+T; i++)
                for (k = kk; k < kk+T; k++)
                    for (j = jj; j < jj+T; j++)
                        C[i][j] += A[i][k] * B[k][j];

class GameObject {
    Vector3 position;
    Vector3 velocity;
    Mesh mesh;
    Texture texture;
};

vector<GameObject> objects;

// 모든 객체의 position 업데이트
for (auto& obj : objects) {
    obj.position += obj.velocity * dt;
    // 매번 GameObject 전체를 cache에 가져옴
    // mesh, texture는 사용 안 하지만 캐시 차지
}

vector<Vector3> positions;
vector<Vector3> velocities;
vector<Mesh> meshes;
vector<Texture> textures;

// position 업데이트
for (int i = 0; i < entities.size(); i++) {
    positions[i] += velocities[i] * dt;
    // position과 velocity만 캐시에
    // 100% cache 활용
}

[id=1, name="Alice", age=30, country="KR"]
[id=2, name="Bob", age=25, country="US"]

id:      [1, 2, 3, ...]
name:    ["Alice", "Bob", "Charlie", ...]
age:     [30, 25, 28, ...]
country: ["KR", "US", "JP", ...]