Perf/deep merkle executor misc

crypto/crypto/src/merkle_tree/backends/field_element_vector.rs

@@ -41,18 +41,14 @@ where
         let mut hasher = D::new();
         hasher.update(input[0].as_bytes());
         hasher.update(input[1].as_bytes());
-        let mut result_hash = [0_u8; NUM_BYTES];
-        result_hash.copy_from_slice(&hasher.finalize());
-        result_hash
+        hasher.finalize().into()
     }
 
     fn hash_new_parent(left: &[u8; NUM_BYTES], right: &[u8; NUM_BYTES]) -> [u8; NUM_BYTES] {
         let mut hasher = D::new();
         hasher.update(left);
         hasher.update(right);
-        let mut result_hash = [0_u8; NUM_BYTES];
-        result_hash.copy_from_slice(&hasher.finalize());
-        result_hash
+        hasher.finalize().into()
     }
 }
 
@@ -82,9 +78,7 @@ where
     pub fn hash_bytes(data: &[u8]) -> [u8; NUM_BYTES] {
         let mut hasher = D::new();
         hasher.update(data);
-        let mut result = [0u8; NUM_BYTES];
-        result.copy_from_slice(&hasher.finalize());
-        result
+        hasher.finalize().into()
     }
 }
 
@@ -104,18 +98,14 @@ where
         for element in input.iter() {
             hasher.update(element.as_bytes());
         }
-        let mut result_hash = [0_u8; NUM_BYTES];
-        result_hash.copy_from_slice(&hasher.finalize());
-        result_hash
+        hasher.finalize().into()
     }
 
     fn hash_new_parent(left: &[u8; NUM_BYTES], right: &[u8; NUM_BYTES]) -> [u8; NUM_BYTES] {
         let mut hasher = D::new();
         hasher.update(left);
         hasher.update(right);
-        let mut result_hash = [0_u8; NUM_BYTES];
-        result_hash.copy_from_slice(&hasher.finalize());
-        result_hash
+        hasher.finalize().into()
     }
 }
 

crypto/stark/src/fri/mod.rs

@@ -6,6 +6,8 @@ use crypto::fiat_shamir::is_transcript::IsStarkTranscript;
 use math::field::element::FieldElement;
 use math::field::traits::{IsFFTField, IsField, IsSubFieldOf};
 use math::traits::AsBytes;
+#[cfg(feature = "parallel")]
+use rayon::prelude::*;
 
 use crate::config::{FriLayerMerkleTree, FriLayerMerkleTreeBackend};
 
