RequantTESTNET
Requant research

Adaptive-Precision Dense Linear Solvers on GPUs

Abstract

Native FP64 and mixed-precision solver routes are tested on two cohorts and real structural matrices. The report retains 1,664 attempts, including failed targets, fallback and factor-reuse costs.

Study 7 of the Consumer Blackwell programme. See the research methodology for timing and replay boundaries.

Two cohorts attempted 1,664 configurations; 1,612 are available and 52 explicitly reject multi-RHS GMRES. The campaign retains 96,720 solve timing observations, 3,861 complete output witnesses (9,953,817 FP64 entries) and 142,992 exact-integer residual samples. Every measured output is copied and linked to its complete retained witness.

Contract and inputs

All methods start from the same stored FP64 A/B and return FP64 X. A solve passes only if every RHS has relative L2 residual <=1e-12 AND relative L2 forward error <=1e-8. Eligibility in the tables requires passing every retained observation for that boundary, including all four changing RHS variants for host requests. Forward error is measured against a mathematically exact manufactured solution of the stored system; it is not measured against another rounded GPU solver.

Controlled matrices use a signed and row-permuted Walsh basis, dimensions 128/512/1024/2048, and exact spectral condition numbers 1, 2^12, 2^24, 2^36 and 2^40. Integer Walsh transforms of dyadic eigenvalues construct every A entry exactly in FP64. RHS vectors combine three basis directions, including smallest/largest eigenvalues; B and truth are exactly representable. The four RHS variants keep A unchanged. Cases have one or four RHS columns. The second cohort independently changes the matrix/RHS seed and reverses matrix/method order.

Real inputs are BCSSTK09, a clamped plate stiffness matrix (1083), and BCSSTK10, a hot washer stiffness matrix (1086), supplied by John Lewis to the Harwell-Boeing collection and distributed by NIST Matrix Market. Each is tested at exact global scales 2^-20, 1 and 2^20 with one/four RHS columns. Truth consists of selected unit vectors and B of the corresponding original columns, so no RHS-rounding ambiguity is hidden. The two cohorts change real-matrix RHS directions, not the underlying two physical matrices. These are dense-storage precision tests with manufactured loads, not original physical-load accuracy tests or sparse-solver comparisons. Original compressed files, URLs, hashes and attribution are in the data manifest.

Native methods and costs

The native bridge directly calls CUDA 13.3 cuSOLVER on GPU 0 / SM120. Strong FP64 references include SPD Cholesky (Dpotrf/Dpotrs) and general LU. Other references request FP32/FP16/BF16/TF32 factorization with no refinement or classical iterative refinement, FP16 GMRES for one RHS, and the library's FP16 classical-refinement fallback. Equilibrated controls compute D=diag(A)^-1/2, solve DAD y=Db, and return x=Dy; their external residual is always evaluated against original A/B. Requested lowest-precision enums are configuration evidence, not proof that every opaque library operation uses Tensor Cores. No FP4 factorization capability is asserted.

The custom adaptive policy attempts FP16 classical refinement with limit 4, FP32 with limit 12, then FP64 Cholesky. Each attempt starts from original inputs, charges restore/scaling and gates on native status/device info plus full original-system relative L2 residual <=1e-12. An equilibrated version applies Jacobi scaling to the two lower-precision attempts. The online policy never sees the manufactured truth, condition label or forward error. Raw negative iteration/fallback/nonconvergence codes are retained and are not interpreted as negative computational work.

Resident timers include fresh factorization, solve, full FP64 original-system residual, scalar readback and host decisions. CUDA events span library host orchestration gaps; separate host wall times are retained. Complete host-request timers additionally include pageable FP64 A+B H2D and full FP64 X D2H, cycling through four RHS variants. Plan creation, allocation, CPU input generation, numerical replay and history extraction are outside solve timers; plan setup wall time and explicit owned device bytes remain in the CSV. Opaque cuSOLVER/cuBLAS handle/internal allocation costs are additional, so owned bytes are not total peak memory. Thirty observations follow five resident warmups, without changing clocks, services or power settings.

Accuracy-constrained outcomes

A ratio above 1 favors the named method. Ratios use only cases where BOTH the candidate and comparator pass the full contract. Best-library comparisons include the fastest feasible direct/IR/fallback reference in the same group and boundary. Failed solves retain their timings in the CSV but cannot earn an accuracy-constrained speedup.

MethodResident passing groupsHost passing groupsMedian resident speedup vs fresh FP64 CholeskyMedian resident speedup vs best feasible library
cholesky6472/10472/1041.00000.5999
lu6472/10472/1040.67300.4206
fixed_fp3216/10416/1042.27251.0000
fixed_fp1616/10416/1042.04240.9163
fixed_bf1616/10416/1042.05370.9278
fixed_tf3216/10416/1042.10170.9474
ir_fp3266/10465/1041.68831.0000
ir_fp1648/10445/1041.33770.7951
ir_bf1660/10460/1041.19580.7367
ir_tf3260/10460/1041.37600.8315
gmres_fp1625/5223/521.02230.5965
library_fallback_fp1672/10471/1041.02880.6474
equilibrated_library_fp1672/10472/1041.18390.7475
adaptive66/10465/1040.76440.4570
equilibrated_adaptive68/10464/1041.17800.7854
cholesky64_reuse72/10472/104unavailableunavailable

Complete host requests include changing B and both transfers. The ratios below retain the same strict feasibility condition; they are separate from resident timings.

