diff --git a/executor/src/witgen/data_structures/caller_data.rs b/executor/src/witgen/data_structures/caller_data.rs index 69541e7e29..be613d101c 100644 --- a/executor/src/witgen/data_structures/caller_data.rs +++ b/executor/src/witgen/data_structures/caller_data.rs @@ -2,10 +2,8 @@ use itertools::Itertools; use powdr_number::FieldElement; use crate::witgen::{ - global_constraints::RangeConstraintSet, - machines::LookupCell, - processor::{Arguments, OuterQuery}, - AlgebraicVariable, EvalError, EvalResult, EvalValue, + global_constraints::RangeConstraintSet, machines::LookupCell, processor::OuterQuery, + AffineExpression, AlgebraicVariable, EvalError, EvalResult, EvalValue, }; /// A representation of the caller's data. @@ -15,7 +13,7 @@ pub struct CallerData<'a, 'b, T> { /// The raw data of the caller. Unknown values should be ignored. data: Vec, /// The affine expressions of the caller. - arguments: &'b Arguments<'a, T>, + arguments: &'b [AffineExpression, T>], /// Range constraints coming from the caller. range_constraints: &'b dyn RangeConstraintSet, T>, } @@ -36,6 +34,23 @@ impl<'a, 'b, T: FieldElement> From<&'b OuterQuery<'a, '_, T>> for CallerData<'a, } } +impl<'a, 'b, T: FieldElement> CallerData<'a, 'b, T> { + pub fn new( + arguments: &'b [AffineExpression, T>], + range_constraints: &'b dyn RangeConstraintSet, T>, + ) -> Self { + let data = arguments + .iter() + .map(|l| l.constant_value().unwrap_or_default()) + .collect(); + Self { + data, + arguments, + range_constraints, + } + } +} + impl CallerData<'_, '_, T> { /// Returns the data as a list of `LookupCell`s, as expected by `Machine::process_lookup_direct`. pub fn as_lookup_cells(&mut self) -> Vec> { diff --git a/executor/src/witgen/machines/block_machine.rs b/executor/src/witgen/machines/block_machine.rs index b18cfafa74..5c10a7866c 100644 --- a/executor/src/witgen/machines/block_machine.rs +++ b/executor/src/witgen/machines/block_machine.rs @@ -433,19 +433,10 @@ impl<'a, T: FieldElement> BlockMachine<'a, T> { arguments: &[AffineExpression, T>], range_constraints: &dyn RangeConstraintSet, T>, ) -> EvalResult<'a, T> { - let outer_query = match OuterQuery::try_new( - arguments, - range_constraints, - self.parts.connections[&identity_id], - ) { - Ok(outer_query) => outer_query, - Err(incomplete_cause) => return Ok(EvalValue::incomplete(incomplete_cause)), - }; - log::trace!("Start processing block machine '{}'", self.name()); log::trace!("Left values of lookup:"); if log::log_enabled!(log::Level::Trace) { - for l in &outer_query.arguments { + for l in arguments { log::trace!(" {}", l); } } @@ -454,11 +445,7 @@ impl<'a, T: FieldElement> BlockMachine<'a, T> { return Err(EvalError::RowsExhausted(self.name.clone())); } - let known_inputs = outer_query - .arguments - .iter() - .map(|e| e.is_constant()) - .collect(); + let known_inputs = arguments.iter().map(|e| e.is_constant()).collect(); let operation_id = self.find_operation_id(identity_id).and_then(|index| { let v = arguments[index].constant_value()?; Some((index, v)) @@ -468,12 +455,19 @@ impl<'a, T: FieldElement> BlockMachine<'a, T> { .compile_cached(mutable_state, identity_id, &known_inputs, operation_id) .is_some() { - let updates = self.process_lookup_via_jit(mutable_state, identity_id, outer_query)?; + let caller_data = CallerData::new(arguments, range_constraints); + let updates = self.process_lookup_via_jit(mutable_state, identity_id, caller_data)?; assert!(updates.is_complete()); self.block_count_jit += 1; return Ok(updates); } + let outer_query = OuterQuery::new( + arguments, + range_constraints, + self.parts.connections[&identity_id], + ); + // TODO this assumes we are always using the same lookup for this machine. let mut sequence_iterator = self .processing_sequence_cache @@ -528,7 +522,7 @@ impl<'a, T: FieldElement> BlockMachine<'a, T> { &mut self, mutable_state: &MutableState<'a, T, Q>, identity_id: u64, - outer_query: OuterQuery<'a, 'b, T>, + mut caller_data: CallerData<'a, 'b, T>, ) -> EvalResult<'a, T> { assert!( (self.rows() + self.block_size as DegreeType) <= self.degree, @@ -536,8 +530,7 @@ impl<'a, T: FieldElement> BlockMachine<'a, T> { ); self.data.finalize_all(); - let mut values = CallerData::from(&outer_query); - let mut lookup_cells = values.as_lookup_cells(); + let mut lookup_cells = caller_data.as_lookup_cells(); let operation_id = self.find_operation_id(identity_id) .and_then(|index| match &lookup_cells[index] { @@ -555,7 +548,7 @@ impl<'a, T: FieldElement> BlockMachine<'a, T> { )?; assert!(success); - values.into() + caller_data.into() } fn find_operation_id(&self, identity_id: u64) -> Option { diff --git a/executor/src/witgen/machines/double_sorted_witness_machine_32.rs b/executor/src/witgen/machines/double_sorted_witness_machine_32.rs index 6a56e68eb0..9753c05f10 100644 --- a/executor/src/witgen/machines/double_sorted_witness_machine_32.rs +++ b/executor/src/witgen/machines/double_sorted_witness_machine_32.rs @@ -247,10 +247,7 @@ impl<'a, T: FieldElement> Machine<'a, T> for DoubleSortedWitnesses32<'a, T> { range_constraints: &dyn RangeConstraintSet, T>, ) -> EvalResult<'a, T> { let connection = self.parts.connections[&identity_id]; - let outer_query = match OuterQuery::try_new(arguments, range_constraints, connection) { - Ok(outer_query) => outer_query, - Err(incomplete_cause) => return Ok(EvalValue::incomplete(incomplete_cause)), - }; + let outer_query = OuterQuery::new(arguments, range_constraints, connection); let mut data = CallerData::from(&outer_query); if self.process_lookup_direct(mutable_state, identity_id, &mut data.as_lookup_cells())? { Ok(EvalResult::from(data)?.report_side_effect()) diff --git a/executor/src/witgen/machines/dynamic_machine.rs b/executor/src/witgen/machines/dynamic_machine.rs index 68d34a265b..68d1b0e5e1 100644 --- a/executor/src/witgen/machines/dynamic_machine.rs +++ b/executor/src/witgen/machines/dynamic_machine.rs @@ -69,10 +69,7 @@ impl<'a, T: FieldElement> Machine<'a, T> for DynamicMachine<'a, T> { range_constraints: &dyn RangeConstraintSet, T>, ) -> EvalResult<'a, T> { let identity = *self.parts.connections.get(&identity_id).unwrap(); - let outer_query = match OuterQuery::try_new(arguments, range_constraints, identity) { - Ok(outer_query) => outer_query, - Err(incomplete_cause) => return Ok(EvalValue::incomplete(incomplete_cause)), - }; + let outer_query = OuterQuery::new(arguments, range_constraints, identity); log::trace!("Start processing secondary VM '{}'", self.name()); log::trace!("Arguments:"); diff --git a/executor/src/witgen/machines/fixed_lookup_machine.rs b/executor/src/witgen/machines/fixed_lookup_machine.rs index 9e983744af..75a18cb0f5 100644 --- a/executor/src/witgen/machines/fixed_lookup_machine.rs +++ b/executor/src/witgen/machines/fixed_lookup_machine.rs @@ -392,10 +392,7 @@ impl<'a, T: FieldElement> Machine<'a, T> for FixedLookup<'a, T> { ) -> EvalResult<'a, T> { let identity = self.connections[&identity_id]; - let outer_query = match OuterQuery::try_new(arguments, range_constraints, identity) { - Ok(outer_query) => outer_query, - Err(incomplete_cause) => return Ok(EvalValue::incomplete(incomplete_cause)), - }; + let outer_query = OuterQuery::new(arguments, range_constraints, identity); self.process_plookup_internal(mutable_state, identity_id, outer_query) } diff --git a/executor/src/witgen/processor.rs b/executor/src/witgen/processor.rs index 00c742425d..39032751fc 100644 --- a/executor/src/witgen/processor.rs +++ b/executor/src/witgen/processor.rs @@ -61,16 +61,16 @@ pub struct OuterQuery<'a, 'b, T: FieldElement> { } impl<'a, 'b, T: FieldElement> OuterQuery<'a, 'b, T> { - pub fn try_new( + pub fn new( arguments: &'b [AffineExpression, T>], range_constraints: &'b dyn RangeConstraintSet, T>, connection: Connection<'a, T>, - ) -> Result>> { - Ok(Self { + ) -> Self { + Self { range_constraints, connection, arguments: arguments.to_vec(), - }) + } } pub fn is_complete(&self) -> bool {