Ivan's wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
# False sharing (OpenMP)
**False sharing** is a performance problem that occurs when two threads write to different variables that happen to occupy the same cache line. Cache lines are typically 64 bytes wide. The hardware cache-coherence protocol must keep that line consistent across cores, so every write by one thread invalidates the cached copy in the other and forces a round-trip to main memory. The threads are accessing distinct variables and no actual race condition exists, but performance collapses as if they were contending on the same location.

```c
int counter[MAX_THREADS];  // adjacent ints, very likely on the same cache line

#pragma omp parallel
{
    int tid = omp_get_thread_num();
    for (int i = 0; i < N; i++)
        counter[tid]++;   // each thread writes a different element, but the same cache line
}
```

The fix is to avoid per-thread arrays of small values entirely, preferring private variables with a single write-back at the end:

```c
// private accumulation; no shared memory touched inside the loop
int total = 0;
#pragma omp parallel reduction(+:total)
{
    for (int i = 0; i < N; i++)
        total++;
}
```

When a per-thread array is genuinely needed, wrap each element in a struct with `alignas(64)` so that the compiler places each element on its own cache line:

```c
struct alignas(64) padded_int {
    int val;
    // 60 bytes of implicit padding follow; one struct per cache line
};

struct padded_int counter[MAX_THREADS];

#pragma omp parallel
{
    int tid = omp_get_thread_num();
    for (int i = 0; i < N; i++)
        counter[tid].val++;   // each element on a separate cache line; no false sharing
}
```

`alignas` is part of C11 / C++11; include `<stdalign.h>` in C or `<cstddef>` in C++. False sharing is silent: the program produces correct results at a fraction of the expected speed, so it tends to surface only when measured speedup falls well below the thread count.