Fragment Abstraction for Concurrent Shape Analysis

Abstract

A major challenge in automated verification is to develop techniques that are able to reason about fine-grained concurrent algorithms that consist of an unbounded number of concurrent threads, which operate on an unbounded domain of data values, and use unbounded dynamically allocated memory. Existing automated techniques consider the case where shared data is organized into singly-linked lists. We present a novel shape analysis for automated verification of fine-grained concurrent algorithms that can handle heap structures which are more complex than just singly-linked lists, in particular skip lists and arrays of singly linked lists, while at the same time handling an unbounded number of concurrent threads, an unbounded domain of data values (including timestamps), and an unbounded shared heap. Our technique is based on a novel shape abstraction, which represents a set of heaps by a set of fragments. A fragment is an abstraction of a pair of heap cells that are connected by a pointer field. We have implemented our approach and applied it to automatically verify correctness, in the sense of linearizability, of most linearizable concurrent implementations of sets, stacks, and queues, which employ singly-linked lists, skip lists, or arrays of singlylinked lists with timestamps, which are known to us in the literature.

Parameterized verification of systems with component identities, using view abstraction

“…Abdulla et al [6] verify the timestamp-based stack and queue from [22], which have much in common with the timestamp-based queue we have analysed. They use essentially the same specification technique as us, focusing on two distinguished data values.…”

“…In this section, we describe a number of examples we have analysed using our framework. Figure 6 summarises the results 6 . Each check was successful, verifying that all such systems are error-free, and, in three cases, deadlock-free.…”

“…Other verification techniques that target linked lists have recorded reachability-type properties explicitly, either by recording that a node is "private" (i.e. not yet added to the list; for example [5,6]), or by modelling reachability between pairs of nodes (for example [7,43]). View abstraction does not capture this automatically; but we have demonstrated ways to capture it within models.…”

“…those states st such that every view of st is in S; we call these concretizations. Informally (using the terminology of [6]), we "piece together" the views in S to create concretizations. We then calculate concrete transitions from those concretizations, and form the views of the resulting states.…”

Verifying concurrent multicopy search structures

“…There has also been much work on obtaining fully automated proofs of linearizability by static analysis and model checking [Abdulla et al 2013[Abdulla et al , 2018Amit et al 2007;Bouajjani et al 2013Bouajjani et al , 2015Bouajjani et al , 2017Cerný et al 2010;Dragoi et al 2013;Lesani et al 2014;Vafeiadis 2009;Zhu et al 2015]. The proof framework presented in this paper is capable of reasoning about implementations that are beyond the reach of current automatic techniques, via interactive (though still machine-checked) template proofs.…”