Concurrency

Defines the data-race-free contract, sequential consistency for race-free programs and no meaning for a race.

The normative wording for every memory order, fence and read-modify-write, the text a compiler is checked against.

The table that turns each memory order into x86 and Arm instructions, so what an order costs is read off the page.

States what the kernel assumes any CPU may reorder and what each barrier and access primitive guarantees.

Where herd7, litmus7 and klitmus7 live, the tools that run a litmus test against the x86, Arm and kernel models.

Derives counting, partitioning, locking and deferral with code that runs, the textbook the section assumes.

The origin of the queue lock, each waiter spinning on its own line, measured against ticket and test-and-set locks.

Derives a correct user-space mutex from futex and shows the lost wakeups and extra kernel entries naive versions pay.

Defines blowup and allocator-induced false sharing, which per-processor heaps under a bounded global heap avoid.

The design statement for per-CPU caches built on restartable sequences and a hugepage-aware back end for TLB reach.

States linearizability and the consensus hierarchy and builds both into working stacks, queues, lists and hash tables.

The lock-free queue later libraries copy, with the counted pointer against ABA and a two-lock queue beside it.

The standard-track form of safe reclamation, fixing when a retired node may be freed while a reader still holds it.

The kernel's own statement of RCU as publish, wait for readers and keep old versions, with a free read side.

Defines liburcu's quiescent-state, signal-based and general RCU flavours and measures each read side against locks.

Defines work and critical path, proves the work-stealing bound, and shows they alone predict a runtime's speedup.

States the work-first principle, that overhead belongs on the rare steal path and not on every spawn.

Gives the work-stealing deque a proven atomics form and derives which fence push, take and steal need on Arm and x86.

Fixes fork-join and tasking semantics, and the wait and binding controls deciding if idle workers spin, sleep or move.

The shipping work-stealing runtime, arenas and task groups over a deque, the home of grain size and spin-before-sleep.