Distributed Reductions for the Maximum Weight Independent Set Problem

TL;DR

This work addresses the NP-hard Maximum Weight Independent Set (MWIS) problem on graphs that exceed a single machine's memory by introducing distributed data-reduction techniques that apply local MWIS rules within a distributed-memory setting. It presents two solver families—distributed reduce-and-greedy and distributed reduce-and-peel—with both synchronous and asynchronous variants, and demonstrates that graph partitioning can further shrink graphs before reduction. In experiments on up to $p=1024$ processors, the approach achieves substantial speedups over the state-of-the-art sequential solver while enabling MWIS on graphs with more than $10^9$ vertices and $1.7 imes10^{10}$ edges; the asynchronous reductions reach about 33x speedup and the reduce-and-greedy variant up to about 50x, with trade-offs in solution quality. The results show that distributed reductions yield compact, globally equivalent problem instances and enable scalable MWIS solvers on massive graphs, paving the way for broader adoption of distributed-memory techniques in combinatorial optimization.

Abstract

Finding maximum-weight independent sets in graphs is an important NP-hard optimization problem. Given a vertex-weighted graph $G$, the task is to find a subset of pairwise non-adjacent vertices of $G$ with maximum weight. Most recently published practical exact algorithms and heuristics for this problem use a variety of data-reduction rules to compute (near-)optimal solutions. Applying these rules results in an equivalent instance of reduced size. An optimal solution to the reduced instance can be easily used to construct an optimal solution for the original input. In this work, we present the first distributed-memory parallel reduction algorithms for this problem, targeting graphs beyond the scale of previous sequential approaches. Furthermore, we propose the first distributed reduce-and-greedy and reduce-and-peel algorithms for finding a maximum weight independent set heuristically. In our practical evaluation, our experiments on up to $1024$ processors demonstrate good scalability of our distributed reduce algorithms while maintaining good reduction impact. Our asynchronous reduce-and-peel approach achieves an average speedup of $33\times$ over a sequential state-of-the-art reduce-and-peel approach on 36 real-world graphs with a solution quality close to the sequential algorithm. Our reduce-and-greedy algorithms even achieve average speedups of up to $50\times$ at the cost of a lower solution quality. Moreover, our distributed approach allows us to consider graphs with more than one billion vertices and 17 billion edges.

Figures (9)

• Figure 4.1: Graph $\mathop{\mathrm{\mathcal{G}}}\nolimits$ is distributed over PE $1$ and $2$ (left). PE $1$ proposes to include vertex $c$; PE $2$ proposes to include $y$ and then $x$ (middle). Note that at the time when $c$ and $x$ are proposed to be included, the only neighbor $b$ of $c$ in $G_i$ was already reduced by PE $2$. Thus, proposing to include $c$ and $x$ reduces globally an isolated cut-edge as stated in \ref{['lem:IncInterfaceVertices']}. Since both have equal weight, we can simply use the PE ranks to break ties between $c$ and $x$ for an MWIS $\mathop{\mathrm{\mathcal{I}}}\nolimits$ of $\mathop{\mathrm{\mathcal{G}}}\nolimits$. This is described in Remark \ref{['rem:includeVertex']} in more detail.
• Figure 4.2: Example of \ref{['dred:HeavyVertex']} in the perspective of PE $i$. The reduction proposes to include the interface vertex $v\in V_i$ in $G_i$ because ${\color{red}10}=\mathop{\mathrm{\omega}}\nolimits_i(v)\geq\alpha(G_i[N_i(v)])={\color{red}10}$. The closed neighborhood $N_i[v]$ is reduced from $G_i$ which results in $G_i'=G_i-N_i[v]$.
• Figure 4.3: Example of \ref{['dred:BasicSingleEdge']} from the perspective of PE $i$. The reduction excludes the interface vertex $v\in V_i$ in $G_i$ because for a neighbor $u\in N_i(v)$ holds ${\color{red}10}=\mathop{\mathrm{\omega}}\nolimits_i(u)\geq\mathop{\mathrm{\omega}}\nolimits_i(N_i(u)\setminus N_i(v))={\color{red}9}$. This results in the reduced graph $G_i'=G_i-v$.
• Figure 4.4: Example for \ref{['dred:ExtendedSingleEdge']} from the perspective of PE $i$. It holds ${\color{red}11}=w_i(v)\geq \mathop{\mathrm{\omega}}\nolimits_i(N(v)) - \mathop{\mathrm{\omega}}\nolimits_i(u) = {\color{red} 10}$. Thus, the reduction excludes the common local neighbors $x_1$ and $x_2$ of the adjacent local vertices $v$ and $u$. This results in the reduced graph $G_i'=G_i-v$.
• Figure 7.1: (Relative) reduction impact on the number of vertices when running DisReduA in our strong-scaling experiments on up to 1 024 cores.

Theorems & Definitions (26)

• Proof 1
• Definition 4.1: Distributed Reduction Model
• Lemma 4.2: Upper Bound for Ghost Weights
• Lemma 4.3: Neighborhood
• Lemma 4.4: Include Alternatives
• Lemma 4.5: Include Operation
• Remark 4.6: Include Operation
• Lemma 4.7: Remaining Vertex
• Proof 2
• Remark 4.8: Exhaustively Reducing Degree One Vertices