Weak Memory Concurrency: Sequential Consistency Fails on CPUs

Sequential consistency, defined by Leslie Lamport, treats a concurrent program as if its instructions were interleaved in some order. Within each thread the instructions must execute in program order, but instructions from different threads may appear in any order. Under this model two threads that write to distinct locations X and Y cannot both read the initial value 0 when each reads the other’s write.

Reality of Modern Systems

Compilers reorder instructions to improve performance, and CPUs may execute later instructions while waiting for a cache miss. Both optimizations change the observable order of operations. Store buffers add a further layer: each core keeps a private FIFO queue for writes. When a thread reads, it first checks its own buffer; if the address is present, the pending value is returned, otherwise the read accesses main memory. Writes leave the buffer only after asynchronous propagation, so other threads can temporarily see stale values. These mechanisms produce outcomes that violate sequential consistency, such as both threads observing 0 in the classic “a = 0, b = 0” test after a few hundred iterations.

Advanced Memory Behaviors

Multi‑copy atomicity describes whether all threads observe memory updates in the same order. x86 processors from Intel and AMD generally respect this property, while IBM Power architectures do not, allowing weak behaviors. ARM historically permitted weak ordering but recent implementations have moved toward stronger specifications. Distributed systems often tolerate weak behaviors because a universal order of operations is unnecessary; for example, Facebook wall posts can appear in different orders on different replicas without breaking correctness.

Abstraction Layers

At a high level—far up the abstraction chain—operating systems and programming‑language designers aim to hide weak memory effects, letting developers write code as if sequential consistency holds. At lower levels—hardware, C, or Rust—those weak behaviors become visible, requiring careful reasoning or explicit synchronization primitives. The contrast mirrors a “classical vs. quantum” analogy: the macro view appears deterministic, while the micro view reveals probabilistic, non‑intuitive interactions.