pdGRASS: A Fast Parallel Density-Aware Algorithm for Graph Spectral Sparsification

TL;DR

pdGRASS is a novel parallel algorithm for graph spectral sparsification that significantly improves scalability and efficiency over previous methods, enabling faster computations with high-quality sparsifiers.

Contribution

The paper introduces pdGRASS, a parallel, density-aware GSS algorithm that overcomes data dependency issues, achieving faster edge recovery and better scalability compared to feGRASS.

Findings

pdGRASS achieves 3.9x to 8.8x speedup over feGRASS.

Sparsifiers from pdGRASS reduce PCG iteration counts by 1.2x to 1.8x.

Over 1000x worst-case runtime improvement over feGRASS.

Abstract

Graph Spectral Sparsification (GSS) identifies an ultra-sparse subgraph, or sparsifier, whose Laplacian matrix closely approximates the spectral properties of the original graph, enabling substantial reductions in computational complexity for computationally intensive problems in scientific computing. The state-of-the-art method for efficient GSS is feGRASS, consisting of two steps: 1) spanning tree generation and 2) off-tree edge recovery. However, feGRASS suffers from two main issues: 1) difficulties in parallelizing the recovery step for strict data dependencies, and 2) performance degradation on skewed inputs, often requiring multiple passes to recover sufficient edges. To address these challenges, we propose parallel density-aware Graph Spectral Sparsification (pdGRASS), a parallel algorithm that organizes edges into disjoint subtasks without data dependencies between them, enabling efficient parallelization and sufficient edge recovery in a single pass. We empirically evaluate feGRASS and pdGRASS based on 1) off-tree edge-recovery runtime and 2) sparsifier quality, measured by the iteration count required for convergence in a preconditioned conjugate gradient (PCG) application. The evaluation demonstrates that, depending on the number of edges recovered, pdGRASS achieves average speedups ranging from 3.9x to 8.8x. The resulting sparsifiers also show between 1.2x higher and 1.8x lower PCG iteration counts, with further improvements as more edges are recovered. Additionally, pdGRASS mitigates the worst-case runtimes of feGRASS with over 1000x speedup. These results highlight pdGRASS's significant improvements in scalability and performance for the graph spectral sparsification problem.

Tables

Table 1. TABLE I: Work-Span analysis of each step in pdGRASS.

Step	Work	Span
1	$O\left(\right|E\left|\lg \right|V\left|\right))$	$O\left({\lg }^2\left|V\right|\right)$
2	$O\left(\left|E\right|\lg \left|E\right|\right)$	$O\left({\lg }^2\left|E\right|\right)$
3	$O\left(\left|E\right|\lg \left|E\right|\right)$	$O\left({\lg }^2\left|E\right|\right)$
4	$O\left(\sum _{i=0}^k{\left|S_i\right|}^2\right)$	$O\left({\left|S_o\right|}^2/p+{\left|S_{\text{serial}}\right|}^2\right)$
Total	$O\left(\left|E\right|\lg \left|E\right|+\sum _{i=0}^k{\left|S_i\right|}^2\right)$	$O\left({\lg }^2\left|E\right|+{\left|S_o\right|}^2/p+{\left|S_{\text{serial}}\right|}^2\right)$
$p$: number of parallel threads. $k$: number of subtasks.
$S_i$: set of edges in $i$-th subtask. $S_{\text{serial}}$: the largest sequential subtask.

Table 2. TABLE II: Evaluation of runtime and subgraph quality. T f ​ e T_{fe} (ms) and T p ​ d − 32 T_{pd-32} (ms) represent the execution times of feGRASS and pdGRASS (with 32 threads), respectively. P ​ a ​ s ​ s Pass represents the number of passes required by feGRASS to restore a sufficient number of edges. The P ​ a ​ s ​ s Pass for pdGRASS is omitted because it always completes in one single pass. i ​ t ​ e ​ r f ​ e iter_{fe} and i ​ t ​ e ​ r p ​ d iter_{pd} represents the number of iterations for the PCG solver to converge when using the generated sparsifier as the preconditioner.

			$\alpha =0.02$						$\alpha =0.05$						$\alpha =0.10$
Graph	$\left|V\right|$	$\left|E\right|$	$T_{fe}$	Pass	$ite{r}_{fe}$	$T_{pd-32}$	$ite{r}_{pd}$	$\frac{ite{r}_{fe}}{ite{r}_{pd}}$	$T_{fe}$	Pass	$ite{r}_{fe}$	$T_{pd-32}$	$ite{r}_{pd}$	$\frac{ite{r}_{fe}}{ite{r}_{pd}}$	$T_{fe}\left(ms\right)$	pass	$ite{r}_{fe}$	$T_{pd-32}$	$ite{r}_{pd}$	$\frac{ite{r}_{fe}}{ite{r}_{pd}}$
01-mi2010	3.30E5	7.89E5	82	1	83	3	93	0.9	116	3	66	6	35	1.9	180	6	57	12	24	2.4
02-mo2010	3.44E5	8.28E5	88	1	84	4	93	0.9	130	3	65	6	34	1.9	202	6	57	13	25	2.3
03-oh2010	3.65E5	8.84E5	92	1	81	3	92	0.9	134	3	65	8	34	1.9	210	6	53	16	25	2.1
04-pa2010	4.22E5	1.03E6	81	1	83	7	93	0.9	117	3	66	11	34	1.9	182	6	58	20	25	2.3
05-il2010	4.52E5	1.08E6	115	1	81	11	99	0.8	170	3	68	13	56	1.2	270	5	55	24	26	2.1
06-tx2010	9.14E5	2.23E6	276	1	87	24	97	0.9	471	3	72	47	34	2.1	836	6	39	96	27	1.4
07-com-DBLP	3.17E5	1.05E6	252	2	134	118	135	1.0	475	6	131	385	121	1.1	897	14	124	1139	105	1.2
08-com-Amazon	3.35E5	9.26E5	130	2	72	128	82	0.9	208	4	61	347	60	1.0	334	7	54	635	49	1.1
09-com-Youtube∗	1.13E6	2.99E6	-	6931	199	1353	190	1.0	-	38308	224	8544	127	1.8	-	103081	161	23062	93	1.7
10-coAuthorsCiteseer	2.27E5	8.14E5	192	2	175	53	111	1.6	341	5	160	160	101	1.6	582	10	128	387	93	1.4
11-citationsCiteseer	2.68E5	1.16E6	514	4	131	115	126	1.0	1245	15	94	338	113	0.9	3021	52	104	791	70	1.5
12-coAuthorsDBLP	2.99E5	9.78E5	248	3	86	105	89	1.0	477	6	83	342	74	1.1	883	14	80	889	62	1.3
13-coPapersDBLP	5.40E5	1.52E7	10770	2	200	105	234	0.9	22813	6	206	420	215	1.0	42865	13	202	3703	192	1.1
14-NACA0015	1.04E6	3.11E6	352	1	98	26	234	0.4	519	2	83	49	85	1.0	834	4	66	92	30	2.2
15-M6	3.50E6	1.05E7	1500	1	105	164	106	1.0	2192	2	89	372	91	1.0	3520	4	66	786	31	2.1
16-333SP	3.71E6	1.11E7	1550	1	107	222	187	0.6	2218	2	88	419	85	1.0	3489	4	69	865	30	2.3
17-AS365	3.80E6	1.14E7	1629	1	105	242	182	0.6	2390	2	87	437	91	1.0	3863	4	70	906	30	2.3
18-NLR	4.16E6	1.25E7	1818	1	108	221	193	0.6	2674	2	89	502	90	1.0	4256	4	71	1052	30	2.4
$\ast$Time out for feGRASS on graph com-Youtube, for $\alpha =0.02,0.05$, feGRASS runs over 10 minutes; for $\alpha =0.10$, feGRASS runs over 1 hour.

