Parallelizing the Approximate Minimum Degree Ordering Algorithm: Strategies and Evaluation

TL;DR

This work tackles the challenge of parallelizing the approximate minimum degree (AMD) ordering algorithm in shared memory to reduce fill-in before Cholesky factorization. It introduces a novel framework based on parallel elimination of distance-2 independent sets, along with specialized concurrent data structures to minimize memory contention. The approach yields the first scalable shared-memory AMD implementation, achieving up to 8.30x speedup on 64 threads over the sequential SuiteSparse AMD and maintaining ordering quality with a near 1.1x fill-in factor. These results demonstrate a practical path to accelerating sparse preconditioning, enabling faster solutions for large-scale scientific computations and informing future parallelization strategies for graph-based matrix factorization orders.

Abstract

The approximate minimum degree algorithm is widely used before numerical factorization to reduce fill-in for sparse matrices. While considerable attention has been given to the numerical factorization process, less focus has been placed on parallelizing the approximate minimum degree algorithm itself. In this paper, we explore different parallelization strategies, and introduce a novel parallel framework that leverages multiple elimination on distance-2 independent sets. Our evaluation shows that parallelism within individual elimination steps is limited due to low computational workload and significant memory contention. In contrast, our proposed framework overcomes these challenges by parallelizing the work across elimination steps. To the best of our knowledge, our implementation is the first scalable shared memory implementation of the approximate minimum degree algorithm. Experimental results show that we achieve up to an 8.30x speedup using 64 threads over the state-of-the-art sequential implementation in SuiteSparse.

Figures (7)

• Figure 1: An example illustrating how elimination graphs work. For demonstration purposes, we eliminate vertices 5, 2, and 9 in order, rather than following the minimum degree criterion. When a vertex is eliminated, its neighbors form a clique.
• Figure 2: An example illustrating how quotient graphs work. For demonstration purposes, we eliminate variables 5, 2, and 9 in order, rather than following the minimum degree criterion. Circles represent variables and squares represent elements.
• Figure 3: An example illustrating how to compute approximate degrees after eliminating variable 7. To determine the exact degree of variable 8 in $\mathcal{G}^4$, which is 4, one would need to compute $|\mathcal{L}_2 \cup \mathcal{L}_7 \cup \mathcal{L}_9 \setminus \{8\}|$. A naïve estimate using a union bound results in double counting, as variables 4 and 6 appear twice, yielding an estimate of 6. The approximate degree, however, mitigates such double counting by leveraging information already captured in $\mathcal{L}_7$ (from the pivot 7). Specifically, the estimate is computed as $|\mathcal{L}_7 \setminus \{8\}| + |\mathcal{L}_2 \setminus \mathcal{L}_7| + |\mathcal{L}_9 \setminus \mathcal{L}_7| = 5$, with only variable 6 being double counted.
• Figure 4: When multiple elimination is applied to an independent set $\{1, 3, 7, 9\}$, memory contention arises because multiple pivots attempt to update the connections of shared neighbors---variables 2, 4, 6, and 8. Moreover, since these variables are adjacent to more than one pivot, computing their approximate degrees becomes cumbersome. In contrast, using multiple elimination on a distance-2 independent set $\{1, 9\}$ avoids these issues entirely, where variables 2 and 4 are only adjacent to pivot 1 and variables 6 and 8 are only adjacent to pivot 9.
• Figure 5: Runtime breakdown of our parallel AMD algorithm as the number of threads scales from 1 to 64.