@@ -119,8 +121,15 @@ where
 {
     if !fri_layers.is_empty() {
         let num_layers = fri_layers.len();
-        iotas
-            .iter()
+        // Each query (iota) walks the FRI layers independently, reading only the
+        // immutable layer evaluations + Merkle trees. Parallel across queries
+        // (under the `parallel` feature); `map().collect()` preserves order, so
+        // the output is byte-identical to the serial path.
+        #[cfg(not(feature = "parallel"))]
+        let iota_iter = iotas.iter();
+        #[cfg(feature = "parallel")]
+        let iota_iter = iotas.par_iter();
+        iota_iter
             .map(|iota_s| {
                 let mut layers_evaluations_sym = Vec::with_capacity(num_layers);
                 let mut layers_auth_paths = Vec::with_capacity(num_layers);

crypto/stark/src/prover.rs

@@ -1553,55 +1553,62 @@ pub trait IsStarkProver<
         FieldElement<Field>: AsBytes,
         FieldElement<FieldExtension>: AsBytes,
     {
-        let mut openings = Vec::with_capacity(indexes_to_open.len());
-
         let lde_trace = &round_1_result.lde_trace;
         let main_commit = &round_1_result.main;
         let is_preprocessed = main_commit.is_preprocessed();
         let num_precomputed_cols = main_commit.num_precomputed_cols;
         let total_cols = lde_trace.num_main_cols();
 
-        for index in indexes_to_open.iter() {
-            // For preprocessed tables, open the main split (multiplicities only);
-            // for normal tables, open all main columns.
-            let main_trace_opening = if is_preprocessed {
-                Self::open_polys_with(domain, &main_commit.tree, *index, |row| {
-                    lde_trace.gather_main_row_range(row, num_precomputed_cols, total_cols)
-                })
-            } else {
-                Self::open_polys_with(domain, &main_commit.tree, *index, |row| {
-                    lde_trace.gather_main_row(row)
-                })
-            };
-
-            // For preprocessed tables, also open the precomputed-columns tree.
-            let precomputed_trace_opening = main_commit.precomputed_tree.as_ref().map(|tree| {
-                Self::open_polys_with(domain, tree, *index, |row| {
-                    lde_trace.gather_main_row_range(row, 0, num_precomputed_cols)
-                })
-            });
-
-            let composition_openings = Self::open_composition_poly(
-                &round_2_result.composition_poly_merkle_tree,
-                &round_2_result.lde_composition_poly_evaluations,
-                *index,
-            );
-
-            let aux_trace_polys = round_1_result.aux.as_ref().map(|aux| {
-                Self::open_polys_with(domain, &aux.tree, *index, |row| {
-                    lde_trace.gather_aux_row(row)
-                })
-            });
+        // Each query index opens independently and only reads immutable
+        // structures (Merkle trees + LDE), so the per-query authentication-path
+        // walks run in parallel (under the `parallel` feature). `map().collect()`
+        // preserves order, so the openings vector is byte-identical to serial.
+        #[cfg(not(feature = "parallel"))]
+        let index_iter = indexes_to_open.iter();
+        #[cfg(feature = "parallel")]
+        let index_iter = indexes_to_open.par_iter();
+        index_iter
+            .map(|index| {
+                // For preprocessed tables, open the main split (multiplicities only);
+                // for normal tables, open all main columns.
+                let main_trace_opening = if is_preprocessed {
+                    Self::open_polys_with(domain, &main_commit.tree, *index, |row| {
+                        lde_trace.gather_main_row_range(row, num_precomputed_cols, total_cols)
+                    })
+                } else {
+                    Self::open_polys_with(domain, &main_commit.tree, *index, |row| {
+                        lde_trace.gather_main_row(row)
+                    })
+                };
+
+                // For preprocessed tables, also open the precomputed-columns tree.
+                let precomputed_trace_opening =
+                    main_commit.precomputed_tree.as_ref().map(|tree| {
+                        Self::open_polys_with(domain, tree, *index, |row| {
+                            lde_trace.gather_main_row_range(row, 0, num_precomputed_cols)
+                        })
+                    });
+
+                let composition_openings = Self::open_composition_poly(
+                    &round_2_result.composition_poly_merkle_tree,
+                    &round_2_result.lde_composition_poly_evaluations,
+                    *index,
+                );
 
-            openings.push(DeepPolynomialOpening {
-                composition_poly: composition_openings,
-                main_trace_polys: main_trace_opening,
-                precomputed_trace_polys: precomputed_trace_opening,
-                aux_trace_polys,
-            });
-        }
+                let aux_trace_polys = round_1_result.aux.as_ref().map(|aux| {
+                    Self::open_polys_with(domain, &aux.tree, *index, |row| {
+                        lde_trace.gather_aux_row(row)
+                    })
+                });
 
-        openings
+                DeepPolynomialOpening {
+                    composition_poly: composition_openings,
+                    main_trace_polys: main_trace_opening,
+                    precomputed_trace_polys: precomputed_trace_opening,
+                    aux_trace_polys,
+                }
+            })
+            .collect()
     }
 
     // TODO: propagate errors instead of unwrap() in commit_columns, reconstruct_round1, and expand_columns_to_lde

executor/src/vm/execution.rs

@@ -105,10 +105,15 @@ impl Executor {
 
     /// Run to completion and return all logs (consumes executor)
     pub fn run(mut self) -> Result<ExecutionResult, ExecutorError> {
-        let mut logs = Vec::with_capacity(CHUNK_SIZE);
-
-        while let Some(chunk) = self.resume()? {
-            logs.extend_from_slice(chunk);
+        let mut logs = Vec::new();
+
+        // `resume()` fills `self.logs` (a reused chunk buffer) and returns a
+        // borrow of it. Drop that borrow immediately (`.is_some()`), then *move*
+        // the chunk out with `append` instead of cloning it via
+        // `extend_from_slice`: this avoids holding a second copy of every chunk
+        // and the per-log clone, lowering peak log memory during proving.
+        while self.resume()?.is_some() {
+            logs.append(&mut self.logs);
         }
 
         Ok(ExecutionResult {