[michalharakal]

Summary

Fifth step of the JVM ↔ wasm compute parity series (after #1363, #1364, #1368, #1369): the ops that were scalar Kotlin on both tiers — softmax, the normalisations and scaled dot-product attention — become one C kernel each, bound through FFM on the JVM and in the SIMD128 sidecar on wasmJs. "Both directions" parity: the JVM gains native attention and norms it never had, the browser gets the last missing piece of a transformer block resident in the sidecar.

Kernels (f32_fused.c, shared tree, SIMD128 + NEON + portable bodies, row-pool threading):

• skainet_f32_softmax_rows — softmax / log-softmax per row.
• skainet_f32_layer_norm, skainet_f32_rms_norm — one pass per row, optional affine.
• skainet_f32_sdpa — the full scaledDotProductAttention contract: grouped-query heads, causal, sliding window with rightContext, per-batch keyLengths, and the dense additive mask with its trailing-aligned broadcast. Masked keys score -1e30 and are never multiplied, so a fully padded row stays finite and uniform as the reference does. Query rows are the threading unit (12 heads × 150 tokens → 1800 rows across the pool).

SPI (skainet-backend-api): Fp32SoftmaxKernel, Fp32NormKernel, Fp32AttentionKernel behind KernelProvider.softmaxFp32() / normFp32() / attentionFp32() (default null); supports("softmax" | "layer_norm" | "rms_norm" | "sdpa", ["Float32"]). Served by NativeKernelProvider (FFM) and WasmKernelProvider.

JVM (DefaultCpuOpsJvm): softmax/logSoftmax over the last dimension (from 1024 elements) and scaledDotProductAttention go to the native kernels when the FFM provider is loaded; otherwise the common implementation serves unchanged. The common SDPA's validation is factored into protected helpers (requireSdpaOperands, sdpaKeyLengths, sdpaMaskDims) that the overrides share, so the contract cannot drift.

wasm (WasmCpuOps): the same three ops run in the sidecar with resident outputs, so q/k/v = x · Wᵀ → sdpa → · Wₒᵀ never leaves linear memory.

FusedNormOps (skainet-lang-core): an optional interface beside TensorOps — layerNorm / rmsNorm over the trailing dimensions — which LayerNormalization consults for FP32 input before its decomposed chain. Only the sidecar and the JVM FFM op sets implement it; recording and differentiating op sets never see it, so recorded graphs, lowerings and gradients are unchanged. TensorOps itself is untouched.

Bench: engine-softmax, engine-layer-norm, engine-sdpa on both harnesses (--provider ffm is the fused path on the JVM, panama/scalar the common paths).

A latent loader failure fixed on the way. GCC with -ffast-math and glibc's math-vector.h auto-vectorises a loop over expf/tanhf/erf into libmvec calls (_ZGVbN4v_expf …) that libskainet_kernels.so is not linked against; the symbol resolves lazily, so the process is terminated by the loader at the first call (exit 127, no crash log). The JVM never called such a loop before this PR — f32_ops.c from #1369 carried four of these references unnoticed — and the new softmax loop was the first to hit it. The transcendentals in element loops now go through opaque scalar wrappers (skainet_expf / skainet_tanhf / skainet_erf in skainet_simd.h); the library has no libmvec reference left (nm -D checked), which also keeps it loadable on glibc builds without libmvec (aarch64 before 2.38).

Measured

Node, 12-core laptop, medians; wasm numbers from wasm-bench, JVM from jvm-cpu-publish (--provider ffm = fused native kernels, panama = common Kotlin path with the Vector API elementwise ops and the context's schedule).

Scenario	JVM panama (common path)	JVM ffm (fused)	wasm scalar	wasm simd128-st	wasm simd128-mt
engine-sdpa (12 heads × 150 × 150, head dim 64, causal) — GFLOP/s	10.8 (per-head scalar, all cores via the schedule)	27.9	0.47	13.45	35.24
engine-softmax ([1024, 1024]) — Melem/s	90	208	37.5	104	228
engine-layer-norm (LayerNormalization with affine, [1024, 768]) — Melem/s	5.4	316	2.1	247	351

Attention on the wasm tier goes from 0.47 to 35 GFLOP/s (75×) and on the JVM from 10.8 (the scalar per-head loop spread over all cores) to 27.9 (vectorised dots, four pool threads). A layer norm goes from 2 → 350 Melem/s on wasm and 5 → 316 on the JVM: the decomposed chain allocated ten intermediates per call on both tiers, which is where the time went; the fused pass allocates one output (resident on wasm). The other engine-* scenarios and laya.chain are unchanged against #1369 within noise.

Verification

• :skainet-backends:skainet-backend-native-cpu:jvmTest — new NativeFusedKernelsTest: softmax / log-softmax (bit-identical to the kernel called directly, rows sum to one, small and non-last-dim tensors keep the common loop), LayerNormalization with and without affine and over two trailing dims against a double-precision reference (bit-identical to the kernel → the hook answered), RMS norm, attention over every mask rule (GQA × shapes × causal × lengths × window/rightContext) against the common kernel and against the dense -1e30 mask, three mask broadcast shapes, a fully padded row, and the 12 × 150 × 64 shape that threads. KernelSupportMatrixTest gains the three fused rows and gates them against the FFM provider.
• :skainet-backends:skainet-backend-wasm-simd:wasmJsNodeTest — new test: the same ops on the sidecar against the scalar lane, outputs resident, a projection feeding attention without a download, structured rules vs the dense mask bit for bit on the sidecar kernel. Plus the existing eleven.
• C: f32_fused.c compiled for wasm32 SIMD128 (emcc 4.0.14), the host portable branch and aarch64 NEON (syntax check); the JVM native library builds it.
• scripts/pr-gate.sh --quick, full gate, apiDump.

Next in the series: the browser IO gaps (WP-D1).