fix

Author: ColoCarletti

crypto/math-cuda/src/merkle.rs

@@ -455,15 +455,8 @@ fn build_comp_poly_tree_nodes_dev(
     Ok((nodes_dev, num_leaves, stream))
 }
 
-pub fn build_comp_poly_tree_from_evals_ext3(parts_interleaved: &[&[u64]]) -> Result<Vec<u8>> {
-    let (nodes_dev, _num_leaves, stream) = build_comp_poly_tree_nodes_dev(parts_interleaved)?;
-    let out = stream.clone_dtoh(&nodes_dev)?;
-    stream.synchronize()?;
-    Ok(out)
-}
-
-/// Like [`build_comp_poly_tree_from_evals_ext3`] but keeps the tree nodes on
-/// device (returned as a [`crate::lde::GpuMerkleTree`] with its root), so R4
+/// Build the comp poly Merkle tree on device and keep the nodes resident
+/// (returned as a [`crate::lde::GpuMerkleTree`] with its root), so R4
 /// composition openings gather paths on device instead of copying the whole
 /// tree to host. `leaves_len = lde_size / 2` (row pair leaves).
 pub fn build_comp_poly_tree_from_evals_ext3_keep(
@@ -480,11 +473,12 @@ pub fn build_comp_poly_tree_from_evals_ext3_keep(
     })
 }
 
