Appearance
Regression suites
ADAM is tested in two layers. The regression suites run on every change and detect any change of a committed result, wanted or not. The verification legs assert the physics (an exact solution, a reference, a symmetry, a conservation property) and run for the part a change touches. This page is the reference for the suites; the tasks (run a suite, add a case, refresh a golden, bring up a new machine) are in the regression cookbook.
| Suite | Directory | Cases | Backends | Built modes |
|---|---|---|---|---|
| FLUME | src/tests/flume/regression/ | 55 | CPU (CI), FNL (workstation) | flume-cpu-gnu + flume-cpu-gnu-fft, flume-fnl-nvf + flume-fnl-nvf-fft |
| PRISM | src/tests/prism/regression/ | 24 | CPU (CI), FNL (workstation) | prism-cpu-gnu, prism-fnl-nvf |
The harness
Both suites share one harness pattern, run.sh {cpu|fnl} [--no-build] [--varset <name>]:
- It runs the lints: the GPU race-shape check (
src/tests/lint/check-gpu-race-shapes.sh), then the removed-keys check (src/tests/lint/check-removed-input-keys.sh). - It creates a Python venv at
exe/.regression-venv/on the first run and installsh5pyandnumpyfordigest.py. The venv lives underexe/, notsrc/, becausefobisand the API-doc generator scansrc/. - It builds the backend (skipped with
--no-build). - It discovers the cases: every immediate subdirectory with an
input.ini. - It runs each case under
mpirun -np 2in<case>/work-<backend>/and compares the outputs with<case>/golden/<backend>/.
| Control | Effect |
|---|---|
--no-build | reuse the executables in exe/; FLUME refuses an executable older than any of its sources |
--varset <name> | build with that varset (install) |
REGRESSION_CASES="a b" | run only the named cases; in PRISM a name that is not a case directory stops the harness with exit 2 before the build |
REGRESSION_RUN_GOLDENLESS=1 | run the cases that have no golden for the backend (golden capture) |
REGRESSION_ALLOW_MPIRUN_FAILURE=1 | turn the failure of a run that exits non-zero into a warning, on an environment whose crash is known |
A case fails when its outputs differ from its goldens, and also when its run exits non-zero (a crash or the hard timeout), even if the outputs match: a crash after the last checkpoint is still a crash. The outputs are compared anyway, for the report. The one exemption is the harness's own termination of a run that hung in MPI_Finalize after its end-of-run marker. A case skips when it has no golden for the backend. The summary is PASS: n FAIL: m SKIP: k, and the exit status is non-zero on any failure.
Every case runs on 2 ranks, so a golden is a two-rank golden: a one-rank rerun does not match it.
Goldens and tolerance
The raw HDF5 checkpoints (about 100 MB per rank for PRISM) are not committed. Each case commits compact references, compared tolerance-aware:
| Golden | Content | Comparison |
|---|---|---|
digest.txt | for every checkpoint and every field variable, count, min, max, sum, sum_sq over all blocks, ranks and (for forests) realms (src/tests/prism/regression/digest.py, shared by both suites) | digest.py compare, rtol = 1e-6, atol = 1e-3 |
*-residuals.dat | per-iteration residuals | header verbatim, integer columns exact, float columns within the same tolerances |
*-conservation_history.dat (FLUME) | per-iteration volume integrals of the conservative variables (and | as the residuals |
rtol = 1e-6 absorbs FMA, libm and MPI-reduction-order differences between compilers and machines (about 9 significant digits are still checked); atol = 1e-3 is the floor for antisymmetric fields whose sum is pure cancellation noise. The div_* diagnostics are excluded from the digest (constraint residues at round-off). Per-block metadata that differs only by block partitioning (dxdydz, origin, time_iteration) is downgraded to SKIP_METADATA, which lets a multi-realm run be compared with a single-realm golden.
Bitwise identity is checked separately where it is the contract: FLUME's OpenMP build against the serial one (run-omp-bitwise.sh, in CI), and RIPPLE's rank and CRLF legs.
Golden authority. The CPU goldens are captured in CI (Ubuntu 24.04, gfortran 14, varset ci_gnu); a golden captured on a workstation with another compiler can fail in CI with no real change. The FNL goldens are captured on the GPU workstation; the CI runners have no GPU.
Running
bash
src/tests/flume/regression/run.sh cpu # builds flume-cpu-gnu and flume-cpu-gnu-fft; the CI job
src/tests/flume/regression/run.sh fnl --varset local_nvf # builds flume-fnl-nvf and flume-fnl-nvf-fft
src/tests/prism/regression/run.sh cpu # builds prism-cpu-gnu; the CI job
src/tests/prism/regression/run.sh fnl --varset local_nvf # builds prism-fnl-nvf
REGRESSION_CASES="sod-x brio-wu" src/tests/flume/regression/run.sh cpu --no-buildOn the WSL2 workstation the FNL suites run through run-fnl-local.sh [--no-build] in each suite directory: it loads the nvhpc module, exports the WSL-only MPI settings of GPU5 and calls run.sh fnl --varset local_nvf. It needs Lmod; on any other machine call run.sh directly.
On a one-GPU box the two ranks share the device. Each FNL rank counts the node-local ranks bound to its device (through CUDA_VISIBLE_DEVICES, ROCR_VISIBLE_DEVICES, HIP_VISIBLE_DEVICES and the device it picks) and sizes its block pool for its share; the startup log prints device shared by N rank(s).
FLUME suite
Each case directory src/tests/flume/regression/<case>/ holds a frozen input.ini (a multi-realm case: a forest manifest plus one INI per realm), most of them copies of a verification input cut to a few dozen steps, and the goldens golden/cpu/ and golden/fnl/.
| Script | Role |
|---|---|
run.sh cpu | builds flume-cpu-gnu and flume-cpu-gnu-fft, runs every case, compares; runs in CI |
run-fnl-local.sh | the same on the GPU (flume-fnl-nvf and flume-fnl-nvf-fft, --varset local_nvf); a workstation gate |
run-omp-bitwise.sh | checks that the OpenMP build reproduces the serial one bit for bit (CI) |
Two executables per backend: every case with self_gravity = .true. runs on the -fft executable (FFTW on the CPU, cuFFT on FNL), since every self-gravity solve needs an FFT; the CI job installs libfftw3-dev.
FLUME cases
| Case | Freezes | Issue |
|---|---|---|
sod-x, sod-y, sod-z | Sod shock tube, along each axis | #35 |
sod-hllc | Sod on weno-riemann, HLLC | #47 |
vortex-periodic | isentropic vortex, 100 steps | #35 |
vortex-rk3 | vortex-periodic on the low-storage runge-kutta-3 at CFL 0.8, final state digested: the only case on the low-storage stage update (every other case runs an SSP scheme, and a low-storage scheme is refused on AMR seams and multi-realm runs). At CFL 0.1 the two schemes agree to | #95 |
amr-periodic-reflux | conservation across AMR seams: init-time AMR, reflux | #35 |
amr-periodic-reflux-stage | the same with reflux_cadence = stage | #81 |
shock-cylinder-ib | shock over a cylinder, immersed boundary, 120 steps | #35 |
sod-2realm, sod-2realm-blocks, sod-amr, sod-amr-2realm, sod-amr-refined | multi-realm runs: mirror seams lined up or not, a 2:1 face, the refined coupling | #37, #51, #52 |
rj2a-x, rj2a-y, rj2a-z | Ryu–Jones 2a | #41 |
rj2a-hlld | Ryu–Jones 2a on weno-riemann, HLLD | #47 |
rj2a-2realm | Ryu–Jones 2a in two realms | #41 |
brio-wu | Brio–Wu | #41 |
glm-pulse | GLM cleaning | #41 |
orszag-tang | Orszag–Tang | #41 |
orszag-tang-eglm | Orszag–Tang with EGLM | #47 |
rotor | MHD rotor | #41 |
field-loop | field loop | #41 |
rotated-shock-tube | rotated shock tube | #41 |
uniform-amr-mhd | MHD on a uniform state across 2:1 faces | #41 |
blast-limiter, blast3d-limiter | the Balsara–Spicer blast with the positivity limiter, 2-D and 3-D | #47 |
blast-amr-limiter | the limited blast across two 2:1 seams | #50 |
shear-viscous | viscous waves | #65 |
couette | Couette flow | #65 |
becker-shock | Becker's viscous shock | #65 |
alfven-resistive | the visco-resistive Alfvén wave | #65 |
seam-viscous-amr | the dissipative fluxes across 2:1 seams | #65 |
vortex-regrid | runtime regrids: the vortex, 6 regrids | #74 |
field-loop-regrid | runtime regrids on MHD: the field loop, 10 regrids | #74 |
selfgravity-jeans | Jeans modes: the unstable mode at amplitude | #81 |
selfgravity-amr-stage | self-gravity on a static AMR grid: multigrid, the seam gravity work, per-stage reflux | #81 |
selfgravity-star | the n = 1 polytrope, isolated boundaries, | #81 |
selfgravity-star-amr | the n = 1 polytrope on AMR (SV-14): isolated boundaries by the multigrid's James step, the star of radius 0.3 collapsing, the box refined over | #87 |
sod-ps | passive scalars (PS ps1): the sod-x shock tube with two scalars, 1 left and 0 right of the diaphragm | #92 |
radiative-shock | radiative cooling (CO co7): two streams at the cooling floor | #93 |
noh-de | dual energy (DE de2): the cold planar Noh shock, Mach 845, with physical_model = euler-de, 50 cells, | #91 |
iso-tube | isothermal equation of state (EO eo1): the isothermal shock tube, | #100 |
periodic-1block | the isothermal acoustic wave of EO on one block not refined at init, every face periodic, 48 cells, | #103 |
iso-collide-hllc | isothermal equation of state (EO eo2): two Mach-5 isothermal streams colliding, 100 cells, weno-riemann with the isothermal HLLC, | #100 |
baro-tube | barotropic equation of state (EO eb1): the tube POLY, its left fan crossing the break | #100 |
baro-collide-hllc | barotropic equation of state (EO eb2): the collision POLY, both shocks into the weno-riemann HLLC, | #100 |
baro-jeans-box | barotropic gases under gravity (EO eg4): the barotropic Jeans collapse (POLY on | #100 |
iso-sinks-shu | barotropic gases under gravity (EO eg6): the overdense singular isothermal sphere ( | #100 |
iso-mhd-tube2 | isothermal and barotropic MHD (EO em4): Mignone's isothermal tube 2 (rotational discontinuities), 200 cells in four blocks of one transverse cell, WENO5 flux splitting on Kim's eigenvectors, | #100 |
baro-mhd-glm-hlld | isothermal and barotropic MHD (EO em4): tube 2 with the densities times 5 on POLY (the weno-riemann with the isothermal HLLD on | #100 |
sinks-shu | sink particles (SI si11): the overdense singular isothermal sphere ( | #94 |
tgv-small | the Taylor–Green vortex (T0.2): Re 1600, Mach 0.4, | #119 |
The self-gravity goldens agree across the backends to
PRISM suite
The suite is the structural-change baseline of PRISM. Each case runs in about a minute per backend and is checked against committed goldens or, for the seam cases, against a physics oracle. The operational details (golden capture, tolerance rationale) are also in the suite's README.md.
Coverage
The suite has 24 case directories (an input.ini each). 15 carry a digest golden for the CPU backend and 16 for FNL (rmf-fwl is FNL-goldened only), so a green sweep reports 15 PASS, 11 SKIP on CPU and 16 PASS, 10 SKIP on FNL. A SKIP is a case with no golden for that backend, or one of the two non-case directories reproducers/ and slices/. The other cases are checked by their own check.sh, scaling.sh or coils.sh.
Design
- Structural regressions, not physics. The cases are CI-sized:
16³or8×16×16cells per realm,it_maxof 5 to 10, per-step residual logging. A refactor that changes a reduction, a kernel chain or a seam fill shows up here. - Two backends, one baseline. Every case runs on
prism-cpu-gnuandprism-fnl-nvf; a case is fully covered only when it has goldens for both. - Fixed two-rank runs. Every case runs at
mpirun -np 2, so every run exercises the MPI ghost exchange and the decomposition. - Deterministic across compilers. Runtime refinement is off (
amr_iterations = 0,[amr] frequency = 999999), so no refinement decision depends on a floating-point comparison mid-run; the initial uniform refinement (iu_ref_levels = 2) gives 64 leaf blocks over the two ranks.
PRISM cases
All cases use fdv_order = 6. The rmf*, periodic-pulse-blocks and memory-scaling* cases are physical_model = EM; the four pic-* cases are physical_model = PIC. The pic-*, rmf-open-t0 and rmf-pec-t0 cases use ngc = 6, every other case ngc = 3. All but rmf-hyperbolic run without divergence correction (constrained_transport = no, divergence_correction = no); rmf-hyperbolic is the only case with hyperbolic (GLM) cleaning, on D and B (nv = 11).
Digest/residuals-goldened cases
| Case | Realm | Cadence | Scheme | Exercises |
|---|---|---|---|---|
rmf | single | — | fd | baseline EM case (4 AC coils); the digest anchor and the β cross-config reference target |
rmf-2realm | inter (x-split) | α | fd | single-realm rmf split at x=0; aggregated digest vs the rmf golden (#13 Phase D) |
rmf-2realm-asymK | inter | α | fd | the asymmetric-K validation: realm_1 SSP-33 (K=3) ∥ realm_2 SSP-54 (K=5), the α K-equality-guard removal (#16) |
rmf-2realm-stagesync | inter | β | fd | the load-bearing β oracle — digest must match the single-realm rmf golden bit-for-bit (#18) |
rmf-fwl | single | — | fd | the only fWLayer case (six faces) + 4 coils — guards the FNL fWLayer host→device transfer fix (#31); FNL-goldened, CPU golden pending CI |
rmf-fwl-amr | single | — | fd | rmf-fwl with an init-time box marker refining the x-minus slab to level 3: the fWLayer ranges rebuilt on the refined blocks (#95 P5.1) |
rmf-pml-amr | single | — | fd | the same grid with a CFS PML instead of the layer: the PML support and its RK storage rebuilt on the refined blocks (#95 P5.1) |
rmf-hyperbolic | single | — | fd | rmf with hyperbolic cleaning on D and B (chi = 1, damping alpha = 1e9 1/s): the GLM state layout, φ and ψ in slots 7 and 8, J in 9..11 (#61). Its two init refusals (hyperbolic without constrained transport, poisson) are legs of refusals.sh |
periodic-pulse-blocks | single | — | fd | a Gaussian pulse along +x in a box periodic on every face, 48³ cells as 64 blocks split 32/32 over the two ranks, 192 steps = one period: library periodicity across blocks and ranks |
rmf-pec-t0 | single | — | fd | the four rmf coils carrying their current at t0 inside PEC walls: FLAIL's t0 solves of A give a divergence-free B (#84 E3b); its check.sh asserts max|div B| h / max|B| ≤ 1e-12 and np 1 = np 2 to 1e-12 |
rmf-open-t0 | single | — | fd | the same coils inside exact/open faces (Neumann): the free-space potential in the ghosts, summed on rank 0 (#84 E3c); same check.sh acceptance, away from the faces |
pic-pec-t0 | single | — | fd | the t0 electric field of a PIC plasma box between PEC walls: div D = rho up to the checkerboard mode (#84 E3b); check.sh bound 1e-12 max|rho|, np 1 = np 2 |
pic-open-t0 | single | — | fd | the same plasma inside exact/open faces (#84 E3c); check.sh bound 1e-11 max|rho| beyond 3 cells of the faces, np 1 = np 2 |
PIC cases (check.sh-driven, goldens in golden-check/)
Both run the production PIC path (TSC, conserving current esirkepov_Q10 with the coherent gather, the t0 FLAIL solves, FD6, SSP(5,4), fixed seed) through the shared driver pic_check.sh, as legs: CPU np 1 on one block for the first 4 steps, FNL np 1, and FNL np 2 on the same grid as 64 blocks. Every leg also asserts Gauss's law at t0 and charge conservation to round-off. Their goldens sit in golden-check/, not golden/, because run.sh runs every goldened case at -np 2, which the single-rank CPU leg refuses; run.sh reports them as SKIP.
| Case | Exercises |
|---|---|
pic-periodic | uniform plasma periodic on every face, plane wave of one box length, 32×24×24 cells, 40 steps: periodic current fold and particle wrap on three axes |
pic-slab-pulse | a plasma slab 3 c/ω_pe thick, PEC along x and periodic in y, z, gaussian_derivative_pulse through the slab, 384×24×24 cells, 1152 steps |
Capacity probes (no golden)
memory-scaling runs a minimal EM case (it_max = 1) at -np 1 and -np 2 and asserts, through scaling.sh, how the per-rank block capacity nb scales: it halves on the CPU (host memory shared by the ranks of a node) and stays constant on FNL (one device per rank). memory-scaling-coils is the same case with the four rmf coils; coils.sh asserts that the capacity budget counts 3 block-sized fields per coil.
Inter-realm 1:1 seam anchor
rmf-2realm-fd-pulse — a source-free Gaussian pulse split at x=0 into two same-resolution realms glued by a β mirror seam. It isolates the seam mechanism (inter-realm peer copy) from any resolution jump: a 1:1 seam must be div-free exactly like a 1:1 intra-block interface, and it holds div(B) = div(D) = 0 — but only under β. Under α the seam ghosts go unfilled during RK substages and div(B) leaks (this is the #31 diagnosis). For a 1:1 same-dt seam, β is correct and required.
It carries a check.sh oracle (three legs, -np 1, CPU by default, PRISM_EXE= to override):
- β cadence, as committed —
max|div(D)|andmax|div(B)|must both sit at round-off (1.0E-13) on both realms. Measured: exactly0.0for all four quantities. - Health — both realms reach 100% with no error/abort/NaN and both divergence histories exist.
- α cadence, negative control — rewriting
coupling_cadencetoend_of_stepmust pushdiv(B)above tolerance. Measured:4.56E+02, identically on both realms. Without this leg the first two could pass vacuously (a seam that stopped being exercised would also read zero), so it is what gives the oracle teeth. It asserts only that α leaks, not a magnitude — α's drift is not a quantity this suite has reason to hold fixed.
Not run by run.sh
Like the AMR-seam oracles, this check.sh is invoked by hand, not by the sweep — and the case has no digest golden, so run.sh reports it as a SKIP. Run it directly after touching fill_seam_from_peer_forest, post_step_forest, or any forest seam path.
FV reflux on a capped last step
rmf-amr-fv-pulse-timed (#38) — the source-free pulse of rmf-amr-fd-pulse on the FV path, a band x ∈ [-0.03, 0.03] refined 2:1 (two seam planes, both x boundaries coarse) and time-driven: time_max is 4.5 steps, so PRISM caps the fifth step at half a step. With J = 0 the FV update with reflux keeps the domain integrals of D and B constant, and the Berger-Colella correction must be scaled by the step the update used, not by the forest's uncapped dt. Its check.sh asserts that the last step is capped, that the reflux diagnostic is printed, and that every integral drifts by at most 1e-9 (relative to the largest D, or B, integral). The y extent is twice that of rmf-amr-fd-pulse (12σ each side): with the narrower box the Gaussian tails leak through the y faces and even the grid without seams drifts by 1e-8 per step. The reflux-sensitive integral is ∫Dz (its x-flux is Hy); ∫Bx has no x-flux and cannot see the defect. Measured on CPU and FNL: ∫Dz drifts 1.0e-11 over the four full steps (the seams' disturbance reaching the x boundaries) and 2.2e-11 after the capped one. Negative control (the fix reverted): the same drift up to step 4, then 1.4e-7 on the capped step, 6500 times larger; the tolerance sits 45× above the fixed run and 140× below the reverted one.
Inter-realm misaligned-block anchor
rmf-2realm-fv-pulse-blocks (#51) — the 1:1 mirror pulse on the FV path (fv_centered, 20 steps) with the seam blocks of the two realms not lined up: one realm on 4 blocks per axis (the same cells), first realm 1 (the register side: each register face holds 2x2 realm-2 faces), then realm 2 (each realm-2 face scattered into 4 register faces). Its check.sh asserts that the register closes exactly, max|F_coarse-F_fine_sum| = 0 on every face and step (320 and 80 lines), and that the fields match the single-realm FV pulse within 1e-13. They are not compared bitwise: PRISM FV is not invariant under a change of block layout at round-off (the single realm alone on 4 blocks per axis instead of 2 differs by 6.6e-16). Measured on CPU and FNL: mismatch 0, fields within 3.7e-15.
Inter-realm 2:1 seam anchor
rmf-2realm-fd-pulse-refined (#52) — rmf-amr-fd-pulse split at its 2:1 face x=0 into a fine realm (x<0, one level finer, no marker) and a coarse realm (x>0) glued by coupling = refined, β cadence. The union is the single-realm cell set, so the split must reproduce rmf-amr-fd-pulse bit for bit, including its #29 seam div(B) source: the inter-realm 2:1 seam reuses the intra-realm formulas, so the source must be neither smaller nor larger. Its check.sh (-np 2 by default, --np N, PRISM_EXE= to override) runs both and asserts:
- Health — both runs reach 100% with no error/abort/NaN.
- Fields — every checkpoint field (B, D, J,
div_*,res_*) bitwise on every cell (multirealm_oracle.py --fields-only --tol 0). Measured: 147456 cells, 27 fields, CPU and FNL. - Divergence histories — at every step the single-realm
max|div(D)|andmax|div(B)|equal the larger of the two realms' values. Measured:max|div(B)|6.86 → 12.65 in both, the coarse realm holding the maximum at steps 1–2 and the fine one at steps 3–5. - Seam div(B) monitor —
[IO].seam_divB_tol = 1(warn-only) fires on the split.
At -np 2 the refined split leaves one rank with no block of a realm, so the case also exercises the collective ghost update on an empty rank. Like the 1:1 anchor, the case has no digest golden and is run by hand.
AMR-seam cases (digest-goldened and check.sh-driven)
Three single-realm cases carry a static intra-realm 2:1 AMR jump (markers_number = 1, an AMR_GEO box marker covering the x<0 half). They are doubly covered: digest + residuals goldens on both backends (#24), which run.sh checks like any other case, plus a bespoke check.sh asserting a physics oracle with a marker-off control leg for contrast. The oracles are not invoked by run.sh — run them directly (they are the only thing that checks the seam div(B) behaviour).
| Case | Scheme | check.sh oracle |
|---|---|---|
rmf-amr | fv_centered | refinement happens → 2:1 jump exists; the AMR seam registers (SEAM_KIND_INTRA_REALM_AMR); Berger-Colella reflux fires non-zero; np1 ≡ np2 register parity (#28) |
rmf-amr-fd | fd_centered | control max|div(B)| ≤ 1e-13 (interior identity intact); seam max|div(B)| within ±5% of a pinned baseline; div(J) truthfulness within a factor-3 band (#26) |
rmf-amr-fd-pulse | fd_centered | source-free two-invariant oracle (div(D) structural-zero, div(B) seam baseline ±5%); a --convergence p_obs ≥ 0.8 refinement ladder; and the RK-contract legs — leap-splitting refusal + SSP-11 instrument (#25) |
The pulse case is the valid convergence instrument: with J = 0 the Maxwell system conserves both discrete divergences, so any seam div(B) is attributable to the 2:1 jump alone (no coil h⁻² contamination). Its --convergence leg is what pins the seam div(B) source as O(h^p) truncation-order (see div(B) at 2:1 seams).
Reproducers
src/tests/prism/regression/reproducers/ holds standalone minimal reproducers (not cases): fnl_mpi_rndv.sh for the FNL UCX-rendezvous SIGABRT on WSL (#12, the UCX_RNDV_THRESH=inf workaround) and a gfortran-16 debug-mode -fcheck=bounds false-positive reproducer.
Research cases
Research and development inputs live under src/tests/prism/<backend>/{fd,fv}/<family>/: long integrations, full AMR, sized for physics validation. They are not regression anchors, and run.sh never descends into them.
Unit tests
The library and application unit tests are separate build modes (test-* in build modes), run as mpirun -np <N> exe/<test_executable>. The families are the FDV operators on trigonometric and step fields (test-fdv-*, CPU and FNL), AMR (test-amr-*, test-tree-closest-block, test-periodic-ghost), seams (test-seam-interpolation, test-quadtree-seam-ghost), the Poisson solvers and FLAIL (test-poisson-fft, test-poisson-mg, test-flail-bc), the RK tableaux (test-rk-ssp-tableau), PRISM reflux (test-prism-reflux-apply), turbulence (test-sgs, test-kep, test-wm, test-df), and FLUME's libraries and user criteria (test-flume-*, test-ripple-crest-criterion). The tests the FLUME cases rely on are described in FLUME unit tests.
Changes to core numerics or parallel logic are gated on both maintained toolchains (versions in install): gfortran for the CPU backend (the *-debug modes add bounds checking and FPE traps) and nvfortran for FNL.
See also
- Regression cookbook: run a suite, add a case, refresh a golden, bring up a new machine.
- Forest (multi-realm): the seam machinery the PRISM cases exercise.
kernel_inventory.md: the PRISM-FNL OpenACC kernel-class audit.