Consistently name empiricial constraints

Author: georgwiese

autoprecompiles/src/adapter.rs

@@ -6,7 +6,7 @@ use std::{fmt::Display, sync::Arc};
 use powdr_number::FieldElement;
 use serde::{Deserialize, Serialize};
 
-use crate::DataDrivenConstraints;
+use crate::EmpiricalConstraints;
 use crate::{
     blocks::{BasicBlock, Instruction, Program},
     constraint_optimizer::IsBusStateful,
@@ -46,13 +46,19 @@ pub trait PgoAdapter {
         config: &PowdrConfig,
         vm_config: AdapterVmConfig<Self::Adapter>,
         labels: BTreeMap<u64, Vec<String>>,
-        execution_stats: DataDrivenConstraints,
+        empirical_constraints: EmpiricalConstraints,
     ) -> Vec<AdapterApcWithStats<Self::Adapter>> {
         let filtered_blocks = blocks
             .into_iter()
             .filter(|block| !Self::Adapter::should_skip_block(block))
             .collect();
-        self.create_apcs_with_pgo(filtered_blocks, config, vm_config, labels, execution_stats)
+        self.create_apcs_with_pgo(
+            filtered_blocks,
+            config,
+            vm_config,
+            labels,
+            empirical_constraints,
+        )
     }
 
     fn create_apcs_with_pgo(
@@ -61,7 +67,7 @@ pub trait PgoAdapter {
         config: &PowdrConfig,
         vm_config: AdapterVmConfig<Self::Adapter>,
         labels: BTreeMap<u64, Vec<String>>,
-        execution_stats: DataDrivenConstraints,
+        empirical_constraints: EmpiricalConstraints,
     ) -> Vec<AdapterApcWithStats<Self::Adapter>>;
 
     fn pc_execution_count(&self, _pc: u64) -> Option<u32> {

autoprecompiles/src/data_driven_constraints.rs renamed to autoprecompiles/src/empirical_constraints.rs

@@ -11,7 +11,7 @@ use crate::{
 
 /// "Constraints" that were inferred from execution statistics.
 #[derive(Serialize, Deserialize, Clone, Default)]
-pub struct DataDrivenConstraints {
+pub struct EmpiricalConstraints {
     /// For each program counter, the range constraints for each column.
     /// The range might not hold in 100% of cases.
     pub column_ranges_by_pc: BTreeMap<u32, Vec<(u32, u32)>>,
@@ -30,22 +30,22 @@ pub struct DebugInfo {
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct ExecutionStatsJson {
-    pub execution_stats: DataDrivenConstraints,
+pub struct EmpiricalConstraintsJson {
+    pub empirical_constraints: EmpiricalConstraints,
     pub debug_info: DebugInfo,
 }
 
-pub fn add_ai_constraints<A: Adapter>(
-    execution_stats: &DataDrivenConstraints,
+pub fn add_empirical_constraints<A: Adapter>(
+    empirical_constraints: &EmpiricalConstraints,
     subs: &[Vec<u64>],
     block: &BasicBlock<A::Instruction>,
     columns: impl Iterator<Item = AlgebraicReference>,
 ) -> (
     Vec<SymbolicConstraint<A::PowdrField>>,
     Vec<SymbolicConstraint<A::PowdrField>>,
 ) {
-    let range_constraints = &execution_stats.column_ranges_by_pc;
-    let equivalence_classes_by_block = &execution_stats.equivalence_classes_by_block;
+    let range_constraints = &empirical_constraints.column_ranges_by_pc;
+    let equivalence_classes_by_block = &empirical_constraints.equivalence_classes_by_block;
 
     let mut range_analyzer_constraints = Vec::new();
     let mut equivalence_analyzer_constraints = Vec::new();

autoprecompiles/src/lib.rs

@@ -1,7 +1,7 @@
 use crate::adapter::{Adapter, AdapterApc, AdapterVmConfig};
 use crate::blocks::BasicBlock;
 use crate::bus_map::{BusMap, BusType};
-use crate::data_driven_constraints::{add_ai_constraints, DataDrivenConstraints};
+use crate::empirical_constraints::{add_empirical_constraints, EmpiricalConstraints};
 use crate::evaluation::AirStats;
 use crate::expression_conversion::algebraic_to_grouped_expression;
 use crate::symbolic_machine_generator::convert_machine_field_type;
@@ -27,7 +27,7 @@ pub mod adapter;
 pub mod blocks;
 pub mod bus_map;
 pub mod constraint_optimizer;
-pub mod data_driven_constraints;
+pub mod empirical_constraints;
 pub mod evaluation;
 pub mod execution_profile;
 pub mod expression;
@@ -423,7 +423,7 @@ pub fn build<A: Adapter>(
     vm_config: AdapterVmConfig<A>,
     degree_bound: DegreeBound,
     apc_candidates_dir_path: Option<&Path>,
-    execution_stats: &DataDrivenConstraints,
+    empirical_constraints: &EmpiricalConstraints,
 ) -> Result<AdapterApc<A>, crate::constraint_optimizer::Error> {
     let start = std::time::Instant::now();
 
@@ -433,12 +433,13 @@ pub fn build<A: Adapter>(
         &vm_config.bus_map,
     );
 
-    let (range_analyzer_constraints, _equivalence_analyzer_constraints) = add_ai_constraints::<A>(
-        execution_stats,
-        &column_allocator.subs,
-        &block,
-        machine.main_columns(),
-    );
+    let (range_analyzer_constraints, _equivalence_analyzer_constraints) =
+        add_empirical_constraints::<A>(
+            empirical_constraints,
+            &column_allocator.subs,
+            &block,
+            machine.main_columns(),
+        );
 
     let labels = [("apc_start_pc", block.start_pc.to_string())];
     metrics::counter!("before_opt_cols", &labels)

autoprecompiles/src/pgo/cell/mod.rs

@@ -13,7 +13,7 @@ use crate::{
     blocks::BasicBlock,
     evaluation::EvaluationResult,
     pgo::cell::selection::parallel_fractional_knapsack,
-    DataDrivenConstraints, PowdrConfig,
+    EmpiricalConstraints, PowdrConfig,
 };
 
 mod selection;
@@ -92,7 +92,7 @@ impl<A: Adapter + Send + Sync, C: Candidate<A> + Send + Sync> PgoAdapter for Cel
         config: &PowdrConfig,
         vm_config: AdapterVmConfig<Self::Adapter>,
         labels: BTreeMap<u64, Vec<String>>,
-        execution_stats: DataDrivenConstraints,
+        empirical_constraints: EmpiricalConstraints,
     ) -> Vec<AdapterApcWithStats<Self::Adapter>> {
         tracing::info!(
             "Generating autoprecompiles with cell PGO for {} blocks",
@@ -132,7 +132,7 @@ impl<A: Adapter + Send + Sync, C: Candidate<A> + Send + Sync> PgoAdapter for Cel
                     vm_config.clone(),
                     config.degree_bound,
                     config.apc_candidates_dir_path.as_deref(),
-                    &execution_stats,
+                    &empirical_constraints,
                 )
                 .ok()?;
                 let candidate = C::create(

autoprecompiles/src/pgo/instruction.rs

@@ -4,7 +4,7 @@ use crate::{
     adapter::{Adapter, AdapterApcWithStats, AdapterVmConfig, PgoAdapter},
     blocks::BasicBlock,
     pgo::create_apcs_for_all_blocks,
-    DataDrivenConstraints, PowdrConfig,
+    EmpiricalConstraints, PowdrConfig,
 };
 
 pub struct InstructionPgo<A> {
@@ -30,7 +30,7 @@ impl<A: Adapter> PgoAdapter for InstructionPgo<A> {
         config: &PowdrConfig,
         vm_config: AdapterVmConfig<Self::Adapter>,
         _labels: BTreeMap<u64, Vec<String>>,
-        execution_stats: DataDrivenConstraints,
+        empirical_constraints: EmpiricalConstraints,
     ) -> Vec<AdapterApcWithStats<Self::Adapter>> {
         tracing::info!(
             "Generating autoprecompiles with instruction PGO for {} blocks",
@@ -71,7 +71,7 @@ impl<A: Adapter> PgoAdapter for InstructionPgo<A> {
                 );
         }
 
-        create_apcs_for_all_blocks::<Self::Adapter>(blocks, config, vm_config, execution_stats)
+        create_apcs_for_all_blocks::<Self::Adapter>(blocks, config, vm_config, empirical_constraints)
     }
 
     fn pc_execution_count(&self, pc: u64) -> Option<u32> {

autoprecompiles/src/pgo/mod.rs

@@ -6,7 +6,7 @@ use strum::{Display, EnumString};
 use crate::{
     adapter::{Adapter, AdapterApcWithStats, AdapterVmConfig, ApcWithStats},
     blocks::BasicBlock,
-    DataDrivenConstraints, PowdrConfig,
+    EmpiricalConstraints, PowdrConfig,
 };
 
 mod cell;
@@ -77,7 +77,7 @@ fn create_apcs_for_all_blocks<A: Adapter>(
     blocks: Vec<BasicBlock<A::Instruction>>,
     config: &PowdrConfig,
     vm_config: AdapterVmConfig<A>,
-    execution_stats: DataDrivenConstraints,
+    empirical_constraints: EmpiricalConstraints,
 ) -> Vec<AdapterApcWithStats<A>> {
     let n_acc = config.autoprecompiles as usize;
     tracing::info!("Generating {n_acc} autoprecompiles in parallel");
@@ -98,7 +98,7 @@ fn create_apcs_for_all_blocks<A: Adapter>(
                 vm_config.clone(),
                 config.degree_bound,
                 config.apc_candidates_dir_path.as_deref(),
-                &execution_stats,
+                &empirical_constraints,
             )
             .unwrap()
         })

autoprecompiles/src/pgo/none.rs

@@ -4,7 +4,7 @@ use crate::{
     adapter::{Adapter, AdapterApcWithStats, AdapterVmConfig, PgoAdapter},
     blocks::BasicBlock,
     pgo::create_apcs_for_all_blocks,
-    DataDrivenConstraints, PowdrConfig,
+    EmpiricalConstraints, PowdrConfig,
 };
 
 pub struct NonePgo<A> {
@@ -29,7 +29,7 @@ impl<A: Adapter> PgoAdapter for NonePgo<A> {
         config: &PowdrConfig,
         vm_config: AdapterVmConfig<Self::Adapter>,
         _labels: BTreeMap<u64, Vec<String>>,
-        execution_stats: DataDrivenConstraints,
+        empirical_constraints: EmpiricalConstraints,
     ) -> Vec<AdapterApcWithStats<Self::Adapter>> {
         // cost = number_of_original_instructions
         blocks.sort_by(|a, b| b.statements.len().cmp(&a.statements.len()));
@@ -43,6 +43,6 @@ impl<A: Adapter> PgoAdapter for NonePgo<A> {
             );
         }
 
-        create_apcs_for_all_blocks::<Self::Adapter>(blocks, config, vm_config, execution_stats)
+        create_apcs_for_all_blocks::<Self::Adapter>(blocks, config, vm_config, empirical_constraints)
     }
 }

openvm/src/customize_exe.rs

@@ -13,7 +13,7 @@ use crate::memory_bus_interaction::OpenVmMemoryBusInteraction;
 use crate::opcode::branch_opcodes_bigint_set;
 use crate::powdr_extension::chip::PowdrAir;
 use crate::utils::UnsupportedOpenVmReferenceError;
-use crate::{execution_stats, OriginalCompiledProgram};
+use crate::{empirical_constraints, OriginalCompiledProgram};
 use crate::{CompiledProgram, SpecializedConfig};
 use itertools::Itertools;
 use openvm_instructions::instruction::Instruction as OpenVmInstruction;
@@ -219,7 +219,7 @@ pub fn customize<'a, P: PgoAdapter<Adapter = BabyBearOpenVmApcAdapter<'a>>>(
         })
         .collect();
 
-    let execution_stats = execution_stats(
+    let empirical_constraints = empirical_constraints(
         exe.clone(),
         SpecializedConfig::new(
             original_config.clone(),
@@ -236,7 +236,7 @@ pub fn customize<'a, P: PgoAdapter<Adapter = BabyBearOpenVmApcAdapter<'a>>>(
         &config,
         vm_config,
         labels,
-        execution_stats,
+        empirical_constraints,
     );
     metrics::gauge!("total_apc_gen_time_ms").set(start.elapsed().as_millis() as f64);
 

openvm/src/execution_stats.rs renamed to openvm/src/empirical_constraints.rs

@@ -6,8 +6,8 @@ use openvm_stark_backend::p3_matrix::dense::DenseMatrix;
 use openvm_stark_sdk::openvm_stark_backend::p3_field::PrimeField32;
 use openvm_stark_sdk::p3_baby_bear::BabyBear;
 use powdr_autoprecompiles::blocks::BasicBlock;
-use powdr_autoprecompiles::data_driven_constraints::{
-    DataDrivenConstraints, DebugInfo, ExecutionStatsJson,
+use powdr_autoprecompiles::empirical_constraints::{
+    DebugInfo, EmpiricalConstraints, EmpiricalConstraintsJson,
 };
 use std::collections::hash_map::Entry;
 use std::collections::BTreeMap;
@@ -30,24 +30,24 @@ struct Trace {
     rows_by_pc: HashMap<u32, Vec<usize>>,
 }
 
-pub fn execution_stats(
+pub fn empirical_constraints(
     exe: Arc<VmExe<BabyBear>>,
     vm_config: SpecializedConfig,
     inputs: StdIn,
     blocks: &[BasicBlock<Instr<BabyBear>>],
-) -> DataDrivenConstraints {
+) -> EmpiricalConstraints {
     let (trace, debug_info) = collect_trace(exe, vm_config, inputs);
-    let execution_stats = generate_execution_stats(blocks, trace);
+    let empirical_constraints = generate_empirical_constraints(blocks, trace);
 
     // Export to disk
-    let export = ExecutionStatsJson {
-        execution_stats: execution_stats.clone(),
+    let export = EmpiricalConstraintsJson {
+        empirical_constraints: empirical_constraints.clone(),
         debug_info,
     };
     let json = serde_json::to_string_pretty(&export).unwrap();
-    std::fs::write("execution_stats.json", json).unwrap();
+    std::fs::write("empirical_constraints.json", json).unwrap();
 
-    execution_stats
+    empirical_constraints
 }
 
 fn collect_trace(
@@ -136,10 +136,10 @@ fn collect_trace(
     (trace, debug_info)
 }
 
-fn generate_execution_stats(
+fn generate_empirical_constraints(
     blocks: &[BasicBlock<Instr<BabyBear>>],
     trace: Trace,
-) -> DataDrivenConstraints {
+) -> EmpiricalConstraints {
     // Block ID -> instruction count mapping
     let instruction_counts = blocks
         .iter()
@@ -236,7 +236,7 @@ fn generate_execution_stats(
         })
         .collect();
 
-    DataDrivenConstraints {
+    EmpiricalConstraints {
         column_ranges_by_pc: column_ranges_by_pc.into_iter().collect(),
         equivalence_classes_by_block: intersected_equivalence_classes,
     }

openvm/src/lib.rs

@@ -3,7 +3,7 @@
 #![cfg_attr(feature = "tco", feature(explicit_tail_calls))]
 #![cfg_attr(feature = "tco", feature(core_intrinsics))]
 
-use crate::execution_stats::execution_stats;
+use crate::empirical_constraints::empirical_constraints;
 use derive_more::From;
 use eyre::Result;
 use itertools::Itertools;
@@ -74,7 +74,7 @@ use crate::powdr_extension::{PowdrExtensionExecutor, PowdrPrecompile};
 mod air_builder;
 pub mod bus_map;
 pub mod cuda_abi;
-mod execution_stats;
+mod empirical_constraints;
 pub mod extraction_utils;
 pub mod opcode;
 pub mod symbolic_instruction_builder;