Contention Adapting Search Trees

Abstract

With multicores being ubiquitous, concurrent data structures are becoming increasingly important. This paper proposes a novel approach to concurrent data structure design where the data structure collects statistics about contention and adapts dynamically according to this statistics. We use this approach to create a contention adapting binary search tree (CA tree) that can be used to implement concurrent ordered sets and maps. Our experimental evaluation shows that CA trees scale similar to recently proposed algorithms on a big multicore machine on various scenarios with a larger set size, and outperform the same data structures in more contended scenarios and in sequential performance. We also show that CA trees are well suited for optimization with hardware lock elision. In short, we propose a practically useful and easy to implement and show correct concurrent search tree that naturally adapts to the level of contention. 14th International Symposium on Parallel and Distributed Computing 978-1-4673-7148-3/15 $31.00 statLock(base.lock); 11 if (base.valid == false) { 12 statUnlock(base.lock); 13 return doOperation(tree, operation, key); // retry 14 } else { 15 Object result = operation.execute(base.root, key); 16 if (base.lock.statistics > MAX _ CONTENTION) { 17 if (size(base.root) < 2) base.lock.statistics = 0; 18 else highContentionSplit(tree, base, prevNode); 19 } else if (base.lock.statistics < MIN _ CONTENTION) { 20 if (prevNode == null) base.lock.statistics = 0; 21 else lowContentionJoin(tree, base, prevNode);

Scaling Reliably

“…While some of the improvements made to the Erlang Virtual Machine (Section i) have been thoroughly reported in conference publications [66,46,47,69,70,71], others are reported here for the first time (Sections iii, ii).…”

RCU‐HTM: A generic synchronization technique for highly efficient concurrent search trees

“…Coarse‐grained locking, that is, a single lock protecting the entire ST, is the simplest and most straightforward implementation; however, its performance is poor since all operations are serialized 1 . Fine‐grained approaches either lock specific parts of the tree in an adaptive way 2 or each node individually 3‐8 . Contention‐adaptive STs 2 use an additional layer of routing nodes that route traversals to specific subtrees that are then locked.…”

“…Fine‐grained approaches either lock specific parts of the tree in an adaptive way 2 or each node individually 3‐8 . Contention‐adaptive STs 2 use an additional layer of routing nodes that route traversals to specific subtrees that are then locked. Although this technique is generic, the additional routing layer adds an extra overhead on each tree traversal.…”

“…Fine‐grained locking techniques aim to exploit this concurrency by locking only parts of the tree. Contention‐adaptive trees lock specific parts of the tree depending on the contention level, 2 while more fine‐grained approaches lock each node independently 3‐8 . Fine‐grained approaches have several drawbacks:…”

Jiffy: A Lock-free Skip List with Batch Updates and Snapshots

“…Smaller revisions are more suited for write-heavy workloads whereas large revisions benefit read-dominated workloads, especially when they feature many range scan operations. Automatic adaptation to the workload is accomplished on per-revision basis through a simple, yet versatile policy based on monitoring the time concurrent threads spend executing update (i.e., put, remove and batch update) and read (i.e., lookup or range scan) operations, not by counting the number of operations performed or monitoring the contention on shared references, as in other existing approaches, e.g., [43,44,51].…”