Semi-Linearizability (SL) reduces coordination by requiring a strict global order only for operations whose dependencies or invariants need one. In DeMon, the prototype described in the CIDR 2026 paper, strong operations use consensus while weak operations use reliable causal broadcast and can be answered locally before asynchronous replication. Watermarks help preserve the required ordering between those paths; SL is not a blanket promise that every write is safe to run without coordination.
What is Semi-Linearizability?
Semi-Linearizability is a consistency model for geo-distributed applications. Instead of imposing the same strict ordering mechanism on every operation, it expresses ordering relationships among application operations. The system can then choose coordination suited to the dependencies that actually matter.
| # | Preview | Product | Price | |
|---|---|---|---|---|
| 1 |
|
Distributed Systems | $32.68 | Buy on Amazon |
| 2 |
|
Understanding Distributed Systems, Second Edition: What every developer should know about large... | $32.41 | Buy on Amazon |
| 3 |
|
Distributed Systems | $35.00 | Buy on Amazon |
| 4 |
|
Foundations of Scalable Systems: Designing Distributed Architectures | $42.49 | Buy on Amazon |
| 5 |
|
Distributed Systems: Concepts and Design | $255.63 | Buy on Amazon |
As an Amazon Associate I earn from qualifying purchases.
The goal is to avoid over-coordination: some operations may proceed without being placed in a global strict order against every other operation, while operations that must protect an invariant still receive stronger ordering guarantees. The CIDR 2026 paper, “Event Horizon: Asymmetric Dependencies for Fast Geo-Distributed Operations”, introduces the formal model. The terms strong, weak, and semi are useful explanatory categories, but should not be treated as a substitute for the paper’s formal semantics.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsHow can it cut coordination without breaking invariants?
The key is to model dependencies between operations, not to label all writes as either safe or unsafe. If an operation can execute without a global order against unrelated operations, it may use a weaker path. If another operation relies on the state those operations create, it may need a stronger path and a mechanism to account for the dependencies.
#1 Best Overall
DeMon demonstrates this design with two paths:
- Strong operations: replicated through a consensus protocol, OmniPaxos, which orders the log of strong operations.
- Weak operations: disseminated through reliable causal broadcast. A receiving replica executes a weak operation and can answer locally before asynchronous replication completes.
Replicas track weak operations with counters. Vector-clock-style watermarks summarize that state and act as synchronization barriers between the paths. The important ordering direction in the paper is that weak operations must be ordered after strong operations that happened before them. Watermarks help maintain this relationship; they should not be interpreted as a universal guarantee that a strong operation has seen every weak update at every replica.
Which operations need linearizability?
That depends on the application’s invariants and dependency graph, not just on whether an operation is a read or a write. An operation may be a candidate for weaker coordination when its correctness does not depend on a single global order against other concurrent operations. An operation that settles shared state or makes a consequential decision may need stronger ordering.
Auction example
In the paper’s illustrative auction workload, individual Bid operations can be weak when their dependencies permit it, while CloseAuction is strong because closing must resolve the relevant bidding state consistently. This is an example of asymmetric dependencies: bids need not necessarily be put into one global order against every other bid, but closing must account for the state relevant to the outcome. It is not a universal prescription for auction software; the correct classification depends on the system’s rules and invariants.
A practical way to classify operations
- List the operations and invariants. Write down what must remain true after each operation, including the decisions that depend on prior state.
- Map dependency directions. Identify which operations must observe or follow which earlier operations. Do not assume that all operations depend on one another equally.
- Choose coordination only after mapping dependencies. Treat weaker coordination as a candidate only where the application’s required ordering permits it; retain stronger ordering for operations whose correctness depends on resolving shared state.
- Check the cross-path behavior. Verify how the system tracks and enforces dependencies between weak and strong operations, including what a response means before asynchronous replication completes.
This is a design framework, not a tested migration recipe or a guarantee that a particular application can remove a specific share of its coordination.
Rank #3
How does this differ from coordinating every operation?
Uniform strict coordination applies the same broad ordering burden to all operations. SL instead uses operation-specific dependencies to decide where coordination is necessary. The comparison is about the design and coordination path, not a ranking of consistency models across every workload.
| Design question | Uniform strict coordination | Semi-Linearizability as demonstrated by DeMon |
|---|---|---|
| Which operations are coordinated? | Operations share a strict ordering approach. | Strong operations use consensus; weak operations use reliable causal broadcast, based on their dependency requirements. |
| Can an operation be answered locally? | The supplied study does not establish a general local-response rule for this category. | DeMon can answer a weak operation at the receiving replica before asynchronous replication. |
| How are dependencies across paths handled? | Not specified as a distinct cross-path mechanism in the comparison presented here. | Replica counters and vector-clock-style watermarks help connect the weak and strong paths. |
| What is the main cost? | Potentially coordinating operations whose dependencies do not require the same strict order. | More complex operation classification and dependency handling; incorrect classification can undermine invariants. |
What did the DeMon evaluation show?
The CIDR 2026 paper evaluated DeMon across five regions—US-East, Finland, Brazil, US-West, and Singapore—using standard RUBiS extended with CloseAuction. In that workload, the paper reports that Bid, which it treats as a weak operation under SL, accounted for 60% of update operations.
- The paper reports sub-millisecond latency for more than 75% of the evaluated workload. This is a result for the described five-region RUBiS evaluation, not a general deployment guarantee.
- The paper abstract reports four orders of magnitude lower latency on the most frequent RUBiS operation than state-of-the-art systems. This claim is specific to that operation and the paper’s experimental comparison; it does not establish a general production speedup.
- Strong operations have materially different latency behavior from weak operations in the evaluation, so the overall result should not be read as a latency promise for every operation.
The primary details and workload are in the CIDR 2026 paper; its abstract is also available in the TU Delft Repository record.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
What are the trade-offs?
- Weaker immediate visibility: a weak operation may be answered locally before asynchronous replication, so that response does not mean every replica has already received it.
- More design and implementation work: the application must identify dependencies, classify operations correctly, and maintain the cross-path ordering the invariants require.
- Misclassification is a correctness risk: if an operation is assigned weaker coordination despite depending on an order the system does not preserve, the intended invariant may fail.
- Workload sensitivity: the reported gains reflect a specific benchmark, operation mix, and five-region setup. They do not establish how much coordination or latency another system can eliminate.
The DEV Community overview offers an accessible introduction; the CIDR paper remains the source for the formal model and DeMon’s mechanisms.
Quick Recap
Best Value
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