Table 3. TABLE III: Statistics of pdGRASS on the com-youtube graph with and without the Judge-Before-Parallel optimization.

Graph: com-youtube	$Without$	$With$
# off-tree edges in biggest task	1852735	1758087
# edges in parallel blocks	1852735	719602
# edges skipped in parallel	1058401 (57%)	0
# edges explored in parallel	794334 (43%)	719602 (100%)
# false positive edges	3048	60

Table 4. TABLE IV: Runtime(ms) of feGRASS (1 thread) and pdGRASS on 1 / 8 / 32 1/8/32 threads ( T 1 T_{1} , T 8 T_{8} , and T 32 T_{32} , respectively), when α = 0.02 \alpha=0.02 .

Graph	$T_{fe}$	$T_1$	$\frac{T_{fe}}{T_1}$	$T_8$	$\frac{T_1}{T_8}$	$T_{32}$	$\frac{T_1}{T_{32}}$	$\frac{T_{fe}}{T_{32}}$
01	82	58	1.4	7	8.3	3	19.3	27.3
02	88	54	1.6	9	6.0	4	13.5	22.0
03	92	58	1.6	10	5.8	3	19.3	30.7
04	81	91	0.9	13	7.0	7	13.0	11.6
05	115	100	1.2	15	6.7	11	9.1	10.5
06	276	350	0.8	53	6.6	24	14.6	11.5
07	252	762	0.3	200	3.8	118	6.5	2.14
08	130	540	0.2	157	3.4	128	4.2	1.0
09∗	-	10631	-	2409	4.4	1353	7.9	-
10	192	207	0.9	68	3.0	53	3.9	3.6
11	514	592	0.9	185	3.2	115	5.2	4.5
12	248	635	0.4	170	3.7	105	6.1	2.4
13	10770	748	14.4	180	4.2	105	7.1	102.6
14	352	469	0.8	57	8.2	26	18.0	13.5
15	1500	4528	0.3	410	11.0	164	27.6	9.2
16	1550	4157	0.4	547	7.6	222	18.7	7.0
17	1629	5326	0.3	551	9.7	242	22.0	6.7
18	1818	6080	0.3	628	9.7	221	27.5	8.2

Equations

$$L_G(i,j)=\{\begin{array}{ll}-w_{i,j},& (i,j)\in E\\ \sum _{(i,k)\in E}{w}_{i,k},& i=j\\ 0,& \text{otherwise.}\end{array}$$

$$\frac{1}{\sigma }{u}^T{L}_{P}u\le u^T{L}_{G}u\le \sigma u^T{L}_{P}u$$

$$W_{\mathrm{eff}}(e)=w_{u,v}\times \frac{\log (\max \{\mathrm{deg}(u),\mathrm{deg}(v)\})}{{\mathrm{dist}}_G(root,u)+{\mathrm{dist}}_G(root,v)}$$

$$R_T(u,v)={\mathrm{dist}}_{re}(u,{\mathrm{LCA}}_T(u,v))+{\mathrm{dist}}_{re}(v,{\mathrm{LCA}}_T(u,v)),$$

$$S_{u,\beta }=\{v:\text{dist}(u,v)\le \beta ,\beta =c\}$$

$$(u^{\prime }\in S_{u,\beta }\vee v^{\prime }\in S_{v,\beta })\vee (u^{\prime }\in S_{v,\beta }\vee v^{\prime }\in S_{u,\beta }).$$

$$(u^{\prime }\in S_{u,\beta }\cup S_{v,\beta })\vee (v^{\prime }\in S_{u,\beta }\cup \in S_{v,\beta }).$$

$${\beta }_{u,v}^{\ast }=\min \{\text{dist}(u,\text{LCA}(u,v)),\text{dist}(v,\text{LCA}(u,v)),c\}$$

$$(u^{\prime }\in S_{u,{\beta }^{\ast }}\wedge v^{\prime }\in S_{v,{\beta }^{\ast }})\vee (u^{\prime }\in S_{v,{\beta }^{\ast }}\wedge v^{\prime }\in S_{u,{\beta }^{\ast }}).$$

$$\mathrm{dist}(u^{\prime },v^{\prime })$$

$$<\mathrm{dist}(u^{\prime },\mathrm{LCA}(u,v))+\mathrm{dist}(\mathrm{LCA}(u,v),v^{\prime }).$$

Full text

1. difficulties in parallelizing the recovery step for strict data dependencies, and 2) performance degradation on skewed inputs, often requiring multiple passes to recover sufficient edges.

