We partition to parallelize multiplication of one or more dense vectors by a sparse matrix (SpMVor SpMM ). We consider contiguous partitions, where the  rows (or columns) of a sparse matrix with N nonzeros are split into K parts without reordering. We propose exact and approximate contiguous partitioners that minimize the maximum runtime of any processor under a diverse family of cost models that combine work and hypergraph communication terms in symmetric or asymmetric settings. This differs from traditional partitioning models which minimize total communication, or from traditional load balancing models which only balance work. One can view our algorithms as optimally rounding one-dimensional embeddings of direct K-way noncontiguous partitioning problems. Our algorithms use linear space. Our 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_{ \text{high }/(c_{ \text{low }\epsilon)) is O(N^C) for C < 1, where c_{ \text{high } and c_{ \text{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_{ \text{high }/(c_{ \text{low }\epsilon)) from linear time , but is faster in practice . We empirically demonstrate that all of our algorithms efficiently produce high-quality contiguous partitions  .
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 .
R
We partition to parallelize multiplication of one or more dense vectors by a sparse matrix (SpMVor SpMM
Graph partitioning schedules parallel calculations like sparse matrix-vector multiply (SpMV
A
m
R
exact and approximate contiguous partitioners that minimize the maximum runtime of any processor under a diverse family of cost models that combine work and hypergraph communication terms in symmetric or asymmetric settings. This differs from traditional partitioning models which minimize total communication, or from traditional load balancing models which only balance work. One can view our algorithms as optimally rounding one-dimensional embeddings of direct K-way noncontiguous partitioning problems. Our algorithms
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
R
Our
The
R
\text{high
high
R
\text{low
low
R
\text{high
high
R
\text{low
low
R
\text{high
high
R
\text{low
low
D
, but is faster in practice
D
all of
A
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