Linearizability: a correctness condition for concurrent objects

@article{Herlihy1990LinearizabilityAC,
  title={Linearizability: a correctness condition for concurrent objects},
  author={Maurice Herlihy and Jeannette M. Wing},
  journal={ACM Trans. Program. Lang. Syst.},
  year={1990},
  volume={12},
  pages={463-492}
}
A concurrent object is a data object shared by concurrent processes. Linearizability is a correctness condition for concurrent objects that exploits the semantics of abstract data types. It permits a high degree of concurrency, yet it permits programmers to specify and reason about concurrent objects using known techniques from the sequential domain. Linearizability provides the illusion that each operation applied by concurrent processes takes effect instantaneously at some point between its… 

Figures from this paper

Towards linking correctness conditions for concurrent objects and contextual trace refinement

This paper presents the main issues that surround correctness conditions for concurrent objects and provides some answers by linking different correctness conditions with a form of trace refinement.

Modular Verification of Concurrency-Aware Linearizability

A thread- and procedure-modular verification technique for reasoning about CA-objects and their clients is developed and the first proof of linearizability of the elimination stack is presented, in which the stack's elimination subcomponent is specified and verified independently of its particular usage by the stack.

Weakening Correctness and Linearizability for Concurrent Objects on Multicore Processors

This paper argues that there are two fundamental ways of defining correctness of concurrent objects on the weak memory models of multicore processors: one can abstract from concurrent interleaving and weak memory effects at the specification level, or the other requires a weakening of linearizability.

Randomized wait-free concurrent objects (extended abstract)

This paper shows how to construct randomized wait-free implementations of long-lived concurrent objects, implementations that guarantee that every operation completes in a finite number of steps, even against a powerful adversary.

Speculative linearizability

This work rigorously defines speculative linearizability and proves the intra-object composition theorem in a trace-based as well as an automaton-based model, and expects this framework to enable, for the first time, scalable specifications and mechanical proofs of speculative implementations of linearizable objects.

Brief announcement: concurrency-aware linearizability

This paper presents Concurrency Aware Linearizability (CAL), a new correctness condition which allows to formally specify the behaviour of a certain class of concurrency-aware objects and believes that CAL can be used as a basis for modular formal verification techniques for concurrency -aware objects.

Mechanizing a Correctness Proof for a Lock-Free Concurrent Stack

This paper shows how to verify that a concurrent lock-free implementation of a stack is correct by mechanizing the proof that it is linearizable, linearizability being a correctness notion for concurrent objects.

Comparison Under Abstraction for Verifying Linearizability

A static analysis for verifying linearizability of concurrent unbounded linked data structures is presented and the ability to prove that two (unboundedsize) memory layouts of two programs are isomorphic in the presence of abstraction is proved.

Concurrent Specifications Beyond Linearizability

With the advent of parallel architectures, distributed programs are used intensively and the question of how to formally specify the behaviors expected from such programs becomes crucial. A very

Proving correctness of highly-concurrent linearisable objects

These examples are demonstrative of common design patterns such as lock coupling, optimistic, and lazy synchronisation, and it is proved that they are linearisable, safe, and they correctly implement a high-level abstraction.
...

References

SHOWING 1-10 OF 49 REFERENCES

Axioms for concurrent objects

This paper defines and discusses linearizability, and gives examples of how to reason about concurrent objects and verify their implementations based on their (sequential) axiomatic specifications.

Verification of concurrent programs, Part I: The temporal framework

The temporal formalism is introduced as a tool for reasoning about sequences of states and the set of interesting properties is classified into invariance (safety), eventuality (liveness, and precedence) properties.

Impossibility and universality results for wait-free synchronization

A hierarchy of objects is derived such that no object at one level has a wait-free implementation in terms of objects at lower levels, and it is shown that atomic read/write registers are at the bottom of the hierarchy: they cannot be used to constructWait-free implementations of many simple and familiar data types.

Local atomicity properties: modular concurrency control for abstract data types

This paper introduces several local constraints on individual objects that suffice to ensure global atomicity of actions and presents three local atomicity properties, each of which is optimal.

Proving monitors revisited : a first step towards verifying object oriented systems

An axiomatic characterization of monitors, based on assumption-commitment style reasoning, is given that is sound and (relatively) complete that is a first step towards the formal verification of object oriented systems.

Proving Liveness Properties of Concurrent Programs

A formal proof method, based on temporal logic, for deriving liveness properties is presented, which allows a rigorous formulation of simple informal arguments and how to reason with temporal logic and use safety (invariance) properties in proving liveness is shown.

Efficient locking for concurrent operations on B-trees

The B-tree and its variants have been found to be highly useful for storing large amounts of information, especially on secondary storage devices, and a single additional “link” pointer in each node allows a process to easily recover from tree modifications performed by other concurrent processes.

A Proof System for Communicating Sequential Processes

An axiomatic proof system is presented for proving partial correctness and absence of deadlock of communicating sequential processes, the key (meta) rule introduces cooperation between proofs, and CSP's new convention for distributed termination of loops is dealt with.

Implementing atomic actions on decentralized data

A mechanism that solves both problems of synchronization of accesses to shared data and recovering the state of such data in the case of failures simultaneously in a way that is compatible with requirements of decentralized systems is described.

An Axiomatic Treatment of a Parallel Programming Language

A semantically-based axiomatic treatment of a parallel programming language with shared variable concurrency and conditional critical regions, essentially the language discussed by Owicki and Gries, and defines sequential and parallel composition of assertions which correspond precisely to syntactic constructs of the programming language.