To address these challenges, we propose parallel density-aware Graph Spectral Sparsification (pdGRASS), a parallel algorithm that organizes edges into disjoint subtasks without data dependencies between them, enabling efficient parallelization and sufficient edge recovery in a single pass. We empirically evaluate feGRASS and pdGRASS based on 1) off-tree edge-recovery runtime and 2) sparsifier quality, measured by the iteration count required for convergence in a preconditioned conjugate gradient (PCG) application. The evaluation demonstrates that, depending on the number of edges recovered, pdGRASS achieves average speedups ranging from $3.9\times$ to $8.8\times$. The resulting sparsifiers also show between $1.2\times$ higher and $1.8\times$ lower PCG iteration counts, with further improvements as more edges are recovered. Additionally, pdGRASS mitigates the worst-case runtimes of feGRASS with over $1000\times$ speedup. These results highlight pdGRASS’s significant improvements in scalability and performance for the graph spectral sparsification problem.

I Introduction

Graph spectral sparsification (GSS) aims to construct a sparsifier, which is a nearly-linear-sized subgraph that can approximate the spectral information (i.e., eigenvalues and eigenvectors) of the original graph. Researchers have investigated this problem in both theory [1, 2, 3, 4] and practice[5, 6, 7, 8, 9, 10]. Using the sparsifier rather than the original graph facilitates near-linear-time algorithms for a wide variety of computationally-intensive matrix and graph applications such as scientific computing [4], max-flow problems in graphs [11, 12, 13, 4], data mining [14], social network analysis [15], solving large systems of equations [16], machine learning [17], and computer-aided design (CAD) for very large-scale integration (VLSI) [5, 18]. Due to the heavy computational complexity of these applications, graph sparsification is necessary to solve large-scale problems in a reasonable timeframe. Unfortunately, most existing implementations of algorithms for GSS are sequential and stop short of parallelization.

Edge recovery in sparsification. The state-of-the-art method for GSS is feGRASS [7] and pGRASS [19] (a parallel implementation of feGRASS but not open-sourced), which performs two key steps: 1) spanning-tree generation and 2) recovering “dissimilar” spectrally-critical off-tree edges that were not chosen in the first phase but are necessary for improving the approximation quality. The main challenge in designing parallel algorithms for GSS is the off-tree edge recovery phase, as spanning-tree generation has well-known optimized solutions.

Challenges to parallelization from data dependencies. An off-tree edge can be recovered only if it is not similar to all previous recovered edges. In other words, each iteration is inherently dependent on the results of the previous iterations, imposing a sequential constraint on the overall process. The state-of-the-art parallel implementation for GSS is pGRASS [20, 21], which parallelizes over edges in batches but incurs excess work. Edges in the same batch can be similar edges. Specifically, if there are $p$ threads, pGRASS performs similarity check on the next $p$ edges simultaneously while there can be redundant computation, which is unavoidable for the correctness of the parallel algorithm.

Since there is no available implementation for pGRASS, we compare our algorithm directly with feGRASS.

Worst-case inputs. The off-tree edge recovery phase only stops when the algorithm recovers a fixed number of edges of $\alpha|V|$, where $\alpha$ is a predefined ratio that specifies the proportion of edges to be recovered (default value is 2%) and $|V|$ is the number of vertices. For a small $\alpha$ such as 0.01, one pass through the off-tree edges is sufficient to recover enough edges, but when $\alpha$ is set to a moderately larger value, such as 0.05, the feGRASS strategy may require many passes through the off-tree edges to recover enough edges to meet the required threshold. In an extreme case, on the com-Youtube graph in part V, we found that feGRASS requires over $6000$ passes to recover $0.02|V|$ edges. It reveals that algorithm based on vertex cover degrades severely on certain special graph structures.

Density-aware graph spectral sparsification. To address these issues, we propose parallel density-aware Graph Spectral Sparsification (pdGRASS), a fast and accurate parallel algorithm for GSS. Like feGRASS and pGRASS, pdGRASS follows a two-step framework but introduces two key modifications:

1. changing the edge-similarity condition to a “strict” condition to recover more edges in one pass for various graph structures, which gives rise to 2) a careful parallelization strategy based on division of the entire problem into independent “subtasks”. The proposed subtask-level parallelization significantly reduces the data dependencies between edges in feGRASS and pGRASS through subtask partitioning. Furthermore, we find that the strict condition enables pdGRASS to complete recovery in a single pass by retaining more edges.

Mixed parallel strategy. We empirically evaluate several parallelization strategies for pdGRASS and propose a mixed approach that exploits parallelism both within and across subtasks. This is necessary because real-world graphs, characterized by a few high-degree and many low-degree vertices, lead to skewed subtask sizes. Parallelizing only along one dimension would leave performance on the table and unnecessarily serialize the computation. Meanwhile, a mixed parallel strategy can adapt the ratio of the two parallel strategies based on the number of available cores, achieving better speedup.

Results summary. We evaluate the state-of-the-art serial algorithm feGRASS 111We compare with feGRASS because no open-source implementation of pGRASS is available.[7] and the proposed pdGRASS based on:

1. their off-tree edge recovery runtime, and 2) the iteration count required for convergence in a downstream preconditioned conjugate gradient (PCG)[22] solver.  Figure 1 summarizes the results in terms of runtime and PCG iteration count on a suite of 18 input graphs. As $\alpha$ increases and more edges are required to be recovered, the data points collectively shift toward the upper right direction, reflecting consistent improvements of pdGRASS over feGRASS in both run-time efficiency and sparsifier quality as shown in Figure 1. Finally, as detailed in Section V, pdGRASS achieves strong parallel scaling on both uniform and skewed inputs, enabled by its mixed parallel strategy across and within subtasks. On 32 threads, pdGRASS attains an average parallel speedup of $11.3\times$ for $\alpha=0.02$, and further improves to $13.7\times$ and $14.8\times$ for $0.05$ and $0.10$.

II Preliminaries

This section presents background and current algorithms for graph spectral sparsification problem. We introduce key concepts such as the graph Laplacian matrix and then review with the efficient serial algorithm feGRASS [7] and pGRASS [19].

II-A Graph Spectral Sparsification

The Graph Spectral Sparsification (GSS) problem takes a weighted undirected graph $G=(V,E,w)$ as input and generates an ultra-sparse subgraph (also called a sparsifier) $P$ as output which is “spectrally similar” to the original graph $G$.

We first define the Laplacian matrix of a graph $G$, denoted by $L_{G}\in\mathbb{R}^{|V|\times|V|}$.

