In the Search for Optimal Concurrency

Abstract

Implementing a concurrent data structure typically begins with defining its sequential specification. However, when used 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 of concurrent operations must be rejected. But can we ensure that we do not "overuse" synchronization, i.e., that we reject a concurrent schedule only if it violates correctness?In this paper, we treat this question formally by introducing the notion of a concurrency-optimal implementation. A program's concurrency is defined here as its ability to accept concurrent schedules, i.e., interleavings of steps of its sequential implementation. An implementation is concurrency-optimal if it accepts all interleavings that do not violate the program's correctness. We explore the concurrency properties of search data structures which can be represented in the form of directed acyclic graphs exporting insert, delete and search operations. We prove, for the first time, that pessimistic (e.g., based on conservative locking) and optimistic serializable (e.g., based on serializable transactional memory) implementations of search data-structures are incomparable in terms of concurrency. Specifically, there exist simple interleavings of sequential code that cannot be accepted by any pessimistic (and resp., serializable optimistic) implementation, but accepted by a serializable optimistic one (and resp., pessimistic). Thus, neither of these two implementation classes is concurrency-optimal.

A Concurrency-Optimal Binary Search Tree

“…Although lots of efforts have been devoted to improve the scalability of binary search trees as the concurrency level increases, we are not aware of any work measuring their concurrency. Measuring concurrency has already been expressed as the idea of comparing a concurrent data structure to its sequential counterpart [11] and this reasoning was generalized to a class of search structures organizing nodes in a directed acyclic graph [12]. While a similar reasoning was applied to a linked list [14] to measure its concurrency, the existence of a concurrency-optimal binary search tree has never been addressed to our knowledge.…”

“…In this section, we show that our implementation is concurrency-optimal [12]. Intuitively, a concurrency-optimal implementation employs as much synchronization as necessary for ensuring correctness of the implemented high-level abstraction -in our case, the linearizable set object [17].…”

“…We present a novel LS-linearizable concurrent BST-based set implementation. We prove that the implementation is optimally concurrent with respect to a standard internal sequential tree [13]. The proposed implementation employs the optimistic "lazy" locking approach [16] that distinguishes logical and physical deletion of a node and makes sure that read-only operations are wait-free [17], i.e., cannot be delayed by concurrent processes.…”

“…Intuitively, we would like to use exactly as little synchronization as sufficient for ensuring linearizability of the high-level implemented abstraction. This expectation brings up the notion of a concurrency-optimal implementation [12] that only rejects a schedule if it does violate linearizability.…”

“…To be able to reason about the "amount of concurrency" exhibited by implementations employing different synchronization techniques, we consider the recently introduced notion of "local serializability" (on top of linearizability) and the metric of the "amount of concurrency" defined via sets of accepted (locally sequential) schedules [13]. Local serializability, intuitively, requires the sequence of sequential steps locally observed by every given process to be consistent with some execution of the sequential algorithm.…”