Pith. sign in

REVIEW 3 major objections 4 minor 46 references

ShyLU node: On-node Scalable Solvers and Preconditioners Recent Progresses and Current Performance

T0 review · 3 major / 4 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Enhanced ShyLU-node solvers prove efficient for real workloads on CPU and GPU nodes, with Basker beating PARDISO on some circuit matrices, Tacho a 17.7x ice-sheet speedup, and FastILU outpacing standard ILU.

desk verdict A clearly-written software status report with plausible, internally consistent performance numbers; the main weakness is reproducibility, not the algorithms. read the letter →

arxiv 2506.05793 v2 pith:VT5PC4W6 submitted 2025-06-06 math.NA cs.NA

Ichitaro Yamazaki , Nathan Ellingwood , Sivasankaran Rajamanickam This is my paper
classification math.NAcs.NA MSC 65F0565F1065F5065Y05
keywords sparsedirectsolverincompleteLUfactorizationGPUlinearalgebracircuitsimulationdomaindecompositionland-icemodelingTrilinosperformanceportability
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper reports that the ShyLU-node package, enhanced since its original release, now provides linear solvers and a preconditioner that are efficient and robust enough for real scientific and engineering workloads on a single multicore CPU or GPU node. Three components are showcased: Basker, a threaded sparse LU solver for circuit matrices; Tacho, a multifrontal solver used inside a domain-decomposition preconditioner for an Antarctic ice-sheet simulation; and FastILU, an iterative incomplete-LU preconditioner for GPUs. The measurements show Basker can beat Intel's PARDISO on some modern circuit matrices, Tacho delivers up to a 17.7x speedup over CPU cores for local subdomain solves on an NVIDIA A100, and FastILU outperforms standard ILU when a large fill level is needed. The paper's aim is to motivate broader adoption of these open-source, performance-portable solvers by documenting their current state.

What carries the argument

The argument runs on three computational engines. Basker is a column-wise sparse LU factorization that reorders the matrix into block triangular form, factorizes the small diagonal blocks in parallel, then factorizes the largest block in parallel via nested dissection and level-set scheduling. Tacho is a multifrontal sparse direct solver built on Kokkos that uses level-set scheduling for factorization and offers four sparse-triangular-solve (SpTRSV) variants, including a no-fill partitioned-inverse variant that turns the triangular solve into a sequence of sparse matrix-vector products. FastILU is an iterative variant of level-based ILU in which every nonzero entry of the factors is updated in parallel each sweep, with parallelism independent of the matrix sparsity structure; it is paired with FastSpTRSV, an out-of-place iterative triangular solve. These mechanisms are what expose enough parallelism to keep a GPU busy on matrices whose sparsity would otherwise limit parallel speedup.

What would settle it

Run the Basker-versus-PARDISO comparison on a public corpus of modern circuit matrices, such as the SuiteSparse collection: the claim that Basker may outperform PARDISO on certain sparsity structures would be falsified if PARDISO is at least as fast on every matrix in the corpus.

Watch

Extended reading notes

Core claim

The paper's central claim is that after years of robustness and functionality improvements, the ShyLU-node solvers are competitive with vendor-optimized alternatives on current node architectures. For Basker, it claims a threaded column-wise sparse LU factorization, using block triangular form plus nested dissection and level-set scheduling, 'may outperform the vendor-optimized sparse direct solver, PARDISO MKL, depending on the sparsity structure of the matrix.' For Tacho, it claims that as the local subdomain solver in a two-level Schwarz preconditioner for the Albany land-ice simulation, the GPU implementation accelerates the local solves 17.7 times over CPU cores when 4 MPI ranks are used on one Perlmutter node and 2.6 times when 64 are used. For FastILU, it claims that the iterative variant of level-based ILU 'obtained the performance benefit over the standard ILU, especially when a large value of level is needed.' The paper also claims these solvers remain performance portable across CPU, NVIDIA GPU, and AMD GPU architectures through Kokkos.

Load-bearing premise

The performance conclusions rest on a few benchmark matrices that are not all publicly available, single hardware configurations, and comparisons against a baseline from the same developer ecosystem; if these do not represent typical production workloads, the reported advantages may not generalize.

Editorial extensions

