compact data ref.

executor/src/witgen/data_structures/finalizable_data.rs

@@ -121,6 +121,36 @@ impl<T: FieldElement> CompactData<T> {
     }
 }
 
+/// A mutable reference into CompactData that is meant to be used
+/// only for a certain block of rows, starting from row index zero.
+/// It allows negative row indices as well.
+pub struct CompactDataRef<'a, T: FieldElement> {
+    data: &'a mut CompactData<T>,
+    row_offset: usize,
+}
+
+impl<'a, T: FieldElement> CompactDataRef<'a, T> {
+    /// Creates a new reference to the data, supplying the offset of the row
+    /// that is supposed to be "row zero".
+    pub fn new(data: &'a mut CompactData<T>, row_offset: usize) -> Self {
+        Self { data, row_offset }
+    }
+
+    pub fn get(&self, row: i32, col: u32) -> T {
+        let (v, known) = self.data.get(self.inner_row(row), col as u64);
+        assert!(known);
+        v
+    }
+
+    pub fn set(&mut self, row: i32, col: u32, value: T) {
+        self.data.set(self.inner_row(row), col as u64, value);
+    }
+
+    fn inner_row(&self, row: i32) -> usize {
+        (row + self.row_offset as i32) as usize
+    }
+}
+
 /// A data structure that stores witness data.
 /// It allows to finalize rows, which means that those rows are then stored in a more
 /// compact form. Information about range constraints on those rows is lost, but the
@@ -381,11 +411,11 @@ impl<T: FieldElement> FinalizableData<T> {
         }
     }
 
-    // TODO somehow we need to return a row offset because of the non-finalized rows.
-    pub fn append_new_finalized_rows(&mut self, count: usize) -> &mut CompactData<T> {
+    pub fn append_new_finalized_rows<'a>(&'a mut self, count: usize) -> CompactDataRef<'a, T> {
         assert!(self.post_finalized_data.is_empty());
+        let row_zero = self.finalized_data.len();
         self.finalized_data.append_new_rows(count);
-        &mut self.finalized_data
+        CompactDataRef::new(&mut self.finalized_data, row_zero)
     }
 
     /// Takes all data out of the [FinalizableData] and returns it as a list of columns.

executor/src/witgen/machines/block_machine.rs

@@ -327,12 +327,6 @@ impl<'a, T: FieldElement> BlockMachine<'a, T> {
         RowIndex::from_i64(self.rows() as i64 - 1, self.degree)
     }
 
-    fn get_row(&self, row: RowIndex) -> &Row<T> {
-        // The first block is a dummy block corresponding to rows (-block_size, 0),
-        // so we have to add the block size to the row index.
-        &self.data[(row + self.block_size).into()]
-    }
-
     fn process_plookup_internal<'b, Q: QueryCallback<T>>(
         &mut self,
         mutable_state: &'b mut MutableState<'a, 'b, T, Q>,
@@ -349,19 +343,12 @@ impl<'a, T: FieldElement> BlockMachine<'a, T> {
             }
         }
 
-        // TOOD move this into its own function?
-        if self.parts.prover_functions.is_empty() {
-            let known_inputs = outer_query
-                .left
-                .iter()
-                .map(|e| e.is_constant())
-                .collect::<BitVec>();
-            if self
-                .jit_driver
-                .can_answer_lookup(identity_id, &known_inputs)
-            {
-                return self.process_lookup_via_jit(mutable_state, identity_id, outer_query);
-            }
+        let known_inputs = outer_query.left.iter().map(|e| e.is_constant()).collect();
+        if self
+            .jit_driver
+            .can_answer_lookup(identity_id, &known_inputs)
+        {
+            return self.process_lookup_via_jit(mutable_state, identity_id, outer_query);
         }
 
         // TODO this assumes we are always using the same lookup for this machine.
@@ -444,23 +431,15 @@ impl<'a, T: FieldElement> BlockMachine<'a, T> {
             (self.rows() + self.block_size as DegreeType) < self.degree,
             "Block machine is full (this should have been checked before)"
         );
-        // TODO minus one?
-        let row_offset = self.data.len();
         self.data
             .finalize_range(self.first_in_progress_row..self.data.len());
         self.first_in_progress_row = self.data.len() + self.block_size;
+        //TODO can we properly access the last row of the dummy block?
         let data = self.data.append_new_finalized_rows(self.block_size);
-        // TODO finalize self.data, extend by one (finalized) block.
-        // un-finalize the last block / last row in the interpreted case if it is finalized.
-        // TOOD window at which row?
 
-        let success = self.jit_driver.process_lookup_direct(
-            mutable_state,
-            identity_id,
-            values,
-            data,
-            row_offset,
-        )?;
+        let success =
+            self.jit_driver
+                .process_lookup_direct(mutable_state, identity_id, values, data)?;
         assert!(success);
 
         let mut result = EvalValue::complete(vec![]);

executor/src/witgen/machines/jit_machine_driver.rs

@@ -2,8 +2,8 @@ use bit_vec::BitVec;
 use powdr_number::FieldElement;
 
 use crate::witgen::{
-    data_structures::finalizable_data::CompactData, EvalError, FixedData, MutableState,
-    QueryCallback,
+    data_structures::finalizable_data::{CompactData, CompactDataRef},
+    EvalError, FixedData, MutableState, QueryCallback,
 };
 
 use super::{LookupCell, MachineParts};
@@ -40,8 +40,7 @@ impl<'a, T: FieldElement> JitMachineDriver<'a, T> {
         _mutable_state: &'b mut MutableState<'a, 'b, T, Q>,
         identity_id: u64,
         values: Vec<LookupCell<'c, T>>,
-        data: &'d CompactData<T>,
-        row_offset: usize,
+        data: CompactDataRef<'d, T>,
     ) -> Result<bool, EvalError<T>> {
         todo!();
     }