Owicki-Gries Reasoning for Weak Memory Models

Lahav, Ori; Vafeiadis, Viktor

doi:10.1007/978-3-662-47666-6_25

Cited by 76 publications

(90 citation statements)

References 15 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Therefore, similar to [33], it is unclear how to handle the program with dependencies across loop iterations introduced in Section 1. Similarly, since no program in Lahav et al's paper, which performed Owicki-Gries reasoning for weak memory models, contains multiple statements except SK [27], it is never clear how to handle dependencies across loop iterations. In addition, they did not show their completeness.…”

Section: Related Workmentioning

confidence: 99%

Concurrent Program Logic for Relaxed Memory Consistency Models with Dependencies across Loop Iterations

Abe

Maeda

2017

Journal of Information Processing

View full text Add to dashboard Cite

Abstract:Relaxed memory consistency models specify effects of executions of statements among threads, which may or may not be reordered. Such reorderings may cross loop iterations. To the best of our knowledge, however, there exists no concurrent program logic which explicitly handles the reorderings across loop iterations. This paper provides concurrent program logic for relaxed memory consistency models that can represent, for example, total store ordering, partial store ordering, relaxed memory ordering, and acquire and release consistency. There are two novel aspects to our approach. First, we translate a concurrent program into a family of directed acyclic graphs with finite nodes and transitive edges called program graphs according to a memory consistency model that we adopt. These represent dependencies among statements which represent reorderings of not only statements but also visibility of their effects. Second, we introduce auxiliary variables that temporarily buffer the effects of write operations on shared memory, and explicitly describe the reflections of the buffered effects to shared memory. Specifically, we define a small-step operational semantics for the program graphs with the introduced auxiliary variables, then define sound and relatively complete logic to the semantics.

show abstract

Section: Related Workmentioning

confidence: 99%

Concurrent Program Logic for Relaxed Memory Consistency Models with Dependencies across Loop Iterations

Abe

Maeda

2017

Journal of Information Processing

View full text Add to dashboard Cite

show abstract

“…This can be achieved by either extending existing program logics for weak memory, or developing new program logics for currently unsupported models. In particular, we can reason about the PSI models presented here by developing custom proof rules in the existing program logics for RA such as [22,39].…”

Section: Discussionmentioning

confidence: 99%

On Parallel Snapshot Isolation and Release/Acquire Consistency

Raad

Lahav

Vafeiadis

2018

Programming Languages and Systems

Self Cite

View full text Add to dashboard Cite

Abstract. Parallel snapshot isolation (PSI) is a standard transactional consistency model used in databases and distributed systems. We argue that PSI is also a useful formal model for software transactional memory (STM) as it has certain advantages over other consistency models. However, the formal PSI definition is given declaratively by acyclicity axioms, which most programmers find hard to understand and reason about.To address this, we develop a simple lock-based reference implementation for PSI built on top of the release-acquire memory model, a wellbehaved subset of the C/C++11 memory model. We prove that our implementation is sound and complete against its higher-level declarative specification.We further consider an extension of PSI allowing transactional and non-transactional code to interact, and provide a sound and complete reference implementation for the more general setting. Supporting this interaction is necessary for adopting a transactional model in programming languages.

show abstract

“…First, uses the Owicki-Gries method [29] to verify concurrent programs. These methods are unsound for weak memory models [22], so , and hence our proofs, assume a sequentially-consistent memory model. Second, 's strategy for building the simulation relation requires implementations to have statically-known linearization points because it checks that there exists exactly one atomic section in each code path where the global state is modi ed, and this modi cation is simulated by the speci cation.…”

Section: Implementation and Evaluationmentioning

confidence: 99%

Verifying Visibility-Based Weak Consistency

Krishna

Emmi

Enea

et al. 2020

Programming Languages and Systems

View full text Add to dashboard Cite

Multithreaded programs generally leverage e cient and thread-safe concurrent objects like sets, key-value maps, and queues. While some concurrentobject operations are designed to behave atomically, each witnessing the atomic e ects of predecessors in a linearization order, others forego such strong consistency to avoid complex control and synchronization bottlenecks. For example, contains (value) methods of key-value maps may iterate through key-value entries without blocking concurrent updates, to avoid unwanted performance bottlenecks, and consequently overlook the e ects of some linearization-order predecessors. While such weakly-consistent operations may not be atomic, they still o er guarantees, e.g., only observing values that have been present. In this work we develop a methodology for proving that concurrent object implementations adhere to weak-consistency speci cations. In particular, we consider (forward) simulation-based proofs of implementations against relaxedvisibility speci cations, which allow designated operations to overlook some of their linearization-order predecessors, i.e., behaving as if they never occurred. Besides annotating implementation code to identify linearization points, i.e., points at which operations' logical e ects occur, we also annotate code to identify visible operations, i.e., operations whose e ects are observed; in practice this annotation can be done automatically by tracking the writers to each accessed memory location. We formalize our methodology over a general notion of transition systems, agnostic to any particular programming language or memory model, and demonstrate its application, using automated theorem provers, by verifying models of Java concurrent object implementations.

show abstract

Owicki-Gries Reasoning for Weak Memory Models

Cited by 76 publications

References 15 publications

Concurrent Program Logic for Relaxed Memory Consistency Models with Dependencies across Loop Iterations

Concurrent Program Logic for Relaxed Memory Consistency Models with Dependencies across Loop Iterations

On Parallel Snapshot Isolation and Release/Acquire Consistency

Verifying Visibility-Based Weak Consistency

Contact Info

Product

Resources

About