c systems notebook

Memory-Order-Semantik

memory_order_seq_cst (sequentiell konsistent)

Die stärkste und am leichtesten zu verstehende Memory Order ist memory_order_seq_cst (sequentiell konsistent). Sie garantiert sequentielle Konsistenz: Alle atomaren Operationen mit dieser Memory Order erscheinen in einer einzigen globalen Reihenfolge, die von allen Threads gleich beobachtet wird. Diese Semantik entspricht am ehesten dem intuitiven Modell von Parallelität, ist aber auch die restriktivste. Wird kein expliziter Memory-Order-Parameter angegeben, verwendet C standardmäßig memory_order_seq_cst.

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

atomic_int x = 0;
atomic_int y = 0;

int thread1(void *arg) {
    atomic_store_explicit(&x, 1, memory_order_seq_cst);
    int r1 = atomic_load_explicit(&y, memory_order_seq_cst);
    printf("Thread 1 sieht y = %d\n", r1);  // 📣 Thread 1 sieht y = 0 oder 1
    return 0;
}

int thread2(void *arg) {
    atomic_store_explicit(&y, 1, memory_order_seq_cst);
    int r2 = atomic_load_explicit(&x, memory_order_seq_cst);
    printf("Thread 2 sieht x = %d\n", r2);  // 📣 Thread 2 sieht x = 0 oder 1
    return 0;
}

Mit sequentieller Konsistenz ist garantiert, dass nicht beide Threads den Wert 0 sehen können. Mindestens einer der Threads muss den Wert 1 beobachten. Alle seq_cst-Operationen sind in eine globale Reihenfolge eingebettet. Entweder schreibt Thread 1 x, bevor Thread 2 x liest, oder Thread 2 schreibt y, bevor Thread 1 y liest, oder beide Ordnungen gelten. Mit schwächeren Memory Orders wäre das Ergebnis r1 == 0 && r2 == 0 erlaubt. Der Unterschied ist rein semantisch, aber entscheidend für die Korrektheit.

memory_order_relaxed

Die schwächste Memory Order ist memory_order_relaxed. Sie garantiert ausschließlich Atomarität, aber keinerlei Ordnung zwischen verschiedenen atomaren Variablen. Eine relaxed Operation kann gegenüber anderen Operationen frei umsortiert werden, solange die Semantik innerhalb eines einzelnen Threads erhalten bleibt. Relaxed eignet sich für Fälle, in denen ausschließlich der Endwert zählt und keine Thread-übergreifenden Abhängigkeiten bestehen.

atomic_int counter = 0;

int incrementer(void *arg) {
    for (int i = 0; i < 1000000; i++) {
        atomic_fetch_add_explicit(&counter, 1, memory_order_relaxed);
    }
    return 0;
}

Hier ist relaxed korrekt, da nur der finale Wert des Zählers relevant ist. Die Reihenfolge, in der Inkremente zwischen Threads sichtbar werden, spielt keine Rolle. Relaxed erlaubt dem Compiler und der CPU maximale Freiheit. Auf schwächeren Architekturen kann dies messbare Vorteile bringen. Wird relaxed jedoch für Synchronisation eingesetzt, entstehen Programme ohne formale Korrektheitsgarantie.

memory_order_acquire und memory_order_release

Die Memory Orders memory_order_acquire und memory_order_release arbeiten paarweise zusammen und etablieren gezielte Happens-Before-Relationen. Eine Release-Operation synchronisiert mit einer Acquire-Operation, die denselben Wert liest. Alle Speicheroperationen, die vor der Release-Operation im schreibenden Thread stattfanden, werden für den lesenden Thread nach der Acquire-Operation sichtbar.

int shared_data = 0;
atomic_bool ready = false;

int producer(void *arg) {
    shared_data = 42;
    atomic_store_explicit(&ready, true, memory_order_release);
    puts("Producer: Daten geschrieben und Flag gesetzt");
    return 0;
}

int consumer(void *arg) {
    while (!atomic_load_explicit(&ready, memory_order_acquire)) {
    }
    printf("Consumer: Gelesener Wert: %d\n", shared_data);
    return 0;
}

Der Zugriff auf shared_data ist hier korrekt, obwohl sie nicht atomar ist. Die Release-Store-Operation synchronisiert mit der Acquire-Load-Operation und erzeugt eine Happens-Before-Relation. Ohne diese Semantik wäre das Programm formal falsch. Es könnte veraltete oder undefinierte Werte lesen, auch wenn es auf bestimmten Systemen scheinbar zuverlässig funktioniert. Genau solche Fehler treten typischerweise nur unter Last oder auf anderen Architekturen auf.

memory_order_acq_rel

Die Memory Order memory_order_acq_rel kombiniert Acquire- und Release-Semantik und wird für Read-Modify-Write-Operationen verwendet. Die Operation empfängt Synchronisation aus vorherigen Releases und gibt sie an nachfolgende Acquires weiter.

atomic_compare_exchange_weak_explicit(
    &token, &expected, id,
    memory_order_acq_rel, memory_order_relaxed)

Der Erfolgsfall verwendet memory_order_acq_rel, da hier sowohl Erwerb als auch Weitergabe von Synchronisation nötig sind. Der Fehlschlag verwendet memory_order_relaxed, da keine Ordnung etabliert wird. Die anschließende Release-Operation beim Freigeben des Tokens stellt sicher, dass der nächste erfolgreiche Acquire alle vorherigen Änderungen sieht.

memory_order_consume

Die Memory Order memory_order_consume ist als Optimierung für datenabhängige Zugriffe gedacht. In der Praxis wird sie kaum verwendet, da ihre Semantik schwer handhabbar ist und die meisten Implementierungen sie wie Acquire behandeln. Ihre explizite Nutzung wird nicht empfohlen.

Fazit

Die Wahl der Memory Order ist Teil der Programmlogik. memory_order_seq_cst ist immer korrekt, aber nicht immer erforderlich. Relaxed ist nur dann korrekt, wenn keinerlei Synchronisation benötigt wird. Acquire-Release bildet den Kern der meisten lock-freien Kommunikationsmuster.

Zu schwache Memory Orders führen zu Programmen ohne formale Korrektheitsgarantie. Sie kompilierten, laufen oft unauffällig und zeigen Fehler erst unter seltenen Timing-Bedingungen oder auf anderen Architekturen. Diese Fehler sind schwer zu reproduzieren und kaum systematisch zu debuggen.

Memory Orders garantieren Sichtbarkeit und Ordnung, aber keine korrekte Architektur. Erst ein korrektes Synchronisationsprotokoll macht ihre Verwendung sinnvoll. Wer Memory Orders falsch wählt, schreibt Programme, deren Verhalten nicht zuverlässig definiert ist.