Cycle 4 (LPF wd=8) closure: M1=100%, R=0.34, M4=+4.1%, PASS

Fourth daedalus-fourier kernel — VP9 8-tap inner loop filter wd=8
h_8_8 variant. Width extension of cycle 2's wd=4; completes VP9
inner-edge LPF coverage. Full cycle Phase 1-7 + M4'''' in one
combined go (cycle compressed since incremental from cycle 2).

Phase 5 review explicitly skipped (incremental ~30-line shader
delta from cycle 2 + same geometry + cycle-2 RED-pattern checks
still apply). Flagged in docs/k4_lpf8_phase4_7.md per dev_process.md
"Skipping phases is a deliberate choice that should be flagged."

Phase 6 v1 first-light: M1'''' 100.0000% bit-exact (65536/65536)
first try. Shaderdb shows 231 inst, 4 hardware threads, 0 spills,
27 max-temps, 48 uniforms — compiler at the latency-hiding ceiling.

Performance:

  M3'''' NEON (single-core)  52.382 Medge/s
  M2'''' QPU isolation       17.847 Medge/s
  R''''                      0.341  → ORANGE band
  30fps floor margin         9.2x (isolation), 20.3x (mixed)

M4'''' concurrent matrix:

  NEON 4-core                37.823 Medge/s  <- baseline
  QPU only                   14.867 Medge/s
  MIXED NEON-3 + QPU         39.389 Medge/s  <- +4.1% PASS

Verdict: YELLOW-via-M4'''' PASS. Deploy wd=8 LPF on QPU alongside
cycle 2 wd=4. Combined VP9 inner-edge LPF coverage now complete.

Cross-cycle LPF comparison:

  | | wd=4 (k2) | wd=8 (k4) |
  | M3 NEON     | 48.3      | 52.4      |
  | M2 QPU iso  | 19.6      | 17.8      |
  | R iso       | 0.41      | 0.34      |
  | M4 delta    | +6.9%     | +4.1%     |
  | 30fps mixed | 7.2x      | 20.3x     |
  | Verdict     | GO QPU    | GO QPU    |

NEW finding (Phase 9 lesson): NEON gets faster per edge as filter
width grows (20.7 → 19.1 ns wd=4 → wd=8). The relative QPU loss
grows with width. wd=16 would probably flip negative based on the
trend line.

Deployment recipe with cycle 4:

  IDCT 8x8 (k1)     -> QPU   (R=0.92, +7% mixed)
  LPF wd=4 (k2)     -> QPU   (R=0.41, +7% mixed)
  LPF wd=8 (k4)     -> QPU   (R=0.34, +4% mixed)
  MC 8h (k3)        -> CPU   (R=0.067, -19% mixed)
  Entropy           -> CPU   (structural)

VP9 inner-edge LPF coverage complete. Project continues to higgs
deployment plumbing or further kernels per user direction.

New artifacts:
- src/v3d_lpf_h_8_8.comp                 — GLSL shader
- tests/vp9_lpf8_ref.c                   — standalone C ref
- tests/bench_neon_lpf8.c                — M1+M3 bench
- tests/bench_v3d_lpf8.c                 — M1+M2 bench
- tests/bench_concurrent_lpf8.c          — M4 pthread bench
- docs/k4_lpf8_phase1_3.md + phase4_7.md — combined cycle docs

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

CMakeLists.txt

@@ -98,6 +98,14 @@ add_executable(bench_neon_mc
     ${FFC_MC_SOURCES}
 )
 target_compile_options(bench_neon_mc PRIVATE -O3 -march=armv8-a+simd)
+
+# Cycle 4 — VP9 LPF wd=8 NEON baseline (same vendored .S as cycle 2).
+add_executable(bench_neon_lpf8
+    tests/bench_neon_lpf8.c
+    tests/vp9_lpf8_ref.c
+    ${FFASM_LPF_SOURCES}
+)
+target_compile_options(bench_neon_lpf8 PRIVATE -O3 -march=armv8-a+simd)
 # bench_neon_idct doesn't need vulkan/drm — pure CPU baseline.
 
 # ---- Vulkan dispatch-overhead microbench (next chunk) ----------------------
@@ -158,7 +166,18 @@ if (DAEDALUS_BUILD_VULKAN)
         VERBATIM
     )
 
-    add_custom_target(daedalus_shaders ALL DEPENDS ${NOOP_SPV} ${IDCT8_SPV} ${LPF_SPV} ${MC_SPV})
+    set(LPF8_SPV ${CMAKE_BINARY_DIR}/v3d_lpf_h_8_8.spv)
+    add_custom_command(
+        OUTPUT ${LPF8_SPV}
+        COMMAND ${GLSLANG_VALIDATOR} -V --target-env vulkan1.3
+                -o ${LPF8_SPV}
+                ${CMAKE_SOURCE_DIR}/src/v3d_lpf_h_8_8.comp
+        DEPENDS ${CMAKE_SOURCE_DIR}/src/v3d_lpf_h_8_8.comp
+        COMMENT "glslang: v3d_lpf_h_8_8.comp -> v3d_lpf_h_8_8.spv"
+        VERBATIM
+    )
+
+    add_custom_target(daedalus_shaders ALL DEPENDS ${NOOP_SPV} ${IDCT8_SPV} ${LPF_SPV} ${MC_SPV} ${LPF8_SPV})
 
     # v3d_runner — reusable Vulkan plumbing.
     add_library(v3d_runner STATIC src/v3d_runner.c)
@@ -197,6 +216,15 @@ if (DAEDALUS_BUILD_VULKAN)
     target_link_libraries(bench_v3d_mc PRIVATE v3d_runner Vulkan::Vulkan)
     target_compile_options(bench_v3d_mc PRIVATE -O2)
 
+    # Cycle 4 — QPU LPF wd=8 bench.
+    add_executable(bench_v3d_lpf8
+        tests/bench_v3d_lpf8.c
+        tests/vp9_lpf8_ref.c
+    )
+    add_dependencies(bench_v3d_lpf8 daedalus_shaders)
+    target_link_libraries(bench_v3d_lpf8 PRIVATE v3d_runner Vulkan::Vulkan)
+    target_compile_options(bench_v3d_lpf8 PRIVATE -O2)
+
     # M4 — concurrent CPU(NEON) + QPU bench. Links the FFmpeg NEON
     # snapshot so we can run real NEON kernels on pinned CPU cores
     # while the QPU runs its dispatch loop concurrently.
@@ -226,6 +254,15 @@ if (DAEDALUS_BUILD_VULKAN)
     add_dependencies(bench_concurrent_mc daedalus_shaders)
     target_link_libraries(bench_concurrent_mc PRIVATE v3d_runner Vulkan::Vulkan pthread)
     target_compile_options(bench_concurrent_mc PRIVATE -O3 -march=armv8-a+simd)
+
+    # Cycle 4 M4'''' — concurrent LPF wd=8.
+    add_executable(bench_concurrent_lpf8
+        tests/bench_concurrent_lpf8.c
+        ${FFASM_LPF_SOURCES}
+    )
+    add_dependencies(bench_concurrent_lpf8 daedalus_shaders)
+    target_link_libraries(bench_concurrent_lpf8 PRIVATE v3d_runner Vulkan::Vulkan pthread)
+    target_compile_options(bench_concurrent_lpf8 PRIVATE -O3 -march=armv8-a+simd)
 endif()
 
 # ---- Summary ----------------------------------------------------------------