Liveness-Preserving Atomicity Abstraction

Gotsman, Alexey; Yang, Hongseok

doi:10.1007/978-3-642-22012-8_36

Cited by 36 publications

(45 citation statements)

References 16 publications

(30 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…All the definitions of linearizability proposed for various settings so far [11,8,10,9] have assumed a sequentially consistent memory model. This paper is the first to define a notion of linearizability on a weak memory model and show that it validates the Abstraction Theorem (Theorem 4).…”

Section: Related Work and Conclusionmentioning

confidence: 99%

Concurrent Library Correctness on the TSO Memory Model

Burckhardt

Gotsman

Musuvathi

et al. 2012

Programming Languages and Systems

Self Cite

View full text Add to dashboard Cite

Abstract. Linearizability is a commonly accepted notion of correctness for libraries of concurrent algorithms. Unfortunately, it is only appropriate for sequentially consistent memory models, while the hardware and software platforms that algorithms run on provide weaker consistency guarantees. In this paper, we present the first definition of linearizability on a weak memory model, Total Store Order (TSO), implemented by x86 processors. We establish that our definition is a correct one in the following sense: while proving a property of a client of a concurrent library, we can soundly replace the library by its abstract implementation related to the original one by our generalisation of linearizability. This allows abstracting from the details of the library implementation while reasoning about the client. We have developed a tool for systematically testing concurrent libraries against our definition and applied it to several challenging algorithms.

show abstract

Section: Related Work and Conclusionmentioning

confidence: 99%

Concurrent Library Correctness on the TSO Memory Model

Burckhardt

Gotsman

Musuvathi

et al. 2012

Programming Languages and Systems

Self Cite

View full text Add to dashboard Cite

show abstract

“…We hope to lift this restriction by combining our results with a recent generalisation of classical linearizability allowing transfers of memory ownership [9]. Similarly, a previous generalisation of linearizability to handle liveness properties [8] could be used to strengthen specifications of the kind shown in Figure 1a to guarantee properties such as lock-freedom.…”

Section: Discussionmentioning

confidence: 88%

“…Recent work has formalised the intuition that linearizability corresponds to observational abstraction [6] and has extended it to handle liveness [8], resource-transferring programs [9] and the x86 memory model [4]. The latter work is the closest to this paper; in particular, we borrow the decompose-compose approach in the proof of the Abstraction Theorem ( §6.3) from it.…”

Section: Related Workmentioning

confidence: 99%

Library abstraction for C/C++ concurrency

Batty

Dodds

Gotsman

2013

Proceedings of the 40th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages

Self Cite

View full text Add to dashboard Cite

When constructing complex concurrent systems, abstraction is vital: programmers should be able to reason about concurrent libraries in terms of abstract specifications that hide the implementation details. Relaxed memory models present substantial challenges in this respect, as libraries need not provide sequentially consistent abstractions: to avoid unnecessary synchronisation, they may allow clients to observe relaxed memory effects, and library specifications must capture these.In this paper, we propose a criterion for sound library abstraction in the new C11 and C++11 memory model, generalising the standard sequentially consistent notion of linearizability. We prove that our criterion soundly captures all client-library interactions, both through call and return values, and through the subtle synchronisation effects arising from the memory model. To illustrate our approach, we verify implementations against specifications for the lock-free Treiber stack and a producer-consumer queue. Ours is the first approach to compositional reasoning for concurrent C11/C++11 programs.

show abstract

“…Gotsman and Yang [6] propose a new linearizability definition that preserves lock-freedom, and suggest a connection between lock-freedom and a terminationsensitive contextual refinement. We do not redefine linearizability here.…”

Section: Related Work and Conclusionmentioning

confidence: 99%

“…To obtain equivalence to linearizability, the observable behaviors include I/O events but not divergence (i.e., non-termination). Recently, Gotsman and Yang [6] showed that a client program that diverges using a linearizable and lock-free object must also diverge when using the abstract operations instead. Their work reveals a connection between lock-freedom and a form of contextual refinement which preserves termination as well as safety properties.…”

Section: Introductionmentioning

confidence: 99%

Characterizing Progress Properties of Concurrent Objects via Contextual Refinements

Liang

Hoffmann

Feng

et al. 2013

CONCUR 2013 – Concurrency Theory

View full text Add to dashboard Cite

Abstract. Implementations of concurrent objects should guarantee linearizability and a progress property such as wait-freedom, lock-freedom, obstruction-freedom, starvation-freedom, or deadlock-freedom. Conventional informal or semi-formal definitions of these progress properties describe conditions under which a method call is guaranteed to complete, but it is unclear how these definitions can be utilized to formally verify system software in a layered and modular way. In this paper, we propose a unified framework based on contextual refinements to show exactly how progress properties affect the behaviors of client programs. We give formal operational definitions of all common progress properties and prove that for linearizable objects, each progress property is equivalent to a specific type of contextual refinement that preserves termination. The equivalence ensures that verification of such a contextual refinement for a concurrent object guarantees both linearizability and the corresponding progress property. Contextual refinement also enables us to verify safety and liveness properties of client programs at a high abstraction level by soundly replacing concrete method implementations with abstract atomic operations.

show abstract

Liveness-Preserving Atomicity Abstraction

Cited by 36 publications

References 16 publications

Concurrent Library Correctness on the TSO Memory Model

Concurrent Library Correctness on the TSO Memory Model

Library abstraction for C/C++ concurrency

Characterizing Progress Properties of Concurrent Objects via Contextual Refinements

Contact Info

Product

Resources

About