A Concurrency-Optimal Binary Search Tree

@article{Aksenov2017ACB,
  title={A Concurrency-Optimal Binary Search Tree},
  author={Vitaly Aksenov and Vincent Gramoli and Petr Kuznetsov and Anna Malova and Srivatsan Ravi},
  journal={ArXiv},
  year={2017},
  volume={abs/1702.04441}
}
The paper presents the first concurrency-optimal implementation of a binary search tree (BST). The implementation, based on a standard sequential implementation of a partially-external tree, ensures that every schedule, i.e., interleaving of steps of the sequential code, is accepted unless linearizability is violated. To ensure this property, we use a novel read-write locking protocol that protects tree edges in addition to its nodes. 

Optimal Concurrency for List-Based Sets

TLDR
A new algorithm for the list-based set based on a value-aware try-lock is proposed that shows to achieve optimal concurrency: it only rejects concurrent schedules that violate correctness of the implemented set type.

Lock-Free Binary Search Tree Based on Leaf Search

TLDR
This article proposes a Binary Search Tree, CAS, Concurrent Data Structure, Lock-Free, and shows which can beeffectively reduced and reduced and the contention between betweenthe-update-of-the-systems and the-algorithm.

Dynamic Adaptations of Synchronization Granularity in Concurrent Data Structures

TLDR
This dissertation proposes concurrent data structures that dynamically adapt their synchronization granularity and organization based on usage statistics collected at run-time and proposes a concurrent priority queue that dynamically changes its precision based on detected contention.

PaC-trees: supporting parallel and compressed purely-functional collections

TLDR
This paper presents PaC-trees, a purely-functional data structure supporting functional interfaces for sets, maps, and sequences that provides a significant reduction in space over existing approaches and designed CPAM, a C++ library that implements the full functionality of PAM, while offering significant extra functionality for compression.

A Scalable and Energy-Efficient Concurrent Binary Search Tree With Fatnodes

TLDR
A scalable and energy-efficient concurrent binary search tree with fatnodes (namely, FatCBST), and algorithms to perform basic operations on it, which scales well and also provides high performance-per-watt values as compared to the state-of-the-art implementations.

References

SHOWING 1-10 OF 30 REFERENCES

A Concurrency-Optimal List-Based Set

TLDR
This paper proposes a new algorithm based on a versioned try-lock that shows to achieve optimal concurrency: it only rejects concurrent schedules that violate correctness of the implemented type and empirically shows that reaching optimality does not induce a signicant overhead.

Non-blocking binary search trees

This paper describes the first complete implementation of a non-blocking binary search tree in an asynchronous shared-memory system using single-word compare-and-swap operations. The implementation

Brief Announcement: A Concurrency-Optimal List-Based Set

TLDR
Multicore applications require highly concurrent data structures and the algorithm that accepts all correct schedules would then be considered concurrency-optimal.

A practical concurrent binary search tree

TLDR
Experimental evidence shows that the proposed concurrent relaxed balance AVL tree algorithm outperforms a highly tuned concurrent skip list for many access patterns, with an average of 39% higher single- threaded throughput and 32% higher multi-threaded throughput over a range of contention levels and operation mixes.

In the Search for Optimal Concurrency

TLDR
The concurrency properties of \emph{search} data structures which can be represented in the form of directed acyclic graphs exporting insert, delete and search operations are explored and it is proved, for the first time, that pessimistic andoptimistic implementations of search data-structures are incomparable in terms of concurrency.

A non-blocking internal binary search tree

TLDR
Experimental evidence shows this parallel binary search tree algorithm built using single-word reads, writes, and compare-and-swap to be fast when compared with alternative solutions and scalable to large numbers of concurrently executing threads.

Efficient lock-free binary search trees

TLDR
This is the first algorithm for any concurrent tree data-structure in which the modify operations are performed with an additive term of contention measure, and it is proved that the presented algorithm is linearizable.

Practical concurrent binary search trees via logical ordering

TLDR
The experimental results show that the algorithms with lock-free contains and on-time deletion are practical and often comparable to the state-of-the-art.

Brief announcement: From sequential to concurrent: correctness and relative efficiency

TLDR
This work defines the meaning of a correct transformation of a sequential program into a concurrent one and model an execution of this transformation, which promises to make use of the hardware concurrency at low intellectual cost.

A Lazy Concurrent List-Based Set Algorithm

We present a novel “lazy” list-based implementation of a concurrent set object. It is based on an optimistic locking scheme for inserts and removes and includes a simple wait-free membership test.