In the Search for Optimal Concurrency

  title={In the Search for Optimal Concurrency},
  author={Vincent Gramoli and Petr Kuznetsov and Srivatsan Ravi},
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… 
A Concurrency-Optimal Binary Search Tree
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
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
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.


A Concurrency-Optimal List-Based Set
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
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
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
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
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.