memory: make encode_to_memory take object reference

This closes #124.
TritonVM · Aug 21, 2024 · e9ed0d2 · e9ed0d2
1 parent 7affd62
commit e9ed0d2
Show file tree

Hide file tree

Showing 27 changed files with 60 additions and 66 deletions.
diff --git a/tasm-lib/src/hashing/algebraic_hasher/sample_scalars.rs b/tasm-lib/src/hashing/algebraic_hasher/sample_scalars.rs
@@ -124,7 +124,7 @@ mod test {
                 .collect_vec();
             let scalars_pointer = DYN_MALLOC_FIRST_ADDRESS;
 
-            encode_to_memory(memory, scalars_pointer, scalars);
+            encode_to_memory(memory, scalars_pointer, &scalars);
 
             // store all pseudorandomness (not just sampled scalars) to memory
             let safety_offset = BFieldElement::new(1);

diff --git a/tasm-lib/src/hashing/lt_digest.rs b/tasm-lib/src/hashing/lt_digest.rs
@@ -173,8 +173,8 @@ mod tests {
             rhs: Digest,
         ) -> FunctionInitialState {
             let mut memory = HashMap::default();
-            encode_to_memory(&mut memory, lhs_ptr, lhs);
-            encode_to_memory(&mut memory, rhs_ptr, rhs);
+            encode_to_memory(&mut memory, lhs_ptr, &lhs);
+            encode_to_memory(&mut memory, rhs_ptr, &rhs);
 
             let stack = [self.init_stack_for_isolated_run(), vec![lhs_ptr, rhs_ptr]].concat();
 

diff --git a/tasm-lib/src/hashing/merkle_root.rs b/tasm-lib/src/hashing/merkle_root.rs
@@ -212,7 +212,7 @@ impl Function for MerkleRoot {
         let num_non_leaf_nodes = leafs.len();
 
         // skip dummy digest at index 0
-        for (node_index, &node) in (0..num_non_leaf_nodes).zip(mt.nodes()).skip(1) {
+        for (node_index, node) in (0..num_non_leaf_nodes).zip(mt.nodes()).skip(1) {
             let node_address = pointer + bfe!(node_index as u32) * bfe!(Digest::LEN as u32);
             encode_to_memory(memory, node_address, node);
         }
@@ -261,7 +261,7 @@ impl MerkleRoot {
         digests_pointer: BFieldElement,
     ) -> FunctionInitialState {
         let mut memory = HashMap::<BFieldElement, BFieldElement>::new();
-        encode_to_memory(&mut memory, digests_pointer, leafs);
+        encode_to_memory(&mut memory, digests_pointer, &leafs);
         let mut stack = self.init_stack_for_isolated_run();
         stack.push(digests_pointer);
 

diff --git a/tasm-lib/src/hashing/merkle_root_from_xfes_generic.rs b/tasm-lib/src/hashing/merkle_root_from_xfes_generic.rs
@@ -240,7 +240,7 @@ mod test {
                     let node_index = node_count + (1 << (mt.height() - layer));
                     let node = mt.node(node_index).unwrap();
                     let pointer = pointer + BFieldElement::new((node_index * Digest::LEN) as u64);
-                    encode_to_memory(memory, pointer, node);
+                    encode_to_memory(memory, pointer, &node);
                 }
             }
 
@@ -288,7 +288,7 @@ mod test {
             xfe_pointer: BFieldElement,
         ) -> FunctionInitialState {
             let mut memory = HashMap::<BFieldElement, BFieldElement>::new();
-            encode_to_memory(&mut memory, xfe_pointer, xfes);
+            encode_to_memory(&mut memory, xfe_pointer, &xfes);
             let mut stack = self.init_stack_for_isolated_run();
             stack.push(xfe_pointer);
 

diff --git a/tasm-lib/src/hashing/merkle_root_from_xfes_static_size.rs b/tasm-lib/src/hashing/merkle_root_from_xfes_static_size.rs
@@ -145,7 +145,7 @@ mod test {
             for (node_index, &node) in (0..num_not_leaf_nodes).zip(mt.nodes()).skip(num_skips) {
                 let node_address =
                     self.static_memory_pointer + bfe!(node_index) * bfe!(Digest::LEN as u32);
-                encode_to_memory(memory, node_address, node);
+                encode_to_memory(memory, node_address, &node);
             }
 
             stack.extend(mt.root().reversed().values());

diff --git a/tasm-lib/src/hashing/merkle_root_from_xfes_wrapper.rs b/tasm-lib/src/hashing/merkle_root_from_xfes_wrapper.rs
@@ -157,7 +157,7 @@ mod tests {
             for (node_index, &node) in (0..num_not_leaf_nodes).zip(mt.nodes()).skip(num_skips) {
                 let node_address = Self::static_memory_address_for_isolated_run_nodes()
                     + bfe!(node_index) * bfe!(Digest::LEN as u32);
-                encode_to_memory(memory, node_address, node);
+                encode_to_memory(memory, node_address, &node);
             }
 
             memory.insert(
@@ -205,7 +205,7 @@ mod tests {
             xfe_pointer: BFieldElement,
         ) -> FunctionInitialState {
             let mut memory = HashMap::<BFieldElement, BFieldElement>::new();
-            encode_to_memory(&mut memory, xfe_pointer, xfes);
+            encode_to_memory(&mut memory, xfe_pointer, &xfes);
             let mut stack = self.init_stack_for_isolated_run();
             stack.push(xfe_pointer);
 

diff --git a/tasm-lib/src/hashing/merkle_root_static_size.rs b/tasm-lib/src/hashing/merkle_root_static_size.rs
@@ -137,7 +137,7 @@ mod tests {
             let num_not_leaf_nodes = self.num_leaves() as u32;
 
             // `.skip(2)`: dummy-digest at index 0, root at index 1
-            for (node_index, &node) in (0..num_not_leaf_nodes).zip(mt.nodes()).skip(2) {
+            for (node_index, node) in (0..num_not_leaf_nodes).zip(mt.nodes()).skip(2) {
                 let node_address = self.nodes_pointer + bfe!(node_index) * bfe!(Digest::LEN as u32);
                 encode_to_memory(memory, node_address, node);
             }

diff --git a/tasm-lib/src/list/horner_evaluation_dynamic_length.rs b/tasm-lib/src/list/horner_evaluation_dynamic_length.rs
@@ -129,7 +129,7 @@ mod test {
         ) -> FunctionInitialState {
             let mut memory = HashMap::default();
             let mut stack = self.init_stack_for_isolated_run();
-            encode_to_memory(&mut memory, coefficients_pointer, coefficients);
+            encode_to_memory(&mut memory, coefficients_pointer, &coefficients);
 
             stack.push(coefficients_pointer);
             stack.push(indeterminate.coefficients[2]);

diff --git a/tasm-lib/src/list/multiset_equality_u64s.rs b/tasm-lib/src/list/multiset_equality_u64s.rs
@@ -389,7 +389,7 @@ mod tests {
             encode_to_memory(
                 memory,
                 STATIC_MEMORY_FIRST_ADDRESS - bfe!(EXTENSION_DEGREE as u64 - 1),
-                running_product_a,
+                &running_product_a,
             );
 
             stack.push(bfe!((running_product_a == running_product_b) as u64))

diff --git a/tasm-lib/src/memory.rs b/tasm-lib/src/memory.rs
@@ -50,7 +50,7 @@ pub fn last_populated_nd_memory_address(
 pub fn encode_to_memory<T: BFieldCodec>(
     memory: &mut HashMap<BFieldElement, BFieldElement>,
     address: BFieldElement,
-    object: T,
+    object: &T,
 ) -> BFieldElement {
     let encoding = object.encode();
     for (i, e) in encoding.iter().enumerate() {

diff --git a/tasm-lib/src/memory/push_ram_to_stack.rs b/tasm-lib/src/memory/push_ram_to_stack.rs
@@ -90,20 +90,20 @@ impl Function for PushRamToStack {
         let address: BFieldElement = random();
         let value = self.data_type.random_elements(1)[0].clone();
 
-        Self::init_state(address, value)
+        Self::init_state(address, &value)
     }
 
     fn corner_case_initial_states(&self) -> Vec<FunctionInitialState> {
         let address = BFieldElement::zero();
         let value = self.data_type.random_elements(1)[0].clone();
-        let pointer_is_zero = Self::init_state(address, value);
+        let pointer_is_zero = Self::init_state(address, &value);
 
         vec![pointer_is_zero]
     }
 }
 
 impl PushRamToStack {
-    fn init_state<T: BFieldCodec>(address: BFieldElement, value: T) -> FunctionInitialState {
+    fn init_state<T: BFieldCodec>(address: BFieldElement, value: &T) -> FunctionInitialState {
         let mut memory = HashMap::<BFieldElement, BFieldElement>::new();
         encode_to_memory(&mut memory, address, value);
         let mut stack = empty_stack();
@@ -136,7 +136,7 @@ mod tests {
             data_type: DataType::U64,
         };
         let value_stored_to_memory: u64 = (1u64 << 46) + 3;
-        let init_state = PushRamToStack::init_state(BFieldElement::one(), value_stored_to_memory);
+        let init_state = PushRamToStack::init_state(BFieldElement::one(), &value_stored_to_memory);
         let mut final_state = tasm_final_state(
             &ShadowedFunction::new(u64_snippet),
             &init_state.stack,

diff --git a/tasm-lib/src/mmr/verify_mmr_successor.rs b/tasm-lib/src/mmr/verify_mmr_successor.rs
@@ -436,10 +436,8 @@ mod test {
         let mut nondeterminism = NonDeterminism::new(vec![]);
         VerifyMmrSuccessor::update_nondeterminism(&mut nondeterminism, mmr_successor_proof);
         let old_mmr_address = FIRST_NON_DETERMINISTICALLY_INITIALIZED_MEMORY_ADDRESS;
-        let new_mmr_address =
-            encode_to_memory(&mut nondeterminism.ram, old_mmr_address, old_mmr.clone());
-        let _garbage_address =
-            encode_to_memory(&mut nondeterminism.ram, new_mmr_address, new_mmr.clone());
+        let new_mmr_address = encode_to_memory(&mut nondeterminism.ram, old_mmr_address, old_mmr);
+        let _garbage_address = encode_to_memory(&mut nondeterminism.ram, new_mmr_address, new_mmr);
         let mut stack = empty_stack();
         stack.push(old_mmr_address);
         stack.push(new_mmr_address);

diff --git a/tasm-lib/src/structure/tasm_object.rs b/tasm-lib/src/structure/tasm_object.rs
@@ -312,7 +312,7 @@ mod test {
 
         let object = pseudorandom_object(rng.gen());
         let address = rng.gen();
-        encode_to_memory(&mut memory, address, object.clone());
+        encode_to_memory(&mut memory, address, &object);
         let object_again: OuterStruct = *OuterStruct::decode_from_memory(&memory, address).unwrap();
         assert_eq!(object, object_again);
     }
@@ -341,7 +341,7 @@ mod test {
             let address = random_address.into();
             let mut memory: HashMap<BFieldElement, BFieldElement> = HashMap::new();
 
-            encode_to_memory(&mut memory, address, random_object.clone());
+            encode_to_memory(&mut memory, address, &random_object);
             let object_again: NamedFields =
                 *NamedFields::decode_from_memory(&memory, address).unwrap();
             assert_eq!(random_object, object_again);
@@ -406,7 +406,7 @@ mod test {
             let random_address: u64 = thread_rng().gen_range(0..(1 << 30));
             let address = random_address.into();
 
-            encode_to_memory(&mut memory, address, random_object.clone());
+            encode_to_memory(&mut memory, address, &random_object);
             let object_again: TupleStruct =
                 *TupleStruct::decode_from_memory(&memory, address).unwrap();
             assert_eq!(random_object, object_again);
@@ -516,7 +516,7 @@ mod test {
             let random_address: u64 = thread_rng().gen_range(0..(1 << 30));
             let address = random_address.into();
 
-            encode_to_memory(&mut memory, address, obj.to_owned());
+            encode_to_memory(&mut memory, address, obj);
             let stack = [empty_stack(), vec![address]].concat();
 
             // link by hand
@@ -548,8 +548,8 @@ mod test {
         let v = (0..n).map(|_| rng.gen::<Digest>()).collect_vec();
         let mut ram: HashMap<BFieldElement, BFieldElement> = HashMap::new();
         let some_address = FIRST_NON_DETERMINISTICALLY_INITIALIZED_MEMORY_ADDRESS;
-        let none_address = encode_to_memory(&mut ram, some_address, Some(v.clone()));
-        encode_to_memory(&mut ram, none_address, Option::<Vec<Digest>>::None);
+        let none_address = encode_to_memory(&mut ram, some_address, &Some(v.clone()));
+        encode_to_memory(&mut ram, none_address, &Option::<Vec<Digest>>::None);
 
         let some_decoded = *Option::<Vec<Digest>>::decode_from_memory(&ram, some_address).unwrap();
         assert!(some_decoded.is_some());

diff --git a/tasm-lib/src/verifier/challenges/new_generic_dyn_claim.rs b/tasm-lib/src/verifier/challenges/new_generic_dyn_claim.rs
@@ -284,7 +284,7 @@ mod tests {
             let mut memory = HashMap::default();
 
             let claim_pointer = rng.gen();
-            encode_to_memory(&mut memory, claim_pointer, claim);
+            encode_to_memory(&mut memory, claim_pointer, &claim);
 
             let stack = [self.init_stack_for_isolated_run(), vec![claim_pointer]].concat();
             let sponge = Tip5 { state: rng.gen() };

diff --git a/tasm-lib/src/verifier/claim/instantiate_fiat_shamir_with_claim.rs b/tasm-lib/src/verifier/claim/instantiate_fiat_shamir_with_claim.rs
@@ -127,7 +127,7 @@ mod tests {
             let mut memory = HashMap::default();
 
             let claim_pointer = rng.gen();
-            encode_to_memory(&mut memory, claim_pointer, claim);
+            encode_to_memory(&mut memory, claim_pointer, &claim);
 
             let sponge: Tip5 = Tip5 { state: rng.gen() };
             ProcedureInitialState {
@@ -148,7 +148,7 @@ mod tests {
 
                 let claim_pointer = thread_rng().gen();
                 let mut memory = HashMap::default();
-                encode_to_memory(&mut memory, claim_pointer, minimal_claim);
+                encode_to_memory(&mut memory, claim_pointer, &minimal_claim);
                 ProcedureInitialState {
                     stack: [self.init_stack_for_isolated_run(), vec![claim_pointer]].concat(),
                     nondeterminism: NonDeterminism::default().with_ram(memory),

diff --git a/tasm-lib/src/verifier/claim/new_recursive.rs b/tasm-lib/src/verifier/claim/new_recursive.rs
@@ -182,7 +182,7 @@ pub mod tests {
                 output,
             };
 
-            let (claim_pointer, _claim_size) = insert_claim_into_static_memory(memory, claim);
+            let (claim_pointer, _claim_size) = insert_claim_into_static_memory(memory, &claim);
 
             stack.push(claim_pointer);
 

diff --git a/tasm-lib/src/verifier/claim/shared.rs b/tasm-lib/src/verifier/claim/shared.rs
@@ -23,7 +23,7 @@ pub(crate) fn insert_claim_into_static_memory(
         triton_vm::twenty_first::math::b_field_element::BFieldElement,
         triton_vm::twenty_first::math::b_field_element::BFieldElement,
     >,
-    claim: triton_vm::proof::Claim,
+    claim: &triton_vm::proof::Claim,
 ) -> (
     triton_vm::twenty_first::math::b_field_element::BFieldElement,
     u32,

diff --git a/tasm-lib/src/verifier/fri/collinearity_check_x.rs b/tasm-lib/src/verifier/fri/collinearity_check_x.rs
@@ -128,7 +128,7 @@ mod test {
 
             let mut memory = HashMap::<BFieldElement, BFieldElement>::new();
             let fri_verify_address = BFieldElement::zero();
-            encode_to_memory(&mut memory, fri_verify_address, fri_verify);
+            encode_to_memory(&mut memory, fri_verify_address, &fri_verify);
 
             let mut stack = empty_stack();
             stack.push(fri_verify_address);

diff --git a/tasm-lib/src/verifier/fri/derive_from_stark.rs b/tasm-lib/src/verifier/fri/derive_from_stark.rs
@@ -161,7 +161,7 @@ mod tests {
             let local_fri: FriVerify = fri_from_tvm.into();
             let fri_pointer =
                 rust_shadowing_helper_functions::dyn_malloc::dynamic_allocator(memory);
-            encode_to_memory(memory, fri_pointer, local_fri);
+            encode_to_memory(memory, fri_pointer, &local_fri);
             stack.push(fri_pointer)
         }
 

diff --git a/tasm-lib/src/verifier/fri/number_of_rounds.rs b/tasm-lib/src/verifier/fri/number_of_rounds.rs
@@ -117,7 +117,7 @@ mod test {
             let mut memory: HashMap<BFieldElement, BFieldElement> = HashMap::new();
 
             let address = DYN_MALLOC_ADDRESS;
-            encode_to_memory(&mut memory, address, fri_verify);
+            encode_to_memory(&mut memory, address, &fri_verify);
             stack.push(address);
 
             FunctionInitialState { stack, memory }

diff --git a/tasm-lib/src/verifier/fri/standalone_fri_verify.rs b/tasm-lib/src/verifier/fri/standalone_fri_verify.rs
@@ -46,8 +46,8 @@ impl StandaloneFriVerify {
         let digests = fri_verify.extract_digests_required_for_proving(&proof_stream);
         let mut memory = HashMap::<BFieldElement, BFieldElement>::new();
         let proof_stream_pointer = FIRST_NON_DETERMINISTICALLY_INITIALIZED_MEMORY_ADDRESS;
-        let fri_verify_pointer = encode_to_memory(&mut memory, proof_stream_pointer, proof_stream);
-        encode_to_memory(&mut memory, fri_verify_pointer, fri_verify);
+        let fri_verify_pointer = encode_to_memory(&mut memory, proof_stream_pointer, &proof_stream);
+        encode_to_memory(&mut memory, fri_verify_pointer, &fri_verify);
         let nondeterminism = NonDeterminism::new(vec![])
             .with_digests(digests)
             .with_ram(memory);

diff --git a/tasm-lib/src/verifier/fri/verify.rs b/tasm-lib/src/verifier/fri/verify.rs
@@ -1313,13 +1313,13 @@ mod test {
             let proof_iter_current_item_pointer = vm_proof_iter_pointer + BFieldElement::new(2);
 
             let fri_verify_pointer =
-                encode_to_memory(&mut memory, vm_proof_iter_pointer, proof_stream);
+                encode_to_memory(&mut memory, vm_proof_iter_pointer, &proof_stream);
             let proof_iter_pointer =
-                encode_to_memory(&mut memory, fri_verify_pointer, self.test_instance);
+                encode_to_memory(&mut memory, fri_verify_pointer, &self.test_instance);
             encode_to_memory(
                 &mut memory,
                 proof_iter_pointer,
-                proof_iter_current_item_pointer,
+                &proof_iter_current_item_pointer,
             );
             let nondeterminism = NonDeterminism::default()
                 .with_ram(memory)
@@ -1367,7 +1367,7 @@ mod test {
             encode_to_memory(
                 memory,
                 indices_and_leafs_pointer,
-                revealed_indices_and_elements,
+                &revealed_indices_and_elements,
             );
 
             stack.push(indices_and_leafs_pointer);

diff --git a/tasm-lib/src/verifier/master_ext_table/air_constraint_evaluation.rs b/tasm-lib/src/verifier/master_ext_table/air_constraint_evaluation.rs
@@ -380,7 +380,7 @@ mod tests {
         const PROOF_ADDRESS: BFieldElement = BFieldElement::ZERO;
         let mut memory = HashMap::<BFieldElement, BFieldElement>::new();
         let proof_stream = ProofStream::try_from(&proof).unwrap();
-        encode_to_memory(&mut memory, PROOF_ADDRESS, proof);
+        encode_to_memory(&mut memory, PROOF_ADDRESS, &proof);
 
         let assumed_memory_layout = MemoryLayout::conventional_static();
         let MemoryLayout::Static(assumed_memory_layout) = assumed_memory_layout else {

diff --git a/tasm-lib/src/verifier/master_ext_table/verify_table_rows.rs b/tasm-lib/src/verifier/master_ext_table/verify_table_rows.rs
@@ -425,7 +425,7 @@ mod tests {
             let merkle_tree: MerkleTree = CpuParallel::from_digests(&leafs).unwrap();
             let merkle_root = merkle_tree.root();
             let merkle_root_pointer: BFieldElement = rng.gen();
-            encode_to_memory(&mut memory, merkle_root_pointer, merkle_root);
+            encode_to_memory(&mut memory, merkle_root_pointer, &merkle_root);
 
             // Insert all rows into memory, as a list
             let row_pointer: BFieldElement = rng.gen();