If this is right

  • Circuit-simulation codes that currently depend on vendor MKL can use an open-source thread-scalable alternative on matrices whose sparsity lacks large supernodal blocks.
  • Domain-decomposition preconditioners for ice-sheet and other large-scale simulations can offload their local subdomain solves to GPUs and cut solve time by an order of magnitude on current hardware.
  • Users who need high-fill ILU preconditioners on GPUs can generate them faster with FastILU than with standard level-set ILU, at the cost of non-deterministic factorizations.
  • Because the solvers are exposed through the Amesos2 and Ifpack2 interfaces, applications can switch to Basker, Tacho, or FastILU without rewriting their solver calls.
  • A single code base runs on multicore CPUs and on NVIDIA or AMD GPUs, so one Trilinos build can target different node types in a cluster.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Taken together, the three results suggest the single-node factorization bottleneck is no longer the obstacle it once was; follow-on gains for these applications would have to come from distributed-memory communication, coarse-space solves, and the cost of symbolic analysis.
  • The 17.7x GPU speedup at 4 MPI ranks versus the 2.6x at 64 ranks implies the GPU advantage is diluted by subdomain count and MPS overhead; a GPU-aware MPI implementation on clusters like Frontier could restore much of that edge.
  • FastILU's in-place parallel updates make the factorization non-deterministic; production codes that require reproducible solves would need to quantify run-to-run variation in iteration counts, or use a fixed random seed.
  • An independent comparison against other GPU ILU packages would be a natural next test, since the current baseline is a sibling package with overlapping authorship.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. This paper is a software and performance report on three components of the ShyLU-node package in Trilinos: Basker, a threaded sparse direct solver for circuit-simulation matrices; Tacho, a multifrontal sparse direct solver built on Kokkos; and FastILU, an iterative variant of level-based ILU and sparse triangular solve. It describes recent functionality and robustness improvements and reports runtime results on current hardware: Basker versus PARDISO MKL on nine Xyce circuit matrices using up to 16 Intel CPU cores; Tacho as a local subdomain solver in a two-level Schwarz preconditioner for an Albany land-ice simulation on Perlmutter, comparing 64-core CPU runs with A100 GPU runs using MPS; and FastILU versus Kokkos-Kernels standard ILU as a GMRES preconditioner for structured 3D elasticity problems on an NVIDIA H100. The paper concludes that Basker can outperform PARDISO for some circuit matrices, that Tacho accelerates the domain-decomposition solver on GPUs (17.7x at 4 MPI ranks and 2.6x at 64 ranks), and that FastILU gives performance benefits over standard ILU, especially for larger fill levels.

Significance. Taken at face value, the results support the practical claim that the open-source Trilinos solvers are competitive with vendor-tuned sparse solvers on current nodes, which is useful information for the numerical software community. The paper is generally careful to describe the hardware, compilers, and libraries, and it hedges the Basker claim appropriately ('may outperform'). It also reports iteration counts and fill ratios, which allows the reader to evaluate preconditioner quality beyond raw runtimes. The principal weaknesses are the small number of benchmark problems, the absence of repeated-trial statistics, and the ambiguous basis of the CPU-versus-GPU Tacho speedups; these weaknesses currently limit the strength of the paper's quantitative conclusions. The open-source availability of the software is a concrete strength.

major comments (3)
  1. [5, Table 3 and surrounding text] The headline speedups of 17.7x and 2.6x are not well-defined from the reported data. At 4 MPI ranks the CPU run uses 4 cores while the GPU run uses 4 MPS-sliced processes on a shared A100; at 64 MPI ranks the CPU run uses all 64 cores while the GPU run uses 16 ranks per A100. The text states that the comparison uses '16 CPU cores for each GPU,' but Table 3 contains no 16-core CPU column, no GPU kernel-only times, and no MPS overhead figures. As reported, the ratios mix execution modes and cannot support the claim of GPU acceleration at node level. Please report a matched comparison (e.g., full-node CPU time versus full-node GPU time, or one-GPU time with 16 MPS ranks versus 16 CPU cores), and state the MPS overhead explicitly.
  2. [6, Tables 5-6] The FastILU performance benefit is demonstrated only against the standard level-set ILU of Kokkos-Kernels, and reference [20] has overlapping authorship with the present paper; this same-group comparison should be stated explicitly, and an independent baseline (e.g., Ginkgo or a vendor ILU) would strengthen the claim. In addition, the conclusion that FastILU is beneficial 'especially when a large value of level is needed' is based on one structured 3D elasticity problem: at level 0 in Table 6 FastILU is slower in total time than standard ILU, and the benefit at higher levels rests on a single case. Multiple test problems and a disclosed baseline would make the central performance claim more robust.
  3. [4-6, Tables 2-7] All timings appear to be single runs; the paper never states how many trials were averaged, whether the reported times are medians or means, or what the run-to-run variation was. This matters because FastILU is explicitly non-deterministic (Section 6) and because the paper makes quantitative comparative claims. Please state the number of runs and the observed spread for at least the key comparisons (Basker versus PARDISO, Tacho CPU versus GPU, FastILU versus standard ILU), or justify why single runs are sufficient for those claims.