MethodMedian host speedup vs fresh FP64 CholeskyMedian host speedup vs best feasible library
ir_fp321.39841.0000
ir_fp161.24200.8774
library_fallback_fp161.00380.7214
equilibrated_library_fp161.17590.8260
adaptive0.82070.6112
equilibrated_adaptive1.16380.8459

Controlled conditioning and forward-error failures

High conditioning can defeat even native FP64 at the fixed 1e-8 forward-error target. This is retained as an unmet accuracy outcome, not silently relaxed. The following resident success counts span dimensions, RHS counts and both seeds.

Condition numberCholesky64FP32 IRFP16 IRAdaptiveEquilibrated adaptive
2^016/1616/1616/1616/1616/16
2^1216/1616/1616/1616/1616/16
2^2416/1610/164/1610/1612/16
2^360/160/160/160/160/16
2^400/160/160/160/160/16

There are 2,251 changing-RHS adaptive observations whose online residual gate passes while the offline combined accuracy contract fails. Repeated observations of a RHS are not independent failure trials. The complete failure list keeps seed/specification, method, RHS variant and exact witness links. The tested residual-only gate therefore does not certify forward error. A trusted condition estimate or stronger certified stopping rule is future work, not an established capability.

SeedControlled n / conditionMethodRHS variantGPU relative residualActual forward error
20261124128 / 2^24adaptive08.0363e-157.7838e-08
20261124128 / 2^24equilibrated_adaptive19.6322e-132.6061e-06
202612242048 / 2^40equilibrated_adaptive04.771e-164.8236e-05
202612242048 / 2^40adaptive04.771e-164.8236e-05

Real-matrix results at original scale

Reported times are resident milliseconds. A failed candidate is labeled failed rather than included in an equal-accuracy comparison. Global-scale variants and complete host requests are in the CSV.

SeedMatrix / RHSCholesky64FP32 IREquilibrated library FP16AdaptiveEquilibrated adaptive
20261124bcsstk09 / 13.19721.89442.52334.28712.3938
20261124bcsstk09 / 44.91633.51184.22597.74154.2230
20261124bcsstk10 / 13.20321.77582.17134.18912.1750
20261124bcsstk10 / 44.99803.09374.22867.33274.2286
20261224bcsstk10 / 45.00092.69244.25236.95254.2528
20261224bcsstk10 / 13.20321.79952.19504.24462.1927
20261224bcsstk09 / 44.96653.13905.15197.41717.4567
20261224bcsstk09 / 13.21261.93542.44344.38412.4393

Factor reuse and verification

cholesky64_reuse factors A once and solves changing RHS with the retained factor. The factor setup is separately measured thirty times; host setup includes A+B upload. Amortization records report factor_setup/R + solve for R=1/4/16/64. The setup restores a B work buffer even though factorization does not use it, so its small copy cost is conservatively included. Reuse solves still charge the original-system residual and host gate; host requests upload only B. This separate fixed-A workload cannot be mixed into the fresh-factorization frontier.

Reused RHS request countMedian resident amortized speedup vs fresh CholeskyMedian host amortized speedup vs fresh Cholesky
10.99970.9993
42.44132.4382
163.91583.9870
644.64644.8105

Every unique actual output is retained in full; every timed observation names its exact solution hash/witness. CPU replay reconstructs all inputs and checks every output's residual and analytic forward error. Sixteen rows per system/RHS are also evaluated by arbitrary-precision integer dot products with exact binary64 input representations and one final rounding, exposing ordinary FP64 residual cancellation. Cross-platform CPU residual comparisons use a gamma_n dot-rounding bound, while exact integer samples must match bit-for-bit and accuracy pass/fail labels must remain unchanged. Runtime preparation checks compare every scaled matrix/RHS/diagonal entry against independent NumPy operations; CI checks their provenance/counts and independently replays complete solution witnesses.

Native controls cover invalid dimensions/RHS/mode, null plan, unsupported multi-RHS GMRES, singular Cholesky and repeated IRS calls. A first quick attempt reused IRSInfos and produced ALLOC_FAILED on subsequent calls; its source/binary/raw outputs were archived privately. Final campaigns destroy/create this per-solve object inside the timed operation and include a four-call regression control. History is requested only for refinement and retained only for successful positive iteration counts with a defined prefix; unrefined/zero/negative-code calls do not claim initialized histories. The separate sixty-case capability preflight is replayed but is not counted as a performance study or assumed to meet this study's stricter targets.

The implementation follows the NVIDIA cuSOLVER API, with explicit refinement, precision, fallback and iteration limits. Library history entries are its own residual norms/iteration counts, not the external relative L2 metric. Library default stopping tolerances are left unchanged; the external original-system gate is a separate check. GPU contexts from other processes remain present, so measurements are exploratory shared-system observations. No scientific-novelty, architecture-ceiling, universal solver or certified forward-error claim is made.

Reproduction

bash build_solver.sh
OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 python solver_study.py --seed 20261124 --quick --output solver-quick.json
OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 python solver_study.py --seed 20261124 --output solver-a.json
OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 python solver_study.py --seed 20261224 --reverse --output solver-b.json
python verify_solver.py
python summarize_solver.py --check

Use the recorded CUDA 13.3 toolchain and NumPy environment. The complete table, first cohort and second cohort retain setup, failures, raw iteration/status codes, histories, timing series, source/data/binary hashes and output witnesses.

Evidence and source revision

Cite this report

Requant. “Adaptive-Precision Dense Linear Solvers on GPUs.” Technical report, 19 November 2026. Evidence revision d12bcf1c3270f28fe85828725fb2f2c5c790b986. Canonical report.

This is an organizational technical report, not a peer-reviewed publication.