Cross-path CPU suite (Lucy menu [15])

Run: Lucy Bloom Rivers → [15] → pick grid (default 2³) → layer type (or [0] for all).
Code: Lucy examples/seven_layer/cross_path_menu.go
Log: lucy_testing_output/cross_path_layers.txt

Unifies [7] (tiled SC/MC/SIMD) and [14] (native exact + native SIMD) in one side-by-side matrix per layer × dtype.

What it compares

Grid: selectable 1³ / 2³ / 3³ (default 2³) · [5] 3³ SIMD duel (QAT-SIMD vs Nat-SIMD only) · 7 layers/cell · 21 dtypes · train epochs scale by grid (50 / 12 / 6)

Layer types: Dense, SwiGLU, MHA, CNN1, CNN2, CNN3, RNN, LSTM, Embedding, Residual

Per-dtype output

1. Raw timing — forward / backward — SC/MC/SIMD/Nat/NatS wall times
2. Comparison — forward / backward — QAT SC→SIMD, Nat→NatS, best fwd/bwd (QAT vs Nat)
3. Raw timing — training — QAT-SC, QAT-MC, QAT-SIMD, Nat, Nat-SIMD (30 epochs)
4. Train comparisons — QAT SC/MC→SIMD, Nat→NatS, QAT SIMD vs Nat, QAT SIMD vs NatS, best train
5. Parity table — tiled SC↔MC, SC↔SIMD (gated); native↔native-SIMD and SC↔native (informational)
6. Train loss table — final loss per path + PASS/FAIL gates
7. Test tally — gated checks per category + session manifest

Gated tests (per dtype, SIMD layers)

Non-SIMD layers omit SIMD columns (fewer checks).

Native↔native-SIMD parity is reported but not gated — MAC dtypes can legitimately differ from tiled SIMD tolerance bands.

SIMD duel mode (grid [5])

3³ only · 189-layer stack · 6 train epochs · compares only:

Skips SC, MC, native scalar, and parity-vs-SC tables. Per dtype the log prints:

1. One-line summary — PASS/FAIL, 7/7 checks, fwd/bwd/train winner + speedup
2. Raw timing (fwd / bwd) — QAT SIMD-f, NatS-f, QAT SIMD-b, NatS-b wall times
3. QAT-SIMD vs Nat-SIMD — pairwise comparison and per-phase winner per dtype
4. Raw timing (train) — 6-epoch wall time per path
5. Train comparisons — QAT-SIMD vs Nat-SIMD train speedup
6. Dtype spread — slowest → fastest dtype per phase (among winning SIMD path per dtype)
7. Train loss table — Loss₀ and final loss per path + PASS/FAIL gates
8. Test tally — 7 gated checks × 21 dtypes = 147 per layer

Use this when you want apples-to-apples fastest SIMD at the largest practical grid without noise from non-SIMD paths.

Archived SIMD duel results (Jul 2026)

Full [15] → grid [5] → [0] all layers runs, captured off-machine:

Runtime log during a session: lucy_testing_output/cross_path_layers.txt (reset each run).

Pass summary (21 dtypes × layer)

Failures are train-criteria only on the listed rows; forward/backward finiteness still passes. RNN Int8 is a known low-bit + BPTT flake zone at 6 epochs on 3³.

What the duel answers

The duel isolates one design question: for a given layer and dtype, which SIMD stack is faster — QAT-like (GetActive FP32 dequant + DotTile) or native-exact (UseExactDType + *_native_simd.go)?

• QAT-SIMD still pays dequant/materialization cost on MAC dtypes; SIMD helps float paths most.
• Nat-SIMD avoids FP32 staging on integer/FP8 paths; often wins forward on MAC dtypes even when both use DotTile-class kernels.

Training at 6 epochs is mainly a sanity gate (finite loss, harness trainingOK); fwd/bwd tables carry the performance signal.

Performance themes (Dense @ 3³, Float32)

ARM absolute fwd times are ~2× faster than AMD on this Dense stack; relative QAT-vs-Nat winner pattern is similar.

Performance themes (MAC dtypes — Dense forward)

On amd64, Nat-SIMD wins most MAC dtype forwards (QAT-SIMD still dequants through GetActive). On arm64, Float32/BFloat16/FP8-E4M3 forwards can still favor QAT-SIMD; integer paths strongly favor Nat-SIMD (Uint16 up to 9.7×).

Dtype spread tables

Each layer ends with a dtype spread block: among the faster SIMD path per dtype, which dtype is slowest vs fastest for forward, backward, and train.

Example (Dense, amd64):

│ forward    │ Ternary NatS-f 811.6µs→Int64 NatS-f 439.8µs 1.8×  46%
│ backward   │ Uint8 QAT SIMD-b 3.83ms→Int64 NatS-b 2.64ms 1.4×  31%
│ train      │ FP4 NatS 68.6ms→Uint4 QAT SIMD 26.1ms      2.6×  62%

The × column is slow÷fast; gap is approximate percent spread. Use this to see whether perf is dtype-limited (e.g. FP4 train slowest) vs path-limited (same dtype, different QAT/Nat winner in the per-dtype rows above).

On arm64, Dense forward spread is much wider (8.2×, Float16 slowest → Int64 fastest) because some Nat-SIMD forwards time as 0 in the log (sub-timer resolution — treat as “very fast”, not a hard zero).

Reading a one-line summary

· Float32    PASS  7/7  fwd QAT SIMD-f 1.1×  bwd QAT SIMD-b 1.0×  train QAT SIMD 1.0×

NatS-f / NatS-b = native-exact SIMD; SIMD-f / SIMD-b = QAT tiled SIMD.

Train loss table

│ DType      │    Loss₀ QAT-SIMD Nat-SIMD │ QAT    NatS
│ Float64    │   0.3223   0.3223   0.3223 │ PASS   PASS

Loss₀ is shared initial loss; columns are final loss after 6 epochs. QAT / NatS columns are independent PASS/FAIL — one path can fail while the other passes (arm64 Dense Float64: QAT FAIL, NatS PASS).

Session manifest

After [0] or a single layer, the log ends with:

╔══════════════════════════════════════════════════════════════════════╗
║  [15] Cross-path global manifest                                      ║
╚══════════════════════════════════════════════════════════════════════╝
  Dense         dtypes  21/ 21  tests   420/  420  PASS
  ...
  Session dtypes: N passed · M failed
  Session tests:  X passed · Y failed (of Z checks)

Reproduce archived run

cd lucy_bloom_rivers && go run .
# [15] → grid [5] 3³ SIMD duel → layer [0] all types
# Copy lucy_testing_output/cross_path_layers.txt to ~/Documents/loom/simd/ for archiving

Requires GOARCH=amd64 or arm64 with Plan 9 SIMD linked. Full all-layer 3³ duel is ~10–20 minutes per platform.

Related docs