• Corpus ID: 5048723

A Concurrency-Optimal List-Based Set

@article{Gramoli2015ACL,
  title={A Concurrency-Optimal List-Based Set},
  author={Vincent Gramoli and Petr Kuznetsov and Srivatsan Ravi and Richard Di Shang},
  journal={ArXiv},
  year={2015},
  volume={abs/1502.01633}
}
Designing a highly concurrent data structure is an important challenge that is not easy to meet. As we show in this paper, even for a data structure as simple as a linked list used to implement the set type, the most ecient algorithms known so far may reject correct concurrent schedules. We propose a new algorithm based on a versioned try-lock that we show to achieve optimal concurrency: it only rejects concurrent schedules that violate correctness of the implemented type. We show empirically… 

Figures and Tables from this paper

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.
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.
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 Concurrency-Optimal Binary Search Tree
TLDR
The paper presents the first concurrency-optimal implementation of a binary search tree (BST) that ensures that every schedule, i.e., interleaving of steps of the sequential code, is accepted unless linearizability is violated.
A Fast Contention-Friendly Binary Search Tree
TLDR
This paper presents a contention-friendly binary search tree algorithm that features a rebalancing mechanism and guarantees that read-only operations searching for an element execute lock-free, and is compared against five state-of-the-art binary search trees that use locks, transactions or compare-and-swap for synchronization.
The Information Needed for Reproducing Shared Memory Experiments
TLDR
This paper focuses on multi-threaded executions where threads synchronize to access shared memory and presents a series of causes for performance variations that illustrate the difficulty of reproducing a concurrent experiment.

References

SHOWING 1-10 OF 26 REFERENCES
An optimality theory of concurrency control for databases
TLDR
It is formally show that the performance of a scheduler, i.e., the amount of parallelism that it supports, depends explicitly upon the amounts of information that is available to the scheduler.
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.
Wait-free synchronization
TLDR
A hierarchy of objects is derived such that no object at one level has a wait-free implementation in terms of objects at lower levels, and it is shown that atomic read/write registers, which have been the focus of much recent attention, are at the bottom of the hierarchy.
Universal constructions that ensure disjoint-access parallelism and wait-freedom
TLDR
This work shows that there is no universal construction that is both disjoint-access parallel (guaranteeing the processes operating on different parts of an implemented object do not interfere with one another) and wait-free (gu Guaranteeing progress for each nonfaulty process when accessing an object).
Lock-free linked lists and skip lists
TLDR
This work presents a new lock-free implementation of singly-linked lists that uses backlinks that are set when a node is deleted so that concurrent operations visiting the deleted node can recover and proves that the worst-case amortized cost of the operations is linear in the length of the list plus the contention.
Apologizing versus asking permission: optimistic concurrency control for abstract data types
TLDR
Several new optimistic concurrency control techniques for objects in decentralized distributed systems are described here, their correctness and optimality properties are proved, and the circumstances under which each is likely to be useful are characterized.
Why Non-blocking Operations Should be Selfish
TLDR
This paper shows that when summed across every operation in an execution, the interval contention is within a factor of 2 of the point contention, contradicting the folklore belief that point contention leads to a tighter bound on complexity in an amortised context.
Inherent Limitations on Disjoint-Access Parallel Implementations of Transactional Memory
TLDR
A lower bound of Ω(t) is proved on the number of writes needed in order to implement a read-only transaction of t items, which successfully terminates in a disjoint-access parallel TM implementation, which assumes strict serializability and thus hold under the assumption of opacity.
High performance dynamic lock-free hash tables and list-based sets
TLDR
The experimental results show that the new algorithm outperforms the best known lock-free as well as lock-based hash table implementations by significant margins, and indicate that it is the algorithm of choice for implementing shared hash tables.
A Pragmatic Implementation of Non-blocking Linked-Lists
TLDR
This work presents a new non-blocking implementation of concurrent linked-lists supporting linearizable insertion and deletion operations, conceptually simpler and substantially faster than previous schemes.
...
...