Atomics and Memory Consistency

#include <stdatomic.h>
#include <stdio.h>

int main(void)
{
#ifdef __STDC_NO_ATOMICS__
    puts("this implementation has no atomics");
#else
    // Three equivalent spellings of an atomic int:
    _Atomic int a = 0;
    atomic_int b = 0;               // the typedef from <stdatomic.h>
    _Atomic(int) c = 0;

    atomic_store(&a, 1);
    atomic_store(&b, 2);
    atomic_store(&c, 3);

    printf("%d %d %d\n", atomic_load(&a), atomic_load(&b), atomic_load(&c));

    // Is it lock-free, or does the implementation fall back to a hidden mutex?
    printf("int lock-free: %d, pointer lock-free: %d\n",
           (int)atomic_is_lock_free(&a), (int)ATOMIC_POINTER_LOCK_FREE);
#endif
    return 0;
}

#include <stdatomic.h>
#include <stdio.h>
#include <threads.h>

static atomic_int counter = 0;
static atomic_bool ready = false;

static int worker(void *arg)
{
    (void)arg;

    for (int i = 0; i < 100000; ++i) {
        // Read-modify-write, indivisibly. This is the whole point: ++counter on a
        // plain int is three steps and races; atomic_fetch_add is one.
        atomic_fetch_add(&counter, 1);
    }
    return 0;
}

int main(void)
{
    thrd_t a, b;

    if (thrd_create(&a, worker, nullptr) != thrd_success) {
        return 1;
    }
    if (thrd_create(&b, worker, nullptr) != thrd_success) {
        thrd_join(a, nullptr);
        return 1;
    }

    thrd_join(a, nullptr);
    thrd_join(b, nullptr);
    atomic_store(&ready, true);

    // Note: an _Atomic object also supports the ordinary operators, which are
    // shorthand for the seq_cst versions of these calls.
    ++counter;

    printf("counter = %d, ready = %d\n", atomic_load(&counter), (int)atomic_load(&ready));
    return 0;
}

#include <stdatomic.h>
#include <stdio.h>
#include <threads.h>

static int payload = 0;                     // a PLAIN int -- deliberately
static atomic_bool published = false;

static int producer(void *arg)
{
    (void)arg;

    payload = 42;                                       // 1. ordinary write
    atomic_store_explicit(&published, true, memory_order_release);   // 2. release
    return 0;
}

static int consumer(void *arg)
{
    (void)arg;

    // 3. acquire: if it reads true, it synchronizes-with the release above,
    //    so write 1 happens-before this thread's read of payload.
    while (!atomic_load_explicit(&published, memory_order_acquire)) {
        thrd_yield();
    }

    return payload;                                     // 4. safely 42, no race
}

int main(void)
{
    thrd_t p, c;

    if (thrd_create(&c, consumer, nullptr) != thrd_success) {
        return 1;
    }
    if (thrd_create(&p, producer, nullptr) != thrd_success) {
        thrd_join(c, nullptr);
        return 1;
    }

    int seen = 0;
    thrd_join(p, nullptr);
    thrd_join(c, &seen);

    printf("consumer saw %d\n", seen);
    return 0;
}

#include <stdatomic.h>
#include <stdio.h>
#include <threads.h>

// A statistics counter nobody synchronizes on: relaxed is correct AND cheaper.
static atomic_long events = 0;

static int worker(void *arg)
{
    (void)arg;

    for (int i = 0; i < 10000; ++i) {
        // Relaxed: we need the total to be right, not to order anything else.
        atomic_fetch_add_explicit(&events, 1, memory_order_relaxed);
    }
    return 0;
}

int main(void)
{
    thrd_t a, b;

    if (thrd_create(&a, worker, nullptr) != thrd_success) {
        return 1;
    }
    if (thrd_create(&b, worker, nullptr) != thrd_success) {
        thrd_join(a, nullptr);
        return 1;
    }

    thrd_join(a, nullptr);
    thrd_join(b, nullptr);

    // The joins give us the happens-before edge, so this read is well-ordered.
    printf("events = %ld\n", atomic_load_explicit(&events, memory_order_relaxed));
    return 0;
}

#include <stdatomic.h>
#include <stdio.h>

static int data_a = 0;
static int data_b = 0;
static atomic_bool flag = false;

static void publish(void)
{
    data_a = 1;
    data_b = 2;

    // Everything above is ordered before everything below in this thread.
    atomic_thread_fence(memory_order_release);
    atomic_store_explicit(&flag, true, memory_order_relaxed);
}

static bool consume(int *out_a, int *out_b)
{
    if (!atomic_load_explicit(&flag, memory_order_relaxed)) {
        return false;
    }

    atomic_thread_fence(memory_order_acquire);

    *out_a = data_a;                // safe: the fences pair up
    *out_b = data_b;
    return true;
}

int main(void)
{
    int a = 0, b = 0;

    publish();
    printf("%d %d %d\n", (int)consume(&a, &b), a, b);
    return 0;
}

#include <stdalign.h>
#include <stdatomic.h>
#include <stdio.h>

#define CACHE_LINE 64

// Bad: both counters almost certainly share one cache line, so every increment
// by one thread invalidates the other thread's line.
static struct {
    atomic_long a;
    atomic_long b;
} contended;

// Good: each counter gets its own line.
static struct {
    alignas(CACHE_LINE) atomic_long a;
    alignas(CACHE_LINE) atomic_long b;
} padded;

int main(void)
{
    atomic_store(&contended.a, 1);
    atomic_store(&padded.a, 1);

    printf("contended: %zu bytes, padded: %zu bytes\n", sizeof contended, sizeof padded);
    return 0;
}