4 research outputs found
Polynomial-Time Verification and Testing of Implementations of the Snapshot Data Structure
We analyze correctness of implementations of the snapshot data structure in terms of linearizability. We show that such implementations can be verified in polynomial time. Additionally, we identify a set of representative executions for testing and show that the correctness of each of these executions can be validated in linear time. These results present a significant speedup considering that verifying linearizability of implementations of concurrent data structures, in general, is EXPSPACE-complete in the number of program-states, and testing linearizability is NP-complete in the length of the tested execution. The crux of our approach is identifying a class of executions, which we call simple, such that a snapshot implementation is linearizable if and only if all of its simple executions are linearizable. We then divide all possible non-linearizable simple executions into three categories and construct a small automaton that recognizes each category. We describe two implementations (one for verification and one for testing) of an automata-based approach that we develop based on this result and an evaluation that demonstrates significant improvements over existing tools. For verification, we show that restricting a state-of-the-art tool to analyzing only simple executions saves resources and allows the analysis of more complex cases. Specifically, restricting attention to simple executions finds bugs in 27 instances, whereas, without this restriction, we were only able to find 14 of the 30 bugs in the instances we examined. We also show that our technique accelerates testing performance significantly. Specifically, our implementation solves the complete set of 900 problems we generated, whereas the state-of-the-art linearizability testing tool solves only 554 problems
Linearizability Analysis of the Contention-Friendly Binary Search Tree
We present a formal framework for proving the correctness of set
implementations backed by binary-search-tree (BST) and linked lists, which are
often difficult to prove correct using automation. This is because many
concurrent set implementations admit non-local linearization points for their
`contains' procedure. We demonstrate this framework by applying it to the
Contention-Friendly Binary-Search Tree algorithm of Crain et al.
We took care to structure our framework in a way that can be easily
translated into input for model-checking tools such as TLA+, with the aim of
using a computer to verify bounded versions of claims that we later proved
manually. Although this approach does not provide complete proof (i.e., does
not constitute full verification), it allows checking the reasonableness of the
claims before spending effort constructing a complete proof. This is similar to
the test-driven development methodology, that has proven very beneficial in the
software engineering community.
We used this approach and validated many of the invariants and properties of
the Contention-Friendly algorithm using TLA+. It proved beneficial, as it
helped us avoid spending time trying to prove incorrect claims. In one example,
TLA+ flagged a fundamental error in one of our core definitions. We corrected
the definition (and the dependant proofs), based on the problematic scenario
TLA+ provided as a counter-example.
Finally, we provide a complete, manual, proof of the correctness of the
Contention-Friendly algorithm, based on the definitions and proofs of our
two-tiered framework
Improving Bidirectional Heuristic Search by Bounds Propagation
Recent work in bidirectional heuristic search characterize pairs of nodes from which at least one node must be expanded in order to ensure optimality of solutions. We use these findings to propose a method for improving existing heuristics by propagating lower bounds between the forward and backward frontiers. We then define a number of desirable properties for bidirectional heuristic search algorithms, and show that applying the bound propagations adds these properties to many existing algorithms (e.g. to the MM family of algorithms). Finally, experimental results show that applying these propagations significantly reduce the running time of various algorithms
Enriching Non-Parametric Bidirectional Search Algorithms
NBS is a non-parametric bidirectional search algorithm proven to expand at most twice the number of node expansions required to verify the optimality of a solution. We introduce new variants of NBS that are aimed at finding all optimal solutions. We then introduce an algorithmic framework that includes NBS as a special case. Finally, we introduce DVCBS, a new algorithm in this framework that aims to further reduce the number of expansions. Unlike NBS, DVCBS does not have any worst-case bound guarantees, but in practice it outperforms NBS in verifying the optimality of solutions