[Paper Review] Parallel Graph Decompositions Using Random Shifts

Gary L. Miller, Richard Peng+1 more|arXiv (Cornell University)|Jul 14, 2013

Graph Theory and Algorithms16 references15 citations

TL;DR

This paper presents a simplified, efficient parallel algorithm for decomposing undirected unweighted graphs into low-diameter subgraphs with few inter-partition edges. By using random shifts to guide a parallel ball-growing process via shifted shortest paths, it achieves an O(log²n / β) depth and O(m) work for a (β, O(log n / β)) decomposition, matching the best sequential guarantees with improved simplicity.

ABSTRACT

We show an improved parallel algorithm for decomposing an undirected unweighted graph into small diameter pieces with a small fraction of the edges in between. These decompositions form critical subroutines in a number of graph algorithms. Our algorithm builds upon the shifted shortest path approach introduced in [Blelloch, Gupta, Koutis, Miller, Peng, Tangwongsan, SPAA 2011]. By combining various stages of the previous algorithm, we obtain a significantly simpler algorithm with the same asymptotic guarantees as the best sequential algorithm.

Motivation & Objective

• To design a simpler, work-efficient parallel algorithm for low-diameter graph decomposition in undirected unweighted graphs.
• To overcome the sequential bottleneck in traditional ball-growing methods by enabling parallel piece construction using random shifts.
• To achieve asymptotic performance comparable to the best sequential algorithms while maintaining polylogarithmic depth and nearly-linear work.
• To support faster parallel solvers for symmetric diagonally dominant (SDD) linear systems by improving the underlying decomposition subroutine.

Proposed method

• The algorithm uses independent random shifts δu for each vertex u, which are used to define shifted distances dist−δ(u,v) = dist(u,v) − δv.
• Vertices are assigned to clusters based on the minimum shifted distance to any center, forming a partition via a parallel shortest path computation.
• The shifted shortest path computation is implemented using parallel BFS with depth O(log²n / β) and work O(m), leveraging the PRAM model.
• The random shifts ensure that the strong diameter of each cluster is bounded by O(log n / β) with high probability.
• Tie-breaking is handled by the fractional parts of δu, which can be emulated via a random permutation to avoid floating-point arithmetic.
• The algorithm repeats until a valid (β, O(log n / β)) decomposition is found, with constant expected number of iterations due to high success probability.

Experimental results

Research questions

• RQ1 Can a simpler parallel graph decomposition algorithm be designed that matches the theoretical guarantees of the best sequential methods?
• RQ2 How can the sequential dependency in ball-growing be eliminated to enable efficient parallelization?
• RQ3 What role do random shifts play in ensuring low strong diameter and bounded inter-cluster edge count?
• RQ4 Can the performance of SDD linear system solvers be improved by replacing their decomposition subroutine with this new method?
• RQ5 To what extent can random shifts be replaced by random permutations without degrading the theoretical guarantees?

Key findings

• The algorithm computes a (β, O(log n / β)) decomposition in O(log²n / β) depth and O(m) work, matching the best known sequential guarantees.
• The success probability of each iteration is constant, so the expected number of iterations is O(1), leading to expected work and depth bounds.
• The strong diameter of each cluster is bounded by O(log n / β) with high probability due to the properties of the shifted shortest path distances.
• The number of inter-cluster edges is at most βm with high probability, as shown via concentration bounds on the edge boundary.
• The method can be implemented efficiently in the PRAM model using parallel BFS with O(m) work and O(log²n / β) depth.
• The use of random shifts can be replaced by a random permutation of vertices, offering a practical alternative with potentially lower computational cost.