move program into AlgebraicExecutionTrace

triton-vm/benches/prove_fib_100.rs

@@ -36,7 +36,7 @@ fn prove_fib_100(criterion: &mut Criterion) {
     }
 
     let instructions = program.to_bwords();
-    let padded_height = MasterBaseTable::padded_height(&aet, &instructions);
+    let padded_height = MasterBaseTable::padded_height(&aet);
     let claim = Claim {
         input,
         program: instructions,

triton-vm/benches/prove_halt.rs

@@ -31,7 +31,7 @@ fn prove_halt(_criterion: &mut Criterion) {
 
     let code = program.to_bwords();
     let cycle_count = aet.processor_trace.nrows();
-    let padded_height = MasterBaseTable::padded_height(&aet, &code);
+    let padded_height = MasterBaseTable::padded_height(&aet);
     let claim = Claim {
         input: vec![],
         program: code,

triton-vm/benches/verify_halt.rs

@@ -54,7 +54,7 @@ fn verify_halt(criterion: &mut Criterion) {
             panic!("The VM encountered the following problem: {}", error);
         }
         maybe_cycle_count = Some(aet.processor_trace.nrows());
-        let padded_height = MasterBaseTable::padded_height(&aet, &instructions);
+        let padded_height = MasterBaseTable::padded_height(&aet);
         let claim = Claim {
             input: vec![],
             program: instructions,

triton-vm/src/shared_tests.rs

@@ -26,7 +26,7 @@ pub fn parse_setup_simulate(
     input_symbols: Vec<BFieldElement>,
     secret_input_symbols: Vec<BFieldElement>,
     maybe_profiler: &mut Option<TritonProfiler>,
-) -> (AlgebraicExecutionTrace, Vec<BFieldElement>, Program) {
+) -> (AlgebraicExecutionTrace, Vec<BFieldElement>) {
     let program = Program::from_code(code);
 
     let program = program.expect("Program must parse.");
@@ -38,7 +38,7 @@ pub fn parse_setup_simulate(
     }
     prof_stop!(maybe_profiler, "simulate");
 
-    (aet, stdout, program)
+    (aet, stdout)
 }
 
 pub fn parse_simulate_prove(
@@ -47,17 +47,17 @@ pub fn parse_simulate_prove(
     secret_input_symbols: Vec<BFieldElement>,
     maybe_profiler: &mut Option<TritonProfiler>,
 ) -> (Stark, Proof) {
-    let (aet, output_symbols, program) = parse_setup_simulate(
+    let (aet, output_symbols) = parse_setup_simulate(
         code,
         input_symbols.clone(),
         secret_input_symbols,
         maybe_profiler,
     );
 
-    let padded_height = MasterBaseTable::padded_height(&aet, &program.to_bwords());
+    let padded_height = MasterBaseTable::padded_height(&aet);
     let claim = Claim {
         input: input_symbols,
-        program: program.to_bwords(),
+        program: aet.program.to_bwords(),
         output: output_symbols,
         padded_height,
     };

triton-vm/src/stark.rs

@@ -157,12 +157,8 @@ impl Stark {
     ) -> Proof {
         prof_start!(maybe_profiler, "base tables");
         prof_start!(maybe_profiler, "create");
-        let mut master_base_table = MasterBaseTable::new(
-            aet,
-            &self.claim.program,
-            self.parameters.num_trace_randomizers,
-            self.fri.domain,
-        );
+        let mut master_base_table =
+            MasterBaseTable::new(aet, self.parameters.num_trace_randomizers, self.fri.domain);
         prof_stop!(maybe_profiler, "create");
 
         prof_start!(maybe_profiler, "pad");
@@ -917,7 +913,7 @@ pub(crate) mod triton_stark_tests {
         code: &str,
         input_symbols: Vec<BFieldElement>,
         secret_input_symbols: Vec<BFieldElement>,
-    ) -> (AlgebraicExecutionTrace, Vec<BFieldElement>, Program) {
+    ) -> (AlgebraicExecutionTrace, Vec<BFieldElement>) {
         let program = Program::from_code(code);
 
         assert!(program.is_ok(), "program parses correctly");
@@ -927,21 +923,20 @@ pub(crate) mod triton_stark_tests {
         if let Some(error) = err {
             panic!("The VM encountered the following problem: {}", error);
         }
-        (aet, stdout, program)
+        (aet, stdout)
     }
 
     pub fn parse_simulate_pad(
         code: &str,
         stdin: Vec<BFieldElement>,
         secret_in: Vec<BFieldElement>,
     ) -> (Stark, MasterBaseTable, MasterBaseTable) {
-        let (aet, stdout, program) = parse_setup_simulate(code, stdin.clone(), secret_in);
+        let (aet, stdout) = parse_setup_simulate(code, stdin.clone(), secret_in);
 
-        let instructions = program.to_bwords();
-        let padded_height = MasterBaseTable::padded_height(&aet, &instructions);
+        let padded_height = MasterBaseTable::padded_height(&aet);
         let claim = Claim {
             input: stdin,
-            program: instructions,
+            program: aet.program.to_bwords(),
             output: stdout,
             padded_height,
         };
@@ -952,7 +947,6 @@ pub(crate) mod triton_stark_tests {
 
         let mut master_base_table = MasterBaseTable::new(
             aet,
-            &stark.claim.program,
             stark.parameters.num_trace_randomizers,
             stark.fri.domain,
         );

triton-vm/src/table/master_table.rs

@@ -304,9 +304,9 @@ impl MasterTable<XFieldElement> for MasterExtTable {
 }
 
 impl MasterBaseTable {
-    pub fn padded_height(aet: &AlgebraicExecutionTrace, program: &[BFieldElement]) -> usize {
+    pub fn padded_height(aet: &AlgebraicExecutionTrace) -> usize {
         let max_height = [
-            Self::program_length(program),
+            Self::program_length(aet),
             Self::processor_table_length(aet),
             Self::hash_table_length(aet),
             Self::u32_table_length(aet),
@@ -318,8 +318,8 @@ impl MasterBaseTable {
         roundup_npo2(max_height as u64) as usize
     }
 
-    pub fn program_length(program: &[BFieldElement]) -> usize {
-        program.len()
+    pub fn program_length(aet: &AlgebraicExecutionTrace) -> usize {
+        aet.program.to_bwords().len()
     }
 
     pub fn processor_table_length(aet: &AlgebraicExecutionTrace) -> usize {
@@ -343,18 +343,13 @@ impl MasterBaseTable {
 
     pub fn new(
         aet: AlgebraicExecutionTrace,
-        program: &[BFieldElement],
         num_trace_randomizers: usize,
         fri_domain: ArithmeticDomain,
     ) -> Self {
-        let padded_height = Self::padded_height(&aet, program);
+        let padded_height = Self::padded_height(&aet);
         let randomized_padded_trace_len =
             randomized_padded_trace_len(num_trace_randomizers, padded_height);
         let unit_distance = randomized_padded_trace_len / padded_height;
-        let program_len = program.len();
-        let main_execution_len = aet.processor_trace.nrows();
-        let hash_coprocessor_execution_len = Self::hash_table_length(&aet);
-        let u32_coprocesor_execution_len = Self::u32_table_length(&aet);
 
         let num_rows = randomized_padded_trace_len;
         let num_columns = NUM_BASE_COLUMNS;
@@ -363,18 +358,18 @@ impl MasterBaseTable {
         let mut master_base_table = Self {
             padded_height,
             num_trace_randomizers,
-            program_len,
-            main_execution_len,
-            hash_coprocessor_execution_len,
-            u32_coprocesor_execution_len,
+            program_len: Self::program_length(&aet),
+            main_execution_len: Self::processor_table_length(&aet),
+            hash_coprocessor_execution_len: Self::hash_table_length(&aet),
+            u32_coprocesor_execution_len: Self::u32_table_length(&aet),
             randomized_padded_trace_len,
             rand_trace_to_padded_trace_unit_distance: unit_distance,
             fri_domain,
             master_base_matrix,
         };
 
         let program_table = &mut master_base_table.table_mut(TableId::ProgramTable);
-        ProgramTable::fill_trace(program_table, program);
+        ProgramTable::fill_trace(program_table, &aet);
         let op_stack_table = &mut master_base_table.table_mut(TableId::OpStackTable);
         let op_stack_clk_jump_diffs = OpStackTable::fill_trace(op_stack_table, &aet);
         let ram_table = &mut master_base_table.table_mut(TableId::RamTable);

triton-vm/src/table/program_table.rs

@@ -32,6 +32,7 @@ use crate::table::table_column::ProgramBaseTableColumn;
 use crate::table::table_column::ProgramBaseTableColumn::*;
 use crate::table::table_column::ProgramExtTableColumn;
 use crate::table::table_column::ProgramExtTableColumn::*;
+use crate::vm::AlgebraicExecutionTrace;
 
 pub const PROGRAM_TABLE_NUM_PERMUTATION_ARGUMENTS: usize = 0;
 pub const PROGRAM_TABLE_NUM_EVALUATION_ARGUMENTS: usize = 1;
@@ -146,13 +147,17 @@ impl ExtProgramTable {
 }
 
 impl ProgramTable {
-    pub fn fill_trace(program_table: &mut ArrayViewMut2<BFieldElement>, program: &[BFieldElement]) {
+    pub fn fill_trace(
+        program_table: &mut ArrayViewMut2<BFieldElement>,
+        aet: &AlgebraicExecutionTrace,
+    ) {
+        let program = aet.program.to_bwords();
         let program_len = program.len();
         let address_column = program_table.slice_mut(s![..program_len, Address.base_table_index()]);
         let addresses = Array1::from_iter((0..program_len).map(|a| BFieldElement::new(a as u64)));
         addresses.move_into(address_column);
 
-        let instructions = Array1::from(program.to_owned());
+        let instructions = Array1::from(program);
         let instruction_column =
             program_table.slice_mut(s![..program_len, Instruction.base_table_index()]);
         instructions.move_into(instruction_column);

triton-vm/src/vm.rs

@@ -39,7 +39,7 @@ pub fn simulate(
     Vec<BFieldElement>,
     Option<anyhow::Error>,
 ) {
-    let mut aet = AlgebraicExecutionTrace::default();
+    let mut aet = AlgebraicExecutionTrace::new(program.clone());
     let mut state = VMState::new(program);
     // record initial state
     aet.processor_trace
@@ -120,6 +120,9 @@ pub fn run(
 
 #[derive(Debug, Clone)]
 pub struct AlgebraicExecutionTrace {
+    /// The program that was executed in order to generate the trace.
+    pub program: Program,
+
     /// Records the state of the processor after each instruction.
     pub processor_trace: Array2<BFieldElement>,
 
@@ -136,18 +139,17 @@ pub struct AlgebraicExecutionTrace {
     pub u32_entries: Vec<(Instruction, BFieldElement, BFieldElement)>,
 }
 
-impl Default for AlgebraicExecutionTrace {
-    fn default() -> Self {
+impl AlgebraicExecutionTrace {
+    pub fn new(program: Program) -> Self {
         Self {
+            program,
             processor_trace: Array2::default([0, processor_table::BASE_WIDTH]),
             hash_trace: Array2::default([0, hash_table::BASE_WIDTH]),
             sponge_trace: Array2::default([0, hash_table::BASE_WIDTH]),
             u32_entries: vec![],
         }
     }
-}
 
-impl AlgebraicExecutionTrace {
     pub fn append_hash_trace(&mut self, xlix_trace: [[BFieldElement; STATE_SIZE]; NUM_ROUNDS + 1]) {
         let mut hash_trace_addendum = Self::add_round_number_and_constants(xlix_trace);
         hash_trace_addendum