Lock-Free Augmented Trees

TL;DR

The paper addresses designing concurrent augmented trees by introducing a general technique that separates the mutable augmentation into immutable Version-trees attached to a lock-free Node-tree, enabling atomic snapshots and linearizable queries. It demonstrates the approach with a wait-free static trie that supports order-statistic queries in $O(\log N)$ time and a lock-free BST augmentation that maintains $O(h)$ query costs without increasing update time, with an alternative $O(\log |S|)$ query variant. A key idea is cooperative propagation via Refresh/double-Refresh to the root, so a Root.version snapshot can be used to run sequential augmentation code in a wait-free, linearizable manner. The work also provides a variant using red-black trees to speed up queries, analyzes complexity, and extends the technique to other augmentations and to more general multi-point queries, offering a practical framework for lock-free augmented data structures with strong correctness guarantees.

Abstract

Augmenting an existing sequential data structure with extra information to support greater functionality is a widely used technique. For example, search trees are augmented to build sequential data structures like order-statistic trees, interval trees, tango trees, link/cut trees and many others. We study how to design concurrent augmented tree data structures. We present a new, general technique that can augment a lock-free tree to add any new fields to each tree node, provided the new fields' values can be computed from information in the node and its children. This enables the design of lock-free, linearizable analogues of a wide variety of classical augmented data structures. As a first example, we give a wait-free trie that stores a set $S$ of elements drawn from $\{1,\ldots,N\}$ and supports linearizable order-statistic queries such as finding the $k$th smallest element of $S$. Updates and queries take $O(\log N)$ steps. We also apply our technique to a lock-free binary search tree (BST), where changes to the structure of the tree make the linearization argument more challenging. Our augmented BST supports order statistic queries in $O(h)$ steps on a tree of height $h$. The augmentation does not affect the asymptotic running time of the updates. For both our trie and BST, we give an alternative augmentation to improve searches and order-statistic queries to run in $O(\log |S|)$ steps (with a small increase in step complexity of updates). As an added bonus, our technique supports arbitrary multi-point queries (such as range queries) with the same time complexity as they would have in the corresponding sequential data structure.

Figures (12)

• Figure 1: Examples of the trie data structure when $U=\{0,1,2,3\}$. Nodes are shown as squares, Versions are shown as circles containing their $sum$ fields.
• Figure 2: Object types used in wait-free trie data structure.
• Figure 3: Implementation of wait-free augmented trie.
• Figure 4: Key steps of an Insert($3$) into the initially empty set shown in \ref{['init-fig']}.
• Figure 5: Call to Refresh in proof that a double refresh successfully propagates updates to a Node from its children. The horizontal axis represents time, and boxes indicate the interval between a routine's invocation and its response. Numbers refer to line numbers in the pseudocode. An arrow $s_1 \rightarrow s_2$ indicates step $s_1$ must precede step $s_2$.

Theorems & Definitions (22)

• Definition 1
• Lemma 4
• Lemma 7
• Lemma 8
• Corollary 10
• Lemma 12
• Lemma 13: Lemma 14 and 17 of EFHR14
• Lemma 14: Lemma 19 of EFHR14
• Lemma 15: Lemma 20 of EFHR14
• Lemma 16: Lemma 21 of EFHR14