[TABLE]

A graph $P$ is $\sigma$-spectrally similar to a graph $G$ if for any $u\in\mathbb{R}^{|V|}$,

[TABLE]

where $L_{G}$ and $L_{P}$ are the Laplacian matrices of graphs $G$ and $P$, respectively [23]. If graphs $G$ and $P$ are $\sigma$-spectrally similar, then $\kappa(L_{G},L_{P})\leq\sigma^{2}$, where $\kappa(L_{G},L_{P})$ denotes the relative condition number222The condition number of two matrices $A$ and $B$ is defined as $\kappa(A,B)=\lambda_{\text{max}}(A,B)/\lambda_{\text{min}}(A,B)$ where $\lambda_{\text{max}}$ and $\lambda_{\text{min}}$ denote the largest and smallest nonzero generalized eigenvalues, respectively. of their Laplacian matrices.

II-B feGRASS Algorithm [7]

feGRASS is an efficient serial algorithm for GSS, which consists of two main steps: 1) spanning-tree generation based on the Effective Weight of edges and 2) off-tree edge recovery based on the Resistance Distance of paths in the spanning tree.

Definition 1** (Effective weight).**

The effective weight [7] $W_{\mathrm{eff}}$ of an edge $e=(i,j)$ is defined as follows:

[TABLE]

where $G$ denotes the original graph and $root$ is the vertex with the maximum degree in $G$ and $\text{dist}_{G}(\cdot)$ refers unweighted distance, which can be computed by Breadth-First Search(BFS).

Definition 2** (Resistance distance).**

Given a spanning tree $T$, the resistance distance $R_{T}$ (paraphrased333In the original pGRASS [20, 21] paper, the algorithm partitions the spanning tree so it can run Tarjan’s offline least common ancestor (LCA) algorithm [24]. In this paper, we dynamically compute the LCA, so we do not need to partition the spanning tree. from [7]) of an edge $e=(u,v)$ is defined as

[TABLE]

where $\operatorname{dist}_{re}$ is distance of $u,v$ based on resistant weight $W_{re}$ and $W_{re}(e)=1/w(e)$.

After spanning-tree generation, each edge in the original graph belongs to either the tree edge set and off-tree edge set. The next step is off-tree edge recovery based on the concept of “resistance distance” from the theory of electrical resistance networks [25, 3] which determines spectrally criticality.

Intuitively, two off-tree edges are “similar” if they have “similar positions on the spanning tree”. Formally, similarity is determined by vertex neighborhoods of the endpoints of an off-tree edge, which can be computed with BFS process.

Definition 3** (BFS step size and vertex neighborhoods).**

Let $e=(u,v)$ be a recovered off-tree edge and let $T$ be the spanning tree from the first step. The corresponding BFS step size $\beta$ is defined as a small constant $c$ (default value is 8) in the feGRASS algorithm and let $S_{u,\beta}$ (resp., $S_{v,\beta}$) be the $\beta$-hop neighborhood of vertex $u$ (resp., vertex $v$). That is, $S_{u,\beta}$ is a set containing all vertices with distance at most $\beta$ from $u$ (i.e., all vertices visited in $\beta$ BFS iterations from $u$):

[TABLE]

Definition 4** (Similiar edge (Loose Definition)).**

Suppose we have a spanning tree $T$, an off-tree edge $e=(u,v)$, and BFS step size $\beta$ and get two $\beta$-hop vertex neighborhood sets $S_{u,\beta},S_{v,\beta}$.

An off-tree edge $e^{\prime}=(u^{\prime},v^{\prime})$ is similar to off-tree edge $e$ if

[TABLE]

The process of recovering similar edges can be interpreted as a Vertex Cover problem and we can derive an equivalent formulation of the condition 6 stated above as follows.

[TABLE]

The size of the resulting subgraph in the feGRASS algorithm is constrained by the input parameter $\alpha$, determining the number of recovered edges as $\alpha|V|$. The generated subgraph contains $|V|-1+\alpha|V|$ edges in total. If feGRASS fails to recover $\alpha|V|$ edges after one pass, the algorithm will repeat the off-tree-edge recovery process on the remaining off-tree edges until it recovers $\alpha|V|$ edges.

II-C Parallelizing the feGRASS Algorithm

Subsequent work introduced pGRASS [20], a parallel algorithm based on feGRASS, which focuses on parallelizing the off-tree edge recovery step because the other steps have standard parallel solutions. First, the algorithm computes the effective resistance of every edge in the original graph using the spanning tree, which can be parallelized using divide-and-conquer to divide the spanning tree into subtrees [20] and applying Tarjan’s offline LCA algorithm [24].

At a high level, pGRASS parallelizes the seemingly-sequential edge-similarity checks by dividing the off-tree edges upfront into sequential blocks such that parallel threads process edges within each block in parallel. Note that the algorithm may perform excess work because it may process edges that are similar to earlier edges in the block in parallel. After all edges in a block have been processed, pGRASS performs a serial pass through all edges in the block to check whether they should truly be recovered, or if they should have been skipped due to parallel edges within the same block.

II-D Analysis method

In this paper, we analyze parallel algorithms in the work-span model [26, Chapter 27]. The work is the total time to execute the entire algorithm in serial. The span is the longest serial chain of dependencies in the computation. In the work-span model with binary forking, a parallel for loop with $k$ iterations with $O(w_{i})$ work and $O(S_{i})$ span in the $i$-th iteration has $O(\sum\limits^{k}_{i=0}w_{i})$ work and $O(\log(k)+\max\limits_{i=0}^{k}S_{i})$ span.

III Parallel Density-Aware Graph Spectral Sparsification

This section proposes parallel density-aware Graph Spectral Sparsification (pdGRASS), an efficient algorithm for GSS that resolves the drawbacks of feGRASS:

1. loose approximation and 2) redundant work during parallelization.

The pdGRASS algorithm modifies the off-tree edge recovery phase to restrict the similarity condition to recover more off-tree edges within one pass, and parallelize disjoint subproblems that avoid redundant work due to data dependencies as described in Section II.

III-A Density-Aware Approximation Condition

The density-aware approximation restricts the similarity condition in Definition 4 to require that both endpoints of potentially similar edges be contained in the separate $\beta$-hop neighborhoods of the original edge endpoints rather than either endpoint. We further introduce a new definition for the parameter $\beta$ as follows.

