TL;DR: Intel® oneMKL PARDISO 2026.0 delivers significant performance improvements for direct sparse solvers
Key improvements:
- Reordering (Phase1): Up to 2.7x faster with improved paralllel nested dissection
- Geometric mean speedup: 1.7x across diverse matrices
- Parallel nested dissection now the default (iparm[1]=3)
- CNR mode now supports parallel version (no performance penalty for reproducible results)
- Factorization (Phase 2): Up to 12x faster
- Geometric mean speedup: 2.5x
- New optimization option (iparm[1]=43) provides up to 2.3x additional speedup for large matrices
Target audience: oneMKL PARDISO users
Intel® oneAPI Math Kernel Library (oneMKL) PARDISO 2026.0 delivers breakthrough performance for direct sparse solvers—up to 12x faster factorization and 2.7x faster reordering compared to the 2024.0 release. These improvements directly accelerate simulation and scientific computing workflows across diverse industries, including semiconductor design, aerospace engineering, automotive, energy systems, and research institutions worldwide. This article highlights the key optimizations introduced over the past two years and provides practical guidance on parameter settings to help you maximize performance in your applications.
Direct sparse solvers typically consist of three phases: (1) reordering, (2) factorization, and (3) solve. In most applications, the majority of execution time is spent in reordering and factorization, making these the primary focus of our optimization efforts.
Faster reordering
The reordering phase (phase 1) permutes the matrix to reduce fill-in and performs symbolic factorization. This phase is dominated by memory-intensive graph operations and often creates scaling bottlenecks for large problems.
One of the most widely used fill-reducing ordering algorithms is nested dissection. In the oneMKL 2025.0 release, the performance and scalability of our parallel nested dissection implementation was significantly improved, leading to substantial gains in the reordering phase. Figure 1 shows the speedups observed for various matrices from the SuiteSparse Matrix Collection. In the oneMKL 2026.0 release, further optimizations were introduced across several algorithms in this phase, achieving a geometric mean speedup of 1.7x and up to 2.7x speedup on individual matrices compared to oneMKL 2024.0. Details of the benchmark and experimental setup can be found in the Appendix.
Due to these improvements, starting from oneMKL 2026.0 release parallel nested dissection algorithm (iparm[1]=3) is made a default choice rather than the serial version (iparm[1]=2). Using the full node of the test system, the parallel version is on average 2x faster than the serial counterpart on the given dataset. In almost all cases there are no performance drawbacks in going to the parallel version but may result in slightly higher memory requirements.
Furthermore, users requiring bitwise reproducible results (CNR mode) can now benefit from the parallel variant. Previously, oneMKL PARDISO would internally switch to the slower serial METIS version in CNR mode—this limitation has been removed.
Fast factorizations
Intel oneMKL 2026.0 introduces numerous optimizations for the factorization phase (phase 2), delivering dramatic performance gains.
With default iparm settings, factorization receives substantial benefits—up to 12.7x faster compared to oneMKL 2024.0 (see Figure 2). This improvement particularly benefits matrices that factorize relatively quickly, making it ideal for applications requiring multiple factorizations of matrices with the same sparsity pattern after an initial reordering.
Circuit simulation is a prime example where these gains translate directly to real-world impact. Figure 3 highlights the speedups achieved on matrices from this domain, with the circuit5M matrix showing a dramatic 27x improvement. For this particular matrix, a portion of the speedup stems from improved reordering quality, which reduces the number of non-zeros in the L and U factors, thereby decreasing both computation and memory requirements during factorization. Beyond performance gains, newer versions are more robust: many large matrices (like rajat31 and circuit5M) which previously required the 64-bit integer interface (ILP64) due to internal buffer overflows will now run successfully with the standard 32-bit integer interface (LP64).
New optimization for large matrices
For matrices that spend considerable time in factorization, we've introduced aggressive optimization modes. These optimizations begin at the reordering phase and are controlled via the iparm[1] parameter—though most of the performance impact occurs in factorization, the setting must be specified right at the beginning of reordering phase to enable the downstream improvements.
How it works: The digit in the tens place of the iparm[1] setting controls optimization aggressiveness:
- 0 (default): No additional optimization
- 1-9: Increasing levels of optimization, with 9 being the most aggressive
Figure 4 shows speedups achieved using optimization level 4 (iparm[1]=43) compared to the default setting (iparm[1]=3). For large matrices where factorization dominates runtime, this feature accelerates factorization by up to 2.3x and in some cases can even surpass 50% of the theoretical peak floating-point performance of the hardware.
When to use:
- Matrix is large (≥1M non-zeros in input matrix and ≥100M non-zeros in LU factors)
- A single factorization step consumes majority (>50%) of the total solve time
- You can accommodate slightly higher memory usage
Note: Small matrices may experience a slight slowdown when enabling this feature (see left side of Figure 4).
Current Limitations: These optimizations currently apply only to the classical factorization algorithm (default, iparm[23]=0). For optimal factorization performance, we recommend using this code path. Support for other factorization algorithms is planned for future releases.
Other developments
Beyond performance improvements, oneMKL PARDISO 2026.0 includes important bug fixes and enhancements. We've addressed Schur complement issues and improved the convergence behavior of iterative refinement routines. Windows OS users will notice enhanced performance. Numerous stability improvements have also been implemented throughout the codebase. For details, refer to release notes and bug fix log.
Thank you
A big shoutout to the numerous customers and active users of oneMKL PARDISO. Your bug reports and feature requests have enabled us to prioritize development efforts and deliver a better product. Thank you!
Appendix: Experimental setup
All experiments were conducted on a single node with two Intel® Xeon® 6980P Processor on AvenueCity platform with 1536 GB (24 slots/ 64GB/ 8800) total MRDIMM memory, ucode 0x1000405, HT on (used physical cores only), Turbo on, Ubuntu 24.04.4 LTS, 6.8.0-124-generic.
The node was configured in SNC3 (Sub-NUMA Clustering-3) mode, creating six NUMA domains in total (three per socket). We utilized all 256 physical cores with OpenMP thread pinning in close mode. The Intel oneMKL library with OpenMP threading layer and LP64 interface was used throughout, except where noted with * indicating ILP64 interface.
The matrices were sourced from the SuiteSparse Matrix Collection. The solver was configured with custom parameters (iparm[0]=1). All benchmarks employed the classical factorization algorithm (iparm[23]=0). The parallel nested dissection algorithm was used for fill-reducing ordering with default optimization mode (iparm[1]=3), except for Figure 4 where comparative runs with optimization level 4 (iparm[1]=43) were also conducted (details in the corresponding section).
For convergence verification, we ensured all matrices achieved a relative residual of at most 1e-8. Iterative refinement (iparm[7]) with a maximum of eight iterations was enabled for matrices that did not initially converge. In cases where convergence was still not achieved, matching (iparm[12]) and scaling (iparm[10]) features were activated. All other iparm parameters were set to 0.