A calculus of atomic actions

Elmas, Tayfun; Qadeer, Shaz; Tasiran, Serdar

doi:10.1145/1480881.1480885

Cited by 84 publications

(82 citation statements)

References 27 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Out of the three techniques for memory reclamation that we consider in this paper, only restricted versions of the non-blocking stack with hazard pointers that we handle in [7, §B] have been verified: in concurrent separation logic [14], a combination of separation logic and temporal logic [6], a reduction-based tool [3] and interval temporal logic [16]. These papers use different reasoning methods from the one we propose, none of which has been grounded in a pattern common to different algorithms.…”

Section: Related Workmentioning

confidence: 99%

See 1 more Smart Citation

Verifying Concurrent Memory Reclamation Algorithms with Grace

Gotsman

Rinetzky

Yang

2013

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Abstract. Memory management is one of the most complex aspects of modern concurrent algorithms, and various techniques proposed for it-such as hazard pointers, read-copy-update and epoch-based reclamation-have proved very challenging for formal reasoning. In this paper, we show that different memory reclamation techniques actually rely on the same implicit synchronisation pattern, not clearly reflected in the code, but only in the form of assertions used to argue its correctness. The pattern is based on the key concept of a grace period, during which a thread can access certain shared memory cells without fear that they get deallocated. We propose a modular reasoning method, motivated by the pattern, that handles all three of the above memory reclamation techniques in a uniform way. By explicating their fundamental core, our method achieves clean and simple proofs, scaling even to realistic implementations of the algorithms without a significant increase in proof complexity. We formalise the method using a combination of separation logic and temporal logic and use it to verify example instantiations of the three approaches to memory reclamation.

show abstract

Section: Related Workmentioning

confidence: 99%

“…Reasoning naturally about protocols so subtle is very challenging. Out of the above algorithms, only restricted implementations of hazard pointers have been verified [14,6,3,16], and even in this case, the resulting proofs were very complicated (see §6 for discussion).…”

Section: Introductionmentioning

confidence: 99%

Verifying Concurrent Memory Reclamation Algorithms with Grace

Gotsman

Rinetzky

Yang

2013

Lecture Notes in Computer Science

View full text Add to dashboard Cite

show abstract

“…The programs include examples shown in Figure 1, 5 and 4. We also used two real world libraries, a device cache library [6] that reads data from a device and caches the data for subsequent reads, and a C implementation of the Simple Authentication and Security Layer (SASL). This library is a generic server side library that manages security context objects for user sessions.…”

Section: Methodsmentioning

confidence: 99%

Logical Concurrency Control from Sequential Proofs

Deshmukh

Ramalingam

Ranganath

et al. 2010

Programming Languages and Systems

View full text Add to dashboard Cite

Abstract. We are interested in identifying and enforcing the isolation requirements of a concurrent program, i.e., concurrency control that ensures that the program meets its specification. The thesis of this paper is that this can be done systematically starting from a sequential proof, i.e., a proof of correctness of the program in the absence of concurrent interleavings. We illustrate our thesis by presenting a solution to the problem of making a sequential library thread-safe for concurrent clients. We consider a sequential library annotated with assertions along with a proof that these assertions hold in a sequential execution. We show how we can use the proof to derive concurrency control that ensures that any execution of the library methods, when invoked by concurrent clients, satisfies the same assertions. We also present an extension to guarantee that the library is linearizable with respect to its sequential specification.

show abstract

“…Atomicity has been used as a key tool to circumvent this difficulty in many contexts, ranging from model checking [8] to static verification [4]. Atomicity is also a useful concept in programming; programmers tend to think of program executions as interleavings of atomic blocks, and do sequential reasoning on atomic blocks.…”

Section: Introductionmentioning

confidence: 99%

“…PADTAD This paper presents an annotation assistant to debug synchronization idioms used in the program. In this study, we build on the interactive verification tool QED [4]. QED is a verification method for checking assertions in concurrent programs.…”

Section: Introductionmentioning

confidence: 99%

An annotation assistant for interactive debugging of programs with common synchronization idioms

Elmas

Sezgin

Tasiran

et al. 2009

Proceedings of the 7th Workshop on Parallel and Distributed Systems: Testing, Analysis, and Debugging

Self Cite

View full text Add to dashboard Cite

This paper explores an approach to improving the practical usability of static verification tools for debugging synchronization idioms. Synchronization idioms such as mutual exclusion and readers/writer locks are widely-used to ensure atomicity of critical regions. We present an annotation assistant that automatically generates program annotations. These annotations express noninterference between program statements, ensured by the synchronization idioms, and are used to identify atomic code regions. This allows the programmer to debug the use of the idioms in the program. We start by formalizing several well-known idioms by providing an abstract semantics for each idiom. For programs that use these idioms, we require the programmer to provide a few predicates linking the idiom with its realization in terms of program variables. From these, we automatically generate a proof script that is mechanically checked. These scripts include steps such as automatically generating assertions and annotating program actions with them, introducing auxiliary variables and invariants. We have successfully shown the applicability of this approach to several concurrent programs from the literature.

show abstract

A calculus of atomic actions

Cited by 84 publications

References 27 publications

Verifying Concurrent Memory Reclamation Algorithms with Grace

Verifying Concurrent Memory Reclamation Algorithms with Grace

Logical Concurrency Control from Sequential Proofs

An annotation assistant for interactive debugging of programs with common synchronization idioms

Contact Info

Product

Resources

About