Comparison Under Abstraction for Verifying Linearizability

Amit, Daphna; Rinetzky, Noam; Reps, Thomas; Sagiv, Mooly; Yahav, Eran

doi:10.1007/978-3-540-73368-3_49

Cited by 92 publications

(116 citation statements)

References 17 publications

Supporting

Mentioning

115

Contrasting

Order By: Relevance

“…We further show that we can use existing tools for proving classical linearizability (e.g., [16,2]) to establish our generalisation. To this end, we identify a class of linearization-closed properties that, when satisfied by a library, are also satisfied by any other library linearizing it.…”

Section: Introductionmentioning

confidence: 92%

“…We use this in §5 to harness existing linearizability checkers in reasoning about liveness properties. The linearizability of concurrent libraries according to the classical definition can be established using several logics and tools, e.g., based on separation logic [16,15] or TVLA [2]. These logics and tools reduce showing linearizability to proving an invariant relating the states of the implementation and the sequential specification.…”

Section: Concurrent Library Semantics and Linearizabilitymentioning

confidence: 99%

“…More precisely, assume a specification of the effect of every method m in a library A 1 given as a command c m ; return(E m ) for some c m ∈ PComm. Then the tools in [16,15,2] …”

Section: Concurrent Library Semantics and Linearizabilitymentioning

confidence: 99%

See 2 more Smart Citations

Liveness-Preserving Atomicity Abstraction

Gotsman

Yang

2011

Automata, Languages and Programming

View full text Add to dashboard Cite

Abstract. Modern concurrent algorithms are usually encapsulated in libraries, and complex algorithms are often constructed using libraries of simpler ones. We present the first theorem that allows harnessing this structure to give compositional liveness proofs to concurrent algorithms and their clients. We show that, while proving a liveness property of a client using a concurrent library, we can soundly replace the library by another one related to the original library by a generalisation of a well-known notion of linearizability. We apply this result to show formally that lock-freedom, an often-used liveness property of non-blocking algorithms, is compositional for linearizable libraries, and provide an example illustrating our proof technique.

show abstract

Section: Introductionmentioning

confidence: 92%

Section: Concurrent Library Semantics and Linearizabilitymentioning

confidence: 99%

See 1 more Smart Citation

Liveness-Preserving Atomicity Abstraction

Gotsman

Yang

2011

Automata, Languages and Programming

View full text Add to dashboard Cite

show abstract

“…Amit et al [3] verify linearizability by verifying conformance to an abstract specification, which is the same as the implementation, but restricted to serialized executions. They build a specialized abstract domain that correlates the state (including the heap cells) of a concrete thread and the state of the serialized version, and a sequential reference data structure.…”

Section: Introductionmentioning

confidence: 99%

An Integrated Specification and Verification Technique for Highly Concurrent Data Structures

Abdulla

Haziza

Holík

et al. 2013

Tools and Algorithms for the Construction and Analysis of Systems

View full text Add to dashboard Cite

Abstract. We present a technique for automatically verifying safety properties of concurrent programs, in particular programs which rely on subtle dependencies of local states of different threads, such as lock-free implementations of stacks and queues in an environment without garbage collection. Our technique addresses the joint challenges of infinite-state specifications, an unbounded number of threads, and an unbounded heap managed by explicit memory allocation. Our technique builds on the automata-theoretic approach to model checking, in which a specification is given by an automaton that observes the execution of a program and accepts executions that violate the intended specification. We extend this approach by allowing specifications to be given by a class of infinite-state automata. We show how such automata can be used to specify queues, stacks, and other data structures, by extending a data-independence argument. For verification, we develop a shape analysis, which tracks correlations between pairs of threads, and a novel abstraction to make the analysis practical. We have implemented our method and used it to verify programs, some of which have not been verified by any other automatic method before.

show abstract

“…For example, [20], unlike this work and [8], considered only a bounded heap. Static analysis methods based on shape analysis [3,23] are not completely automated. A recent approach by [26] automatically is able to linearizability for unbounded heaps and threads but, reports limited success with concurrent lists.…”

Section: Introductionmentioning

confidence: 99%

Quantitative Synthesis for Concurrent Programs

Černý

Chatterjee

Henzinger

et al. 2011

Computer Aided Verification

View full text Add to dashboard Cite

We present an algorithmic method for the synthesis of concurrent programs that are optimal with respect to quantitative performance measures. The input consists of a sequential sketch, that is, a program that does not contain synchronization constructs, and of a parametric performance model that assigns costs to actions such as locking, context switching, and idling. The quantitative synthesis problem is to automatically introduce synchronization constructs into the sequential sketch so that both correctness is guaranteed and worst-case (or average-case) performance is optimized. Correctness is formalized as race freedom or linearizability.We show that for worst-case performance, the problem can be modeled as a 2-player graph game with quantitative (limit-average) objectives, and for average-case performance, as a 2 1 2 -player graph game (with probabilistic transitions). In both cases, the optimal correct program is derived from an optimal strategy in the corresponding quantitative game. We prove that the respective game problems are computationally expensive (NP-complete), and present several techniques that overcome the theoretical difficulty in cases of concurrent programs of practical interest.We have implemented a prototype tool and used it for the automatic synthesis of programs that access a concurrent list. For certain parameter values, our method automatically synthesizes various classical synchronization schemes for implementing a concurrent list, such as fine-grained locking or a lazy algorithm. For other parameter values, a new, hybrid synchronization style is synthesized, which uses both the lazy approach and coarse-grained locks (instead of standard fine-grained locks). The trade-off occurs because while fine-grained locking tends to decrease the cost that is due to waiting for locks, it increases cache size requirements.

show abstract

Comparison Under Abstraction for Verifying Linearizability

Cited by 92 publications

References 17 publications

Liveness-Preserving Atomicity Abstraction

Liveness-Preserving Atomicity Abstraction

An Integrated Specification and Verification Technique for Highly Concurrent Data Structures

Quantitative Synthesis for Concurrent Programs

Contact Info

Product

Resources

About