optimize infer_tower_product_witness with less traverse

[hero78119]

design rationale

a simple way by just iterate chunk size 2 at once.

benchmark

this result benefits opcode read/write product argument witness inferring.

with command

cargo bench --bench fibonacci --package ceno_zkvm -- --baseline baseline

on ceno server it shows around 3-4% fibonacci e2e performance

fibonacci_max_steps_1048576/prove_fibonacci/fibonacci_max_steps_1048576
                        time:   [3.9635 s 3.9860 s 4.0097 s]
                        change: [-5.4827% -4.7524% -3.9562%] (p = 0.00 < 0.05)
                        Performance has improved.

[matthiasgoergens]

I would suggest using .tuples so that the compiler can help you more.

Something a bit like this:

diff --git a/ceno_zkvm/src/scheme/utils.rs b/ceno_zkvm/src/scheme/utils.rs
index 26a67c3e..7bac7044 100644
--- a/ceno_zkvm/src/scheme/utils.rs
+++ b/ceno_zkvm/src/scheme/utils.rs
@@ -211,21 +211,21 @@ pub(crate) fn infer_tower_product_witness<E: ExtensionField>(
             let cur_layer: Vec<ArcMultilinearExtension<E>> = (0..num_product_fanin)
                 .map(|index| {
                     let mut evaluations = vec![E::ONE; cur_len];
-                    next_layer.chunks_exact(2).for_each(|f| {
-                        match (f[0].evaluations(), f[1].evaluations()) {
+                    next_layer
+                        .iter()
+                        .map(|f| f.evaluations())
+                        .tuples()
+                        .for_each(|(f1, f2)| match (f1, f2) {
                             (FieldType::Ext(f1), FieldType::Ext(f2)) => {
                                 let start: usize = index * cur_len;
-                                (start..(start + cur_len))
+                                (start..start + cur_len)
                                     .into_par_iter()
-                                    .zip(evaluations.par_iter_mut())
+                                    .zip(&mut evaluations)
                                     .with_min_len(MIN_PAR_SIZE)
-                                    .map(|(index, evaluations)| {
-                                        *evaluations *= f1[index] * f2[index]
-                                    })
+                                    .map(|(index, evaluation)| *evaluation *= f1[index] * f2[index])
                                     .collect()
                             }
                             _ => unreachable!("must be extension field"),
-                        }
                         });
                     evaluations.into_mle().into()
                 })

[hero78119]

thanks for the suggestion, but tuples will silently skip the remainder for non-even result without error hints. I would prefer stick to current way of chunks_exact(2) so it's self-explanantion, and terminate with error precisely in runtime