On abstraction and compositionality for weak-memory linearisability

@inproceedings{Dongol2018OnAA,
  title={On abstraction and compositionality for weak-memory linearisability},
  author={Brijesh Dongol and Radha Jagadeesan and James Riely and Alasdair Armstrong},
  booktitle={VMCAI},
  year={2018}
}
Linearisability is the de facto standard correctness condition for concurrent objects. Classical linearisability assumes that the effect of a method is captured entirely by the allowed sequences of calls and returns. This assumption is inadequate in the presence of relaxed memory models, where happens-before relations are also of importance. 
Weakening Correctness and Linearizability for Concurrent Objects on Multicore Processors
TLDR
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.
Linearizability on hardware weak memory models
TLDR
An overview of this research is provided and it is shown that under an interpretation of specification behaviour which abstracts from weak memory effects, the standard definition of linearizability is sound and complete on all hardware weak memory models.
A sound and complete definition of linearizability on weak memory models
TLDR
This paper explains why the original definition of linearizability is not applicable to code running on the weak memory models supported by modern multicore architectures, and provides an alternative definition which is applicable and proved to be both sound and complete.
Making Linearizability Compositional for Partially Ordered Executions
TLDR
This paper presents a generalisation of linearizability for concurrent objects implemented in weak-memory models, an adaptation of simulation-based methods by defining a condition using Lamport’s execution structures and applying it to the C11 memory model, providing a correctness condition for C11 objects.
Causal Linearizability: Compositionality for Partially Ordered Executions
TLDR
This paper presents causal linearizability, a correctness condition for concurrent objects implemented in weak-memory models, abstracts from the details of specific memory models by defining the condition using Lamport's execution structures, and applies it to the C11 memory model, providing a Correctness condition for C11 objects.
Correctness of Concurrent Objects under Weak Memory Models
TLDR
This paper develops a theory for correctness of concurrent objects under weak memory models that enforces the minimal constraints on the placing of observations and on the semantics of objects that underlie object refinement.
Verifying C11-style weak memory libraries
TLDR
This work develops a simple framework for specifying abstract objects that precisely characterises the observability guarantees of abstract method calls and implements such abstractions in RC11 RAR by developing a (contextual) refinement framework for abstract objects.
Verifying C11-Style Weak Memory Libraries via Refinement
TLDR
This paper develops a simple framework for specifying abstract objects that precisely characterises the observability guarantees of abstract method calls, and shows how this framework can be integrated with an operational semantics that enables verification of client programs that execute abstract method Calls from a library they use.
Verifying Visibility-Based Weak Consistency
TLDR
This work develops a methodology for proving that concurrent object implementations adhere to weak-consistency specifications, and considers (forward) simulation-based proofs of implementations against relaxed-visibility specifications, which allow designated operations to overlook some of their linearization-order predecessors.
Compass: strong and compositional library specifications in relaxed memory separation logic
TLDR
This work combines logical atomicity together with richer partial orders to develop stronger specifications in the weaker memory model of Repaired C11 (RC11), and reports the first mechanized verifications of relaxed-memory implementations for the exchanger, the elimination stack, and the Herlihy-Wing queue.
...
...

References

SHOWING 1-10 OF 29 REFERENCES
Quarantining Weakness - Compositional Reasoning under Relaxed Memory Models (Extended Abstract)
TLDR
The notion of linearizability simplifies reasoning in a concurrent setting by intuitively ensuring that each method invocation "takes effect" between its invocation and response events.
Abstraction for concurrent objects
Linearizability and Causality
Most work on the verification of concurrent objects for shared memory assumes sequential consistency, but most multicore processors support only weak memory models that do not provide sequential
An Observational Approach to Defining Linearizability on Weak Memory Models
TLDR
A framework for defining linearizability on weak memory models is presented, which is defined within the framework in terms of memory order as opposed to program order, to be able to define the correctness of concurrent algorithms in a uniform way across a variety of memory models.
Concurrent Library Correctness on the TSO Memory Model
TLDR
This paper presents the first definition of linearizability on a weak memory model, Total Store Order (TSO), implemented by x86 processors and establishes that the definition is a correct one in the following sense: while proving a property of a client of a concurrent library, it can soundly replace the library by its abstract implementation related to the original one by the generalisation oflinearizability.
Liveness-Preserving Atomicity Abstraction
TLDR
It is shown that, while proving a liveness property of a client using a concurrent library, one can soundly replace the library by another one related to the original library by a generalisation of a well-known notion of linearizability.
Library abstraction for C/C++ concurrency
TLDR
This paper proposes a criterion for sound library abstraction in the new C11 and C++11 memory model, generalising the standard sequentially consistent notion of linearizability, and proves that it soundly captures all client-library interactions, both through call and return values, and through the subtle synchronisation effects arising from the memory model.
Verifying Linearizability on TSO Architectures
TLDR
This paper defines linearizability on a weak memory model: the TSO (Total Store Order) memory model, which is implemented in the x86 multicore architecture, and presents the first proof method, to the knowledge, for proving correctness without the need for modification to the algorithm’s natural abstract specification.
Deny-Guarantee Reasoning
TLDR
This paper builds on ideas from separation logic to allow interference to be dynamically split and recombined, in a similar way that separation logic splits and joins heaps, and introduces deny-guarantee reasoning, a reformulation of rely-GUarantee that enables reasoning about dynamically scoped concurrency.
Simplifying ARM concurrency: multicopy-atomic axiomatic and operational models for ARMv8
TLDR
Two formal concurrency models are defined: an operational one, simplifying the Flowing model of Flur et al., and the axiomatic model of the revised ARMv8 specification, and it is proved the equivalence of the two models.
...
...