scispace - formally typeset
Book ChapterDOI

CBTree: a practical concurrent self-adjusting search tree

TLDR
The CBTree is presented, a new counting-based self-adjusting binary search tree that moves more frequently accessed nodes closer to the root that improves performance compared to existing concurrent search trees on non-uniform access sequences derived from real workloads.
Abstract
We present the CBTree, a new counting-based self-adjusting binary search tree that, like splay trees, moves more frequently accessed nodes closer to the root. After m operations on n items, c of which access some item v, an operation on v traverses a path of length $\mathcal{O}(\log\dfrac{m}{c})$ while performing few if any rotations. In contrast to the traditional self-adjusting splay tree in which each accessed item is moved to the root through a sequence of tree rotations, the CBTree performs rotations infrequently (an amortized subconstant o(1) per operation if m≫n), mostly at the bottom of the tree. As a result, the CBTree scales with the amount of concurrency. We adapt the CBTree to a multicore setting and show experimentally that it improves performance compared to existing concurrent search trees on non-uniform access sequences derived from real workloads.

read more

Citations
More filters
Proceedings ArticleDOI

A general technique for non-blocking trees

TL;DR: In this paper, the authors describe a general technique for obtaining provably correct, non-blocking implementations of a large class of tree data structures where pointers are directed from parents to children, where updates are permitted to modify any contiguous portion of the tree atomically.
Proceedings ArticleDOI

Concurrent updates with RCU: search tree as an example

TL;DR: This paper presents citrus, a concurrent binary search tree with a wait-free Contains operation, using RCU synchronization and fine-grained locking for synchronization among updaters, the first RCU-based data structure that allows concurrent updaters.
Posted Content

A General Technique for Non-blocking Trees

TL;DR: A general technique for obtaining provably correct, non-blocking implementations of a large class of tree data structures where pointers are directed from parents to children and an experimental performance analysis demonstrates that the Java implementation of a chromatic tree rivals, and often significantly outperforms, other leading concurrent dictionaries.
Proceedings ArticleDOI

Non-blocking Patricia Tries with Replace Operations

TL;DR: This paper presents a non-blocking Patricia trie implementation for an asynchronous shared-memory system using Compare&Swap, and compares the algorithms to some existing set implementations.
Proceedings ArticleDOI

ThreadScan: Automatic and Scalable Memory Reclamation

TL;DR: This paper takes a new approach to concurrent memory reclamation: instead of manually tracking access to memory locations as done in techniques like hazard pointers, or restricting shared accesses to specific epoch boundaries as in RCU, the algorithm, called ThreadScan, leverages operating system signaling to automatically detect which memory locations are being accessed by concurrent threads.
References
More filters
Proceedings ArticleDOI

Web caching and Zipf-like distributions: evidence and implications

TL;DR: This paper investigates the page request distribution seen by Web proxy caches using traces from a variety of sources and considers a simple model where the Web accesses are independent and the reference probability of the documents follows a Zipf-like distribution, suggesting that the various observed properties of hit-ratios and temporal locality are indeed inherent to Web accesse observed by proxies.
Proceedings ArticleDOI

The PARSEC benchmark suite: characterization and architectural implications

TL;DR: This paper presents and characterizes the Princeton Application Repository for Shared-Memory Computers (PARSEC), a benchmark suite for studies of Chip-Multiprocessors (CMPs), and shows that the benchmark suite covers a wide spectrum of working sets, locality, data sharing, synchronization and off-chip traffic.
Journal ArticleDOI

Linearizability: a correctness condition for concurrent objects

TL;DR: 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.