Randomized Concurrent Set Union and Generalized Wake-Up

Jayanti, Siddhartha; Tarjan, Robert E.; Boix-Adserà, Enric

doi:10.1145/3293611.3331593

Cited by 14 publications

(14 citation statements)

References 21 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Another point is that compression by rank (subtree height) appears to perform particularly well with respect to other methods (in particular, pseudo-random ranks) since it tends to produce higher-quality compressed trees. Notice that this diverges from the theoretical proposals of [11,13], which avoid ranks due to additional algorithmic complexity.…”

Section: Discussionmentioning

confidence: 65%

“…In this situation, SameSet can safely return false, while Unite can link the first root to the current element of the second Find climb. Goel et al used this technique in sequential versions [12], while Jayanti and Tarjan adopted it for the concurrent environment [13].…”

Section: Optimizationsmentioning

confidence: 99%

“…These algorithms achieve a (total) work complexity upper bound of O(m • (α(n, m p ) + log( np m + 1))). Recent work by these authors, in collaboration with Boix-Adserà, suggested an algorithm with the same total work complexity bounds, but showed that this is optimal for a class of natural "symmetric algorithms" [13].…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

In Search of the Fastest Concurrent Union-Find Algorithm

Alistarh,

Fedorov,

Koval

2019

Preprint

View full text Add to dashboard Cite

Union-Find (or Disjoint-Set Union) is one of the fundamental problems in computer science; it has been well-studied from both theoretical and practical perspectives in the sequential case. Recently, there has been mounting interest in analyzing this problem in the concurrent scenario, and several asymptotically-efficient algorithms have been proposed. Yet, to date, there is very little known about the practical performance of concurrent Union-Find. This work addresses this gap. We evaluate and analyze the performance of several concurrent Union-Find algorithms and optimization strategies across a wide range of platforms (Intel, AMD, and ARM) and workloads (social, random, and road networks, as well as integrations into more complex algorithms). We first observe that, due to the limited computational cost, the number of induced cache misses is the critical determining factor for the performance of existing algorithms. We introduce new techniques to reduce this cost by storing node priorities implicitly and by using plain reads and writes in a way that does not affect the correctness of the algorithms. Finally, we show that Union-Find implementations are an interesting application for Transactional Memory (TM): one of the fastest algorithm variants we discovered is a sequential one that uses coarse-grained locking with the lock elision optimization to reduce synchronization cost and increase scalability.

show abstract

Section: Discussionmentioning

confidence: 65%

Section: Optimizationsmentioning

confidence: 99%

See 1 more Smart Citation

In Search of the Fastest Concurrent Union-Find Algorithm

Alistarh,

Fedorov,

Koval

2019

Preprint

View full text Add to dashboard Cite

show abstract

“…Randomized Two-Try Splitting. Next, we incorporate a more sophisticated randomized algorithm by Jayanti, Tarjan, and Boix-Adserà [60], and refer to this algorithm as UF-JTB. The algorithm either performs finds naively, without using any path compression (FindNaive), or uses a strategy called FindTwoTrySplit, which guarantees provably-efficient bounds for their algorithm, assuming a source of random bits.…”

Section: Finish Algorithmsmentioning

confidence: 99%

“…The algorithm either performs finds naively, without using any path compression (FindNaive), or uses a strategy called FindTwoTrySplit, which guarantees provably-efficient bounds for their algorithm, assuming a source of random bits. We refer to [60] for the pseudocode and proofs of correctness. Concurrent Rem's Algorithm.…”

Section: Finish Algorithmsmentioning

confidence: 99%

ConnectIt

Dhulipala¹,

Hong²,

Shun³

2020

Proc. VLDB Endow.

View full text Add to dashboard Cite

Connected components is a fundamental kernel in graph applications. The fastest existing multicore algorithms for solving graph connectivity are based on some form of edge sampling and/or linking and compressing trees. However, many combinations of these design choices have been left unexplored. In this paper, we design the ConnectIt framework, which provides different sampling strategies as well as various tree linking and compression schemes. ConnectIt enables us to obtain several hundred new variants of connectivity algorithms, most of which extend to computing spanning forest. In addition to static graphs, we also extend ConnectIt to support mixes of insertions and connectivity queries in the concurrent setting. We present an experimental evaluation of ConnectIt on a 72-core machine, which we believe is the most comprehensive evaluation of parallel connectivity algorithms to date. Compared to a collection of state-of-the-art static multicore algorithms, we obtain an average speedup of 12.4x (2.36x average speedup over the fastest existing implementation for each graph). Using ConnectIt, we are able to compute connectivity on the largest publicly-available graph (with over 3.5 billion vertices and 128 billion edges) in under 10 seconds using a 72-core machine, providing a 3.1x speedup over the fastest existing connectivity result for this graph, in any computational setting. For our incremental algorithms, we show that our algorithms can ingest graph updates at up to several billion edges per second. To guide the user in selecting the best variants in ConnectIt for different situations, we provide a detailed analysis of the different strategies. Finally, we show how the techniques in ConnectIt can be used to speed up two important graph applications: approximate minimum spanning forest and SCAN clustering.

show abstract

Concurrent disjoint set union

Jayanti

Tarjan

2021

Distrib. Comput.

Self Cite

View full text Add to dashboard Cite

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.

show abstract

Randomized Concurrent Set Union and Generalized Wake-Up

Cited by 14 publications

References 21 publications

In Search of the Fastest Concurrent Union-Find Algorithm

In Search of the Fastest Concurrent Union-Find Algorithm

ConnectIt

Concurrent disjoint set union

Contact Info

Product

Resources

About