[Paper Review] FastSV: A Distributed-Memory Connected Component Algorithm with Fast Convergence

Yongzhe Zhang, Ariful Azad+1 more|arXiv (Cornell University)|Oct 14, 2019

Graph Theory and Algorithms28 references4 citations

TL;DR

FastSV is a high-performance, scalable distributed-memory algorithm for computing connected components in large undirected graphs, leveraging simplified linear algebraic operations from GraphBLAS and novel hooking strategies to accelerate convergence. It achieves 30-second processing of a 134B-edge hyperlink graph using 262K cores on a Cray XC40, outperforming the prior state-of-the-art LACC by an average of 2.21× speedup.

ABSTRACT

This paper presents a new distributed-memory algorithm called FastSV for finding connected components in an undirected graph. Our algorithm simplifies the classic Shiloach-Vishkin algorithm and employs several novel and efficient hooking strategies for faster convergence. We map different steps of FastSV to linear algebraic operations and implement them with the help of scalable graph libraries. FastSV uses sparse operations to avoid redundant work and optimized MPI communication to avoid bottlenecks. The resultant algorithm shows high-performance and scalability as it can find the connected components of a hyperlink graph with over 134B edges in 30 seconds using 262K cores on a Cray XC40 supercomputer. FastSV outperforms the state-of-the-art algorithm by an average speedup of 2.21x (max 4.27x) on a variety of real-world graphs.

Motivation & Objective

• To design a faster, scalable distributed-memory algorithm for connected components in massive graphs.
• To simplify the Shiloach-Vishkin algorithm by removing redundant steps while maintaining fast convergence.
• To optimize performance through dynamic use of sparse operations and efficient MPI communication.
• To achieve high scalability on supercomputing platforms with hundreds of thousands of cores.
• To outperform existing state-of-the-art algorithms like LACC and ParConnect in both runtime and scalability.

Proposed method

• FastSV simplifies the Shiloach-Vishkin algorithm by retaining only two core steps: conditional tree hooking and shortcutting.
• It maps these steps to GraphBLAS operations, using sparse matrix-vector multiplication (SpMV) and sparse matrix sparse vector multiplication (SpMSpV) for efficiency.
• The algorithm dynamically selects between SpMV and SpMSpV based on changes in the grandparent vector to reduce redundant computation.
• It employs optimized MPI communication patterns to avoid bottlenecks in distributed-memory execution.
• Novel hooking strategies are introduced to accelerate convergence, reducing the number of iterations required.
• The implementation uses CombBLAS for distributed-memory platforms and integrates with SuiteSparse:GraphBLAS for shared-memory support.

Experimental results

Research questions

• RQ1 Can a simplified version of the Shiloach-Vishkin algorithm achieve faster convergence and better performance in distributed-memory systems?
• RQ2 How can GraphBLAS operations be effectively used to express and optimize connected component algorithms at scale?
• RQ3 What impact do dynamic operation selection (SpMV vs. SpMSpV) and communication optimization have on performance in large-scale graphs?
• RQ4 Can novel hooking strategies reduce iteration count without sacrificing correctness or scalability?
• RQ5 How does FastSV compare in performance and scalability to the state-of-the-art LACC algorithm on real-world and synthetic graphs?

Key findings

• FastSV computes connected components of a 134B-edge hyperlink graph in just 30 seconds using 262,144 cores on a Cray XC40 supercomputer.
• The algorithm achieves an average speedup of 2.21× (maximum 4.27×) over the prior state-of-the-art LACC algorithm across a variety of real-world graphs.
• The use of dynamic SpMV/SpMSpV selection significantly reduces runtime in later iterations, especially in high-density graphs.
• FastSV's simplified logic and optimized communication enable high scalability, outperforming LACC despite requiring more iterations due to the removal of unconditional hooking.
• The algorithm is generic and portable, supporting both distributed-memory (CombBLAS) and shared-memory (SuiteSparse:GraphBLAS) platforms.
• FastSV demonstrates strong performance on graphs with up to 3.27 billion vertices and 124.9 billion edges, confirming its readiness for exascale-scale data workloads.