TSO-Specific Occurs-Before Relation

• TSO-specific occurs-before relation is a formal construct defining causal ordering in TSO memory models where store buffering delays the global visibility of writes.
• It incorporates explicit buffer propagation and synchronization primitives such as memory fences and atomic read-modify-write operations to guarantee correct temporal ordering.
• This framework is crucial for verifying concurrent algorithms and optimizing performance on architectures like x86/x64.

The TSO-specific occurs-before relation is a formal construct designed to characterize the information flow, causality, and necessary synchronization in concurrent systems running under the Total Store Order (TSO) memory model. Unlike canonical sequential consistency, TSO admits store buffering: each process can delay the visibility of writes to shared memory, leading to executions where operations are not instantaneously visible to other threads. The occurs-before relation adapts Lamport’s happens-before to the context of TSO, incorporating explicit store buffer propagation and synchronization events, thereby enabling precise reasoning about the necessary conditions for correct temporal ordering between events across different processes.

1. Foundations of TSO and Store Buffering

TSO, as implemented in architectures such as x86/x64, allows each processor to enqueue writes into a local FIFO store buffer before these are eventually propagated (flushed) to global memory. While this mechanism greatly enhances hardware-level performance by decoupling memory operations from processor scheduling, it fundamentally complicates the establishment of a global temporal order over events.

In canonical sequential consistency (SC), every memory operation is instantaneously visible to all processes so a total order suffices to describe causality. In TSO, however, a write is seen immediately by the issuing processor but may be delayed for others. Thus, the global order of events becomes a strict partial order governed not only by local program order but also by the timing of buffer flushes and synchronization primitives.

This necessitates a more sophisticated relation—TSO-specific occurs-before—that tracks how execution events actually propagate and become globally visible. For example, in a situation where two threads write to and read from each others' variables, the use or omission of explicit synchronization controls (fences or atomic read-modify-write operations) can determine strong or weak temporal ordering.

2. Formal Definition and Structure of the Occurs-Before Relation

The TSO-specific occurs-before relation, commonly abbreviated as ob, is constructed over execution nodes of the form $(b, t)$ where $b$ is an agent (a process or a dispatcher responsible for propagation) and $t$ is a time index or step. The relation is defined via several base clauses and is closed under transitivity:

• Locality Clause: For every agent $b$ and every time step $t$, $(b,t)$ occurs before $(b, t+1)$.
• Buffer Propagation Clause: If process $i$ writes $x$ (producing a store buffer entry with tag $\kappa$) at time $t$, and dispatcher $d_i$ flushes this write at a later time $t'$ (identified by the same tag), then: $(i, t)\;\text{ob}\;(d_i, t')$.
• Memory Access Clause: If two (possibly distinct) agents $b$ and $c$ access the same shared variable $x$, the relation ensures that the propagation and reading of $x$ are properly ordered. When both actions are buffer reads, a “special case” applies with hidden ordering.
• Synchronization Primitive Clause: A fence ($F$) or atomic read-modify-write ($RMW$) operation by process $i$ at time $t'$ ensures that any prior propagation action by $d_i$ at time $t$ establishes $(d_i, t)\;\text{ob}\;(i, t')$.
• Transitivity Closure: If $(\theta_1)\;\text{ob}\;(\theta_2)$ and $(\theta_2)\;\text{ob}\;(\theta_3)$, then $(\theta_1)\;\text{ob}\;(\theta_3)$.

A representative formal LaTeX expression is: $\forall b, t: \quad (b, t) \;\text{ob}\; (b, t+1)$

$$\text{If } (i, t) \text{ writes } x \text{ with tag } \kappa \text{ and } (d_i, t') \text{ propagates } x \text{ with tag } \kappa, \text{ then } (i, t) \;\text{ob}\; (d_i, t')$$

Ob is a strict partial order: whenever $(\theta) \;\text{ob}\; (\theta')$ holds, the time index increases ($t < t'$). In contrast to naive program order, this relation only advances through actual buffer flushes and explicit synchronization, critically distinguishing those configurations where global visibility is achieved from those where the effect is still locally buffered.