[TABLE]

More formally, the density-aware condition replaces the OR condition with AND condition in the endpoint membership.

Definition 5** (Similiar edge (Strict)).**

Suppose we have a spanning tree $T$, an off-tree edge $e=(u,v)$, and BFS step size $\beta_{u,v}^{*}$ and the $\beta^{*}$-hop vertex sets $S_{u,\beta^{*}},S_{v,\beta^{*}}$. An off-tree edge $e^{\prime}=(u^{\prime},v^{\prime})$ is strictly similar to off-tree edge $e$ if

[TABLE]

To clearly delineate between the two conditions going forward, we will use the term loosely similar to refer to the similarity definition in feGRASS and pGRASS (Definition 4).  Figure 3 presents a worked example of edge similarity under the previous loose condition and the proposed strict condition.

Under strict similarity conditions, only two edges with highly similar positions are considered similar, which enables pdGRASS to recover a sufficient number of edges in a single recovery pass. In contrast, feGRASS, which is based on vertex cover, tends to meet the similarity condition more easily, and thus can only recover a small number of edges in each pass. In extreme cases, feGRASS may recover only one edge per round. More specifically, if the constant $\beta$ is greater than or equal to the diameter of the spanning tree, then recovering any single edge can cover the entire graph.

Properties of strictly-similar edges. Next, we show how the strict edge-similarity condition in Definition 5 give rise to disjoint subproblems without redundant work. The full version of the paper will contain the proofs.

Lemma 6** (Strictly similar edges share their LCA).**

If off-tree edge $e^{\prime}=(u^{\prime},v^{\prime})$ is strictly similar to off-tree edge $e=(u,v)$, on a spanning tree $T$, then $\operatorname{LCA}(u,v)=\operatorname{LCA}(u^{\prime},v^{\prime})$.

Lemma 7** (Contraposition).**

Given two off-tree edges $e=(u,v)$, $e^{\prime}=(u^{\prime},v^{\prime})$ and a spanning tree $T$, if $\ \operatorname{LCA}(u,v)\neq\operatorname{LCA}(u^{\prime},v^{\prime})$, then $e^{\prime}$ cannot be strictly similar to $e$.

Lemma 8** (Strict similarity is non-commutative).**

Given a spanning tree $T$, let $e=(u,v)$ and $e^{\prime}=(u^{\prime},v^{\prime})$ be two strictly similar off-tree edges determined by first recovering $e$, performing BFS from $u$ and $v$ to get $\beta$-hop neighborhoods, and applying the strict similarity condition. If edge $e^{\prime}$ was recovered first, edge $e$ may not have been marked strictly similar to $e^{\prime}$.

Lemma 6 proves that two strictly similar off-tree edges must share a LCA on spanning tree, which forms the basis for dividing all off-tree edges into groups based on their LCA. Then  Lemma 7 (contraposition of  Lemma 6) forms the basis for dividing the off-tree edges into disjoint subtasks in pdGRASS based on the LCA of their endpoints. If the LCAs of the endpoints of two edges do not match, they cannot possibly be strictly similar, so we can skip their similarity check. Therefore, pdGRASS groups off-tree edges based on the LCA of their endpoints. Only edges within a group need to be checked, because edges cannot be strictly similar across groups.

Lemma 8 shows that the edges in the subtasks must be processed in sorted order because strict similarity is non-commutative. In other words, any parallelization within a subtask must process edges in order. According to its definition in Equation 8, $\beta$ is further constrained by the minimum between a shorter distance and a predefined constant $c$, so the final value of $\beta$ is no greater than the one used in the theoretical proof. Hence, the introduction of the constant $c$ does not affect the validity of the previously established properties.

Due to space limitations, we sketch some of the proofs in this section, but will include all proofs in the full version.

IV Parallelizing pdGRASS

This section will 1) show how the properties in Section III give rise to disjoint subtasks and 2) discuss several parallelization strategies of the subtasks depending on their size. Then we analyze the work and span of the proposed pdGRASS algorithm using the analysis model from Section II.

IV-A Parallelization Strategies

First, we propose several subtask parallelization strategies based on the data dependencies shown in Lemmas 7 and 8 and distribution of the size of the subtasks.

Outer parallelization. The most straightforward parallelization method is outer parallelization, or parallelization across the subtasks. By Lemma 7, all of these subtasks can be processed independently because there are no strictly similar edges across subtasks. The similarity checks are embarassingly parallel across subtasks, so there is no need for additional complexity.

Inner parallelization. If some subtasks are much larger than others, which is likely due to the skewed nature of graphs, inter-task parallelization alone may not be sufficient to achieve good parallel speedup. Therefore, we can also perform inner parallelization within tasks using the same blocked method as pGRASS described in Section II. In the initial pGRASS parallelization method, the list of off-tree edges is divided into blocks upfront, and edges in each block are processed in parallel, but the blocks themselves are serialized. Some of the edges in a block may have been marked during a previous block, so the amount of edges that need to be processed in subsequent blocks depends on previous blocks.

During each edge recovery, the algorithm first checks whether the current edge has already been marked. If so, it enters the continue branch and skips further processing. When a set of edges is processed in parallel, threads that enter the continue branch may lead to execution bubbles. We propose an optimization method, Judge-before-Parallel, that extracts the if-condition checks outside the parallel region, thereby eliminating conditional branching and ensuring full thread utilization without idle threads.

Heuristic-based mixed parallel strategy. In pdGRASS, we always apply outer-task parallelism across the independent subtasks, but use heuristics to determine whether to apply inner-task parallelism in a given subtask based on whether the subtasks is sufficiently large (i.e., it has many edges or covers over 10% of total edges). We found that in practice, applying inner-task parallelism in subtasks with at least 1E5 edges resulted in good parallel speedup. Outer parallelism may encounter issues with uneven thread load. When a very large subtask is assigned to a particular thread, that thread may still be executing even after all other subtasks have finished, which results in a decline in overall performance. Therefore, we need to apply an inner parallel strategy for such large tasks.

IV-B Algorithm Description and Analysis

Finally, we describe pdGRASS and analyze its work and span in the binary-forking model described in Section II. The full version will contain the proofs.