minor comments (4)
  1. [4] The references to 'Table 2b' for the matrix properties and for the performance comparison are inconsistent with the actual table layout; the matrix properties are in Figure 2b, and the comparison is in Table 2 (or its subtables). Please correct the pointers.
  2. [6] In the text near Tables 5 and 6, the number of sweeps is called 'nmax = 2,' but the pseudocode in Figure 5 uses the variable smax; please unify the notation.
  3. [Table 4 caption] The caption contains 'CUP' where 'CPU' is intended, and the sentence 'our comparison is based on the CUP experiments using 16 CPU cores for each GPU' should be reworded for clarity.
  4. [6] The paper states that FastILU is non-deterministic and that no variation in iteration counts was observed, but it does not report any variation in runtimes; a sentence on observed runtime variability would help readers interpret Tables 5-7.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the paper is an empirical performance report; its claims rest on open benchmarks and code measurements, not on definitions, fits, or self-citations that reduce to the conclusions.

full rationale

The paper makes no mathematical derivation or prediction from fitted parameters. Its central claims are measured performance comparisons: Basker versus PARDISO MKL (Section 4, Tables 2), Tacho versus CPU runs and SuperLU (Section 5, Tables 3 and 4), and FastILU versus the standard Kokkos-Kernels ILU (Section 6, Tables 5-7). These are directly falsifiable benchmark measurements against open-source or vendor-supplied implementations; nothing is fitted to a subset of data and then renamed as a prediction. Self-citations appear, e.g., to the original Basker and Tacho algorithm papers [5,6], to the FROSch domain-decomposition framework [21], and to a prior experimental study of CPU configurations [44]. These citations introduce implementations or justify run configurations, but the current performance conclusions are not derived from them; they are measured in this paper. The FastILU comparison baseline, Kokkos-Kernels [20], shares authors with the present work, which is a legitimate conflict-of-interest concern for benchmarking fairness, but it is not circular reasoning because the code is open source and the timings are externally reproducible. Similarly, the Tacho speedup comparisons involve MPS and CPU-core-count choices that may affect generality, but that is a benchmarking ambiguity, not a circular reduction. None of the seven enumerated circularity patterns is present: no self-definitional relation, no fitted input called prediction, no load-bearing self-citation that replaces evidence, no author-imported uniqueness theorem, no ansatz smuggled via citation, and no renaming of a known result as new. The paper is self-contained as an empirical report, so the appropriate finding is no significant circularity.

Assumptions & free parameters 6 free parameters · 5 assumptions · 0 invented entities

No new physical, mathematical, or software entities are invented. The free parameters are algorithmic tuning choices that affect every benchmark and are not always reported with exact values. The axioms are empirical assumptions about representativeness, timing stability, baseline fairness, and accuracy criteria. Because no data or code is shipped, these assumptions carry the main burden for the performance claims.

