• 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}
}
• Published 5 February 2015
• Computer Science
• ArXiv
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…
5 Citations

## Figures and Tables from this paper

Brief Announcement: A Concurrency-Optimal List-Based Set
• Computer Science
• 2015
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
• Computer Science
SIROCCO
• 2016
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
• Computer Science
Euro-Par
• 2017
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
• Computer Science
Parallel Process. Lett.
• 2016
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
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 27 REFERENCES
An optimality theory of concurrency control for databases
• Computer Science
SIGMOD '79
• 1979
It is formally show that the performance of a scheduler, i.e., the amount of parallelism that it supports, depends explicitly upon the number of information that is available to the scheduler.
A Lazy Concurrent List-Based Set Algorithm
• Computer Science
Parallel Process. Lett.
• 2007
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
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
• Computer Science
Distributed Computing
• 2015
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).
Linearizability: a correctness condition for concurrent objects
• Computer Science
TOPL
• 1990
This paper defines linearizability, compares it to other correctness conditions, presents and demonstrates a method for proving the correctness of implementations, and shows how to reason about concurrent objects, given they are linearizable.
Lock-free linked lists and skip lists
• Computer Science
PODC '04
• 2004
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
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.
More than you ever wanted to know about synchronization: synchrobench, measuring the impact of the synchronization on concurrent algorithms
A new micro-benchmark suite, called Synchrobench, is developed in C/C++ and Java, hence helping the community evaluate new data structures and synchronization techniques, and concludes that although compare-and-swap helps achieving the best performance on multicores, doing so correctly is hard.
Why Non-blocking Operations Should be Selfish
• Computer Science
DISC
• 2015
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
• Computer Science
SPAA '09
• 2009
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.