Strongly Linearizable Implementations of Snapshots and Other Types

Ovens, Sean; Woelfel, Philipp

doi:10.1145/3293611.3331632

Cited by 10 publications

(4 citation statements)

References 30 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The equivalence to the well-studied notion of forward simulation immediately implies methods for composing concurrent objects, in particular, locality and instantiation. This stands in contrast to the effort needed to prove similar results in [14] and [19].…”

Section: Related Work and Discussionmentioning

confidence: 78%

Putting Strong Linearizability in Context: Preserving Hyperproperties in Programs that Use Concurrent Objects

Attiya,

Enea

2019

Preprint

View full text Add to dashboard Cite

It has been observed that linearizability, the prevalent consistency condition for implementing concurrent objects, does not preserve some probability distributions. A stronger condition, called strong linearizability has been proposed, but its study has been somewhat ad-hoc. This paper investigates strong linearizability by casting it in the context of observational refinement of objects. We present a strengthening of observational refinement, which generalizes strong linearizability, obtaining several important implications.When a concrete concurrent object refines another, more abstract object-often sequential-the correctness of a program employing the concrete object can be verified by considering its behaviors when using the more abstract object. This means that trace properties of a program using the concrete object can be proved by considering the program with the abstract object. This, however, does not hold for hyperproperties, including many security properties and probability distributions of events.We define strong observational refinement, a strengthening of refinement that preserves hyperproperties, and prove that it is equivalent to the existence of forward simulations. We show that strong observational refinement generalizes strong linearizability. This implies that strong linearizability is also equivalent to forward simulation, and shows that strongly linearizable implementations can be composed both horizontally (i.e., locality) and vertically (i.e., with instantiation).For situations where strongly linearizable implementations do not exist (or are less efficient), we argue that reasoning about hyperproperties of programs can be simplified by strong observational refinement of non-atomic abstract objects.

show abstract

Section: Related Work and Discussionmentioning

confidence: 78%

Putting Strong Linearizability in Context: Preserving Hyperproperties in Programs that Use Concurrent Objects

Attiya,

Enea

2019

Preprint

View full text Add to dashboard Cite

show abstract

“…Proving an error bound for an efficient parallel implementation of the CM sketch for existing criteria is not trivial. Using the framework defined by Rinberg et al [32] requires the query to take a strongly linearizable snapshot of the matrix [29]. Distributional linearizability [2] necessitates an analysis of the error bounds directly in the concurrent setting, without leveraging the sketch's existing analysis for the sequential setting.…”

Section: Atomically Increment C[i][h I (A)]mentioning

confidence: 99%

Intermediate Value Linearizability: A Quantitative Correctness Criterion

Rinberg

Keidar

2023

J. ACM

View full text Add to dashboard Cite

Big data processing systems often employ batched updates and data sketches to estimate certain properties of large data. For example, a CountMin sketch approximates the frequencies at which elements occur in a data stream, and a batched counter counts events in batches. This paper focuses on correctness criteria for concurrent implementations of such objects. Specifically, we consider quantitative objects, whose return values are from an ordered domain, with a particular emphasis on (ϵ, δ )-bounded objects that estimate a numerical quantity with an error of at most ϵ with probability at least 1 − δ . The de facto correctness criterion for concurrent objects is linearizability. Intuitively, under linearizability, when a read overlaps an update, it must return the object’s value either before the update or after it. Consider, for example, a single batched increment operation that counts three new events, bumping a batched counter’s value from 7 to 10. In a linearizable implementation of the counter, a read overlapping this update must return either 7 or 10. We observe, however, that in typical use cases, any intermediate value between 7 and 10 would also be acceptable. To capture this additional degree of freedom, we propose Intermediate Value Linearizability (IVL) , a new correctness criterion that relaxes linearizability to allow returning intermediate values, for instance 8 in the example above. Roughly speaking, IVL allows reads to return any value that is bounded between two return values that are legal under linearizability. A key feature of IVL is that we can prove that concurrent IVL implementations of (ϵ, δ )-bounded objects are themselves (ϵ, δ )-bounded. To illustrate the power of this result, we give a straightforward and efficient concurrent implementation of an (ϵ, δ )-bounded CountMin sketch, which is IVL (albeit not linearizable). We present four examples for IVL objects, each showcasing a different way of using IVL. The first is a simple wait-free IVL batched counter, with O (1) step complexity for update. The next considers an (ϵ, δ )-bounded CountMin sketch, and further shows how to relax IVL using the notion of r -relaxation. Our third example is a non-atomic iterator over a data structure. In this example, we augment the data structure with an auxiliary history variable state that includes “tombstones” for items deleted from the data structure. Here, IVL semantics are required at the augmented level. Finally, using a priority queue , we show that some objects require IVL to be paired with other correctness criteria; indeed a natural correctness notion for a concurrent priority queue is IVL coupled with sequential consistency. Lastly, we show that IVL allows for inherently cheaper implementations than linearizable ones. In particular, we show a lower bound of Ω ( n ) on the step complexity of the update operation of any wait-free linearizable batched counter from single-writer multi-reader registers, which is more expensive than our O (1) IVL implementation.

show abstract

“…When updates are strongly linearizable, objects have nonblocking strongly-linearizable implementations from multi-writer registers [8]. The space requirements of the latter implementation is avoided in a nonblocking strongly-linearizable implementation of snapshots [23]. This snapshot implementation is then employed with an algorithm of [2] to get a nonblocking strongly-linearizable universal implementation of any object in which all operations either commute or overwrite.…”

Section: An Implementation Of Safe Agreementmentioning

confidence: 99%

Impossibility of Strongly-Linearizable Message-Passing Objects via Simulation by Single-Writer Registers

Attiya¹,

Constantin²,

Welch³

2021

Preprint

View full text Add to dashboard Cite

A key way to construct complex distributed systems is through modular composition of linearizable concurrent objects. A prominent example is shared registers, which have crash-tolerant implementations on top of message-passing systems, allowing the advantages of shared memory to carry over to message-passing. Yet linearizable registers do not always behave properly when used inside randomized programs. A strengthening of linearizability, called strong linearizability, has been shown to preserve probabilistic behavior, as well as other "hypersafety" properties. In order to exploit composition and abstraction in message-passing systems, it is crucial to know whether there exist strongly-linearizable implementations of registers in message-passing. This paper answers the question in the negative: there are no strongly-linearizable fault-tolerant message-passing implementations of multi-writer registers, max-registers, snapshots or counters. This result is proved by reduction from the corresponding result by Helmi et al. The reduction is a novel extension of the BG simulation that connects shared-memory and message-passing, supports long-lived objects, and preserves strong linearizability. The main technical challenge arises from the discrepancy between the potentially miniscule fraction of failures to be tolerated in the simulated message-passing algorithm and the large fraction of failures that can afflict the simulating shared-memory system. The reduction is general and can be viewed as the reverse of the ABD simulation of shared memory in message-passing.

show abstract

Strongly Linearizable Implementations of Snapshots and Other Types

Cited by 10 publications

References 30 publications

Putting Strong Linearizability in Context: Preserving Hyperproperties in Programs that Use Concurrent Objects

Putting Strong Linearizability in Context: Preserving Hyperproperties in Programs that Use Concurrent Objects

Intermediate Value Linearizability: A Quantitative Correctness Criterion

Impossibility of Strongly-Linearizable Message-Passing Objects via Simulation by Single-Writer Registers

Contact Info

Product

Resources

About