merge blake3-real-hash into mmcs-integration

Carries origin/main (cf3b1e9) onto the MMCS integration branch: the bump guest
allocator default (#869), the VRAM-pressure/R2-race fix (#914), the cuda table
scheduler K = num_airs default (#911), and the device-only cliff recovery at
R4 DEEP / comp-tree / R3 barycentric (#935).

This is the branch where the two sides genuinely interleave. M-4p2 extracted the
round bodies so they take the data they use — `lde_trace`, `composition_parts`,
`rap_challenges` — instead of the whole `Round1`/`Round2`, and `multi_prove_batched`
reuses those same extractions. #935 works the other way: its recoveries write the
resident device data back into those very buffers, which is why upstream widened
the round signatures to `&mut Round1`/`&mut Round2`. Neither shape can simply win.

Resolution rule, applied to all nine hunks: **keep the extraction, move the
mutability onto the extracted parameter.** Each recovery then writes to exactly
the buffer its caller owns, and the batched path keeps sharing one implementation
with the monolithic one.

- `crypto/stark/src/prover.rs` `compute_composition_parts` — `lde_trace` becomes
  `&mut`; the R2 host-evaluator arm takes #935's recover-then-assert (replacing the
  old hard abort) against that parameter rather than `round_1_result.lde_trace`.
- `crypto/stark/src/prover.rs` `compute_composition_parts` — the `evaluate_dev`
  arm keeps the extracted `rap_challenges` and the extracted `lde_trace` in the
  `host_trace_empty` retain flag.
- `crypto/stark/src/prover.rs` `round_2_compute_composition_polynomial` — keeps the
  `CompositionParts` return, and #935's fold of the R2 device parts handle into the
  session (`set_gpu_composition_parts`) is added after the call, where
  `round_1_result` is in scope.
- `crypto/stark/src/prover.rs` `round_3_evaluate_polynomials_in_out_of_domain_element`
  — extracted `lde_trace` and `composition_parts` both become `&mut`; the R3 parts
  OOD arm takes #935's recovery against them.
- `crypto/stark/src/prover.rs` `compute_deep_composition_poly_evaluations` — same
  two parameters become `&mut`; the host DEEP loop's recovery writes through
  `composition_parts` instead of `round_2_result.lde_composition_poly_evaluations`.
- `crypto/stark/src/batched/prover.rs` — the three call sites and `deep_codeword`
  follow the widened signatures; the FRI combine closure captures `retained_parts`
  mutably. That closure is `FnOnce` and runs serially, so the capture adds no
  concurrency requirement.
- `crypto/stark/src/prover.rs` — the two `mut` bindings the split moved: the
  parts the R2 commit recovery writes now live in
  `round_2_compute_composition_polynomial` (so `computed.parts` is bound `mut`
  there), and `compute_composition_parts`'s own local is no longer mutated by
  anything, so it loses the `mut` and the `unused_mut` cfg_attr that went with it.
  Only the cuda lint pass sees either.

Both semantics are live afterwards: nothing is un-genericized, no recovery is
dropped, and the parameter each recovery writes to is the one the caller reads
next.

Gates: stark release 350/0 (RESUME-MMCS-INT.md's 349/0 plus main's new
`table_parallelism_stays_within_one_and_num_airs`); debug batched/mmcs 87/0,
exactly the recorded baseline; crypto 71+1/0 on both round arms; `make lint`
clean across all five combos; fmt clean.

`lfm::` reads 345 passed / 19 failed / 9 ignored against a recorded baseline of
349/15/9, and the merge is NOT the cause. Checked out 46798a5 — this branch's
own pre-merge tip — and ran the same suite there: 345/19/9, and the 19 failing
test names diff byte-identical against the merged tree's. The merge delta is
exactly zero; the recorded baseline is stale, drifted by the fixture/toolchain
trap already documented in the lfm fixture-drift notes. Independently, every
resolution in this merge is inside `#[cfg(feature = "cuda")]` or is a signature
mutability change, and that suite runs without cuda, so it could not have moved
those tests either way.

SEMANTIC-CONFLICT NOTE. The batched path consumes its parts on the host
immediately (`parts_builder.absorb`) and never reads the device parts handle, so
the recoveries are inert there today — `materialize_composition_parts_host`
returns true without touching anything when the evals are already populated, so
the widened signatures cost the batched path nothing and cannot trip its asserts.
The recovery is only reachable on the monolithic path. Flagged because that is a
judgement about reachability, not something a test currently pins.

Author: MauroToscano

.github/workflows/benchmark-pr.yml

@@ -12,6 +12,13 @@ on:
       - 'executor/**'
       - 'bin/cli/**'
       - 'tooling/ethrex-fixtures/**'
+      # syscalls is linked into the guest ELF this job builds, so a change confined to
+      # it changes the bytes proven — a guest allocator swap moves cycles on every
+      # workload. Without it main's baseline would stay stale until some prover file
+      # happened to change, and the comparison guard would suppress the table until
+      # then. pr_main.yaml:99 already hashes 'syscalls/**' into the guest-ELF cache
+      # key; the two lists must agree on what rebuilds the guest.
+      - 'syscalls/**'
       # A baseline is only valid for the workload it measured, and the Makefile is
       # what defines that workload: it names the block and pins the URL and sha256
       # of the .bin this job fetches. Without it a repointed block would leave
@@ -28,6 +35,7 @@ on:
   #     - 'crypto/**'
   #     - 'executor/**'
   #     - 'bin/cli/**'
+  #     - 'syscalls/**'
 
 permissions:
   contents: read
@@ -273,7 +281,8 @@ jobs:
 
           # Optional table parallelism for the HEADLINE benchmark only (the memory
           # growth sweep always runs at default parallelism). `/bench k=N` overrides;
-          # otherwise default (cores/3). /bench-growth no longer forces k=1.
+          # otherwise the build's default (num_airs on cuda, cores/3 on CPU).
+          # /bench-growth no longer forces k=1.
           TABLE_K=""
           if [ "$EVENT_NAME" = "issue_comment" ]; then
             TABLE_K=$(echo "$COMMENT_BODY" | grep -o 'k=[0-9]*' | head -1 | cut -d= -f2)

.github/workflows/hyperfine.yaml

@@ -6,6 +6,11 @@ on:
     paths:
       - 'executor/src/**'
       - 'executor/Cargo.toml'
+      # syscalls is linked into the guest ELFs this job builds and measures, so a change
+      # confined to it moves cycles on every benchmark. The cache key below already
+      # hashes it; both lists must agree on what rebuilds the guest, or a syscalls-only
+      # change (a guest allocator swap, say) never gets benchmarked at all.
+      - 'syscalls/**'
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -35,7 +40,7 @@ jobs:
         id: cache
         with:
           path: ${{ matrix.branch }}_programs/*.elf
-          key: benchmarks-${{ matrix.branch }}-${{ hashFiles( 'executor/programs/bench/**', 'syscalls/src/**' ) }}
+          key: benchmarks-${{ matrix.branch }}-${{ hashFiles( 'executor/programs/bench/**', 'syscalls/**' ) }}
           restore-keys: benchmarks-${{ matrix.branch }}-
 
       - name: Setup Rust Environment
@@ -51,7 +56,7 @@ jobs:
 
       - name: Export benchmark hashes
         id: export-hashes
-        run: echo "benchmark-hashes-${{ matrix.branch }}=${{ hashFiles( 'executor/programs/bench/**', 'syscalls/src/**' ) }}" >> "$GITHUB_OUTPUT"
+        run: echo "benchmark-hashes-${{ matrix.branch }}=${{ hashFiles( 'executor/programs/bench/**', 'syscalls/**' ) }}" >> "$GITHUB_OUTPUT"
 
   build-binaries:
     strategy:

.github/workflows/pr_main.yaml

@@ -175,9 +175,17 @@ jobs:
       - name: Run CLI tests
         run: cargo test -p cli
 
-      - name: Run syscalls host tests (keccak differential vs sha3)
+      - name: Run syscalls host tests (allocator + keccak differential vs sha3)
         run: make test-syscalls
 
+      # The dlmalloc fallback is feature-selected, so nothing else in CI compiles it and it
+      # can rot silently. Its tests run here too.
+      - name: Test the dlmalloc guest allocator fallback
+        run: |
+          cd syscalls
+          cargo test --features dlmalloc-alloc
+          cargo test --release --features dlmalloc-alloc
+
       - name: Run ethrex-crypto host tests (hint verify-then-fallback + ecrecover)
         run: make test-ethrex-crypto
 

Cargo.lock

@@ -514,8 +514,12 @@ check-ethrex-fixture-checksums:
 # differential tests (the keccak sponge vs sha3 reference). Run them explicitly
 # in the crate dir; wired into `test` below and run as a dedicated step
 # in CI's cli-test job (pr_main.yaml).
+# Release too: the allocator's `init` guard degrades to an early return once
+# `debug_assert!` is compiled out, which is the configuration guests are built in,
+# and the test for that path is `#[cfg(not(debug_assertions))]`.
 test-syscalls:
 	cd syscalls && cargo test
+	cd syscalls && cargo test --release
 
 # ethrex-crypto is a detached workspace (excluded from the root members), so a
 # root `cargo test` never runs it. Run it explicitly, like test-syscalls.
@@ -561,6 +565,14 @@ test-disk-spill:
 	cargo test --release -p stark --features disk-spill disk_spill
 	FORCE_DISK_SPILL=1 cargo test --release -p lambda-vm-prover --features disk-spill -- disk_spill count_table_lengths
 
+# Per-target wall clock for the GPU prover targets below. A panic on a device-only
+# cliff assert can leave the prover hung rather than aborting — the panicking thread
+# unwinds while its siblings stay parked in CUDA driver waits, and the process never
+# exits — which would hold the rented merge-queue box until the workflow timeout.
+# 45 min is generous against their normal runtime; the SIGKILL follows 30s later, and
+# timeout's 124 exit fails the target so gpu_test.sh reports the group as failed.
+GPU_TEST_TIMEOUT := timeout -k 30 2700
+
 # math-cuda parity tests (requires NVIDIA GPU + nvcc)
 test-math-cuda:
 	cargo test -p math-cuda --release
@@ -629,13 +641,13 @@ test-blake3-second-source:
 # --test-threads=1: these tests reset and assert on process-global GPU call
 # counters, so they must run serially or one test's reset races another's read.
 test-cuda-integration:
-	cargo test -p lambda-vm-prover --release --features cuda \
+	$(GPU_TEST_TIMEOUT) cargo test -p lambda-vm-prover --release --features cuda \
 	    --test cuda_path_integration -- --ignored --nocapture --test-threads=1
 
 # GPU error-path coverage (requires NVIDIA GPU + nvcc).
 # Forces cuda dispatch errors and asserts the CPU fallback still produces a verifying proof.
 test-cuda-fallback:
-	cargo test -p lambda-vm-prover --release --features test-cuda-faults \
+	$(GPU_TEST_TIMEOUT) cargo test -p lambda-vm-prover --release --features test-cuda-faults \
 	    --test cuda_fallback_tests -- --ignored --nocapture --test-threads=1
 
 # The prover/stark/crypto/ecsm test suite with the GPU (cuda) path enabled (requires NVIDIA
@@ -645,14 +657,14 @@ test-cuda-fallback:
 # compile-recursion-elfs: this unfiltered run executes the non-ignored recursion
 # smoke tests, which read prebuilt guest ELFs; scripts/gpu_test.sh otherwise never builds them.
 test-prover-cuda: compile-recursion-elfs
-	cargo test --release -p lambda-vm-prover -p stark -p crypto -p ecsm \
+	$(GPU_TEST_TIMEOUT) cargo test --release -p lambda-vm-prover -p stark -p crypto -p ecsm \
 	    --features lambda-vm-prover/cuda -- --test-threads=1
 
 # The comprehensive all-instructions prove (ignored by default) on the GPU path (requires
 # NVIDIA GPU + nvcc). GPU counterpart of the all-instructions half of CPU CI's merge-queue-only
 # comprehensive job (the CPU job also runs test_recursion_execute; recursion has no GPU leg yet).
 test-prover-comprehensive-cuda:
-	cargo test --release -p lambda-vm-prover --features cuda \
+	$(GPU_TEST_TIMEOUT) cargo test --release -p lambda-vm-prover --features cuda \
 	    test_prove_elfs_all_instructions_64_full -- --ignored --test-threads=1 --nocapture
 
 # math-cuda quick microbench (median of 10 runs)