At a high level, pdGRASS applies the strict edge-similarity condition and divides the edges into disjoint subtasks according to the LCA of their endpoints. From Lemma 6, if two edges are not strictly similar, they have different LCAs. Edges must be processed sequentially within a subtask, according to Lemma 8, but pdGRASS can apply inner parallel strategy of dividing the edges into blocks, as described in Section II.

There are four main steps in pdGRASS: 1) computing the resistance distance for each off-tree edge, 2) sorting the off-tree edges by their resistance distance, 3) creating subtasks based on shared LCAs and sorting them based on their size, and 4) recovering edges via the strict edge-similarity condition within mixed parallel strategy on subtasks.  Table I summarizes the work and span bounds for each of these steps.

V Evaluation

This section empirically evaluates pdGRASS compared to feGRASS in terms of their 1) recovery runtime and 2) sparsifier quality, in terms of the iteration count required for convergence when using the sparsifier in a downstream application of preconditioned conjugate gradient (PCG)  [22]. Then we evaluate the strong scaling of pdGRASS on representative cases of skewed and uniform subtask distributions to evaluate the impact of different parallelization strategies. Experiments show that the mixed parallel strategy consistently achieves effective parallel scaling across diverse data distributions.

Setup. We performed experiments on an Rocky Linux (8.9, Green Obsidian) server with AMD EPYC 7T83 64-Core Processor. Each core has 32 KB L1d/L1i and 512 KB L2 caches, with a 32 MB L3 cache shared per socket. We implemented pdGRASS in C++17 with OpenMP 4.5 [27] and compiled by GCC 8.5.0. We compare with the open-source444https://github.com/5Mrzhao/CSP/blob/main/Sfegrass.cpp implementation of feGRASS. To do an apples-to-apples comparison of the recovery step, pdGRASS uses the same spanning tree as feGRASS. We report the minimum runtime over 5 trials of the edge recovery step.

The parameter $\alpha$ defines the ratio of edges to be recovered. We evaluate feGRASS and pdGRASS with $\alpha$ set to 0.02, 0.05, and 0.10 to assess performance across different recovery ratios.

We measure sparsifier quality by the iteration count required for convergence in a PCG solver from MATLAB R2023b to evaluate GSS performance. Specifically, given a subgraph $P$ of the original graph $G$, the PCG solver uses $L_{P}$ as the preconditioner to solve $||L_{G}x-b||\leq 10^{-3}||b||$ iteratively. A lower iteration count indicates a higher-quality sparsifier.

Datasets. We evaluate the algorithms on a suite of 18 graphs from the SuiteSparse Matrix Collection [28], including datasets from SNAP [29] and DIMACS10 [30]. We select symmetric matrices representing undirected graphs with a single connected component. For graphs without edge weights, we assign random positive weights uniformly sampled between 1 and 10.  Table II summarizes the graph sizes.

pdGRASS parameters. Given $p$ threads, we set the block size (as defined in Section II) to $p$, enabling $p$ edges to be processed in parallel. This design follows the Judge-Before-Parallel optimization to maximize thread occupancy. pdGRASS first handles large tasks using inner parallelism in a one-by-one manner and then applies outer parallelism to the remaining tasks. The cutoff between inner and outer is defined as 1E5, or 10% of the total off-tree edges, effectively isolating larger subtasks for improved performance. As for $\alpha$, we choose $0.02,0.05,0.10$ and report the results in Table II. The default in previous work [7] is $\alpha=0.02$, but we show that pdGRASS with increasing $\alpha$ can efficiently compute higher-quality subgraphs than with smaller $\alpha$.

Runtime. On 32 threads, pdGRASS shows a significant runtime advantage over feGRASS. Excluding the com-youtube dataset due to a timeout, pdGRASS achieves average speedups of $8.76\times$, $6.32\times$, and $3.94\times$ over feGRASS under 32-thread execution, for $\alpha=0.02$, $0.05$, and $0.10$, respectively. These results align with our algorithmic analysis: as $\alpha$ increases and more edges are recovered, the problem size grows, causing the runtime of pdGRASS with single thread to increase faster than that of feGRASS due to its inherently quadratic complexity, whereas feGRASS operates in linear time.

As discussed in Section I, pdGRASS addresses the worst-case runtimes encountered by feGRASS on challenging inputs. Although feGRASS has lower theoretical complexity, its vertex-cover-based loose similarity condition leads to many edges being marked as similar, often requiring multiple passes to meet recovery targets. com-Youtube, a highly skewed graph where a few high-degree vertices connect to many others, exemplifies this issue. Once a high-degree vertex is covered, nearly all incident edges are marked as similar, severely limiting the number of edges recoverable per pass. Even with $\alpha=0.02$, feGRASS requires over 6000 passes to recover enough edges. While each pass runs in linear time, the cumulative overhead results in significant performance degradation. Excluding com-youtube, feGRASS still requires an average of 1.6, 4.1, and 9.7 passes to recover 2%, 5%, and 10% of edges, respectively. In contrast, pdGRASS ’s stricter similarity condition allows substantially more edges to be recovered per pass.

Quality. As shown in Table II, pdGRASS yields lower PCG iteration counts than feGRASS on most datasets as $\alpha$ increases, indicating improved subgraph quality. The iteration ratio between feGRASS and pdGRASS rises from $0.9\times$ at $\alpha=0.02$ to $1.3\times$ at $\alpha=0.05$, and $1.8\times$ at $\alpha=0.10$, suggesting that pdGRASS benefits more from increased edge recovery. At $\alpha=0.10$, pdGRASS consistently achieves convergence with roughly half the PCG iterations required by feGRASS. Although $\alpha=0.02$ is commonly used in feGRASS as a heuristic to balance quality and runtime, pdGRASS ’s higher efficiency enables the use of larger $\alpha$ values to produce higher-quality subgraphs without significant overhead.

The strict similarity condition in pdGRASS allows more spectrally critical edges to be recovered, leading to higher-quality subgraphs. In contrast, feGRASS employs a looser condition, which often causes some spectrally important edges to be marked as similar and excluded from recovery once their endpoints are covered.

