Concurrent disjoint set union

Abstract

We develop and analyze concurrent algorithms for the disjoint set union (“union-find” ) problem in the shared memory, asynchronous multiprocessor model of computation, with CAS (compare and swap) or DCAS (double compare and swap) as the synchronization primitive. We give a deterministic bounded wait-free algorithm that uses DCAS and has a total work bound of $$O\biggl ( m \cdot \left( \log {\left( \frac{np}{m} + 1 \right) } + \alpha {\left( n, \frac{m}{np} \right) } \right) \biggr )$$ O ( m · log np m + 1 + α n , m np ) for a problem with n elements and m operations solved by p processes, where $$\alpha $$ α is a functional inverse of Ackermann’s function. We give two randomized algorithms that use only CAS and have the same work bound in expectation. The analysis of the second randomized algorithm is valid even if the scheduler is adversarial. Our DCAS and randomized algorithms take $$O(\log n)$$ O ( log n ) steps per operation, worst-case for the DCAS algorithm, high-probability for the randomized algorithms. Our work and step bounds grow only logarithmically with p, making our algorithms truly scalable. We prove that for a class of symmetric algorithms that includes ours, no better step or work bound is possible. Our work is theoretical, but Alistarh et al (In search of the fastest concurrent union-find algorithm, 2019), Dhulipala et al (A framework for static and incremental parallel graph connectivity algorithms, 2020) and Hong et al (Exploring the design space of static and incremental graph connectivity algorithms on gpus, 2020) have implemented some of our algorithms on CPUs and GPUs and experimented with them. On many realistic data sets, our algorithms run as fast or faster than all others.

A Universal Technique for Machine-Certified Proofs of Linearizable Algorithms

“…In particular, we prove the linearizability of two famous data structures: (1) the aforementioned Herlihy-Wing queue [18], which is notorious for being hard to prove correct [30]; and (2) Jayanti's single-writer, single-scanner snapshot algorithm, in which processes play asymmetric roles [22]. We also prove the strong linearizability of the Jayanti-Tarjan union-find object [25,23,26], which is known to be the fastest algorithm for computing connected components on CPUs and GPUs [10,20]. All our proofs have been certified by the proof assistant TLAPS (temporal logic of actions proof system) [29], and are publicly available on GitHub 1 .…”

“…Our proof thereby applies to a wide class of concurrent union-find variants that we dub "any-try splitting". Incidentally, two-try splitting has the better theoretical efficiency bound [26], but one-try splitting seems to perform slightly better in practice on most test cases [10,20]. To our knowledge, other variations of any-try splitting are yet to be tested in practice.…”

“…In this section, we consider Jayanti and Tarjan's concurrent union-find implementation [25,23,26], and describe our TLAPS certified proof of its strong linearizability. We chose Jayanti and Tarjan's algorithm due its extensive use in practice-it is the fastest algorithm for computing connected components of a graph on CPUs [10] and GPUs [20], and has several other applications [2].…”

“…However, for efficiency of future find operations, the Jayanti and Tarjan observed that it helps to compact the tree, i.e., change the parent pointers of the intermediate nodes encountered along the x π -to-root find path to point closer to the root. They presented two variants of compaction for their algorithm [26], called: one-try splitting and two-try splitting. In one-try splitting: for each intermediate node u π on the find path, the implementation attempts to improve u π .par from its parent a π (line 2), to its grand-parent b π (line 3) via a CAS, and then moves on to the next node (the goto line…”

Faster Parallel Exact Density Peaks Clustering

“…In addition to our two dependent point finding algorithms, we also introduce an optimization technique for density computation: while counting the number of points within the neighborhood of a particular query point, we prune the searches through kd-tree subtrees completely contained within that neighborhood by storing the number of points each subtree contains inside the kd-tree and directly adding that number to the total number of points. Finally, we solve the single-linkage clustering step of the algorithm (Step 3) by using a parallel union-find data structure [41], which has O(nα(n, n)) expected work and O(log n) span with high probability, where α represents the inverse Ackermann's function.…”