free parameters (6)
  • Basker partial pivoting threshold tau = 0.001 (default)
    Chosen by hand in Section 4; controls the trade-off between numerical stability and fill-in, and directly affects factorization time and accuracy.
  • Basker zero-column perturbation epsilon = machine epsilon times the 1-norm of the diagonal block
    Introduced in Section 4 as a default when a column has no nonzero entry; affects robustness of the factorization.
  • FastILU number of sweeps smax = 2 in the experiments
    Section 6 states 'We used two sweeps to generate the FastILU preconditioner'; it trades preconditioner quality against factorization time.
  • FastILU damping factor omega = not reported
    Used in Figure 5 pseudocode to update factors at each sweep; the paper says tuning it can stabilize performance but does not give the benchmark values.
  • GMRES restart and convergence tolerance = restart 60, relative residual 1e-6
    Defines when iteration counts are recorded in Sections 5 and 6; the iteration count is the main measure of preconditioner quality.
  • Tacho SpTRSV variant selection = variant 1 for the Albany runs
    Section 5 chooses variant 1 because the numerical factors are recomputed for each solve; this choice affects solve time and setup cost.
assumptions (5)
  • domain assumption Single-run timing measurements are stable and representative.
    Tables 2, 3, 5, 6, and 7 report one number per configuration without variance or repeated runs; the conclusions assume these numbers are reliable.
  • domain assumption The selected Xyce matrices and Albany meshes represent real-world workloads.
    The matrices are supplied by a Sandia collaborator and the meshes are from [43]; neither is published in the paper, so representativeness is assumed.
  • domain assumption Kokkos-Kernels standard ILU is a fair baseline for the FastILU comparison.
    Section 6 compares only against [20], a package with overlapping authorship; the fairness of that baseline is assumed rather than established by external benchmarks.
  • domain assumption The hardware and software environment is configured correctly for benchmarking.
    Sections 4 through 6 list compilers, libraries, and MPS settings; the authors assume these are used correctly and that the measurements reflect the intended configurations.
  • domain assumption GMRES convergence at a relative residual of 1e-6 is the right measure of preconditioner quality.
    Sections 5 and 6 use this criterion for all methods; it may not match the accuracy actually required by the applications.

how reviews work

0 comments
Cite this review

Pith. "Pith review of ShyLU node: On-node Scalable Solvers and Preconditioners Recent Progresses and Current Performance." pith.science (2026). https://pith.science/paper/VT5PC4W6

@misc{pith2026250605793,
  author       = {Pith},
  title        = {Pith review of: ShyLU node: On-node Scalable Solvers and Preconditioners Recent Progresses and Current Performance},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/VT5PC4W6}},
  note         = {Machine review of arXiv:2506.05793}
}
read the original abstract

ShyLU-node is an open-source software package that implements linear solvers and preconditioners on shared-memory multicore CPUs or on a GPU. It is part of the Trilinos software framework and designed to provide a robust and efficient solution of large-scale linear systems from real-world applications on the current and emerging computers. In this paper, we discuss two sparse direct solvers, Basker and Tacho, and an algebraic preconditioner, FastILU, in ShyLU-node package. These ShyLU solvers and preconditioner can be used as a stand-alone global problem solver, as a local subdomain solver for domain decomposition (DD) preconditioner, or as the coarse-problem solver in algebraic multi-grid preconditioner. We present performance results with the sparse direct solvers for real application problems, namely, Basker for Xyce Circuit Simulations and Tacho for Albany Land-Ice Simulation of Antarctica. FastILU has been also used in real-world applications, but in this paper, we illustrate its performance using 3D model problems.

Figures

Figures reproduced from arXiv: 2506.05793 by the authors.

