The amortized complexity of non-blocking binary search trees

Ellen, Faith; Fatourou, Panagiota; Helga, Joanna; Ruppert, Eric

doi:10.1145/2611462.2611486

Cited by 33 publications

(37 citation statements)

References 19 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…For example, in the concurrent computing world, Ellen et al [19] show how to design a non-blocking binary search tree, with later work generalizing this technique [13] and analyzing the amortized complexity [18]. However, these data structures do not maintain balance in the tree (i.e., the height can get large) and their cost depends on the number of concurrent operations.…”

Section: Parallel Search Structuresmentioning

confidence: 99%

Parallel Working-Set Search Structures

Agrawal

Gilbert

Lim

2018

Proceedings of the 30th on Symposium on Parallelism in Algorithms and Architectures

View full text Add to dashboard Cite

In this paper 1 we present two versions of a parallel working-set map on p processors that supports searches, insertions and deletions. In both versions, the total work of all operations when the map has size at least p is bounded by the working-set bound, i.e., the cost of an item depends on how recently it was accessed (for some linearization): accessing an item in the map with recency r takes O(1+logr ) work. In the simpler version each map operation has O (logp) 2 + logn span (where n is the maximum size of the map). In the pipelined version each map operation on an item with recency r has O (logp) 2 + logr span. (Operations in parallel may have overlapping span; span is additive only for operations in sequence.)Both data structures are designed to be used by a dynamic multithreading parallel program that at each step executes a unittime instruction or makes a data structure call. To achieve the stated bounds, the pipelined version requires a weak-priority scheduler, which supports a limited form of 2-level prioritization. At the end we explain how the results translate to practical implementations using work-stealing schedulers.To the best of our knowledge, this is the first parallel implementation of a self-adjusting search structure where the cost of an operation adapts to the access sequence. A corollary of the working-set bound is that it achieves work static optimality: the total work is bounded by the access costs in an optimal static search tree.

show abstract

Section: Parallel Search Structuresmentioning

confidence: 99%

Parallel Working-Set Search Structures

Agrawal

Gilbert

Lim

2018

Proceedings of the 30th on Symposium on Parallelism in Algorithms and Architectures

View full text Add to dashboard Cite

show abstract

“…Specifically, before a record is removed from the data structure, it is marked, and no process is allowed to change a marked node. Search operations can often traverse marked nodes, and even leave the data structure to traverse some retired nodes, and still succeed (see, e.g., [4,7,8,13,16,15,21,23,30,31,33]).…”

Section: Related Workmentioning

confidence: 99%

“…Moreover, for some data structures, the amortized cost of operations depends on the number of marked nodes they traverse. Searching again from an entry point can provably lead to an asymptotic increase in the amortized cost of operations [15].…”

Section: Related Workmentioning

confidence: 99%

See 1 more Smart Citation

Reclaiming Memory for Lock-Free Data Structures

Brown

2015

Proceedings of the 2015 ACM Symposium on Principles of Distributed Computing

View full text Add to dashboard Cite

Memory reclamation for sequential or lock-based data structures is typically easy. However, memory reclamation for lock-free data structures is a significant challenge. Automatic techniques such as garbage collection are inefficient or use locks, and non-automatic techniques either have high overhead, or do not work for many reasonably simple data structures. For example, subtle problems can arise when hazard pointers, one of the most common non-automatic techniques, are applied to many natural lock-free data structures. Epoch based reclamation (EBR), which is by far the most efficient non-automatic technique, allows the number of unreclaimed objects to grow without bound, because one slow or crashed process can prevent all other processes from reclaiming memory.We develop a more efficient, distributed variant of EBR that solves this problem. It is based on signaling, which is provided by many operating systems, such as Linux and UNIX. Our new scheme takes O(1) amortized steps per high-level operation on the lock-free data structure and O(1) steps in the worst case each time an object is removed from the data structure. At any point, O(mn 2 ) objects are waiting to be freed, where n is the number of processes and m is a small constant for most data structures. Experiments show that our scheme has very low overhead: on average 10%, and at worst 28%, for a balanced binary search tree over many thread counts, operation mixes and contention levels. Our scheme also outperforms a highly efficient implementation of hazard pointers by an average of 75%.Typically, memory reclamation code is tightly woven into lockfree data structure code. To improve modularity and facilitate the comparison of different memory reclamation schemes, we also introduce a highly flexible abstraction. It allows a programmer to easily interchange schemes for reclamation, object pooling, allocation and deallocation with virtually no overhead, by changing a single line of code.

show abstract

“…Recently, there has been increased interest in the analytical properties of lock-free data structures [1,9,16]. Herlihy and Shavit [16] suggested that, on realistic schedules, lock-free algorithms ensure that each operation completes in a finite number of its own steps, i.e., that lock-free algorithms are in fact wait-free [13].…”

Section: Introductionmentioning

confidence: 99%

Lock-Free Algorithms under Stochastic Schedulers

Alistarh

Sauerwald

Vojnović

2015

Proceedings of the 2015 ACM Symposium on Principles of Distributed Computing

View full text Add to dashboard Cite

In this work, we consider the following random process, motivated by the analysis of lock-free concurrent algorithms under high memory contention. In each round, a new scheduling step is allocated to one of n threads, according to a distribution p = (p1, p2, . . . , pn), where thread i is scheduled with probability pi. When some thread first reaches a set threshold of executed steps, it registers a win, completing its current operation, and resets its step count to 1. At the same time, threads whose step count was close to the threshold also get reset because of the win, but to 0 steps, being penalized for almost winning. We are interested in two questions: how often does some thread complete an operation (system latency), and how often does a specific thread complete an operation (individual latency)?We provide asymptotically tight bounds for the system and individual latency of this general concurrency pattern, for arbitrary scheduling distributions p. Surprisingly, a simple characterization exists: in expectation, the system will complete a new operation every Θ(1/ p 2) steps, while thread i will complete a new operation every Θ( p 2/p 2 i ) steps. The proof is interesting in its own right, as it requires a careful analysis of how the higher norms of the vector p influence the thread step counts and latencies in this random process. Our result offers a simple connection between the scheduling distribution and the average performance of concurrent algorithms, which has several applications.

show abstract

The amortized complexity of non-blocking binary search trees

Cited by 33 publications

References 19 publications

Parallel Working-Set Search Structures

Parallel Working-Set Search Structures

Reclaiming Memory for Lock-Free Data Structures

Lock-Free Algorithms under Stochastic Schedulers

Contact Info

Product

Resources

About