-/// Build a FRI-layer Merkle tree on device from an interleaved ext3 eval
-/// vector. Each leaf hashes two consecutive ext3 values. `num_leaves =
-/// evals.len() / 6` (since each ext3 is 3 u64s).
-///
-/// Returns the `(2*num_leaves - 1) * 32`-byte node buffer in standard layout.
+/// Test-only parity harness: build a FRI layer Merkle tree on device from an
+/// interleaved ext3 eval vector and return the full host node buffer so tests
+/// can compare it byte for byte against the CPU. Production folds and commits
+/// via [`crate::fri::FriLayer::fold_and_commit_layer`]. Each leaf hashes two
+/// consecutive ext3 values; `num_leaves = evals.len() / 6`. Returns the
+/// `(2*num_leaves - 1) * 32`-byte node buffer in standard layout.
 pub fn build_fri_layer_tree_from_evals_ext3(evals: &[u64]) -> Result<Vec<u8>> {
     assert!(
         evals.len().is_multiple_of(6),

crypto/math-cuda/tests/keccak_leaves.rs

@@ -217,8 +217,14 @@ fn keccak_comp_poly_leaves_matches_cpu() {
             let parts_slices: Vec<&[u64]> =
                 parts_interleaved.iter().map(|v| v.as_slice()).collect();
 
-            let nodes =
-                math_cuda::merkle::build_comp_poly_tree_from_evals_ext3(&parts_slices).unwrap();
+            // Exercise the production keep path, then read the resident nodes
+            // back to host to check the leaf bytes.
+            let tree =
+                math_cuda::merkle::build_comp_poly_tree_from_evals_ext3_keep(&parts_slices)
+                    .unwrap();
+            let be = math_cuda::device::backend().unwrap();
+            let stream = be.next_stream();
+            let nodes: Vec<u8> = stream.clone_dtoh(&*tree.nodes).unwrap();
             let num_leaves = lde_size / 2;
             let leaves_offset = (num_leaves - 1) * 32;
             for i in 0..num_leaves {

crypto/stark/src/instruments.rs

@@ -4,22 +4,18 @@ use std::sync::OnceLock;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
-// =========================================================================
-// Wall-clock span timeline (the trustworthy per-step measurement)
-// =========================================================================
+// Wall clock span timeline: the trustworthy per step latency breakdown.
 //
-// Nested wall clock spans opened and closed on the driving (main) thread at
-// phase boundaries. Unlike the `accum_*` thread local sub timers below (which
-// sum per worker CPU time across rayon threads and over count, so percentages
-// exceed 100%), these spans do not overlap and sum to their parent, so the tree
-// is a true latency breakdown. Parallel regions are measured as a single span
-// around the blocking call (that is their latency); their internal split is
-// reported separately as CPU time, never mixed into the wall tree.
+// Spans open and close on the main thread at phase boundaries. They do not
+// overlap and sum to their parent, so the tree is a true latency breakdown
+// (unlike the accum_* thread local sub timers below, which sum per worker CPU
+// time across rayon threads and can exceed 100%). A parallel region is one span
+// around the blocking call; its internal split is reported separately as CPU
+// time, never mixed into the wall tree.
 //
 //     let _s = instruments::span("trace_build");   // RAII, stops on drop
 //
-// `Instant::now()` is about 20 ns, fine at phase granularity; never put it
-// inside per op loops.
+// Instant::now() is about 20 ns, fine at phase granularity, not in per op loops.
 
 #[derive(Clone, Debug)]
 pub struct SpanRecord {
@@ -138,9 +134,11 @@ pub fn timeline_json(spans: &[SpanRecord]) -> String {
         if i > 0 {
             out.push(',');
         }
+        // Escape the label so a quote or backslash cannot break the JSON.
+        let label = s.label.replace('\\', "\\\\").replace('"', "\\\"");
         out.push_str(&format!(
             "{{\"label\":\"{}\",\"depth\":{},\"wall_ns\":{},\"order\":{},\"start_ns\":{}}}",
-            s.label,
+            label,
             s.depth,
             s.wall.as_nanos(),
             s.order,

crypto/stark/src/prover.rs

@@ -424,14 +424,10 @@ pub fn table_parallelism() -> usize {
     }
 }
 
-/// Heuristic peak device working set for one table, in bytes. Two parts: the
-/// LDE columns co-resident on the GPU (main base field at 8 B, aux ext3 at
-/// 24 B) times a scratch factor for the NTT and leaf hash transients, plus the
-/// resident Merkle trees (main, aux, composition, FRI layers) kept on device R1
-/// to R4. Each full tree is about `2*lde_size` nodes of 32 B (`64*lde_size`);
-/// together at the R4 peak about 256 B per `lde_size` covers them. A deliberate
-/// over estimate that gates a safety ceiling, not a precise allocator. Pass
-/// `aux_cols == 0` where the aux LDE is not yet resident (R1 main commit).
+/// Heuristic peak device bytes for one table: co-resident LDE columns plus the
+/// resident Merkle trees, with a scratch factor for NTT and leaf transients. A
+/// deliberate over estimate for a safety ceiling, not a precise allocator. Pass
+/// aux_cols == 0 when the aux LDE is not yet resident (R1 main commit).
 fn estimate_table_vram_bytes(main_cols: usize, aux_cols: usize, lde_size: usize) -> u64 {
     const BYTES_PER_BASE: u64 = 8;
     const EXT3_BYTES: u64 = 24;
@@ -445,16 +441,12 @@ fn estimate_table_vram_bytes(main_cols: usize, aux_cols: usize, lde_size: usize)
     lde_term.saturating_add(tree_term)
 }
 
-/// Plan contiguous table chunks for parallel proving.
-///
-/// A chunk grows until it reaches `k` tables (the core and RAM bound limit) or
-/// its summed VRAM estimate would exceed `budget`, whichever comes first. A
-/// single table larger than `budget` forms its own chunk (it runs solo rather
-/// than being excluded). With `budget == u64::MAX` the VRAM constraint is never
-/// binding for any realistic estimate, so chunks fall back to fixed size `k`,
-/// the same as the previous `step_by(k)` scheme. So on non-cuda builds and when
-/// VRAM is not binding, scheduling (and therefore the proof) is unchanged.
-/// Returns `(start, end)` half open ranges covering `0..estimates.len()` in order.
+/// Plan contiguous table chunks for parallel proving. A chunk grows until it
+/// hits `k` tables or its summed VRAM estimate would exceed `budget`; a single
+/// table larger than `budget` runs solo. With `budget == u64::MAX` (non-cuda,
+/// or VRAM not binding) chunks fall back to fixed size `k`, identical to the
+/// old `step_by(k)`, so scheduling and the proof are unchanged. Returns
+/// `(start, end)` half open ranges covering `0..estimates.len()` in order.
 fn plan_table_chunks(estimates: &[u64], k: usize, budget: u64) -> Vec<(usize, usize)> {
     let n = estimates.len();
     let k = k.max(1);