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}
}
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… 
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.
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.
Multi-Interval DomLock (MID): Towards Improving Concurrency in Hierarchies
TLDR
MID (Multi-Interval DomLock), a new technique to improve the degree of concurrency of interval-based hierarchical locking, is presented, and can be applied to any arbitrary hierarchy of trees, DAGs and cycles.
Optimistic Transactional Boosting
TLDR
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.

References

SHOWING 1-10 OF 34 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.
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.
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.
Serializability by Locking
TLDR
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
TLDR
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
TLDR
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.
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
TLDR
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
TLDR
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.
Pessimistic Software Lock-Elision
TLDR
Pessimistic lock-elision (PLE), a new approach for non-speculatively replacing read-write locks with pessimistic software transactional code that allows read- write concurrency even for contended code and even if the code includes system calls, is introduced.
...
...