Feat/gkr logup

crypto/stark/src/constraints/evaluator.rs

@@ -17,6 +17,8 @@ use rayon::{
 };
 
 use std::marker::PhantomData;
+#[cfg(feature = "instruments")]
+use std::time::Instant;
 
 pub struct ConstraintEvaluator<
     Field: IsSubFieldOf<FieldExtension> + IsFFTField + Send + Sync,
@@ -252,6 +254,9 @@ where
         #[cfg(all(debug_assertions, not(feature = "parallel")))]
         let boundary_polys: Vec<Polynomial<FieldElement<Field>>> = Vec::new();
 
+        #[cfg(feature = "instruments")]
+        let timer = Instant::now();
+
         let trace_length = domain.interpolation_domain_size;
         let lde_periodic_columns = air
             .get_periodic_column_polynomials(trace_length)
@@ -267,6 +272,15 @@ where
             .collect::<Result<Vec<Vec<FieldElement<Field>>>, FFTError>>()
             .unwrap();
 
+        #[cfg(feature = "instruments")]
+        println!(
+            "     Evaluating periodic columns on lde: {:#?}",
+            timer.elapsed()
+        );
+
+        #[cfg(feature = "instruments")]
+        let timer = Instant::now();
+
         // Fused boundary evaluation: compute (trace[col] - value) on-the-fly
         // instead of pre-computing all boundary_polys_evaluations.
         // This eliminates N_constraints × LDE_size intermediate allocations.
@@ -296,6 +310,12 @@ where
             })
             .collect();
 
+        #[cfg(feature = "instruments")]
+        println!(
+            "     Evaluated boundary polynomials on LDE: {:#?}",
+            timer.elapsed()
+        );
+
         #[cfg(all(debug_assertions, not(feature = "parallel")))]
         let boundary_zerofiers = Vec::new();
 
@@ -305,17 +325,27 @@ where
         #[cfg(all(debug_assertions, not(feature = "parallel")))]
         let _transition_evaluations: Vec<FieldElement<FieldExtension>> = Vec::new();
 
+        #[cfg(feature = "instruments")]
+        let timer = Instant::now();
         let zerofier_data = air.transition_zerofier_evaluations_grouped(domain);
+        #[cfg(feature = "instruments")]
+        println!(
+            "     Evaluated transition zerofiers: {:#?}",
+            timer.elapsed()
+        );
 
         // Iterate over all LDE domain and compute the part of the composition polynomial
         // related to the transition constraints and add it to the already computed part of the
         // boundary constraints.
 
+        #[cfg(feature = "instruments")]
+        let timer = Instant::now();
+
         let num_transition = air.num_transition_constraints();
         let num_periodic = lde_periodic_columns.len();
         let offsets = &air.context().transition_offsets;
 
-        Self::evaluate_transitions(
+        let evaluations_t = Self::evaluate_transitions(
             air,
             lde_trace,
             &lde_periodic_columns,
@@ -327,6 +357,14 @@ where
             num_periodic,
             offsets,
             &self.logup_table_offset,
-        )
+        );
+
+        #[cfg(feature = "instruments")]
+        println!(
+            "     Evaluated transitions and accumulated results: {:#?}",
+            timer.elapsed()
+        );
+
+        evaluations_t
     }
 }

crypto/stark/src/debug.rs

@@ -96,6 +96,7 @@ pub fn validate_trace<
             .map(|(trace_steps, constraint)| trace_steps - constraint.end_exemptions())
             .collect();
 
+    // Pre-compute LogUp alpha powers once for all steps.
     let logup_alpha_powers: Vec<FieldElement<FieldExtension>> =
         if rap_challenges.len() > LOGUP_CHALLENGE_ALPHA {
             compute_alpha_powers(
@@ -106,6 +107,7 @@ pub fn validate_trace<
             Vec::new()
         };
 
+    // Compute logup_table_offset = table_contribution / trace_length
     let logup_table_offset = match bus_public_inputs {
         Some(bpi) => {
             let n_inv = FieldElement::<Field>::from(trace_length as u64)

crypto/stark/src/fri/fri_functions.rs

@@ -17,15 +17,37 @@ pub fn fold_evaluations_in_place<F: IsSubFieldOf<E>, E: IsField>(
     zeta: &FieldElement<E>,
     inv_twiddles: &[FieldElement<F>],
 ) {
-    let half = evals.len() / 2;
-    for j in 0..half {
-        let lo = &evals[2 * j];
-        let hi = &evals[2 * j + 1];
-        let sum = lo + hi;
-        let diff = lo - hi;
-        evals[j] = &sum + &(&inv_twiddles[j] * &(zeta * &diff));
+    #[cfg(feature = "parallel")]
+    {
+        use rayon::prelude::*;
+        // Evaluations are stored interleaved: pairs (evals[2j], evals[2j+1]).
+        // Fold each pair in parallel, collecting into a new Vec of half length.
+        let folded: Vec<FieldElement<E>> = evals
+            .par_chunks(2)
+            .zip(inv_twiddles.par_iter())
+            .map(|(pair, tw)| {
+                let lo = &pair[0];
+                let hi = &pair[1];
+                let sum = lo + hi;
+                let diff = lo - hi;
+                &sum + &(tw * &(zeta * &diff))
+            })
+            .collect();
+        *evals = folded;
+    }
+
+    #[cfg(not(feature = "parallel"))]
+    {
+        let half = evals.len() / 2;
+        for j in 0..half {
+            let lo = &evals[2 * j];
+            let hi = &evals[2 * j + 1];
+            let sum = lo + hi;
+            let diff = lo - hi;
+            evals[j] = &sum + &(&inv_twiddles[j] * &(zeta * &diff));
+        }
+        evals.truncate(half);
     }
-    evals.truncate(half);
 }
 
 /// Compute inverse twiddle factors for evaluation-form FRI folding.