Visibility reasoning for concurrent snapshot algorithms

  title={Visibility reasoning for concurrent snapshot algorithms},
  author={Joakim {\"O}hman and Aleksandar Nanevski},
  journal={Proceedings of the ACM on Programming Languages},
  pages={1 - 30}
Visibility relations have been proposed by Henzinger et al. as an abstraction for proving linearizability of concurrent algorithms that obtains modular and reusable proofs. This is in contrast to the customary approach based on exhibiting the algorithm's linearization points. In this paper we apply visibility relations to develop modular proofs for three elegant concurrent snapshot algorithms of Jayanti. The proofs are divided by signatures into components of increasing level of abstraction… 

Compass: strong and compositional library specifications in relaxed memory separation logic

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.



Aspect-Oriented Linearizability Proofs

The task of proving linearizability of concurrent queue algorithms with respect to the queue specification is reduced to establishing four basic properties, each of which can be proved independently by simpler arguments.

Verifying Visibility-Based Weak Consistency

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.

Proving Linearizability Using Forward Simulations

It is shown that, contrary to common belief, many such complex implementations, including, e.g., the Herlihy and Wing Queue and the Time-Stamped Stack, can be proved correct using only forward simulation arguments, which leads to simple and natural correctness proofs for these implementations that are amenable to automation.

Concurrent Data Structures Linked in Time

This paper embraces the dynamic nature of linearization points, and encodes it as part of the data structure's auxiliary state, so that it can be dynamically modified in place by auxiliary code, as needed when some appropriate run-time event occurs.

On library correctness under weak memory consistency: specifying and verifying concurrent libraries under declarative consistency models

A general declarative framework is proposed that allows to specify concurrent libraries declaratively, and to verify library implementations against their specifications compositionally, and is sufficient to encode standard models such as SC, (R)C11 and TSO.

The future is ours: prophecy variables in separation logic

This paper presents the first account of prophecy variables in a Hoare-style program logic that is flexible enough to verify logical atomicity (a relative of linearizability) for classic examples from the concurrency literature like RDCSS and the Herlihy-Wing queue.

A Scalable, Correct Time-Stamped Stack

A new stack theorem is presented, mechanised in Isabelle, which characterises the orderings sufficient to establish stack semantics, and it is shown that the TS stack is indeed linearizable.

Efficient Wait-Free Implementation of Multiword LL/SC Variables

  • P. JayantiS. Petrovic
  • Computer Science
    25th IEEE International Conference on Distributed Computing Systems (ICDCS'05)
  • 2005
The authors considered the problem of implementing a W-word LL/SC object shared by N processes and presented an algorithm that uses novel buffer management ideas to cut down the space complexity by a factor of N to O(NW), while still being time optimal.

Forward and backward simulations

A unified, comprehensive presentation of simulation techniques for verification of concurrent systems is given, in terms of a simple untimed automaton model, with details of refinements, forward and backward simulations, and history and prophecy relations are defined.

Forward and Backward Simulations: I. Untimed Systems

A unified, comprehensive presentation of simulation techniques for verification of concurrent systems is given, in terms of a simple untimed automaton model, where history and prophecy relations are defined and it is shown how invariants can be incorporated into all the simulations.