A Constructive Approach for Proving Data Structures’ Linearizability

Lev-Ari, Kfir; Chockler, Gregory; Keidar, Idit

doi:10.1007/978-3-662-48653-5_24

Cited by 11 publications

(12 citation statements)

References 9 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…For this aim, we have to start with the usual definition of executions as history sequences and to define for each history H that describes a run of the Lazy Set algorithm a structure M H that corresponds to H. In fact, it is not difficult to see that it is possible to retrieve H from M H , so that these two mathematical objects and returning t rue. The Add protocol needs only one locking in [6] and in our paper, but it needs two locking (of pred and curr) in the earlier version [5], in [3], [4], [10] (these papers use two locking for the REMOVE operations as well).…”

Section: Discussionmentioning

confidence: 99%

On the Lazy Set object

Abraham¹

2018

Preprint

View full text Add to dashboard Cite

The aim of this article is to employ the Lazy Set algorithm as an example for a mathematical framework for proving the linearizability of a distributed system. The proof in this approach is divided into two stages of lower and higher abstraction level. At the higher level a list of "axioms" is formulated and a proof is given that any model theoretic structure that satisfies these axioms is linearizable. At this level the algorithm is not mentioned. At the lower level, a Simpler Lazy Set algorithm is described, and it is shown that any execution of this simpler algorithm generates a model of these axioms (and is therefore linearizable). Finally the linearization of the Lazy Set algorithm is obtained by proving that any of its executions has a reduct that is an execution of the Simpler algorithm. So the reduct executions are linearizable and this entails immediately linearizability of the Lazy Set algorithm itself.

show abstract

Section: Discussionmentioning

confidence: 99%

On the Lazy Set object

Abraham¹

2018

Preprint

View full text Add to dashboard Cite

show abstract

“…Highly-concurrent algorithms are notoriously difficult to prove correct [Feldman et al 2018;Lev-Ari et al 2015a;O'Hearn et al 2010;Vafeiadis 2008]. The standard desired correctness condition is linearizability [Herlihy and Wing 1990], which requires that every operation appears to take effect atomically at some point during its execution.…”

Section: Introductionmentioning

confidence: 99%

“…Accordingly, an emerging research thrust is to design proof techniques that enable using sequential reasoning to simplify proving the correctness of highly-concurrent algorithms [Feldman et al 2018;Lev-Ari et al 2015a]. The vision is for correctness proofs to follow from a meta-theorem about properties of the algorithm's sequential code, i.e., when running without interference.…”

Section: Introductionmentioning

confidence: 99%

Proving Highly-Concurrent Traversals Correct

Feldman¹,

Khyzha²,

Constantin³

et al. 2020

Preprint

View full text Add to dashboard Cite

Modern highly-concurrent search data structures, such as search trees, obtain multi-core scalability and performance by having operations traverse the data structure without any synchronization. As a result, however, these algorithms are notoriously difficult to prove linearizable, which requires identifying a point in time in which the traversal's result is correct. The problem is that traversing the data structure as it undergoes modifications leads to complex behaviors, requiring intricate reasoning about all interleavings of reads by traversals and writes mutating the data structure.In this paper, we present a general proof technique for proving unsynchronized traversals correct in a significantly simpler manner, compared to typical concurrent reasoning and prior proof techniques. Our framework relies only on sequential properties of traversals and on a conceptually simple and widely-applicable condition about the ways an algorithm's writes mutate the data structure. Establishing that a target data structure satisfies our condition requires only simple concurrent reasoning, without considering interactions of writes and reads. This reasoning can be further simplified by using our framework.To demonstrate our technique, we apply it to prove several interesting and challenging concurrent binary search trees: the logical-ordering AVL tree, the Citrus tree, and the full contention-friendly tree. Both the logical-ordering tree and the full contention-friendly tree are beyond the reach of previous approaches targeted at simplifying linearizability proofs.

show abstract

“…Recently Lev-Ari et al [14,15] proposed a constructive methodology for proving correctness of CDSs. They have developed a very interesting notion of base-points and base-conditions to prove linearizability.…”

Section: Introductionmentioning

confidence: 99%

“…al. 's work, [14,15] we assume that these events by different threads are (1) atomic read, write on shared/local memory objects; (2) atomic read-modify-write or rmw operations such compare & swap etc. on shared memory objects (3) method invocation or inv event & response or rsp event on CDSs.…”

Section: Introductionmentioning

confidence: 99%

Proving Correctness of Concurrent Objects by Validating Linearization Points

Peri¹,

Sa²,

Singh³

et al. 2017

Preprint

View full text Add to dashboard Cite

Concurrent data structures or CDS such as concurrent stacks, queues, sets etc. have become very popular in the past few years partly due to the rise of multi-core systems. Such concurrent CDSs offer great performance benefits over their sequential counterparts. But one of the greatest challenges with CDSs has been developing correct structures and then proving correctness of these structures. We believe that techniques that help prove correctness of these CDSs can also guide in developing new CDSs.An intuitive & popular techniques to prove correctness of CDSs is using Linearization Points or LPs. A LP is an (atomic) event in the execution interval of each method such that the execution of the entire method seems to have taken place in the instant of that event. One of the main challenges with the LP based approach is to identify the correct LPs of a CDS. Identifying the correct LPs can be deceptively wrong in many cases. In fact in many cases, the LP identified or even worse the CDS itself could be wrong. To address these issues, several automatic tools for verifying linearizability have been developed. But we believe that these tools don't provide insight to a programmer to develop the correct concurrent programs or identify the LPs.Considering the complexity of developing a CDS and verifying its correctness, we address the most basic problem of this domain in this paper: given the set of LPs of a CDS, how to show its correctness? We assume that we are given a CDS and its LPs. We have developed a hand-crafted technique of proving correctness of the CDSs by validating its LPs. As observed earlier, identifying the correct LPs is very tricky and erroneous. But since our technique is hand-crafted, we believe that the process of proving correctness might provide insight to identify the correct LPs, if the currently chosen LP is incorrect. We also believe that this technique might also offer the programmer some insight to develop more efficient variants of the CDS.The proposed proof technique can be applied to prove the correctness of several commonly used CDSs developed in literature such as Lock-free Linked based Sets, Skiplists etc. Our technique will also show correctness of CDSs in which the LPs of method might lie outside the methods (may seem to take effect in code of other method) such as lazy-list based set. To show the efficacy of this technique, we show the correctness of lazy-list and hoh-locking-list based set.

show abstract

A Constructive Approach for Proving Data Structures’ Linearizability

Cited by 11 publications

References 9 publications

On the Lazy Set object

On the Lazy Set object

Proving Highly-Concurrent Traversals Correct

Proving Correctness of Concurrent Objects by Validating Linearization Points

Contact Info

Product

Resources

About