# In the Search for Optimal Concurrency

@article{Gramoli2016InTS,
title={In the Search for Optimal Concurrency},
author={Vincent Gramoli and Petr Kuznetsov and Srivatsan Ravi},
journal={ArXiv},
year={2016},
volume={abs/1603.01384}
}
• Published 4 March 2016
• Computer Science
• ArXiv
Implementing a concurrent data structure typically begins with defining its sequential specification. However, when used \emph{as is}, a nontrivial sequential data structure, such as a linked list, a search tree, or a hash table, may expose incorrect behavior: lost updates, inconsistent responses, etc. To ensure correctness, portions of the sequential code operating on the shared data must be "protected" from data races using synchronization primitives and, thus, certain schedules of the steps…
3 Citations
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.
Optimistic Transactional Boosting
• Computer Science
IEEE Transactions on Parallel and Distributed Systems
• 2017
This paper introducesOptimistic Transactional Boosting (OTB), an optimistic methodology for extending designs in order to support the composition of multiple operations into one atomic execution by building a single traversal phase and a single commit phase for the whole atomic execution.
Optimal Concurrency for List-Based Sets
• Computer Science
PaCT
• 2021
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.

## References

SHOWING 1-10 OF 35 REFERENCES
A Concurrency-Optimal List-Based Set
• Computer Science
ArXiv
• 2015
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.
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.
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.
Serializability by Locking
The author shows that it is possible to determine efficiently whether the transactions in a given set can be permitted to run safely by themselves without the need of any control while ensuring viewserializability, although the problem is np-complete in the case of state serializability.
Transactional memory: architectural support for lock-free data structures
• Computer Science
ISCA '93
• 1993
Simulation results show that transactional memory matches or outperforms the best known locking techniques for simple benchmarks, even in the absence of priority inversion, convoying, and deadlock.
Principles of Transactional Memory
• Computer Science
Synthesis Lectures on Distributed Computing Theory
• 2010
The aim of this book is to provide theoretical foundations for transactional memory, as well as answering precisely when a TM implementation is correct, what kind of properties it can ensure, what are the power and limitations of a TM, and what inherent trade-offs are involved in designing a TM algorithm.
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.
A theoretical foundation of multi-level concurrency control
Until recently concurrency control theory has focussed on one-level systems, I. 8. regarding schedules simply as sequences of read and write operatlons on objects of one particular abstractlon level
The serializability of concurrent database updates
Several efficiently recognizable subclasses of the class of senahzable histories are introduced and it is shown how these results can be extended to far more general transaction models, to transactions with partly interpreted functions, and to distributed database systems.
Towards formally specifying and verifying transactional memory
• Computer Science
Formal Aspects of Computing
• 2012
TMS1 (Transactional Memory Specification 1), a precise specification of correct behaviour of a TM runtime library, is presented and a simulation proof that TMS2 implements TMS1 is presented, thus showing that to prove that an implementation satisfies T MS1, it suffices to proved that it satisfies TMS 2.