chore: rename **Step to **Executor (#1949)

Now that our traits are unified around Executor

This was a find/replace excluding the following:
codec.rs,memcpy.s,memset.s,ECDSA.md,**/recursion/**,**/pairing/**,**/ff_derive/**

closes INT-4350

Author: jonathanpwang

crates/circuits/mod-builder/src/core_chip.rs

@@ -203,7 +203,7 @@ impl<F, A> FieldExpressionMetadata<F, A> {
 
 impl<F, A> AdapterCoreMetadata for FieldExpressionMetadata<F, A>
 where
-    A: AdapterTraceStep<F>,
+    A: AdapterTraceExecutor<F>,
 {
     #[inline(always)]
     fn get_adapter_width() -> usize {
@@ -234,7 +234,7 @@ impl<'a, F, A> CustomBorrow<'a, FieldExpressionCoreRecordMut<'a>, FieldExpressio
     }
 
     unsafe fn extract_layout(&self) -> FieldExpressionRecordLayout<F, A> {
-        panic!("Should get the Layout information from FieldExpressionStep");
+        panic!("Should get the Layout information from FieldExpressionExecutor");
     }
 }
 
@@ -273,7 +273,7 @@ impl<'a> FieldExpressionCoreRecordMut<'a> {
 }
 
 #[derive(Clone)]
-pub struct FieldExpressionStep<A> {
+pub struct FieldExpressionExecutor<A> {
     adapter: A,
     pub expr: FieldExpr,
     pub offset: usize,
@@ -282,7 +282,7 @@ pub struct FieldExpressionStep<A> {
     pub name: String,
 }
 
-impl<A> FieldExpressionStep<A> {
+impl<A> FieldExpressionExecutor<A> {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
         adapter: A,
@@ -301,7 +301,7 @@ impl<A> FieldExpressionStep<A> {
         };
         assert_eq!(opcode_flag_idx.len(), local_opcode_idx.len() - 1);
         tracing::info!(
-            "FieldExpressionCoreStep: opcode={name}, main_width={}",
+            "FieldExpressionCoreExecutor: opcode={name}, main_width={}",
             BaseAir::<BabyBear>::width(&expr)
         );
         Self {
@@ -376,10 +376,11 @@ impl<A> FieldExpressionFiller<A> {
     }
 }
 
-impl<F, A, RA> PreflightExecutor<F, RA> for FieldExpressionStep<A>
+impl<F, A, RA> PreflightExecutor<F, RA> for FieldExpressionExecutor<A>
 where
     F: PrimeField32,
-    A: 'static + AdapterTraceStep<F, ReadData: Into<DynArray<u8>>, WriteData: From<DynArray<u8>>>,
+    A: 'static
+        + AdapterTraceExecutor<F, ReadData: Into<DynArray<u8>>, WriteData: From<DynArray<u8>>>,
     for<'buf> RA: RecordArena<
         'buf,
         FieldExpressionRecordLayout<F, A>,

crates/vm/src/arch/integration_api.rs

@@ -94,8 +94,8 @@ pub struct AdapterAirContext<T, I: VmAdapterInterface<T>> {
 /// Helper trait for CPU tracegen.
 pub trait TraceFiller<F>: Send + Sync {
     /// Populates `trace`. This function will always be called after
-    /// [`TraceStep::execute`], so the `trace` should already contain the records necessary to fill
-    /// in the rest of it.
+    /// [`TraceExecutor::execute`], so the `trace` should already contain the records necessary to
+    /// fill in the rest of it.
     fn fill_trace(
         &self,
         mem_helper: &MemoryAuxColsFactory<F>,
@@ -118,7 +118,7 @@ pub trait TraceFiller<F>: Send + Sync {
     }
 
     /// Populates `row_slice`. This function will always be called after
-    /// [`TraceStep::execute`], so the `row_slice` should already contain context necessary to
+    /// [`TraceExecutor::execute`], so the `row_slice` should already contain context necessary to
     /// fill in the rest of the row. This function will be called for each row in the trace which
     /// is being used, and for all other rows in the trace see `fill_dummy_trace_row`.
     ///
@@ -167,10 +167,10 @@ where
 }
 
 /// A helper trait for expressing generic state accesses within the implementation of
-/// [TraceStep]. Note that this is only a helper trait when the same interface of state access
+/// [TraceExecutor]. Note that this is only a helper trait when the same interface of state access
 /// is reused or shared by multiple implementations. It is not required to implement this trait if
-/// it is easier to implement the [TraceStep] trait directly without this trait.
-pub trait AdapterTraceStep<F>: Clone {
+/// it is easier to implement the [TraceExecutor] trait directly without this trait.
+pub trait AdapterTraceExecutor<F>: Clone {
     const WIDTH: usize;
     type ReadData;
     type WriteData;

crates/vm/src/arch/record_arena.rs

@@ -569,7 +569,7 @@ impl<M> AdapterCoreLayout<M> {
 }
 
 /// Empty metadata that implements `AdapterCoreMetadata`
-/// **NOTE**: `AS` is the adapter type that implements `AdapterTraceStep`
+/// **NOTE**: `AS` is the adapter type that implements `AdapterTraceExecutor`
 /// **WARNING**: `AS::WIDTH` is the number of field elements, not the size in bytes
 pub struct AdapterCoreEmptyMetadata<F, AS> {
     _phantom: PhantomData<(F, AS)>,
@@ -601,7 +601,7 @@ impl<F, AS> Default for AdapterCoreEmptyMetadata<F, AS> {
 
 impl<F, AS> AdapterCoreMetadata for AdapterCoreEmptyMetadata<F, AS>
 where
-    AS: super::AdapterTraceStep<F>,
+    AS: super::AdapterTraceExecutor<F>,
 {
     #[inline(always)]
     fn get_adapter_width() -> usize {

crates/vm/src/arch/vm.rs

@@ -67,7 +67,7 @@ use crate::{
             AddressMap, CHUNK,
         },
         program::{trace::VmCommittedExe, ProgramHandler},
-        public_values::PublicValuesStep,
+        public_values::PublicValuesExecutor,
         SystemChipComplex, SystemRecords, SystemWithFixedTraceHeights, PV_EXECUTOR_IDX,
     },
 };
@@ -461,7 +461,7 @@ where
             .then(|| {
                 instance.handler.executors[PV_EXECUTOR_IDX]
                     .as_any_kind()
-                    .downcast_ref::<PublicValuesStep<Val<E::SC>>>()
+                    .downcast_ref::<PublicValuesExecutor<Val<E::SC>>>()
                     .unwrap()
                     .generate_public_values()
             })

crates/vm/src/system/mod.rs

@@ -40,7 +40,7 @@ use crate::{
             online::GuestMemory,
             MemoryAirInventory, MemoryController, TimestampedEquipartition, CHUNK,
         },
-        native_adapter::{NativeAdapterAir, NativeAdapterStep},
+        native_adapter::{NativeAdapterAir, NativeAdapterExecutor},
         phantom::{
             CycleEndPhantomExecutor, CycleStartPhantomExecutor, NopPhantomExecutor, PhantomAir,
             PhantomChip, PhantomExecutor, PhantomFiller,
@@ -49,7 +49,7 @@ use crate::{
             air::Poseidon2PeripheryAir, new_poseidon2_periphery_air, Poseidon2PeripheryChip,
         },
         program::{ProgramBus, ProgramChip},
-        public_values::{PublicValuesChip, PublicValuesCoreAir, PublicValuesStep},
+        public_values::{PublicValuesChip, PublicValuesCoreAir, PublicValuesExecutor},
     },
 };
 
@@ -135,7 +135,7 @@ pub enum TouchedMemory<F> {
 
 #[derive(Clone, AnyEnum, Executor, MeteredExecutor, PreflightExecutor, From)]
 pub enum SystemExecutor<F: Field> {
-    PublicValues(PublicValuesStep<F>),
+    PublicValues(PublicValuesExecutor<F>),
     Phantom(PhantomExecutor<F>),
 }
 
@@ -236,8 +236,8 @@ impl<F: PrimeField32> VmExecutionConfig<F> for SystemConfig {
     type Executor = SystemExecutor<F>;
 
     /// The only way to create an [ExecutorInventory] is from a [SystemConfig]. This will add an
-    /// executor for [PublicValuesStep] if continuations is disabled. It will always add an executor
-    /// for [PhantomChip], which handles all phantom sub-executors.
+    /// executor for [PublicValuesExecutor] if continuations is disabled. It will always add an
+    /// executor for [PhantomChip], which handles all phantom sub-executors.
     fn create_executors(
         &self,
     ) -> Result<ExecutorInventory<Self::Executor>, ExecutorInventoryError> {
@@ -246,8 +246,8 @@ impl<F: PrimeField32> VmExecutionConfig<F> for SystemConfig {
         if self.has_public_values_chip() {
             assert_eq!(inventory.executors().len(), PV_EXECUTOR_IDX);
 
-            let public_values = PublicValuesStep::new(
-                NativeAdapterStep::default(),
+            let public_values = PublicValuesExecutor::new(
+                NativeAdapterExecutor::default(),
                 self.num_public_values,
                 (self.max_constraint_degree as u32).checked_sub(1).unwrap(),
             );
@@ -397,8 +397,8 @@ where
 
         let public_values_chip = config.has_public_values_chip().then(|| {
             VmChipWrapper::new(
-                PublicValuesStep::new(
-                    NativeAdapterStep::default(),
+                PublicValuesExecutor::new(
+                    NativeAdapterExecutor::default(),
                     config.num_public_values,
                     config.max_constraint_degree as u32 - 1,
                 ),

crates/vm/src/system/native_adapter/mod.rs

@@ -29,7 +29,7 @@ use util::{tracing_read_or_imm_native, tracing_write_native};
 
 use super::memory::{online::TracingMemory, MemoryAuxColsFactory};
 use crate::{
-    arch::{get_record_from_slice, AdapterTraceFiller, AdapterTraceStep},
+    arch::{get_record_from_slice, AdapterTraceExecutor, AdapterTraceFiller},
     system::memory::offline_checker::{MemoryReadAuxRecord, MemoryWriteAuxRecord},
 };
 
@@ -170,19 +170,19 @@ pub struct NativeAdapterRecord<F, const R: usize, const W: usize> {
 /// Operands: b for the first read, c for the second read, a for the first write.
 /// If an operand is not used, its address space and pointer should be all 0.
 #[derive(Clone, Debug)]
-pub struct NativeAdapterStep<F, const R: usize, const W: usize> {
+pub struct NativeAdapterExecutor<F, const R: usize, const W: usize> {
     _phantom: PhantomData<F>,
 }
 
-impl<F, const R: usize, const W: usize> Default for NativeAdapterStep<F, R, W> {
+impl<F, const R: usize, const W: usize> Default for NativeAdapterExecutor<F, R, W> {
     fn default() -> Self {
         Self {
             _phantom: PhantomData,
         }
     }
 }
 
-impl<F, const R: usize, const W: usize> AdapterTraceStep<F> for NativeAdapterStep<F, R, W>
+impl<F, const R: usize, const W: usize> AdapterTraceExecutor<F> for NativeAdapterExecutor<F, R, W>
 where
     F: PrimeField32,
 {
@@ -252,7 +252,7 @@ where
 }
 
 impl<F: PrimeField32, const R: usize, const W: usize> AdapterTraceFiller<F>
-    for NativeAdapterStep<F, R, W>
+    for NativeAdapterExecutor<F, R, W>
 {
     const WIDTH: usize = size_of::<NativeAdapterCols<u8, R, W>>();
 

crates/vm/src/system/public_values/core.rs

@@ -22,7 +22,7 @@ use openvm_stark_backend::{
 use crate::{
     arch::{
         execution_mode::{E1ExecutionCtx, E2ExecutionCtx},
-        get_record_from_slice, AdapterAirContext, AdapterTraceFiller, AdapterTraceStep,
+        get_record_from_slice, AdapterAirContext, AdapterTraceExecutor, AdapterTraceFiller,
         BasicAdapterInterface, E2PreCompute, EmptyAdapterCoreLayout, ExecuteFunc, ExecutionError,
         Executor, MeteredExecutor, MinimalInstruction, PreflightExecutor, RecordArena,
         StaticProgramError, TraceFiller, VmCoreAir, VmExecState, VmStateMut,
@@ -32,7 +32,7 @@ use crate::{
             online::{GuestMemory, TracingMemory},
             MemoryAuxColsFactory,
         },
-        native_adapter::NativeAdapterStep,
+        native_adapter::NativeAdapterExecutor,
         public_values::columns::PublicValuesCoreColsView,
     },
     utils::{transmute_field_to_u32, transmute_u32_to_field},
@@ -125,14 +125,14 @@ pub struct PublicValuesRecord<F> {
 
 /// ATTENTION: If a specific public value is not provided, a default 0 will be used when generating
 /// the proof but in the perspective of constraints, it could be any value.
-pub struct PublicValuesStep<F, A = NativeAdapterStep<F, 2, 0>> {
+pub struct PublicValuesExecutor<F, A = NativeAdapterExecutor<F, 2, 0>> {
     adapter: A,
     encoder: Encoder,
     // Mutex is to make the struct Sync. But it actually won't be accessed by multiple threads.
     pub(crate) custom_pvs: Mutex<Vec<Option<F>>>,
 }
 
-impl<F: Clone, A> PublicValuesStep<F, A> {
+impl<F: Clone, A> PublicValuesExecutor<F, A> {
     /// **Note:** `max_degree` is the maximum degree of the constraint polynomials to represent the
     /// flags. If you want the overall AIR's constraint degree to be `<= max_constraint_degree`,
     /// then typically you should set `max_degree` to `max_constraint_degree - 1`.
@@ -154,7 +154,7 @@ impl<F: Clone, A> PublicValuesStep<F, A> {
 }
 
 // We clone when we want to run a new instance of the program, so we reset the custom public values.
-impl<F: Clone, A: Clone> Clone for PublicValuesStep<F, A> {
+impl<F: Clone, A: Clone> Clone for PublicValuesExecutor<F, A> {
     fn clone(&self) -> Self {
         Self {
             adapter: self.adapter.clone(),
@@ -164,10 +164,10 @@ impl<F: Clone, A: Clone> Clone for PublicValuesStep<F, A> {
     }
 }
 
-impl<F, A, RA> PreflightExecutor<F, RA> for PublicValuesStep<F, A>
+impl<F, A, RA> PreflightExecutor<F, RA> for PublicValuesExecutor<F, A>
 where
     F: PrimeField32,
-    A: 'static + Clone + AdapterTraceStep<F, ReadData = [[F; 1]; 2], WriteData = [[F; 1]; 0]>,
+    A: 'static + Clone + AdapterTraceExecutor<F, ReadData = [[F; 1]; 2], WriteData = [[F; 1]; 0]>,
     for<'buf> RA: RecordArena<
         'buf,
         EmptyAdapterCoreLayout<F, A>,
@@ -212,7 +212,7 @@ where
     }
 }
 
-impl<F, A> TraceFiller<F> for PublicValuesStep<F, A>
+impl<F, A> TraceFiller<F> for PublicValuesExecutor<F, A>
 where
     F: PrimeField32,
     A: 'static + AdapterTraceFiller<F>,
@@ -252,7 +252,7 @@ struct PublicValuesPreCompute<F> {
     pvs: *const Mutex<Vec<Option<F>>>,
 }
 
-impl<F, A> Executor<F> for PublicValuesStep<F, A>
+impl<F, A> Executor<F> for PublicValuesExecutor<F, A>
 where
     F: PrimeField32,
 {
@@ -284,7 +284,7 @@ where
     }
 }
 
-impl<F, A> MeteredExecutor<F> for PublicValuesStep<F, A>
+impl<F, A> MeteredExecutor<F> for PublicValuesExecutor<F, A>
 where
     F: PrimeField32,
 {
@@ -374,7 +374,7 @@ unsafe fn execute_e12_impl<F: PrimeField32, CTX, const B_IS_IMM: bool, const C_I
     state.instret += 1;
 }
 
-impl<F, A> PublicValuesStep<F, A>
+impl<F, A> PublicValuesExecutor<F, A>
 where
     F: PrimeField32,
 {

crates/vm/src/system/public_values/mod.rs

@@ -12,4 +12,4 @@ pub use core::*;
 mod tests;
 
 pub type PublicValuesAir = VmAirWrapper<NativeAdapterAir<2, 0>, PublicValuesCoreAir>;
-pub type PublicValuesChip<F> = VmChipWrapper<F, PublicValuesStep<F>>;
+pub type PublicValuesChip<F> = VmChipWrapper<F, PublicValuesExecutor<F>>;

extensions/algebra/circuit/src/fp2_chip/addsub.rs

@@ -11,15 +11,15 @@ use openvm_circuit_primitives::{
 };
 use openvm_instructions::riscv::RV32_CELL_BITS;
 use openvm_mod_circuit_builder::{
-    ExprBuilder, ExprBuilderConfig, FieldExpr, FieldExpressionCoreAir, FieldExpressionFiller,
-    FieldExpressionStep,
+    ExprBuilder, ExprBuilderConfig, FieldExpr, FieldExpressionCoreAir, FieldExpressionExecutor,
+    FieldExpressionFiller,
 };
 use openvm_rv32_adapters::{
-    Rv32VecHeapAdapterAir, Rv32VecHeapAdapterFiller, Rv32VecHeapAdapterStep,
+    Rv32VecHeapAdapterAir, Rv32VecHeapAdapterExecutor, Rv32VecHeapAdapterFiller,
 };
 
-use super::{Fp2Air, Fp2Chip, Fp2Step};
-use crate::{FieldExprVecHeapStep, Fp2};
+use super::{Fp2Air, Fp2Chip, Fp2Executor};
+use crate::{FieldExprVecHeapExecutor, Fp2};
 
 pub fn fp2_addsub_expr(
     config: ExprBuilderConfig,
@@ -92,11 +92,11 @@ pub fn get_fp2_addsub_step<const BLOCKS: usize, const BLOCK_SIZE: usize>(
     range_checker_bus: VariableRangeCheckerBus,
     pointer_max_bits: usize,
     offset: usize,
-) -> Fp2Step<BLOCKS, BLOCK_SIZE> {
+) -> Fp2Executor<BLOCKS, BLOCK_SIZE> {
     let (expr, local_opcode_idx, opcode_flag_idx) = gen_base_expr(config, range_checker_bus);
 
-    FieldExprVecHeapStep(FieldExpressionStep::new(
-        Rv32VecHeapAdapterStep::new(pointer_max_bits),
+    FieldExprVecHeapExecutor(FieldExpressionExecutor::new(
+        Rv32VecHeapAdapterExecutor::new(pointer_max_bits),
         expr,
         offset,
         local_opcode_idx,
@@ -152,16 +152,20 @@ mod tests {
     use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng};
 
     use crate::fp2_chip::{
-        get_fp2_addsub_air, get_fp2_addsub_chip, get_fp2_addsub_step, Fp2Air, Fp2Chip, Fp2Step,
+        get_fp2_addsub_air, get_fp2_addsub_chip, get_fp2_addsub_step, Fp2Air, Fp2Chip, Fp2Executor,
     };
 
     const NUM_LIMBS: usize = 32;
     const LIMB_BITS: usize = 8;
     const MAX_INS_CAPACITY: usize = 128;
     const OFFSET: usize = Fp2Opcode::CLASS_OFFSET;
     type F = BabyBear;
-    type Harness =
-        TestChipHarness<F, Fp2Step<2, NUM_LIMBS>, Fp2Air<2, NUM_LIMBS>, Fp2Chip<F, 2, NUM_LIMBS>>;
+    type Harness = TestChipHarness<
+        F,
+        Fp2Executor<2, NUM_LIMBS>,
+        Fp2Air<2, NUM_LIMBS>,
+        Fp2Chip<F, 2, NUM_LIMBS>,
+    >;
 
     fn set_and_execute_rand(
         tester: &mut VmChipTestBuilder<F>,