Contiguous Graph Partitioning For Optimal Total Or Bottleneck Communication

TL;DR

This paper introduces near-linear time algorithms for contiguous graph partitioning, optimizing total and bottleneck communication costs, significantly improving efficiency and quality over previous methods in parallel sparse matrix computations.

Contribution

The paper presents the first near-linear time algorithms for contiguous graph partitioning problems, including total and bottleneck objectives, with practical efficiency demonstrated on real matrices.

Findings

Achieved a 53x speedup over prior algorithms for hypergraph connectivity partitioning.

Demonstrated high-quality partitions with mean runtime of 5.15 SpMVs.

Produced efficient partitions for 42 test matrices, improving parallel computation performance.

Abstract

Graph partitioning schedules parallel calculations like sparse matrix-vector multiply (SpMV). We consider contiguous partitions, where the $m$ rows (or columns) of a sparse matrix with $N$ nonzeros are split into $K$ parts without reordering. We propose the first near-linear time algorithms for several graph partitioning problems in the contiguous regime. Traditional objectives such as the simple edge cut, hyperedge cut, or hypergraph connectivity minimize the total cost of all parts under a balance constraint. Our total partitioners use $O(Km + N)$ space. They run in $O((Km\log(m) + N)\log(N))$ time, a significant improvement over prior $O(K(m^2 + N))$ time algorithms due to Kernighan and Grandjean et. al. Bottleneck partitioning minimizes the maximum cost of any part. We propose a new bottleneck cost which reflects the sum of communication and computation on each part. Our bottleneck partitioners use linear space. The exact algorithm runs in linear time when $K^2$ is $O(N^C)$ for $C < 1$. Our $(1 + \epsilon)$-approximate algorithm runs in linear time when $K\log(c_{high}/(c_{low}\epsilon))$ is $O(N^C)$ for $C < 1$, where $c_{high}$ and $c_{low}$ are upper and lower bounds on the optimal cost. We also propose a simpler $(1 + \epsilon)$-approximate algorithm which runs in a factor of $\log(c_{high}/(c_{low}\epsilon))$ from linear time. We empirically demonstrate that our algorithms efficiently produce high-quality contiguous partitions on a test suite of 42 test matrices. When $K = 8$, our hypergraph connectivity partitioner achieved a speedup of $53\times$ (mean $15.1\times$) over prior algorithms. The mean runtime of our bottleneck partitioner was 5.15 SpMVs.