Cache aligned atomics in C++11

Read and write operations on an atomic object are free from data races. However, if one core writes to it, all cache lines occupied by the object are invalidated. If another core is reading from an unrelated object that shares the same cache line, it incurs unnecessary overhead (see false sharing).

To prevent false sharing, we should

1. align the object in memory to the beginning of a cache line,
2. add padding bytes so that no other object can occupy this cache line.

C++17 brought aligned allocation facilities previously only available via boost. Besides being somewhat tedious to use, both only ensure memory alignment (1), but don't add padding bytes (2).

aligned_atomic<T> is a simple specialization of std::atomic<T> that ensures proper memory alignment and padding (1 + 2).

aligned_atomic<T> objects behave just like std::atomic<T>.

#include "aligned_atomic.hpp"

// default alignment is 64 bytes (one cache line on modern computers)
aligned_atomic<size_t> val{0};

// align to 32 bytes
aligned_atomic<size_t, 32> val_32{0};

// some operations
val = 10;
++val;
val.fetch_add(5, std::memory_order_relaxed);

// etc.