Figure 1
Figure 1. Trilinos Linear Solver Interfaces. overhead associated with forming and operating on the supern￾odal blocks, both KLU and Basker are based on a column-wise sparse LU factorization. In addition, the circuit matrices are non-symmetric and some of them can be reordered into a Block Triangular Form (BTF) [31] with small sparse diagonal blocks. After the matrix is reordered into a BTF structure, KLU and Basker need to fa… view at source ↗
Figure 2
Figure 2. BTF Structure and Properties of Test Matrices [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Nested dissection of sparse matrix (eight threads). [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Sparsity Patterns of Xyce Test Matrices (see Table 2b for the matrix descriptions). [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: Pseudocode of Fast ILU(k) and Sparse-triangular solver with the [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

46 extracted references · 45 canonical work pages

  1. [20]

    Rajamanickam, S

    S. Rajamanickam, S. Acer, L. Berger-Vergiat, V . Dang, N. Ellingwood, E. Harvey, B. Kelley, C. R. Trott, J. Wilke, I. Yamazaki, Kokkos Ker- nels: Performance portable sparse/dense linear algebra and graph kernels (2021). arXiv:2103.11991

    arXiv 2021

  2. [1]

    M. Mayr, A. Heinlein, C. Glusa, S. Rajamanickam, M. Arnst, R. A. Bartlett, L. B.-Vergiat, E. G. Boman, K. Devine, G. Harper, M. Heroux, M. Hoemmen, J. Hu, K. Kim, D. P. Kouri, P. Kuberry, K. Liegeois, C. C. Ober, R. Pawlowski, C. P. ad B. Kelley, M. Perego, E. Phipps, D. Ridzal, N. V . Roberts, C. M. Siefert, H. K. Thornquist, R. Tomasetti, C. R. Trott, R...

    work page 2025

  3. [2]

    URL https://trilinos.github.io

    The Trilinos Project Team, The Trilinos Project Website. URL https://trilinos.github.io

    work page

  4. [3]

    C. R. Trott, D. Lebrun-Grandi ´e, D. Arndt, J. Ciesko, V . Dang, N. Elling- wood, R. Gayatri, E. Harvey, D. S. Hollman, D. Ibanez, N. Liber, J. Mad- sen, J. Miles, D. Poliako ff, A. Powell, S. Rajamanickam, M. Simberg, D. Sunderland, B. Turcksin, J. Wilke, Kokkos 3: Programming model extensions for the exascale era, IEEE Transactions on Parallel and Dis- ...

    work page 2022

  5. [4]

    E. Chow, A. Patel, Fine-grained parallel incomplete lu factorization, SIAM Journal on Scientific Computing 37 (2) (2015) C169–C193

    work page 2015

  6. [5]

    K. Kim, H. C. Edwards, S. Rajamanickam, Tacho: Memory-scalable task parallel sparse Cholesky factorization, in: 2018 IEEE International Paral- lel and Distributed Processing Symposium Workshops (IPDPSW), 2018, pp. 550–559

    work page 2018

  7. [6]

    J. D. Booth, S. Rajamanickam, H. Thornquist, Basker: A threaded sparse LU factorization utilizing hierarchical parallelism and data layouts, in: 2016 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW), 2016, pp. 673–682

    work page 2016

  8. [7]

    HUTCHINSON, E

    S. HUTCHINSON, E. KEITER, R. HOEKSTRA, H. W ATTS, A. W A- TERS, T. RUSSO, R. SCHELLS, S. WIX, C. BOGDAN, THE Xyce ™ PARALLEL ELECTRONIC SIMULATOR – AN OVERVIEW, pp. 165– 172

    work page

Show all 46 references
  1. [8]

    URL https://xyce.sandia.gov

    Xyce: Parallel electronic simulation. URL https://xyce.sandia.gov

  2. [9]

    M. J. Ho ffman, M. Perego, S. F. Price, W. H. Lipscomb, T. Zhang, D. Ja- cobsen, I. Tezaur, A. G. Salinger, R. Tuminaro, L. Bertagna, Mpas-albany land ice (mali): a variable-resolution ice sheet model for earth system modeling using voronoi grids, Geoscientific Model Developme...

    2018

  3. [10]

    URL http://sandialabs.github.io/Albany/

    Albany multiphysics code. URL http://sandialabs.github.io/Albany/

  4. [11]

    Clausen, Performance of Aria running on ATS-2, Trilinos User-Developer Group Meeting, https://trilinos.github.io/ trilinos_user-developer_group_meeting_2022.html (2022)

    J. Clausen, Performance of Aria running on ATS-2, Trilinos User-Developer Group Meeting, https://trilinos.github.io/ trilinos_user-developer_group_meeting_2022.html (2022)

    2022

  5. [12]

    I. S. Du ff, Direct methods for solving sparse systems of linear equations, SIAM Journal on Scientific and Statistical Computing 5 (3) (1984) 605– 619

    1984

  6. [13]

    T. A. Davis, S. Rajamanickam, W. M. Sid-Lakhdar, A survey of direct methods for sparse linear systems, Acta Numerica 25 (2016) 383–566

    2016

  7. [14]

    J. W. Demmel, J. R. Gilbert, X. S. Li, An asynchronous parallel supern- odal algorithm for sparse Gaussian elimination, SIAM Journal on Matrix Analysis and Applications 20 (4) (1999) 915–952. URL https://github.com/xiaoyeli/superlu_mt

    1999

  8. [15]

    Schenk, K

    O. Schenk, K. Gartner, Two-level dynamic scheduling in PARDISO: Im- proved scalability on shared memory multiprocessing systems, Parallel Computing 28 (2) (2002) 187–197

    2002

  9. [16]

    Y . Chen, T. A. Davis, W. W. Hager, S. Rajamanickam, Algorithm 887: Cholmod, supernodal sparse cholesky factorization and update/downdate, ACM Trans. Math. Softw. 35 (3) (2008)

    2008

  10. [17]

    NVIDIA, cuSOLVER: Direct linear solvers on nvidia gpus, https://developer.nvidia.com/cusolver

  11. [18]

    A. M. D. (AMD), rocSOLVER software for amd rocm platform, https://rocm.docs.amd.com/projects/rocSOLVER

  12. [19]

    H. Anzt, T. Cojean, G. Flegar, F. Gobel, T. Gr ¨utzmacher, P. Nayak, T. Ribizel, Y . M. Tsai, E. S. Quintana-Ort ´ı, Ginkgo: A Modern Linear Operator Algebra Framework for High Performance Computing, ACM Transactions on Mathematical Software 48 (2022) 2:1–2:33

    2022

  13. [21]

    Heinlein, A

    A. Heinlein, A. Klawonn, S. Rajamanickam, O. Rheinbach, Frosch: A fast and robust overlapping schwarz domain decomposition precondi- tioner based on xpetra in trilinos, in: Domain Decomposition Methods in Science and Engineering XXV , 2020, pp. 176–184

    2020

  14. [22]

    Bavier, M

    E. Bavier, M. Hoemmen, S. Rajamanickam, H. Thornquist, Amesos2 and Belos: Direct and iterative solvers for large sparse linear systems, Sci. 11 Program. 20 (3) (2012) 241–255

    2012

  15. [23]

    T. A. Davis, E. P. Natarajan, Algorithm 907: KLU, a direct sparse solver for circuit simulation problems, ACM Trans. Math. Softw. 37 (3) (2010)

    2010

  16. [24]

    X. S. Li, J. W. Demmel, J. R. Gilbert, L. Grigori, M. Shao, I. Yamazaki, SuperLU users’ guide, Tech. Rep. LBNL-44289, Lawrence Berkeley Na- tional Laboratory, last update: June 2018 (1999)

    1999

  17. [25]

    Amestoy, I

    P. Amestoy, I. Du ff, J.-Y . L’Excellent, Multifrontal parallel distributed symmetric and unsymmetric solvers, Computer Methods in Applied Me- chanics and Engineering 184 (2) (2000) 501–520

    2000

  18. [26]

    Prokopenko, C

    A. Prokopenko, C. M. Siefert, J. J. Hu, M. Hoemmen, A. Klinvex, Ifpack2 User’s Guide 1.0, Tech. Rep. SAND2016-5338, Sandia National Labs (2016)

    2016

  19. [27]

    B.-Vergiat, C

    L. B.-Vergiat, C. A. Glusa, J. J. Hu, M. Mayr, A. Prokopenko, C. M. Siefert, R. S. Tuminaro, T. A. Wiesner, MueLu user’s guide, Tech. Rep. SAND2019-0537, Sandia National Laboratories (2019)

    2019

  20. [28]

    E. C. Cyr, J. N. Shadid, R. S. Tuminaro, Teko: A block precondition- ing capability with concrete example applications in Navier-Stokes and MHD, SIAM Journal on Scientific Computing 38 (5) (2016) S307–S331

    2016

  21. [29]

    Baker, M

    C. Baker, M. Heroux, Tpetra, and the use of generic programming in scientific computing, Scientific Programming 20 (2) (2012)

    2012

  22. [30]

    Milewicz, E

    R. Milewicz, E. Harvey, E. Ridgway, S. Grayson, A. Brundage, J. En- gelmann, E. Ho ffman, E. Friedman-Hill, S. Jackson, B. Hautzenroeder, N. Francis, G. Orient, Towards sustainable scientific workflows: DevOps infrastructure development in the engineering common model framewor...

    2022

  23. [31]

    I. S. Du ff, J. K. Reid, Algorithm 529: Permutations to block triangular form, ACM Trans. Math. Softw. 4 (2) (1978) 189–192

    1978

  24. [32]

    Anderson, Y

    E. Anderson, Y . Saad, Solving sparse triangular linear systems on parallel computers, Int. J. High Speed Comput. 1 (1989) 73–95

    1989

  25. [33]

    Karypis, V

    G. Karypis, V . Kumar, METIS: A software package for partitioning unstructured graphs, partitioning meshes, and computing fill-reducing orderings of sparse matrices, https: //github.com/KarypisLab/METIS (1997)

    1997

  26. [34]

    P. R. Amestoy, T. A. Davis, I. S. Du ff, Algorithm 837: AMD, an approx- imate minimum degree ordering algorithm, ACM Trans. Math. Softw. 30 (3) (2004) 381–388

    2004

  27. [35]

    E. R. Keiter, H. K. Thornquist, R. J. Hoekstra, T. V . Russo, R. L. Schiek, E. L. Rankin, Parallel Transistor-Level Circuit Simulation, Springer Netherlands, 2011, pp. 1–21

    2011

  28. [36]

    Yamazaki, S

    I. Yamazaki, S. Rajamanickam, N. Ellingwood, Performance portable supernode-based sparse triangular solver for manycore architectures, in: 49th International Conference on Parallel Processing - ICPP, 2020

    2020

  29. [37]

    F. L. Alvarado, A. Pothen, R. Schreiber, Highly parallel sparse triangular solution, in: Graph Theory and Sparse Matrix Computation, 1993, pp. 141–157

    1993

  30. [38]

    J. V o, Revolutionary speedups in SIERRA structural dynamics enhance mission impact, Trilinos User-Developer Group Meet- ing, https://trilinos.github.io/trilinos_user-developer_ group_meeting_2022.html (2022)

    2022

  31. [39]

    Hardesty, D

    S. Hardesty, D. Ridzal, Plato optimization-based design, Trilinos User-Developer Group Meeting, https://trilinos.github.io/ trilinos_user-developer_group_meeting_2023.html (2023)

    2023

  32. [40]

    Glasby, S

    R. Glasby, S. Hamilton, S. Slattery, CFD simulations with Panzer, Trili- nos User-Developer Group Meeting, https://trilinos.github.io/ trilinos_user-developer_group_meeting_2022.html (2022)

    2022

  33. [41]

    Y . Saad, M. H. Schultz, GMRES: a generalized minimal residual al- gorithm for solving nonsymmetric linear systems, SIAM J. Sci. Statist. Comput. 7 (1986) 856–869

    1986

  34. [42]

    Demeshko, J

    I. Demeshko, J. Watkins, I. K. Tezaur, O. Guba, W. F. Spotz, A. G. Salinger, R. P. Pawlowski, M. A. Heroux, Toward performance portabil- ity of the Albany finite element analysis code using the Kokkos library, The International Journal of High Performance Computing Application...

    2019

  35. [43]

    Watkins, M

    J. Watkins, M. Carlson, K. Shan, I. Tezaur, M. Perego, L. Bertagna, C. Kao, M. J. Hoffman, S. F. Price, Performance portable ice-sheet mod- eling with MALI, The International Journal of High Performance Com- puting Applications 37 (5) (2023) 600–625

    2023

  36. [44]

    Yamazaki, A

    I. Yamazaki, A. Heinlein, S. Rajamanickam, An experimental study of two-level Schwarz domain-decomposition preconditioners on GPUs, in: 2023 IEEE International Parallel and Distributed Processing Symposium (IPDPS), 2023, pp. 680–689

    2023

  37. [45]

    M. T. Jones, P. E. Plassmann, Scalable iterative solution of sparse linear systems, Parallel Computing 20 (5) (1994) 753–773

    1994

  38. [46]

    T. A. Manteu ffel, An incomplete factorization technique for positive def- inite linear systems, Mathematics of Computation 34 (150) (1980) 473– 497. 12

    1980

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.