Performance

Headline numbers by platform and workload, measured against vendor libraries. Gap = Sonium ÷ vendor, so 1.00× is parity and cells marked not measured are honest gaps — not parity claims. The full living report is PERF.md in the repo; the iterative dataset is ITERATIVE_PERF.json. Tables below are generated from perf/*.md by website/scripts/generate_perf_data.py — each section names its source.

Apple M1

8 cores, macOS · vendor refs: Accelerate, SuperLU · criterion medians, rustc 1.99.0 · measured 2026-10-15 @ 39fde79e

Dense BLAS

GEMM vs Accelerate: parity on square NN (0.97–1.03×) with wins on thin shapes (0.64–0.89×); GEMV wins big (down to 0.03×). BLAS-1 is mixed — nrm2 wins everywhere (0.29–0.50×), real axpy/dot/scal trail at large n (up to 3.5×).

perf/m1-blas.md · measured 2026-10-15 @ 39fde79e

Dense LAPACK

Factorization kernels vs Accelerate (lapack_compare). QR median 1.7×; Cholesky 5.04×/2.32× at 512/1024; LU dgetrf 1.36–2.39×. Full size sweep in perf/m1-lapack.md.

perf/m1-lapack.md · measured 2026-10-15 @ 39fde79e

FFT

Not measured on M1: no perf/m1-fft.md dataset exists. Rerun the FFT cells on the M1 host (just perf-m1) to fill this section.

Sparse matrix

CSR SpMV roofline preflight (f32, prebaked): 75.42 µs, 7.8 GB/s effective. Effective bandwidth inside a CG+AMG Poisson 2-D solve (f64, self-reported — bytes moved ÷ solve time, so solver overhead is included; no vendor comparison).

perf/m1-sparse-matrix.md · measured 2026-10-15 @ 39fde79e

Dense solvers

Blocked LU, one factorization + one solve per timing, vs Accelerate. Mid sizes trail 1.8–2.8×.

perf/m1-dense-solvers.md · measured 2026-10-15 @ 39fde79e

Sparse solvers + preconditioners

Sparse direct vs SuperLU: not measured on M1 (the SuperLU column is unmeasured in perf/m1-sparse-solvers.md). Simplicial/Supernodal absolute times are in the dataset; rerun with SuperLU to fill this comparison.

CG + AMG on Poisson 2-D (f64): iterations stay nearly flat (12 → 18) over a 100× size range — the signature of an effective multigrid preconditioner.

Full dataset: 62 runs over 12 solver/preconditioner pairs (GMRES, FGMRES, CG, BiCGSTAB, IDR(s) × none/Jacobi/ILU/ILUT/AMG) on 5 matrices (Poisson, Helmholtz, 3-D Laplacian, anisotropic diffusion, saddle-point) — see perf/m1-sparse-solvers.md and ITERATIVE_PERF.json.

perf/m1-sparse-solvers.md · measured 2026-10-15 @ 39fde79e

Apple M4 Pro

14 cores, macOS · vendor refs: Accelerate, SuperLU · criterion medians, rustc 1.99.0 · measured 2026-10-07 → 10-15 @ 3e449331

Dense BLAS

GEMM vs Accelerate: parity-or-better on square NN up to 1024 and thin shapes; GEMV wins big across the board. BLAS-1 is mixed — nrm2 wins everywhere, real axpy/dot/scal trail at large n.

perf/m4-blas.md · measured 2026-10-07 @ 3e449331

Dense LAPACK

Factorization kernels vs Accelerate (lapack_compare). QR is a steady ~1.5×; Cholesky reaches parity past N=2048 after a small-N dispatch pathology (potrf_f64 24.5×/15.69× at 512/1024); LU dgetrf is the open gap at 3.16–7.53×. Full size sweep in perf/m4-lapack.md.

perf/m4-lapack.md · measured 2026-10-07 @ 3e449331

FFT

Single forward complex/real FFTs (f32/f64) vs Accelerate vDSP DFT. Audio band 512–4096 points, large band 1–4M points; cells are gap ranges over the sizes in each band (gap = Sonium ÷ Accelerate). Full size sweep in perf/m4-fft.md.

perf/m4-fft.md (Seeded 2026-10-15 (not yet measured; regenerate with just perf-cell m4 fft))

Sparse matrix

CSR SpMV roofline preflight (f32, prebaked): 112.18 µs, 5.3 GB/s effective. Effective bandwidth inside a CG+AMG Poisson 2-D solve (f64, self-reported — bytes moved ÷ solve time, so solver overhead is included; no vendor comparison).

perf/m4-sparse-matrix.md · measured 2026-10-07 @ 3e449331

Dense solvers

Blocked LU, one factorization + one solve per timing, vs Accelerate. Down from 15–27× in the August small-N dataset; mid sizes still trail 1.9–4.6×.

perf/m4-dense-solvers.md · measured 2026-10-07 @ 3e449331

Sparse solvers + preconditioners

Sparse direct vs SuperLU 7 (conv-diff grids, 1e-10 residual gate). Simplicial sits at 1.3–1.8× — down from 28–45× in August; supernodal trails at 2.5–3.9×.

CG + AMG on Poisson 2-D (f64): iterations stay nearly flat (12 → 18) over a 100× size range — the signature of an effective multigrid preconditioner.

Full dataset: 62 runs over 12 solver/preconditioner pairs (GMRES, FGMRES, CG, BiCGSTAB, IDR(s) × none/Jacobi/ILU/ILUT/AMG) on 5 matrices (Poisson, Helmholtz, 3-D Laplacian, anisotropic diffusion, saddle-point) — see perf/m4-sparse-solvers.md and ITERATIVE_PERF.json.

perf/m4-sparse-solvers.md · measured 2026-10-07 @ 3e449331

x86-64 — Threadripper PRO 3995WX

128 logical CPUs, Linux, rustc 1.98.1 · vendor refs: OpenBLAS (pthread, tuned threads), SuperLU, UMFPACK, CHOLMOD, PETSc · interleaved same-process A/B, median-of-reps, Sonium at 16 threads · measured 2026-09-27 → 10-15

Dense BLAS

GEMM vs OpenBLAS, hot medians, best-vs-best @32T (2026-09-27). Parity-or-better on square NN up to 1024 and thin shapes; trans-A and 2048 MT scaling are the open gaps.

GEMV vs OpenBLAS (first look, contended box — magnitudes only): NoTrans single-thread 1.1–1.6×, Trans single-thread 1.8–3.7× (serial kernel gap), Trans multi-thread large sizes ~parity.

Best-vs-best worklog 2026-09-27 — see root PERF.md

Dense LAPACK

Factorizations vs OpenBLAS LAPACK, criterion medians, residual-gated at 1e-10 (2026-10-01). Full size sweep in perf/x86-lapack.md.

Criterion medians, residual-gated at 1e-10 (2026-10-01) — curated snapshot; see perf/x86-lapack.md for the refresh cells

FFT

Single forward complex/real FFTs (f32/f64) vs rustfft (complex) and realfft (real). Audio band 512–4096 points, large band 1–4M points; cells are gap ranges over the sizes in each band (gap = Sonium ÷ rustfft). Full size sweep in perf/x86-fft.md.

perf/x86-fft.md · measured 2026-10-15 @ ca156e4f

Sparse matrix

CSR SpMV roofline preflight (f32, prebaked): 111.26 µs, 5.3 GB/s effective (2026-10-01). No CPU vendor A/B yet — GPU SpMV/SpMM parity numbers are under CUDA.

perf/x86-sparse-matrix.md · measured 2026-10-01 @ 47d8c891

Dense solvers

End-to-end factor+solve. dgetrf-1024 in-place passes the project's ≤1.2× gate (2026-09-27); dgetrf-2048 at 1.44× needs panel/Schur work.

perf/x86-dense-solvers.md (Seeded 2026-10-01 from root PERF.md D3 records (Threadripper PRO 3995WX, 2026-09-26 → 27))

Sparse solvers + preconditioners

Sparse direct vs SuperLU, interleaved rep-trajectory A/B with a 1e-10 residual gate (2026-09-28). Supernodal crosses over simplicial past n≈1600; the remaining gap is serial factor throughput.

Sparse Cholesky (5-pt Laplacian, n=16384) vs CHOLMOD: numeric factor 0.77× (faster), analyze ~8× (ordering gap), total 2.0×.

Sonium vs PETSc KSP, f64, largest sizes (2026-10-01, 108 runs, harness validation 37/43 — full table in perf/x86-sparse-solvers.md). AMG-preconditioned pairs are near parity; unpreconditioned GMRES rows compare different restart lengths and truncation, not solver quality.

perf/x86-sparse-solvers.md · measured 2026-10-01 @ 47d8c891; sparse-direct + Cholesky rows: interleaved A/B 2026-09-28, see PERF.md

CUDA — RTX PRO 6000 Blackwell

Driver 610.57, idle GPU · vendor refs: cuBLAS, cuSPARSE, cuSOLVER · solver loops use persistent device handles (PersistentDeviceCsr / PrebakedSpmv) · measured 2026-09-26 → 10-15 @ 47d8c891

Dense BLAS

Bitwise-verified parity with cuBLAS across sizes 1024/2048/4096.

perf/cuda-blas.md (Seeded 2026-10-01 from root PERF.md compute-202609 worklog (idle RTX PRO 6000, 2026-09-27))

Dense LAPACK

One-shot getrf_f64 kernel A/B incl. host→device upload (2026-10-01): we win while upload dominates, cuSOLVER past the 2048 → 4096 crossover. Solver loops use the persistent prebaked path (delegation row) at parity.

perf/cuda-lapack.md · measured 2026-10-01 @ 47d8c891; delegation row: 2026-09-26 record

FFT

Host-CPU comparison (the fft harness has no GPU arm): single forward complex/real FFTs (f32/f64) vs rustfft (complex) and realfft (real). Audio band 512–4096 points, large band 1–4M points; cells are gap ranges over the sizes in each band (gap = Sonium ÷ rustfft). Full size sweep in perf/cuda-fft.md.

perf/cuda-fft.md (Seeded 2026-10-15 (not yet measured; regenerate with just perf-cell cuda fft))

Sparse matrix

perf/cuda-sparse-matrix.md (Seeded 2026-10-01 from root PERF.md x86/GPU record (RTX PRO 6000, 2026-09-26 → 27))

Dense solvers

GPU LU via delegation at 1.00× (see LAPACK). One-shot entries carry documented non-live costs (validating 266× = full device-to-host validation; unchecked 9× = per-call prebake) — solver loops use the persistent prebaked path at parity.

perf/cuda-dense-solvers.md (seed 2026-10-01 from 2026-09-26 record)

Sparse solvers + preconditioners

Block GMRES workstation, N=512 diagonal f32, 8 rhs (2026-10-01): CPU 2.980 ms vs CUDA 2.924 ms — a tie on a tiny overhead-dominated smoke system; a production-size comparison is still open. CUDA GMRES-IR (mixed-precision refinement) converges with outer/inner residuals digit-identical to the CPU baseline, but clean-window timing is still queued (tenant contention dominates current numbers).

perf/cuda-sparse-solvers.md · measured 2026-10-01 @ 47d8c891

OpenCourant (Radioss) — head-to-head

Measured 2026-10-18 on AMD Threadripper PRO 3995WX + NVIDIA RTX PRO 6000 Blackwell. Regenerated by website/scripts/generate_perf_data.py (also run by just website-demos) from perf/oc/*.json (sonium.oc-bench/v1 bundles, correctness-gated) and the curated cavity dataset in oc-benchmarks.json; full report in perf/oc-explicit.md (just perf-oc).

Explicit dynamics — serial vs serial

Same checked-in deck pair, material cards, and stop time on both sides; metric is ns per DOF per cycle (own adaptive dt per side, so cycle counts differ). Sonium is faster on all six decks.

Threaded scaling — 16 threads

Same 16 decks at 16 threads (t16 both sides): engine SMP16 runs 0.4–3.3× its own serial, so sonium wins 15 of 16 per-cycle (1.4–170.2×). Losses: beam_warping. Engine MPI best shown for context.

perf/oc/*.json correctness-gated bundles (2026-10-12); full matrix in perf/oc-explicit.md

Wall time to matched accuracy — lid-driven cavity

Wall time to matched accuracy: lid-driven cavity at Re=100 against Ghia reference profiles (max error gate 0.03). Sonium runs its incompressible Navier-Stokes solver; OpenCourant (Radioss) runs a low-Mach compressible ALE surrogate, its closest native option.

GPU — Sonium CPU vs CUDA

Sonium is faster at every thread count and more accurate at the gate (0.0162 vs 0.0264 max error). Both codes saturate with threads: sonium 1.44x self-speedup at 16 threads, the engine 3.95x at 32.

Every GPU row is backend-audited per solve: a silent CPU fallback marks the row failed instead of relabeling it.

Methodology

Reproduce: just perf-x86 · just perf-cuda · just bench-lapack · just bench-petsc-run · per-cell reports in perf/, full report in PERF.md (repo root).