[cekees]

What

The prototype's masked element kernel runs under Kokkos: threads on a CPU, a GPU through CUDA, from the same headers. Experimental, not part of the proteus build.

• masked.h: the loop body is now elementMaskedOne; elementKernelMasked is the loop over it. portable.h makes the functions KOKKOS_INLINE_FUNCTION under ADRH_USE_KOKKOS.
• kokkos_kernel.h: elementKernelKokkos (the prototype's interface) and assembleColored, which colors the elements by node sharing, and in one launch per color computes each element and adds it to the global residual and a block-CSR Jacobian. No atomics.
• module_kokkos.cpp: adrh_kokkos, same calling convention as adrh_proto. ADRH_MODULE=adrh_kokkos python ad_regression.py (or compare_with_python.py) runs the existing Proteus comparison on it. golden.py compares any two builds.
• bench_kokkos.cpp, build_kokkos.sh, README section.

Decision this implements: Kokkos with element coloring for threads and devices in the generated kernels (cekees, 2026-10-24).

Results

Details and the table are in experimental/adrh/README.md; raw logs are beside the campaign notes.

• The port is the prototype. Kokkos element kernel is bitwise the host kernel on the CPU for all four functors. Against Proteus: element residual and Jacobian 8.6e-16 and 6.0e-16; the advection-diffusion regression in 2D and 3D, all seven boundary treatments, agrees with the Proteus model to 1.2e-14 or better, L2 rates 1.85 to 2.00.
• Same bits at every thread count (1 to 96) and on both RTX 6000 Ada cards, run to run.
• Speed: 11x at 12 threads on an M4 Max, 52 to 63x on 96 Zen 4 threads. One Ada card equals the 96-core node on Poisson and the coupled system, is 3x slower on the five-component chain.
• Bits across platforms depend on fused multiply-add. With contraction off (-ffp-contract=off, --fmad=false), Apple arm64, x86-64 and the GPU give identical bits for Poisson and the five-component chain, and identical Jacobians for all four. The two kernels that call sin differ in the residual's last bit between C libraries and CUDA.

A finding in the host prototype

The compile-time loop helpers were left as real calls whenever the kernel was reached through a member function, which pushes every array of the element into memory: the Poisson kernel ran 3.2x slower there than in a plain loop. Kokkos was not the cause. They are always_inline now, which also speeds the host prototype (masked coupled system 3.4 to 1.3 microseconds per element, masked five-component chain 6.6 to 2.5). Host outputs are bit-identical to before except the 2D advection-diffusion arrays, which move by 3e-16 (FMA contraction under the new inlining). affineP1 uses if constexpr for its 2D branch (the dead 3D branch indexed out of range).

Not done

No pytest: the directory's checks are scripts, and a Kokkos CI leg needs the build-system decision (kernels in a CMake-built library). The CUDA build was run on ceds-model only.

🤖 Generated with Claude Code