Strong Scalability. We conducted a comparison between feGRASS and pdGRASS by evaluating their performance ratios on 1, 8, and 32 threads. As the number of threads increases to 32, pdGRASS consistently surpasses feGRASS in performance across all datasets, with an average speedup of $8.8\times$. Notably, pdGRASS delivers over $20\times$ speedup on 5 out of 18 tested datasets. Furthermore, pdGRASS scales efficiently, achieving an average speedup of $5.8\times$ on 8 threads and $11.3\times$ on 32 threads. On skewed inputs, the inner parallel region dominates execution time due to extreme load imbalance, while the outer region contributes minimally and quickly saturates in speedup. A mixed parallel strategy is essential in this case to balance the workload and improve scalability. On more uniform inputs, even task distribution enables efficient parallelism, resulting in near-ideal strong scaling across threads. More detailed tables will be included in the full version.

VI Conclusion

We present pdGRASS, an efficient parallel Graph Spectral Sparsification (GSS) algorithm generating density-aware subgraphs. pdGRASS improves the state-of-the-art feGRASS by 1) restricting edge-similarity conditions to recover more edges per pass, and 2) parallelizing over the resulting independent subtasks. Experiments demonstrate significant enhancements in graph quality and runtime. A mixed parallel strategy is proposed to handle graph structures with diverse subtask distributions, ensuring balanced workload and full thread utilization.

Appendix A Proofs

Lemma (Strictly similar edges share their LCA) If off-tree edge $e^{\prime}=(u^{\prime},v^{\prime})$ is strictly similar to off-tree edge $e=(u,v)$, on a spanning tree $T$, then $\operatorname{LCA}(u,v)=\operatorname{LCA}(u^{\prime},v^{\prime})$.

Lemma (Contraposition) Given two off-tree edges $e=(u,v)$, $e^{\prime}=(u^{\prime},v^{\prime})$ and a spanning tree $T$, if $\ \operatorname{LCA}(u,v)\neq\operatorname{LCA}(u^{\prime},v^{\prime})$, then $e^{\prime}$ cannot be strictly similar to $e$.

Proof.

Without loss of generality, let $u^{\prime}\in S_{u,\beta}$ and $v^{\prime}\in S_{v,\beta}$. By construction, $\operatorname{LCA}(u,v)$ is also an ancestor of both $u^{\prime}$ and $v^{\prime}$. For contradiction, suppose there is another vertex $w=\operatorname{LCA}(u^{\prime},v^{\prime})\neq\operatorname{LCA}(u,v)$, such that $w$ has greater depth than $\operatorname{LCA}(u,v)$. Therefore,

[TABLE]

However, there is only one path between any two vertices on a tree. If there were another such vertex $w$ with greater depth, it would have also been the LCA of $u$ and $v$. Thus, the LCA for both pairs of vertices must be the same: $\operatorname{LCA}(u^{\prime},v^{\prime})=\operatorname{LCA}(u,v)$. ∎

Lemma (Strict similarity is non-commutative) Given a spanning tree $T$, let $e=(u,v)$ and $e^{\prime}=(u^{\prime},v^{\prime})$ be two strictly similar off-tree edges determined by first recovering $e$, performing BFS from $u$ and $v$ to get $\beta$-hop neighborhoods, and applying the strict similarity condition. If edge $e^{\prime}$ was recovered first, edge $e$ may not have been marked strictly similar to $e^{\prime}$.

Proof.

Without loss of generality, assume \operatorname{dist}(\operatorname{LCA},u)\leq\ \ $\operatorname{dist}(\operatorname{LCA},v)$, so $\beta=\operatorname{dist}(\operatorname{LCA},u)$. Also without loss of generality, suppose that $u^{\prime}\in S_{u,\beta}$ and $v^{\prime}\in S_{v,\beta}$, and that $\beta^{\prime}=\operatorname{dist}(\operatorname{LCA},v^{\prime})<\operatorname{dist}(\operatorname{LCA},u^{\prime})$. Suppose that $\beta^{\prime}<\beta$. We will proceed with proof by construction. Let $\beta^{\prime}<\operatorname{dist}(\operatorname{LCA},v)/2$. Therefore, $v^{\prime}$ is $v$’s ancestor and $\operatorname{LCA}$’s descendant. By definition, $\operatorname{dist}(\operatorname{LCA},v)=\operatorname{dist}(\operatorname{LCA},v^{\prime})+\operatorname{dist}(v^{\prime}v)$ and $\operatorname{dist}(lca,v^{\prime})<dist(v^{\prime},v)$. Since $\beta^{\prime}=\operatorname{dist}(\operatorname{LCA},v^{\prime})<dist(v^{\prime},v)$, when performing $\beta^{\prime}$-hop BFS from vertex $v^{\prime}$, vertex $v$ will not be visited. Thus, off-tree edge $e$ would not be marked similar to $e^{\prime}$ if $e^{\prime}$ was recovered first.  Figure 5 illustrates an example of non-commutative property for strict similarity. ∎

Lemma (Work analysis) Let $S_{i}$ denote the set of edges in subtask $i$, and let $k$ be the number of subtasks. The pdGRASS algorithm has $O(|E|\lg|E|+\sum\limits^{k}_{i=0}|S_{i}|^{2})$ work.

Proof.

The first step computes the resistance distance for each off-tree edge, which takes $O(|E|\lg|V|)$ work using binary lifting as described earlier. The second step sorts the off-tree edges based on their resistance distance, which takes $O(|E|\lg|E|)$ work with any standard sorting algorithm. Preparing the subtasks takes $O(|E|\lg|E|)$ work with one serial pass through the off-tree edges and subsequent sorting of subtasks based on their size in edges. The fourth step recovers off-tree edges according to the strict edge-similarity condition. In the worst case, every edge in each subtask must check against every edge after it in the subtask if no edges are marked similar. Therefore, the worst-case work of subtask $i$ is $|S_{i}|^{2}$, and the worst-case work over all the subtasks is $O(|E|\lg|E|+\sum\limits^{k}_{i=0}|S_{i}|^{2})$. The work of the entire algorithm is $O(|E|\lg|E|+\sum\limits^{k}_{i=0}|S_{i}|^{2})$ by adding up the work of the steps. ∎

Lemma (Span analysis) Let $p$ denote the number of parallel threads, $S_{i}$ denote the set of edges in subtask $i$, and let $S_{\text{serial}}$ denote the largest subtask that is performed sequentially. The pdGRASS algorithm has $O(\lg^{2}|E|+|S_{0}|^{2}/p+|S_{\text{serial}}|^{2})$ span.

