A Randomized Concurrent Algorithm for Disjoint Set Union

  title={A Randomized Concurrent Algorithm for Disjoint Set Union},
  author={Siddhartha V. Jayanti and Robert Endre Tarjan},
  journal={Proceedings of the 2016 ACM Symposium on Principles of Distributed Computing},
  • Siddhartha V. JayantiR. Tarjan
  • Published 25 July 2016
  • Computer Science, Mathematics
  • Proceedings of the 2016 ACM Symposium on Principles of Distributed Computing
Disjoint set union is a basic problem in data structures with a wide variety of applications. [] Key Result Finally, under our independence assumption our algorithm achieves speedup close to linear for applications in which all or most of the processes can be kept busy, thereby partially answering an open problem posed by them.

Randomized Concurrent Set Union and Generalized Wake-Up

This work designs a randomized algorithm that performs at most O(log n) work per operation, and designs a class of "symmetric algorithms'' that captures the complexities of all the known algorithms for the disjoint set union problem, and proves that the algorithm has optimal total work complexity for this class.

In Search of the Fastest Concurrent Union-Find Algorithm

This work evaluates and analyzes the performance of several concurrent Union-Find algorithms and optimization strategies across a wide range of platforms and workloads and finds one of the fastest algorithm variants is a sequential one that uses coarse-grained locking with the lock elision optimization to reduce synchronization cost and increase scalability.

Fast Arrays: Atomic Arrays with Constant Time Initialization

The first algorithms for sequential fast arrays for concurrent fast arrays are presented, which are linearizable and wait-free, uses only linear space, and supports all operations – initialize, read, and write – in constant time.

Disjoint Set Union for Trees

To validate the performance some data sets are generated and solution involving Dsu for trees and two other brute force approaches were executed and runtime of each approach suggests that DSU for Tree takes approximately (Log(N)/N) times the runtime of brute force approach.

Simple Concurrent Connected Components Algorithms

A class of simple algorithms for concurrently computing the connected components of an n-vertex, m-edge graph shows that even a basic problem like connected components still has secrets to reveal.

Simple Concurrent Labeling Algorithms for Connected Components

The results show that even a basic problem like connected components still has secrets to reveal, and all the algorithms studied are simpler than related algorithms in the literature.

A Universal Technique for Machine-Certified Proofs of Linearizable Algorithms

Linearizability has been the long standing gold standard for consistency in concurrent data structures. However, proofs of linearizability can be long and intricate, hard to produce, and extremely

Concurrent disjoint set union

It is proved that for a class of symmetric algorithms that includes the authors' DCAS and randomized algorithms, no better step or work bound is possible, making their algorithms truly scalable.

ConnectIt: A Framework for Static and Incremental Parallel Graph Connectivity Algorithms

The ConnectIt framework is designed, which provides different sampling strategies as well as various tree linking and compression schemes, and is able to compute connectivity on the largest publicly-available graph in under 10 seconds using a 72-core machine.

The Amortized Analysis of a Non-blocking Chromatic Tree

It is proved that a certain implementation of a non-blocking chromatic tree has amortized cost $O(\dot{c} + \log n)$ for each operation, where c is the maximum number of concurrent operations during the execution and n is themaximum number of keys in the tree during the operation.



Wait-free parallel algorithms for the union-find problem

This paper gives a wait-free implementation of an efficient algorithm for union-find and shows that the worst case performance of the algorithm can be improved by simulating a synchronized algorithm, or bysimulating a larger machine if the data structure requests support sufficient parallelism.

A Scalable Parallel Union-Find Algorithm for Distributed Memory Computers

This paper presents the first scalable parallel implementation of the Union-Find algorithm suitable for distributed memory computers and shows the efficiency of the implementation through a series of tests to compute spanning forests of very large graphs.

Wait-free synchronization

A hierarchy of objects is derived such that no object at one level has a wait-free implementation in terms of objects at lower levels, and it is shown that atomic read/write registers, which have been the focus of much recent attention, are at the bottom of the hierarchy.

The cell probe complexity of dynamic data structures

New lower and upper bounds on the time per operation are proved to implement solutions to some familiar dynamic data structure problems including list representation, subset ranking, partial sums, and the set union problem.

A more practical PRAM model

This paper introduces the Asynchronous PRAM model of computation, a variant of the PRAM in which the processors run asy ~chronously and there is an explicit charge for synchronization. A fanfily of

Efficiency of a Good But Not Linear Set Union Algorithm

It is shown that, if t(m, n) is seen as the maximum time reqmred by a sequence of m > n FINDs and n -- 1 intermixed UNIONs, then kima(m), n is shown to be related to a functional inverse of Ackermann's functmn and as very slow-growing.

Disjoint Set Union with Randomized Linking

It is proved that randomized linking is asymptotically as efficient as linking by rank.

Multi-core on-the-fly SCC decomposition

This paper presents a novel parallel, on-the-fly SCC algorithm that preserves the linear-time property by letting workers explore the graph randomly while carefully communicating partially completed SCCs, and develops a concurrent, iterable disjoint set structure.

On-The-Fly parallel decomposition of strongly connected components

This work considers parallelizing SCC algorithms in the setting of an on-the-fly implementation (to be able to detect SCCs while constructing the graph) and proposes a new algorithm that is able to do so and outperforms existing techniques.