s

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["crates/prover", "crates/air_utils"]
+members = ["crates/prover", "crates/air_utils", "crates/air_utils_derive"]
 resolver = "2"
 
 [workspace.package]

crates/air_utils/Cargo.toml

@@ -8,6 +8,7 @@ bytemuck.workspace = true
 itertools.workspace = true
 rayon = { version = "1.10.0", optional = false }
 stwo-prover = { path = "../prover" }
+stwo-air-utils-derive = { path = "../air_utils_derive" }
 
 [lib]
 bench = false

crates/air_utils/src/lib.rs

@@ -1,2 +1,3 @@
 #![feature(exact_size_is_empty, raw_slice_split, portable_simd, array_chunks)]
 pub mod trace;
+pub mod examples;

crates/air_utils/src/trace/component_trace.rs

@@ -64,8 +64,9 @@ impl<const N: usize> ComponentTrace<N> {
     /// The caller must ensure that the column is populated before being used.
     #[allow(clippy::uninit_vec)]
     pub unsafe fn uninitialized(log_size: u32) -> Self {
+        let log_size = std::cmp::max(log_size, LOG_N_LANES);
+        let n_simd_elems = 1 << (log_size - LOG_N_LANES);
         let data = [(); N].map(|_| {
-            let n_simd_elems = (1 << log_size) / N_LANES;
             let mut vec = Vec::with_capacity(n_simd_elems);
             vec.set_len(n_simd_elems);
             vec

crates/air_utils/src/trace/examle_lookup_data.rs

@@ -1,174 +1,28 @@
+#![allow(unused)]
 // TODO(Ohad): write a derive macro for this.
+use stwo_air_utils_derive::StwoIterable;
+use stwo_prover::core::backend::simd::m31::PackedM31;
+use stwo_prover::core::backend::simd::m31::N_LANES;
 use rayon::iter::plumbing::{bridge, Consumer, Producer, ProducerCallback, UnindexedConsumer};
 use rayon::prelude::*;
-use stwo_prover::core::backend::simd::m31::{PackedM31, N_LANES};
 
+#[derive(StwoIterable)]
+#[allow(dead_code)]
 pub struct LookupData {
-    pub lu0: Vec<[PackedM31; 2]>,
-    pub lu1: Vec<[PackedM31; 4]>,
+    lu3: [Vec<[PackedM31; 16]>; 4],
+    lu0: Vec<[PackedM31; 2]>,
+    lu1: Vec<[PackedM31; 4]>,
+    lu2: Vec<[PackedM31; 8]>,
+    lu4: [Vec<[PackedM31; 32]>; 4],
 }
-impl LookupData {
-    /// # Safety
-    pub unsafe fn uninitialized(log_size: u32) -> Self {
-        let length = 1 << log_size;
-        let n_simd_elems = length / N_LANES;
-        let mut lu0 = Vec::with_capacity(n_simd_elems);
-        let mut lu1 = Vec::with_capacity(n_simd_elems);
-        lu0.set_len(n_simd_elems);
-        lu1.set_len(n_simd_elems);
 
-        Self { lu0, lu1 }
-    }
-
-    pub fn iter_mut(&mut self) -> LookupDataIterMut<'_> {
-        LookupDataIterMut::new(&mut self.lu0, &mut self.lu1)
-    }
-
-    pub fn par_iter_mut(&mut self) -> ParLookupDataIterMut<'_> {
-        ParLookupDataIterMut {
-            lu0: &mut self.lu0,
-            lu1: &mut self.lu1,
-        }
-    }
-}
-
-pub struct LookupDataMutChunk<'trace> {
-    pub lu0: &'trace mut [PackedM31; 2],
-    pub lu1: &'trace mut [PackedM31; 4],
-}
-pub struct LookupDataIterMut<'trace> {
-    lu0: *mut [[PackedM31; 2]],
-    lu1: *mut [[PackedM31; 4]],
-    phantom: std::marker::PhantomData<&'trace ()>,
-}
-impl<'trace> LookupDataIterMut<'trace> {
-    pub fn new(slice0: &'trace mut [[PackedM31; 2]], slice1: &'trace mut [[PackedM31; 4]]) -> Self {
-        Self {
-            lu0: slice0 as *mut _,
-            lu1: slice1 as *mut _,
-            phantom: std::marker::PhantomData,
-        }
-    }
-}
-impl<'trace> Iterator for LookupDataIterMut<'trace> {
-    type Item = LookupDataMutChunk<'trace>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.lu0.is_empty() {
-            return None;
-        }
-        let item = unsafe {
-            let (head0, tail0) = self.lu0.split_at_mut(1);
-            let (head1, tail1) = self.lu1.split_at_mut(1);
-            self.lu0 = tail0;
-            self.lu1 = tail1;
-            LookupDataMutChunk {
-                lu0: &mut (*head0)[0],
-                lu1: &mut (*head1)[0],
-            }
-        };
-        Some(item)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = self.lu0.len();
-        (len, Some(len))
-    }
-}
-
-impl ExactSizeIterator for LookupDataIterMut<'_> {}
-impl DoubleEndedIterator for LookupDataIterMut<'_> {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        if self.lu0.is_empty() {
-            return None;
-        }
-        let item = unsafe {
-            let (head0, tail0) = self.lu0.split_at_mut(self.lu0.len() - 1);
-            let (head1, tail1) = self.lu1.split_at_mut(self.lu1.len() - 1);
-            self.lu0 = head0;
-            self.lu1 = head1;
-            LookupDataMutChunk {
-                lu0: &mut (*tail0)[0],
-                lu1: &mut (*tail1)[0],
-            }
-        };
-        Some(item)
-    }
-}
-
-struct RowProducer<'trace> {
-    lu0: &'trace mut [[PackedM31; 2]],
-    lu1: &'trace mut [[PackedM31; 4]],
-}
-
-impl<'trace> Producer for RowProducer<'trace> {
-    type Item = LookupDataMutChunk<'trace>;
-
-    fn split_at(self, index: usize) -> (Self, Self) {
-        let (lu0, rh0) = self.lu0.split_at_mut(index);
-        let (lu1, rh1) = self.lu1.split_at_mut(index);
-        (RowProducer { lu0, lu1 }, RowProducer { lu0: rh0, lu1: rh1 })
-    }
-
-    type IntoIter = LookupDataIterMut<'trace>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        LookupDataIterMut::new(self.lu0, self.lu1)
-    }
-}
-
-pub struct ParLookupDataIterMut<'trace> {
-    lu0: &'trace mut [[PackedM31; 2]],
-    lu1: &'trace mut [[PackedM31; 4]],
-}
-
-impl<'trace> ParLookupDataIterMut<'trace> {
-    pub fn new(slice0: &'trace mut [[PackedM31; 2]], slice1: &'trace mut [[PackedM31; 4]]) -> Self {
-        Self {
-            lu0: slice0,
-            lu1: slice1,
-        }
-    }
-}
-
-impl<'trace> ParallelIterator for ParLookupDataIterMut<'trace> {
-    type Item = LookupDataMutChunk<'trace>;
-
-    fn drive_unindexed<D>(self, consumer: D) -> D::Result
-    where
-        D: UnindexedConsumer<Self::Item>,
-    {
-        bridge(self, consumer)
-    }
-
-    fn opt_len(&self) -> Option<usize> {
-        Some(self.len())
-    }
-}
-
-impl IndexedParallelIterator for ParLookupDataIterMut<'_> {
-    fn len(&self) -> usize {
-        self.lu0.len()
-    }
-
-    fn drive<D: Consumer<Self::Item>>(self, consumer: D) -> D::Result {
-        bridge(self, consumer)
-    }
-
-    fn with_producer<CB: ProducerCallback<Self::Item>>(self, callback: CB) -> CB::Output {
-        callback.callback(RowProducer {
-            lu0: self.lu0,
-            lu1: self.lu1,
-        })
-    }
-}
 
 #[cfg(test)]
 mod tests {
     use itertools::{all, Itertools};
     use rayon::iter::{IndexedParallelIterator, ParallelIterator};
     use rayon::slice::ParallelSlice;
-    use stwo_prover::core::backend::simd::m31::{PackedM31, N_LANES};
+    use stwo_prover::core::backend::simd::m31::{PackedM31, LOG_N_LANES, N_LANES};
     use stwo_prover::core::fields::m31::M31;
 
     use crate::trace::component_trace::ComponentTrace;
@@ -178,20 +32,33 @@ mod tests {
     fn test_lookup_data() {
         const N_COLUMNS: usize = 5;
         const LOG_SIZE: u32 = 8;
-        let mut trace = ComponentTrace::<N_COLUMNS>::zeroed(LOG_SIZE);
+        let mut trace = ComponentTrace::<N_COLUMNS>::zeroed(LOG_SIZE );
         let arr = (0..1 << LOG_SIZE).map(M31::from).collect_vec();
-        let mut lookup_data = unsafe { LookupData::uninitialized(LOG_SIZE) };
-        let expected: (Vec<_>, Vec<_>) = arr
+        let mut lookup_data = unsafe { LookupData::uninitialized(LOG_SIZE - LOG_N_LANES) };
+        let expected: (Vec<_>, Vec<_>, Vec<_>) = arr
             .array_chunks::<N_LANES>()
             .map(|x| {
                 let x = PackedM31::from_array(*x);
                 let x1 = x + PackedM31::broadcast(M31(1));
                 let x2 = x + x1;
                 let x3 = x + x1 + x2;
                 let x4 = x + x1 + x2 + x3;
-                ([x, x4], [x1, x1.double(), x2, x2.double()])
+                (
+                    [x, x4],
+                    [x1, x1.double(), x2, x2.double()],
+                    [
+                        x3,
+                        x3.double(),
+                        x4,
+                        x4.double(),
+                        x,
+                        x.double(),
+                        x1,
+                        x1.double(),
+                    ],
+                )
             })
-            .unzip();
+            .multiunzip();
 
         trace
             .par_iter_mut()
@@ -207,6 +74,35 @@ mod tests {
                     *row[4] = *row[0] + *row[1] + *row[2] + *row[3];
                     *lookup_data.lu0 = [*row[0], *row[4]];
                     *lookup_data.lu1 = [*row[1], row[1].double(), *row[2], row[2].double()];
+                    *lookup_data.lu2 = [
+                        *row[3],
+                        row[3].double(),
+                        *row[4],
+                        row[4].double(),
+                        *row[0],
+                        row[0].double(),
+                        *row[1],
+                        row[1].double(),
+                    ];
+                    *lookup_data.lu3[0] = [
+                        *row[3],
+                        row[3].double(),
+                        *row[4],
+                        row[4].double(),
+                        *row[0],
+                        row[0].double(),
+                        *row[1],
+                        row[1].double(),
+                        *row[3],
+                        row[3].double(),
+                        *row[4],
+                        row[4].double(),
+                        *row[0],
+                        row[0].double(),
+                        *row[1],
+                        row[1].double(),
+                    ]
+
                 })
             });
 

crates/air_utils_derive/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "stwo-air-utils-derive"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = "2.0.90"
+quote = "1.0.37"
+itertools = "0.13.0"
+proc-macro2 = "1.0.92"