iTechGuides is reader-supported. When you buy through links on our site, we may earn an affiliate commission. As an Amazon Associate I earn from qualifying purchases. Learn more
Semi-Linearizability (SL) is a consistency model that uses linearizability only where an application’s operation dependencies require it. Instead of coordinating every operation in one global order, a system can let some operations execute locally and asynchronously replicate them, while coordinating decisive operations that must resolve shared state. The goal is to reduce unnecessary coordination without sacrificing the invariants the application depends on—not to make every write safe without coordination.
Why cut coordination at the operation level?
In a geo-distributed system, replicas in different regions need to keep application state consistent despite network delays. A uniform, strict ordering policy can require coordination across regions even for operations that do not depend on one another in a way that matters to the application’s rules. That coordination can add latency.
| # | Preview | Product | Price | |
|---|---|---|---|---|
| 1 |
|
Distributed Systems | $32.68 | Buy on Amazon |
| 2 |
|
Understanding Distributed Systems, Second Edition: What every developer should know about large... | $31.50 | 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 |
Semi-Linearizability addresses this by expressing ordering relationships between application operations. The system can then choose coordination appropriate to those dependencies. The CIDR 2026 paper introducing SL describes its aim as executing operations with linearizability guarantees “only when strictly necessary,” to avoid over-coordination. Read the CIDR 2026 paper, “Event Horizon: Asymmetric Dependencies for Fast Geo-Distributed Operations”.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →That distinction matters: SL is not a blanket eventual-consistency policy, nor a promise that every operation can skip coordination. An operation can run with weaker coordination only if the required dependencies and invariants remain intact.
#1 Best Overall
What does semi-linearizability mean?
Linearizability gives operations the effect of taking place atomically at a single point in time, in an order consistent with real-time precedence. It is a strong guarantee, but enforcing one global order can make operations wait for coordination that their application-level dependencies may not require.
SL makes the ordering requirements of operations explicit. Some operations need a strict order with other operations; others can tolerate a less restrictive relationship. The paper’s formal model defines the semantics. The labels “strong,” “weak,” and “semi” or “intermediate” are useful explanatory categories, but they should not be treated as a complete specification of the model.
| Operation category | Intended ordering treatment | What to check |
|---|---|---|
| Strong | Requires linearizable coordination with relevant operations. | Identify which invariant or dependency requires a decisive, coordinated result. |
| Weak | Can use a less restrictive path when its dependencies permit it. | Confirm what may be temporarily invisible elsewhere and what must already have happened before it. |
| Semi or intermediate | An explanatory label for guarantees between the strong and weak cases; the exact requirements depend on the formal model. | Specify the ordering relationships rather than relying on the label alone. |
These categories are not interchangeable with familiar consistency-model names. To determine whether an operation can use a weaker path, start from the application’s invariants and dependencies, then apply SL’s formal semantics.
How does DeMon implement the idea?
The paper demonstrates SL with DeMon, a geo-replicated, in-memory prototype. It separates strong and weak operations into different paths rather than making every operation pass through the same coordination mechanism.
Strong operations use consensus
DeMon uses OmniPaxos consensus to replicate the log of strong operations. This path supplies the coordinated ordering needed for operations whose effects must be resolved consistently.
Weak operations use reliable causal broadcast
DeMon disseminates weak operations through reliable causal broadcast. A receiving replica executes a weak operation and can answer locally before asynchronous replication completes. This can avoid waiting for a global consensus round, but it also means the result is not immediately visible at every replica.
Rank #3
Watermarks connect the paths
Replicas track weak operations with counters. Vector-clock-style watermarks summarize that state and serve as synchronization barriers between the paths. They help maintain the dependencies required by the model; they should not be interpreted as a guarantee that any strong operation has seen every weak operation everywhere.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11The direction of the dependency is important: the paper says weak operations must be ordered after strong operations that happened before them. Watermarks are part of maintaining that relationship while the system avoids consensus for every operation. The paper describes DeMon’s protocol and dependency handling.
Which operations might need linearizability?
The paper uses an auction workload to show how operation requirements can differ. A bid can be weak when its dependencies allow it; closing the auction is strong because it must settle the relevant bidding state. The example illustrates asymmetric dependencies: bids need not all be placed in one global order against every other bid, while closing must resolve the state relevant to the outcome.
This is an example of the model, not a general prescription for auction software. A real system would need to define exactly what counts as a valid bid, how concurrent bids are treated, and what state closing must include. If the proposed weak path can violate any of those rules, the classification is wrong or the dependency design is incomplete.
How to assess whether an operation can use a weaker path
Make the correctness requirements explicit before selecting a coordination mechanism. A useful design sequence is:
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
- List application operations. Include ordinary updates as well as boundary operations such as closing, committing, or finalizing a result.
- State the invariants. Write down what must never happen, such as finalizing an outcome that omits a prior relevant update.
- Draw dependency directions. For each operation, identify which earlier operations must be reflected in its execution and which operations need not be globally ordered against one another.
- Assign coordination requirements. Use the formal SL model to decide which operations require linearizable treatment and which can use weaker coordination without violating those dependencies.
- Check visibility and concurrency cases. Trace what a replica may return before asynchronous dissemination finishes, and what a later strong operation is required to observe.
- Validate the protocol against the invariants. Treat operation classification as a correctness decision, not just a latency optimization; test concurrent and delayed-delivery cases against the stated requirements.
This is a reasoning framework, not a migration recipe or a guarantee that a particular share of operations can avoid coordination. The answer depends on the application’s dependency graph and the protocol used to enforce it.
Best Value
What are the trade-offs?
- Visibility can lag across replicas. A weak operation may be answered locally before it has been replicated asynchronously, so another region may not immediately reflect it.
- Correctness shifts into the operation model. Misclassifying an operation or omitting a required dependency can break an invariant. The fact that an operation is frequent does not by itself make it safe to weaken.
- There is more protocol complexity. Separate paths, dependency tracking, watermarks, and reconciliation require careful design and validation.
- Latency differs by operation. Avoiding consensus may benefit weak operations, but strong operations still need their coordinated path and can have materially different latency behavior.
SL is most relevant when an application’s operations have genuinely asymmetric dependencies and the cost of coordinating every operation is significant. If the invariants require a single strict order across all operations, dividing them into weaker and stronger paths may not help.
What did the DeMon evaluation show?
The CIDR 2026 paper evaluated DeMon on a five-region setup—US-East, Finland, Brazil, US-West, and Singapore—using standard RUBiS extended with a CloseAuction operation. In that described workload, Bid was classified as weak and accounted for 60% of update operations.
- The paper reports sub-millisecond latency for more than 75% of the evaluated workload.
- Its abstract reports four orders of magnitude lower latency on the most frequent RUBiS operation than state-of-the-art systems.
These are results for the paper’s benchmark and comparison, not a general production speedup or a prediction for other workloads, network layouts, or implementations. Strong and weak operations have different latency behavior, so the aggregate result should not be read as saying every operation was sub-millisecond. See the paper’s evaluation and its TU Delft Repository record and abstract.
How should you interpret the model?
Semi-Linearizability is a way to align coordination with application dependencies: coordinate operations that must establish a strict result, and consider less restrictive execution for operations whose invariants permit it. DeMon shows one design using consensus, reliable causal broadcast, and watermarks to connect the paths. Whether the approach is appropriate depends on being able to specify and preserve the required ordering precisely—not simply on wanting faster writes.
For an accessible introduction alongside the formal paper, see Nainik Mehta’s DEV Community explainer on Semi-Linearizability.
Quick Recap
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.