Proof.

The span of the first step is $O(\lg^{2}|V|)$ from the span of constructing the skip table. The $|E|$ LCA and distance queries have $O(\lg|E|+\lg|V|)$ span, which is asymptotically smaller than the span of skip-table construction.

Steps 2 and 3 can be solved with any standard parallel sorting algorithm, such as parallel merge sort, in $O(\lg^{2}|E|)$ span [26].

The span of the edge-recovery step is $O(|S_{o}|^{2}/p+|S_{\text{serial}}|^{2})$. All of the subtasks can proceed in parallel, and some of them are further parallelized internally using the same blocking method as pGRASS. The largest task $S_{o}$ dominates the time for the tasks that use intra-task parallelism, and processing it takes $O(|S_{0}|^{2}/p)$ span. In the worst case, no edges are marked as similar, so the subtask takes quadratic work, but all of the comparisons can proceed in parallel. Furthermore, the largest serial task dominates the span for the sequential tasks, and contributes $O(|S_{\text{serial}}|^{2})$ to the span in the worst case. The span of the entire algorithm is $O(\lg^{2}|E|+|S_{o}|^{2}/p+|S_{\text{serial}}|^{2})$ by adding up the span of the steps. ∎

Appendix B Algorithm details

B-A Analysis

Work analysis. First, we give an analysis of the work in the worst case, which is dominated by the edge-recovery phase and therefore the subtasks. Theoretically, the worst-case work is quadratic in the size of the subproblems because the algorithm cannot guarantee that any edges marked as similar, so all edges must be compared with all other edges. However, in practice, the runtime is much better than the suggested worst-case bound, because many edges are marked similar and can be skipped.

Lemma 9** (Work analysis).**

Let $S_{i}$ denote the set of edges in subtask $i$, and let $k$ be the number of subtasks. The pdGRASS algorithm has $O(|E|\lg|E|+\sum\limits^{k}_{i=0}|S_{i}|^{2})$ work.

Span analysis. Next, we analyze the span, or the longest path through the computation DAG (and the time on infinitely many processors) in the binary forking model described in Section II.

Lemma 10** (Span analysis).**

Let $p$ denote the number of parallel threads, $S_{i}$ denote the set of edges in subtask $i$, and let $S_{\text{serial}}$ denote the largest subtask that is performed sequentially. The pdGRASS algorithm has $O(\lg^{2}|E|+|S_{0}|^{2}/p+|S_{\text{serial}}|^{2})$ span.

Appendix C Judge-Before-Parallel Optimization

Table III shows that on the skewed com-youtube graph, where $95\%$ of the edges are in the largest subtask, 57% of thread iterations enter the “continue” branch during execution and become idle without Judge-before-Parallel optimization. For the other $43\%$ of thread iterations, $0.4\%$ of the computation is redundant which does not contribute to the final results. In contrast, the inner parallel strategy in pdGRASS with the Judge-before-Parallel optimization reduces the percentage of redundant edge computations to $0.01\%$.

Appendix D Data

D-A Parallel Scalability of pdGRASS

Next, we measure 1) the scalability of pdGRASS on all datasets with 8 and 32 threads as well as the 2) strong scaling with increasing thread count on two representative inputs. Due to space limitations, we report results with with $\alpha=0.02$ in Table IV, but we find that the results are similar with different $\alpha$.

First, we conducted a comparison between feGRASS and pdGRASS by evaluating their performance ratios on 1, 8, and 32 threads. In a single-threaded setting, feGRASS demonstrates better performance than pdGRASS across the majority of datasets, aligning with our prior theoretical complexity analysis. As the number of threads increases to 32, pdGRASS consistently surpasses feGRASS in performance across all datasets, with an average speedup of $8.8\times$. Notably, pdGRASS delivers over $20\times$ speedup on many of the tested datasets. Furthermore, pdGRASS scales efficiently, achieving an average speedup of $5.8\times$ on 8 threads and $11.3\times$ on 32 threads.

Strong scaling on representative cases. Furthermore, we select two representative cases to further investigate typical subtask distribution patterns. The com-Youtube graph represents a skewed distribution, where the largest subtask occupies the majority of the workload. In contrast, the M6 dataset illustrates a uniform distribution, characterized by a large number of subtasks, each with relatively small data sizes. These two representative subtask distributions reflect two extreme cases of parallel execution strategies within the algorithm. In scenarios with a skewed distribution, the largest subtask accounts for most of the workload, rendering the outer parallelism ineffective. In such cases, parallel efficiency relies heavily on inner parallel execution. In contrast, when subtasks are uniformly distributed, the algorithm relies entirely on outer parallelism, taking advantage of the balanced workload to deliver strong scalability and improved performance.

Scaling on skewed inputs. First, we study the strong scaling on the skewed com-Youtube graph. In this case, the inner parallel part accounts for nearly the entire execution time because the largest subtask accounts for over 99% of the off-tree edges, leading to severe load imbalance across threads. Therefore, a mixed parallel strategy becomes essential to effectively handle such workload imbalances.

Figures 7 and 8 show the thread speedup for inner and outer parallel parts, respectively. In contrast, the outer parallel component processes a limited number of subtasks with relatively small data volumes, contributing only a negligible portion of the total runtime. For outer parallel part, tasks with fewer subtasks and smaller scales quickly reach an upper bound in speedup as the number of threads increases. In Figure 8, a good speedup is achieved at 2 threads, but as the thread count continues to rise, the speedup plateaus at around $2\times$. For inner parallel part, although the algorithm introduces additional computations for serial checks to ensure correctness, Figure 7 still shows that the speedup continues to increase as the number of threads grows, achieving around $8\times$ speedup with 32 threads.

Scaling on uniform inputs. Next, we measure the strong scaling on the M6 graph, which exhibits a more uniform distribution on the subtask sizes. In this case, the largest subtask accounts for less than 0.3%, while the number of subtasks is large and their distribution is relatively balanced. In this scenario, all tasks are assigned to the outer parallel part, as this ensures even thread load distribution and keeps threads fully utilized. As shown in Figure 6, the speedup approaches the ideal value with thread scaling (about $28\times$ speedup on 32 threads).