Linear-Time Multilevel Graph Partitioning via Edge Sparsification

TL;DR

The paper tackles the trade-off between partition quality and runtime in graph partitioning by presenting a linear-time multilevel framework that uses edge sparsification to enforce geometric reduction across levels. By combining geometric coarsening with 2-hop clustering under a size bound and multiple sparsification strategies, the authors prove an $O(n+m)$ expected total work and demonstrate strong empirical performance. They integrate the method into KaMinPar, achieving up to $4\times$ speedups with only about 1% loss in the partition objective and outperforming both linear-time single-level and streaming partitions. The work also analyzes worst-case instances via modularity and shows that graphs with low modularity are more prone to slower behavior, motivating the sparsification step as a practical safeguard.

Abstract

The current landscape of balanced graph partitioning is divided into high-quality but expensive multilevel algorithms and cheaper approaches with linear running time, such as single-level algorithms and streaming algorithms. We demonstrate how to achieve the best of both worlds with a \emph{linear time multilevel algorithm}. Multilevel algorithms construct a hierarchy of increasingly smaller graphs by repeatedly contracting clusters of nodes. Our approach preserves their distinct advantage, allowing refinement of the partition over multiple levels with increasing detail. At the same time, we use \emph{edge sparsification} to guarantee geometric size reduction between the levels and thus linear running time. We provide a proof of the linear running time as well as additional insights into the behavior of multilevel algorithms, showing that graphs with low modularity are most likely to trigger worst-case running time. We evaluate multiple approaches for edge sparsification and integrate our algorithm into the state-of-the-art multilevel partitioner KaMinPar, maintaining its excellent parallel scalability. As demonstrated in detailed experiments, this results in a $1.49\times$ average speedup (up to $4\times$ for some instances) with only 1\% loss in solution quality. Moreover, our algorithm clearly outperforms state-of-the-art single-level and streaming approaches.

Figures (9)

• Figure 1: Illustration of Theorem \ref{['thm:twohop_analysis']}, with examples of the different cluster types. Note that the green cluster to the right is created by 2-hop clustering.
• Figure 2: Contracting the bolded edges leads to increased density on the coarse graph.
• Figure 3: Remaining total edge weight (left) and number of edges (right) after one coarsening step, compared to the modularity of the graph. The $y$-values are denoted as a fraction of the initial value. Based on Lemma \ref{['lemma:modularity']}, we expect most points (i.e., graphs) to be in the upper right half.
• Figure 4: Relative cut and running time of KaMinPar with weighted threshold sampling (T-Weight), uniform sampling (UR), or threshold sampling via Weighted Forest Fire scores (T-WFF) versus baseline (no sparsification) on the tuning benchmark set with $k = 16$.
• Figure 5: Partition quality (left) and speedup over baseline (no sparsification, right) of sparsification algorithms: weighted threshold sampling (T-Weight), uniform sampling (UR), and threshold sampling via (Weighted) Forest Fire scores (T-(W)FF).

Theorems & Definitions (2)

• Theorem 1
• Lemma 2