perf: remove step from Program (#1897)

jonathanpwang · web-flow · commit 41c2b4b064e9 · 2025-07-24T19:46:51.000-07:00
We always use `DEFAULT_PC_STEP = 4` and this can lead to slightly better compiler optimizations. closes INT-4385 comparison: https://github.com/axiom-crypto/openvm-reth-benchmark/actions/runs/16510779617 (6% on E1)
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -5,6 +5,11 @@ All notable changes to OpenVM will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project follows a versioning principles documented in [VERSIONING.md](./VERSIONING.md).
 
+## [Unreleased]
+
+### Changed
+- (Toolchain) Removed `step` from `Program` struct because `DEFAULT_PC_STEP = 4` is always used.
+
 ## v1.3.0 (2025-07-15)
 
 No circuit constraints or verifying keys were changed in this release.
diff --git a/crates/toolchain/instructions/src/program.rs b/crates/toolchain/instructions/src/program.rs
@@ -28,52 +28,42 @@ pub struct Program<F> {
         deserialize_with = "deserialize_instructions_and_debug_infos"
     )]
     pub instructions_and_debug_infos: Vec<Option<(Instruction<F>, Option<DebugInfo>)>>,
-    pub step: u32,
     pub pc_base: u32,
 }
 
 #[derive(Clone, Debug, Default)]
 pub struct ProgramDebugInfo {
     inner: Arc<Vec<Option<DebugInfo>>>,
     pc_base: u32,
-    step: u32,
 }
 
 impl<F: Field> Program<F> {
-    pub fn new_empty(step: u32, pc_base: u32) -> Self {
+    pub fn new_empty(pc_base: u32) -> Self {
         Self {
             instructions_and_debug_infos: vec![],
-            step,
             pc_base,
         }
     }
 
-    pub fn new_without_debug_infos(
-        instructions: &[Instruction<F>],
-        step: u32,
-        pc_base: u32,
-    ) -> Self {
+    pub fn new_without_debug_infos(instructions: &[Instruction<F>], pc_base: u32) -> Self {
         Self {
             instructions_and_debug_infos: instructions
                 .iter()
                 .map(|instruction| Some((instruction.clone(), None)))
                 .collect(),
-            step,
             pc_base,
         }
     }
 
     pub fn new_without_debug_infos_with_option(
         instructions: &[Option<Instruction<F>>],
-        step: u32,
         pc_base: u32,
     ) -> Self {
         Self {
             instructions_and_debug_infos: instructions
                 .iter()
                 .map(|instruction| instruction.clone().map(|instruction| (instruction, None)))
                 .collect(),
-            step,
             pc_base,
         }
     }
@@ -90,7 +80,6 @@ impl<F: Field> Program<F> {
                 .zip_eq(debug_infos.iter())
                 .map(|(instruction, debug_info)| Some((instruction.clone(), debug_info.clone())))
                 .collect(),
-            step: DEFAULT_PC_STEP,
             pc_base: 0,
         }
     }
@@ -107,7 +96,7 @@ impl<F: Field> Program<F> {
     }
 
     pub fn from_instructions(instructions: &[Instruction<F>]) -> Self {
-        Self::new_without_debug_infos(instructions, DEFAULT_PC_STEP, 0)
+        Self::new_without_debug_infos(instructions, 0)
     }
 
     pub fn len(&self) -> usize {
@@ -138,7 +127,7 @@ impl<F: Field> Program<F> {
             .flat_map(|(index, option)| {
                 option.clone().map(|(instruction, debug_info)| {
                     (
-                        self.pc_base + (self.step * (index as u32)),
+                        self.pc_base + (DEFAULT_PC_STEP * (index as u32)),
                         instruction,
                         debug_info,
                     )
@@ -186,7 +175,6 @@ impl<F> Program<F> {
         ProgramDebugInfo {
             inner: Arc::new(debug_infos),
             pc_base: self.pc_base,
-            step: self.step,
         }
     }
 }
@@ -218,9 +206,8 @@ impl ProgramDebugInfo {
     /// ## Panics
     /// If `pc` is out of bounds.
     pub fn get(&self, pc: u32) -> &Option<DebugInfo> {
-        let step = self.step;
         let pc_base = self.pc_base;
-        let pc_idx = ((pc - pc_base) / step) as usize;
+        let pc_idx = ((pc - pc_base) / DEFAULT_PC_STEP) as usize;
         &self.inner[pc_idx]
     }
 }
@@ -295,7 +282,7 @@ mod tests {
 
     #[test]
     fn test_program_serde() {
-        let mut program = Program::<F>::new_empty(4, 0);
+        let mut program = Program::<F>::new_empty(0);
         program.instructions_and_debug_infos.push(Some((
             Instruction::from_isize(VmOpcode::from_usize(113), 1, 2, 3, 4, 5),
             None,
diff --git a/crates/toolchain/transpiler/src/lib.rs b/crates/toolchain/transpiler/src/lib.rs
@@ -1,10 +1,7 @@
 //! A transpiler from custom RISC-V ELFs to OpenVM executable binaries.
 
 use elf::Elf;
-use openvm_instructions::{
-    exe::VmExe,
-    program::{Program, DEFAULT_PC_STEP},
-};
+use openvm_instructions::{exe::VmExe, program::Program};
 pub use openvm_platform;
 use openvm_stark_backend::p3_field::PrimeField32;
 use transpiler::{Transpiler, TranspilerError};
@@ -29,11 +26,7 @@ impl<F: PrimeField32> FromElf for VmExe<F> {
     type ElfContext = Transpiler<F>;
     fn from_elf(elf: Elf, transpiler: Self::ElfContext) -> Result<Self, TranspilerError> {
         let instructions = transpiler.transpile(&elf.instructions)?;
-        let program = Program::new_without_debug_infos_with_option(
-            &instructions,
-            DEFAULT_PC_STEP,
-            elf.pc_base,
-        );
+        let program = Program::new_without_debug_infos_with_option(&instructions, elf.pc_base);
         let init_memory = elf_memory_image_to_openvm_memory_image(elf.memory_image);
 
         Ok(VmExe {
diff --git a/crates/vm/src/arch/execution.rs b/crates/vm/src/arch/execution.rs
@@ -28,10 +28,9 @@ pub type Result<T> = std::result::Result<T, ExecutionError>;
 pub enum ExecutionError {
     #[error("execution failed at pc {pc}")]
     Fail { pc: u32 },
-    #[error("pc {pc} out of bounds for program of length {program_len}, with pc_base {pc_base} and step = {step}")]
+    #[error("pc {pc} out of bounds for program of length {program_len}, with pc_base {pc_base}")]
     PcOutOfBounds {
         pc: u32,
-        step: u32,
         pc_base: u32,
         program_len: usize,
     },
diff --git a/crates/vm/src/arch/interpreter.rs b/crates/vm/src/arch/interpreter.rs
@@ -7,7 +7,10 @@ use std::{
 use itertools::Itertools;
 use openvm_circuit_primitives_derive::AlignedBytesBorrow;
 use openvm_instructions::{
-    exe::VmExe, instruction::Instruction, program::Program, LocalOpcode, SystemOpcode,
+    exe::VmExe,
+    instruction::Instruction,
+    program::{Program, DEFAULT_PC_STEP},
+    LocalOpcode, SystemOpcode,
 };
 use openvm_stark_backend::p3_field::{Field, PrimeField32};
 use rand::{rngs::StdRng, SeedableRng};
@@ -233,13 +236,11 @@ unsafe fn execute_impl<F: PrimeField32, Ctx: E1ExecutionCtx>(
 }
 
 fn get_pc_index<F: Field>(program: &Program<F>, pc: u32) -> Result<usize, ExecutionError> {
-    let step = program.step;
     let pc_base = program.pc_base;
-    let pc_index = ((pc - pc_base) / step) as usize;
+    let pc_index = ((pc - pc_base) / DEFAULT_PC_STEP) as usize;
     if !(0..program.len()).contains(&pc_index) {
         return Err(ExecutionError::PcOutOfBounds {
             pc,
-            step,
             pc_base,
             program_len: program.len(),
         });
@@ -365,7 +366,7 @@ fn get_pre_compute_instructions<'a, F: PrimeField32, E: InsExecutorE1<F>, Ctx: E
             let buf: &mut [u8] = buf;
             let pre_inst = if let Some((inst, _)) = inst_opt {
                 tracing::trace!("get_e2_pre_compute_instruction {inst:?}");
-                let pc = program.pc_base + i as u32 * program.step;
+                let pc = program.pc_base + i as u32 * DEFAULT_PC_STEP;
                 if let Some(handler) = get_system_opcode_handler(inst, buf) {
                     PreComputeInstruction {
                         handler,
@@ -415,7 +416,7 @@ fn get_e2_pre_compute_instructions<
             let buf: &mut [u8] = buf;
             let pre_inst = if let Some((inst, _)) = inst_opt {
                 tracing::trace!("get_e2_pre_compute_instruction {inst:?}");
-                let pc = program.pc_base + i as u32 * program.step;
+                let pc = program.pc_base + i as u32 * DEFAULT_PC_STEP;
                 if let Some(handler) = get_system_opcode_handler(inst, buf) {
                     PreComputeInstruction {
                         handler,
diff --git a/crates/vm/src/system/program/mod.rs b/crates/vm/src/system/program/mod.rs
@@ -1,5 +1,7 @@
 use openvm_instructions::{
-    instruction::Instruction, program::Program, LocalOpcode, SystemOpcode, VmOpcode,
+    instruction::Instruction,
+    program::{Program, DEFAULT_PC_STEP},
+    LocalOpcode, SystemOpcode, VmOpcode,
 };
 use openvm_stark_backend::{
     config::StarkGenericConfig,
@@ -58,7 +60,6 @@ pub struct ProgramHandler<F, E> {
     pc_handler: Vec<PcEntry<F>>,
     execution_frequencies: Vec<u32>,
     pc_base: u32,
-    step: u32,
 }
 
 impl<F: Field, E> ProgramHandler<F, E> {
@@ -110,15 +111,13 @@ impl<F: Field, E> ProgramHandler<F, E> {
             executors,
             pc_handler,
             pc_base: program.pc_base,
-            step: program.step,
         })
     }
 
     #[inline(always)]
     fn get_pc_index(&self, pc: u32) -> usize {
-        let step = self.step;
         let pc_base = self.pc_base;
-        ((pc - pc_base) / step) as usize
+        ((pc - pc_base) / DEFAULT_PC_STEP) as usize
     }
 
     /// Returns `(executor, pc_entry, pc_idx)`.
@@ -130,7 +129,6 @@ impl<F: Field, E> ProgramHandler<F, E> {
             .get(pc_idx)
             .ok_or_else(|| ExecutionError::PcOutOfBounds {
                 pc,
-                step: self.step,
                 pc_base: self.pc_base,
                 program_len: self.pc_handler.len(),
             })?;
diff --git a/crates/vm/src/system/program/tests/mod.rs b/crates/vm/src/system/program/tests/mod.rs
@@ -288,7 +288,7 @@ fn test_program_with_undefined_instructions() {
         )),
     ];
 
-    let program = Program::new_without_debug_infos_with_option(&instructions, DEFAULT_PC_STEP, 0);
+    let program = Program::new_without_debug_infos_with_option(&instructions, 0);
 
     interaction_test(program, vec![0, 2, 5]);
 }
diff --git a/crates/vm/src/system/program/trace.rs b/crates/vm/src/system/program/trace.rs
@@ -3,7 +3,11 @@ use std::{borrow::BorrowMut, sync::Arc};
 use derivative::Derivative;
 use itertools::Itertools;
 use openvm_circuit::arch::hasher::poseidon2::Poseidon2Hasher;
-use openvm_instructions::{exe::VmExe, program::Program, LocalOpcode, SystemOpcode};
+use openvm_instructions::{
+    exe::VmExe,
+    program::{Program, DEFAULT_PC_STEP},
+    LocalOpcode, SystemOpcode,
+};
 use openvm_stark_backend::{
     config::{Com, PcsProverData, StarkGenericConfig, Val},
     p3_commit::Pcs,
@@ -169,7 +173,7 @@ pub(crate) fn generate_cached_trace<F: Field>(program: &Program<F>) -> RowMajorM
     let padding = padding_instruction();
     while !instructions.len().is_power_of_two() {
         instructions.push((
-            program.pc_base + instructions.len() as u32 * program.step,
+            program.pc_base + instructions.len() as u32 * DEFAULT_PC_STEP,
             padding.clone(),
         ));
     }
diff --git a/extensions/native/compiler/src/conversion/mod.rs b/extensions/native/compiler/src/conversion/mod.rs
@@ -565,7 +565,7 @@ pub fn convert_program<F: PrimeField32, EF: ExtensionField<F>>(
         }
     }
 
-    let mut result = Program::new_empty(DEFAULT_PC_STEP, 0);
+    let mut result = Program::new_empty(0);
     result.push_instruction_and_debug_info(init_register_0, init_debug_info);
     for block in program.blocks.iter() {
         for (instruction, debug_info) in block.0.iter().zip(block.1.iter()) {

Original file line number	Diff line number	Diff line change
`@@ -28,52 +28,42 @@ pub struct Program<F> {`
`28`	`28`	`deserialize_with = "deserialize_instructions_and_debug_infos"`
`29`	`29`	`)]`
`30`	`30`	`pub instructions_and_debug_infos: Vec<Option<(Instruction<F>, Option<DebugInfo>)>>,`
`31`		`- pub step: u32,`
`32`	`31`	`pub pc_base: u32,`
`33`	`32`	`}`
`34`	`33`
`35`	`34`	`#[derive(Clone, Debug, Default)]`
`36`	`35`	`pub struct ProgramDebugInfo {`
`37`	`36`	`inner: Arc<Vec<Option<DebugInfo>>>,`
`38`	`37`	`pc_base: u32,`
`39`		`- step: u32,`
`40`	`38`	`}`
`41`	`39`
`42`	`40`	`impl<F: Field> Program<F> {`
`43`		`- pub fn new_empty(step: u32, pc_base: u32) -> Self {`
	`41`	`+ pub fn new_empty(pc_base: u32) -> Self {`
`44`	`42`	`Self {`
`45`	`43`	`instructions_and_debug_infos: vec![],`
`46`		`- step,`
`47`	`44`	`pc_base,`
`48`	`45`	`}`
`49`	`46`	`}`
`50`	`47`
`51`		`- pub fn new_without_debug_infos(`
`52`		`- instructions: &[Instruction<F>],`
`53`		`- step: u32,`
`54`		`- pc_base: u32,`
`55`		`- ) -> Self {`
	`48`	`+ pub fn new_without_debug_infos(instructions: &[Instruction<F>], pc_base: u32) -> Self {`
`56`	`49`	`Self {`
`57`	`50`	`instructions_and_debug_infos: instructions`
`58`	`51`	`.iter()`
`59`	`52`	`.map(\|instruction\| Some((instruction.clone(), None)))`
`60`	`53`	`.collect(),`
`61`		`- step,`
`62`	`54`	`pc_base,`
`63`	`55`	`}`
`64`	`56`	`}`
`65`	`57`
`66`	`58`	`pub fn new_without_debug_infos_with_option(`
`67`	`59`	`instructions: &[Option<Instruction<F>>],`
`68`		`- step: u32,`
`69`	`60`	`pc_base: u32,`
`70`	`61`	`) -> Self {`
`71`	`62`	`Self {`
`72`	`63`	`instructions_and_debug_infos: instructions`
`73`	`64`	`.iter()`
`74`	`65`	`.map(\|instruction\| instruction.clone().map(\|instruction\| (instruction, None)))`
`75`	`66`	`.collect(),`
`76`		`- step,`
`77`	`67`	`pc_base,`
`78`	`68`	`}`
`79`	`69`	`}`
`@@ -90,7 +80,6 @@ impl<F: Field> Program<F> {`
`90`	`80`	`.zip_eq(debug_infos.iter())`
`91`	`81`	`.map(\|(instruction, debug_info)\| Some((instruction.clone(), debug_info.clone())))`
`92`	`82`	`.collect(),`
`93`		`- step: DEFAULT_PC_STEP,`
`94`	`83`	`pc_base: 0,`
`95`	`84`	`}`
`96`	`85`	`}`
`@@ -107,7 +96,7 @@ impl<F: Field> Program<F> {`
`107`	`96`	`}`
`108`	`97`
`109`	`98`	`pub fn from_instructions(instructions: &[Instruction<F>]) -> Self {`
`110`		`- Self::new_without_debug_infos(instructions, DEFAULT_PC_STEP, 0)`
	`99`	`+ Self::new_without_debug_infos(instructions, 0)`
`111`	`100`	`}`
`112`	`101`
`113`	`102`	`pub fn len(&self) -> usize {`
`@@ -138,7 +127,7 @@ impl<F: Field> Program<F> {`
`138`	`127`	`.flat_map(\|(index, option)\| {`
`139`	`128`	`option.clone().map(\|(instruction, debug_info)\| {`
`140`	`129`	`(`
`141`		`- self.pc_base + (self.step * (index as u32)),`
	`130`	`+ self.pc_base + (DEFAULT_PC_STEP * (index as u32)),`
`142`	`131`	`instruction,`
`143`	`132`	`debug_info,`
`144`	`133`	`)`
`@@ -186,7 +175,6 @@ impl<F> Program<F> {`
`186`	`175`	`ProgramDebugInfo {`
`187`	`176`	`inner: Arc::new(debug_infos),`
`188`	`177`	`pc_base: self.pc_base,`
`189`		`- step: self.step,`
`190`	`178`	`}`
`191`	`179`	`}`
`192`	`180`	`}`
`@@ -218,9 +206,8 @@ impl ProgramDebugInfo {`
`218`	`206`	`/// ## Panics`
`219`	`207`	/// If `pc` is out of bounds.
`220`	`208`	`pub fn get(&self, pc: u32) -> &Option<DebugInfo> {`
`221`		`- let step = self.step;`
`222`	`209`	`let pc_base = self.pc_base;`
`223`		`- let pc_idx = ((pc - pc_base) / step) as usize;`
	`210`	`+ let pc_idx = ((pc - pc_base) / DEFAULT_PC_STEP) as usize;`
`224`	`211`	`&self.inner[pc_idx]`
`225`	`212`	`}`
`226`	`213`	`}`
`@@ -295,7 +282,7 @@ mod tests {`
`295`	`282`
`296`	`283`	`#[test]`
`297`	`284`	`fn test_program_serde() {`
`298`		`- let mut program = Program::<F>::new_empty(4, 0);`
	`285`	`+ let mut program = Program::<F>::new_empty(0);`
`299`	`286`	`program.instructions_and_debug_infos.push(Some((`
`300`	`287`	`Instruction::from_isize(VmOpcode::from_usize(113), 1, 2, 3, 4, 5),`
`301`	`288`	`None,`
Original file line number	Diff line number	Diff line change
`@@ -288,7 +288,7 @@ fn test_program_with_undefined_instructions() {`
`288`	`288`	`)),`
`289`	`289`	`];`
`290`	`290`
`291`		`- let program = Program::new_without_debug_infos_with_option(&instructions, DEFAULT_PC_STEP, 0);`
	`291`	`+ let program = Program::new_without_debug_infos_with_option(&instructions, 0);`
`292`	`292`
`293`	`293`	`interaction_test(program, vec![0, 2, 5]);`
`294`	`294`	`}`
Original file line number	Diff line number	Diff line change
`@@ -565,7 +565,7 @@ pub fn convert_program<F: PrimeField32, EF: ExtensionField<F>>(`
`565`	`565`	`}`
`566`	`566`	`}`
`567`	`567`
`568`		`- let mut result = Program::new_empty(DEFAULT_PC_STEP, 0);`
	`568`	`+ let mut result = Program::new_empty(0);`
`569`	`569`	`result.push_instruction_and_debug_info(init_register_0, init_debug_info);`
`570`	`570`	`for block in program.blocks.iter() {`
`571`	`571`	`for (instruction, debug_info) in block.0.iter().zip(block.1.iter()) {`