Go with the Flow: Compositional Abstractions for Concurrent Data Structures (Extended Version)

11/09/2017
by   Siddharth Krishna, et al.
0

Concurrent separation logics have helped to significantly simplify correctness proofs for concurrent data structures. However, a recurring problem in such proofs is that data structure abstractions that work well in the sequential setting are much harder to reason about in a concurrent setting due to complex sharing and overlays. To solve this problem, we propose a novel approach to abstracting regions in the heap by encoding the data structure invariant into a local condition on each individual node. This condition may depend on a quantity associated with the node that is computed as a fixpoint over the entire heap graph. We refer to this quantity as a flow. Flows can encode both structural properties of the heap (e.g. the reachable nodes from the root form a tree) as well as data invariants (e.g. sortedness). We then introduce the notion of a flow interface, which expresses the relies and guarantees that a heap region imposes on its context to maintain the local flow invariant with respect to the global heap. Our main technical result is that this notion leads to a new semantic model of separation logic. In this model, flow interfaces provide a general abstraction mechanism for describing complex data structures. This abstraction mechanism admits proof rules that generalize over a wide variety of data structures. To demonstrate the versatility of our approach, we show how to extend the logic RGSep with flow interfaces. We have used this new logic to prove linearizability and memory safety of nontrivial concurrent data structures. In particular, we obtain parametric linearizability proofs for concurrent dictionary algorithms that abstract from the details of the underlying data structure representation. These proofs cannot be easily expressed using the abstraction mechanisms provided by existing separation logics.

READ FULL TEXT
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

05/10/2018

Order out of Chaos: Proving Linearizability Using Local Views

Proving the linearizability of highly concurrent data structures, such a...
09/12/2021

Verifying Concurrent Multicopy Search Structures

Multicopy search structures such as log-structured merge (LSM) trees are...
11/19/2019

Local Reasoning for Global Graph Properties

Separation logics are widely used for verifying programs that manipulate...
10/06/2021

Visibility Reasoning for Concurrent Snapshot Algorithms

Visibility relations have been proposed by Henzinger et al. as an abstra...
10/23/2020

On Algebraic Abstractions for Concurrent Separation Logics

Concurrent separation logic is distinguished by transfer of state owners...
09/19/2019

Proof Pearl: Magic Wand as Frame

Separation logic adds two connectives to assertion languages: separating...
01/30/2020

VERONICA: Expressive and Precise Concurrent Information Flow Security (Extended Version with Technical Appendices)

Methods for proving that concurrent software does not leak its secrets h...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.