3. Synchronization Primitives and Ensuring Temporal Ordering

Correctness properties like linearizability require real-time ordering of certain events. Under TSO, memory fences ($F$) and atomic read-modify-write ($RMW$) operations become the only ways to force necessary ob-chains between events occurring at different sites:

• Memory Fence ($F$): Ensures the store buffer of the process is completely flushed before the next operation. The formal ob-clause is such that propagation by the dispatcher $(d_i, t)$ is ordered before the fence execution $(i, t')$.
• Atomic RMW: Only allowed when the buffer is empty, merging a read and write atomically. This ensures that all prior writes are visible before the RMW operation and produces a strong occurs-before chain.

The Delaying the Future (DtF) theorem proves that if no ob-chain exists between two events, one may be arbitrarily delayed without detection by the other process. Thus, essential ordering is only established by explicit synchronization actions that build an ob-chain (as in $(b,t)\;\text{ob}\;(c, t')$).

This semantic mechanism establishes lower bounds for implementations: for many concurrent objects (e.g., linearizable registers, atomic snapshots), at least one synchronization action (fence or atomic RMW) must be used to guarantee the required causal order.

4. Generalization and Theoretical Significance

The TSO-specific occurs-before relation extends Lamport’s happens-before by incorporating the mechanism of buffer propagation and the role of synchronization. As illustrated in (Nataf et al., 15 Aug 2025), the classical happens-before, which is sufficient for message-passing systems, fails to account for the asynchronous and buffered nature of memory visibility in TSO architectures.

The explicit modeling of the propagation agent (dispatcher $d_i$) and the detector ($i$) for buffer flushes captures the path of information flow, precisely reflecting causality under buffering. The analysis describes that information (memory updates) only becomes globally causally effective when a propagation event links the write to subsequent operations—this is only guaranteed via synchronization primitives.

Mathematically, the ob relation is a strict partial order, and the presence of full ob-chains between operations is equated with the ability to enforce the necessary orderings for correctness. The non-existence of such a chain formally precludes the realization of real-time ordering guarantees.

5. Practical Consequences and Applications

For systems programming and the design of concurrent algorithms on x86/x64 platforms, understanding the TSO-specific occurs-before relation is critical. Costly synchronization operations (fences, atomic RMWs) are not merely performance optimizations; they embody the only mechanism for enforcing real-time order of events under TSO. Eliminating or misplacing these primitives may lead to subtle consistency violations—e.g., both processors in a litmus test reading “stale” values due to lack of ordered buffer flushes.

Verification methods and automated tools that aim to establish correctness (e.g., linearizability, data-race freedom) must explicitly model the ob relation and recognize that only fence/RMW-induced chains can assure the requisite causal order. Lower-bounds for the number of synchronizations required are derived by analyzing where ob-chains are necessary.

6. Extension to Other Consistency Models and Future Directions

Although specifically developed for TSO, this occurs-before framework has analytical significance for other relaxed memory models and distributed consistency conditions. The analysis in (Nataf et al., 15 Aug 2025) generalizes prior lower-bound arguments and helps elucidate the relationship between buffering, information flow, and synchronization in weak memory systems.

Future research avenues include refining the ob relation for hardware variants with differing buffer propagation semantics, extending automated verification tools to fully capture ob-based causality, and leveraging similar relational approaches for reasoning about novel memory architectures and persistent memory systems.

7. Summary of Formalism

The TSO-specific occurs-before relation:

• Generalizes classical happens-before for systems with store buffers.
• Formally defines causal ordering over nodes $(b,t)$ using base and propagation clauses, synchronization links, and transitive closure.
• Establishes that fences and atomic RMWs are essential for constructing ob-chains required for temporal consistency.
• The absence of such a chain permits unobserved (arbitrarily delayed) reordering, fundamentally impacting correctness guarantees.
• Provides a rigorous semantic foundation for reasoning about memory synchronization and verifying the correctness of multiprocessor concurrent algorithms.

The expressiveness and precision of the ob relation support both theoretical advances and practical design of synchronization disciplines under TSO, directly linking architectural mechanisms to consistency properties of concurrent systems (Nataf et al., 15 Aug 2025).