Aspect-Oriented Linearizability Proofs

Henzinger, Thomas A.; Sezgin, Ali; Vafeiadis, Viktor

doi:10.1007/978-3-642-40184-8_18

Cited by 51 publications

(70 citation statements)

References 14 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Our stack theorem lets us prove that the TS stack is linearizable with respect to sequential stack semantics. This theorem builds on Henzinger et al who have a similar theorem for queues [11]. Their theorem is defined (almost) entirely in terms of the sequential order on methodswhat we call precedence, pr.…”

Section: Related Workmentioning

confidence: 87%

“…Our stack theorem (Theorem 1) builds on a similar theorem for queues proved by Henzinger et al [11]. As with our definition of order-correctness (Definition 5), their theorem forbids certain bad orderings between operations.…”

Section: Stacks and Insert-remove Ordermentioning

confidence: 89%

“…Henzinger et al [11] have just such a set of conditions for queues. (They call this approach aspect-oriented).…”

Section: Specification-specific Conditions (Aka Aspects)mentioning

confidence: 99%

“…We have developed stack conditions sufficient to ensure linearizability with respect to Stack. Unlike [11], our conditions are not expressed using only pr (indeed, we believe this would be impossible -see supplementary Appendix C). Rather we require an auxiliary insertremove order ir which relates pushes to pops and vice versa, but that does not order pairs of pushes or pairs of pops.…”

Section: Specification-specific Conditions (Aka Aspects)mentioning

confidence: 99%

“…In the absence of pop operations, elements can remain entirely unordered. We solve this with a new theorem (mechanised in the Isabelle proof assistant) which builds on Henzinger et al's aspect oriented technique [11]. Rather than a total order, we need only generate an order from push to pop operations, and vice versa, which avoids certain violations.…”

Section: Introductionmentioning

confidence: 99%

See 4 more Smart Citations

A Scalable, Correct Time-Stamped Stack

2015

View full text Add to dashboard Cite

Concurrent data-structures, such as stacks, queues, and deques, often implicitly enforce a total order over elements in their underlying memory layout. However, much of this order is unnecessary: linearizability only requires that elements are ordered if the insert methods ran in sequence. We propose a new approach which uses timestamping to avoid unnecessary ordering. Pairs of elements can be left unordered (represented by unordered timestamps) if their associated insert operations ran concurrently, and order imposed as necessary by the eventual remove operations.We realise our approach in a new non-blocking datastructure, the TS (timestamped) stack. In experiments on x86, the TS stack outperforms and outscales all its competitors -for example, it outperforms the elimination-backoff stack by factor of two. In our approach, more concurrency translates into less ordering, giving less-contended removal and thus higher performance and scalability. Despite this, the TS stack is linearizable with respect to stack semantics.The weak internal ordering in the TS stack presents a challenge when establishing linearizability: standard techniques such as linearization points work well when there exists a total internal order. We present a new stack theorem, mechanised in Isabelle, which characterises the orderings sufficient to establish stack semantics. By applying our stack theorem, we show that the TS stack is indeed correct. Our theorem constitutes a new, generic proof technique for concurrent stacks, and it paves the way for future weaklyordered data-structure designs.

show abstract

Section: Related Workmentioning

confidence: 87%

Section: Stacks and Insert-remove Ordermentioning

confidence: 89%

“…Henzinger et al [11] have just such a set of conditions for queues. (They call this approach aspect-oriented).…”

Section: Specification-specific Conditions (Aka Aspects)mentioning

confidence: 99%

Section: Specification-specific Conditions (Aka Aspects)mentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 3 more Smart Citations

A Scalable, Correct Time-Stamped Stack

2015

View full text Add to dashboard Cite

show abstract

Testing for linearizability

Lowe

2016

Concurrency and Computation

View full text Add to dashboard Cite

Summary Linearizability is a well established correctness condition for concurrent datatypes. Informally, a concurrent datatype is linearizable if operation calls appear to have an effect, one at a time, in an order that is consistent with a sequential (specification) datatype, with each operation taking effect between the point at which it is called and when it returns. We present a testing framework for linearizabilty. The basic idea is to generate histories of the datatype randomly, and to test whether each is linearizable. We consider five algorithms—one existing, and four new—for testing whether a history of a concurrent datatype implementation is linearizable. Four of these are generic: they will work with any concurrent datatype for which there is a corresponding sequential specification datatype. The fifth considers specifically a history of a concurrent queue. We also combine algorithms in competition parallel in various ways. We perform an experimental evaluation of the different algorithms. We illustrate that the framework is very effective in finding bugs, and discuss the pragmatics of using the framework. Copyright © 2016 John Wiley & Sons, Ltd.

show abstract

Efficient linearizability checking for actor‐based systems

Al‐Mahfoudh,

Stutsman,

Gopalakrishnan

2023

Softw Pract Exp

View full text Add to dashboard Cite

Recent demand for distributed software had led to a surge in popularity in actor‐based frameworks. However, even with the stylized message passing model of actors, writing correct distributed software is still difficult. We present our work on linearizability checking in DS2, an integrated framework for specifying, synthesizing, and testing distributed actor systems. The key insight of our approach is that often subcomponents of distributed actor systems represent common algorithms or data structures (e.g., a distributed hash table or tree) that can be validated against a simple sequential model of the system. This makes it easy for developers to validate their concurrent actor systems without complex specifications. DS2 automatically explores the concurrent schedules that system could arrive at, and it compares observed output of the system to ensure it is equivalent to what the sequential implementation could have produced. We describe DS2's linearizability checking and test it on several concurrent replication algorithms from the literature. We explore in detail how different algorithms for enumerating the model schedule space fare in finding bugs in actor systems, and we present our own refinements on algorithms for exploring actor system schedules that we show are effective in finding bugs.

show abstract

Aspect-Oriented Linearizability Proofs

Cited by 51 publications

References 14 publications

A Scalable, Correct Time-Stamped Stack

A Scalable, Correct Time-Stamped Stack

Testing for linearizability

Efficient linearizability checking for actor‐based systems

Contact Info

Product

Resources

About