Optimization: Small changes on many functions V2 (wip)

src/execution.rs

@@ -129,9 +129,8 @@ impl Execution {
     }
 
     pub fn clear_registers(&mut self) {
-        for register in self.registers.iter_mut() {
-            *register = TaggedValue::new_raw_integer(U256::zero());
-        }
+        let empty_integer = TaggedValue::new_raw_integer(U256::zero());
+        self.registers = [empty_integer; 15];
     }
 
     pub fn clear_flags(&mut self) {
@@ -300,11 +299,12 @@ impl Execution {
         let pc = self.current_frame()?.pc;
         let raw_opcode = current_context.code_page.get(pc as usize / 4);
 
+        let [a, b, c, d] = raw_opcode.0;
         let raw_op = match pc % 4 {
-            3 => (raw_opcode & u64::MAX.into()).as_u64(),
-            2 => ((raw_opcode >> 64) & u64::MAX.into()).as_u64(),
-            1 => ((raw_opcode >> 128) & u64::MAX.into()).as_u64(),
-            _ => ((raw_opcode >> 192) & u64::MAX.into()).as_u64(), // 0
+            3 => a,
+            2 => b,
+            1 => c,
+            _ => d,
         };
 
         Opcode::try_from_raw_opcode(raw_op)
@@ -389,12 +389,13 @@ impl Stack {
     }
 
     pub fn fill_with_zeros(&mut self, value: usize) {
-        for _ in 0..value {
-            self.stack.push(TaggedValue {
+        self.stack.resize(
+            self.stack.len() + value,
+            TaggedValue {
                 value: U256::zero(),
                 is_pointer: false,
-            });
-        }
+            },
+        );
     }
 
     pub fn get_with_offset(&self, offset: u16, sp: u32) -> Result<TaggedValue, StackError> {
@@ -474,6 +475,17 @@ impl Heap {
         }
     }
 
+    pub fn store_multiple(&mut self, start_address: u32, values: Vec<U256>) {
+        let mut start = start_address as usize;
+        let end = (start + values.len() * 32).min(self.heap.len());
+        let max_to_store = (end - start) / 32;
+
+        for value in &values[..max_to_store] {
+            value.to_big_endian(&mut self.heap[start..(start + 32)]);
+            start += 32;
+        }
+    }
+
     pub fn read(&self, address: u32) -> U256 {
         let mut result = U256::zero();
 

src/op_handlers/opcode_decommit.rs

@@ -23,18 +23,18 @@ pub fn opcode_decommit(
     let mut buffer = [0u8; 32];
     code_hash.to_big_endian(&mut buffer);
 
-    // gas is payed in advance
+    // Gas is paid in advance
     if vm.decrease_gas(extra_cost).is_err()
         || (!ContractCodeSha256Format::is_valid(&buffer) && !BlobSha256Format::is_valid(&buffer))
     {
-        // we don't actually return an err here
+        // We don't actually return an err here
         vm.set_register(1, TaggedValue::zero());
         return Ok(());
     }
 
     let (code, was_decommited) = state.decommit(code_hash);
     if was_decommited {
-        // refund it
+        // Refund it
         vm.increase_gas(extra_cost)?;
     };
 
@@ -52,11 +52,7 @@ pub fn opcode_decommit(
 
     let heap = vm.heaps.get_mut(id).ok_or(HeapError::StoreOutOfBounds)?;
 
-    let mut address = 0;
-    for value in code.iter() {
-        heap.store(address, *value);
-        address += 32;
-    }
+    heap.store_multiple(0, code);
 
     let pointer = FatPointer {
         offset: 0,

src/op_handlers/ptr_add.rs

@@ -2,20 +2,18 @@ use crate::{
     eravm_error::{EraVmError, OperandError},
     execution::Execution,
     ptr_operator::{ptr_operands_read, ptr_operands_store},
-    value::FatPointer,
     Opcode,
 };
 
 pub fn ptr_add(vm: &mut Execution, opcode: &Opcode) -> Result<(), EraVmError> {
-    let (pointer, diff, src0) = ptr_operands_read(vm, opcode)?;
+    let (mut pointer, diff, src0) = ptr_operands_read(vm, opcode)?;
 
     let (new_offset, overflow) = pointer.offset.overflowing_add(diff);
     if overflow {
         return Err(OperandError::Overflow(opcode.variant).into());
     }
-    let new_pointer = FatPointer {
-        offset: new_offset,
-        ..pointer
-    };
-    ptr_operands_store(vm, opcode, new_pointer, src0)
+
+    pointer.offset = new_offset;
+
+    ptr_operands_store(vm, opcode, pointer, src0)
 }

src/op_handlers/ptr_pack.rs

@@ -15,10 +15,18 @@ pub fn ptr_pack(vm: &mut Execution, opcode: &Opcode) -> Result<(), EraVmError> {
         return Err(OperandError::InvalidSrcPointer(opcode.variant).into());
     }
 
-    if src1.value & U256::from(u128::MAX) != U256::zero() {
+    // Check if lower 128 bytes are zero
+    if (src1.value.0[0] | src1.value.0[1]) != 0 {
         return Err(OperandError::Src1LowNotZero(opcode.variant).into());
     }
 
-    let res = TaggedValue::new_pointer(((src0.value << 128) >> 128) | src1.value);
+    let mut value = U256::zero();
+
+    value.0[3] = src1.value.0[3];
+    value.0[2] = src1.value.0[2];
+    value.0[1] = src0.value.0[1];
+    value.0[0] = src0.value.0[0];
+
+    let res = TaggedValue::new_pointer(value);
     address_operands_store(vm, opcode, res)
 }

src/op_handlers/ptr_shrink.rs

@@ -2,20 +2,18 @@ use crate::{
     eravm_error::{EraVmError, OperandError},
     execution::Execution,
     ptr_operator::{ptr_operands_read, ptr_operands_store},
-    value::FatPointer,
     Opcode,
 };
 
 pub fn ptr_shrink(vm: &mut Execution, opcode: &Opcode) -> Result<(), EraVmError> {
-    let (pointer, diff, src0) = ptr_operands_read(vm, opcode)?;
+    let (mut pointer, diff, src0) = ptr_operands_read(vm, opcode)?;
 
     let (new_len, overflow) = pointer.len.overflowing_sub(diff);
     if overflow {
         return Err(OperandError::Overflow(opcode.variant).into());
     }
-    let new_pointer = FatPointer {
-        len: new_len,
-        ..pointer
-    };
-    ptr_operands_store(vm, opcode, new_pointer, src0)
+
+    pointer.len = new_len;
+
+    ptr_operands_store(vm, opcode, pointer, src0)
 }

src/op_handlers/ptr_sub.rs

@@ -2,20 +2,17 @@ use crate::{
     eravm_error::{EraVmError, OperandError},
     execution::Execution,
     ptr_operator::{ptr_operands_read, ptr_operands_store},
-    value::FatPointer,
     Opcode,
 };
 
 pub fn ptr_sub(vm: &mut Execution, opcode: &Opcode) -> Result<(), EraVmError> {
-    let (pointer, diff, src0) = ptr_operands_read(vm, opcode)?;
+    let (mut pointer, diff, src0) = ptr_operands_read(vm, opcode)?;
 
     let (new_offset, overflow) = pointer.offset.overflowing_sub(diff);
     if overflow {
         return Err(OperandError::Overflow(opcode.variant).into());
     }
-    let new_pointer = FatPointer {
-        offset: new_offset,
-        ..pointer
-    };
-    ptr_operands_store(vm, opcode, new_pointer, src0)
+    pointer.offset = new_offset;
+
+    ptr_operands_store(vm, opcode, pointer, src0)
 }

src/opcode.rs

@@ -141,10 +141,12 @@ impl Opcode {
     }
 }
 
+#[inline(always)]
 fn first_four_bits(value: u8) -> u8 {
     value & 0x0f
 }
 
+#[inline(always)]
 fn second_four_bits(value: u8) -> u8 {
     (value & 0xf0) >> 4
 }

src/vm.rs

@@ -342,21 +342,11 @@ fn set_pc(vm: &mut Execution, opcode: &Opcode) -> Result<(), EraVmError> {
 }
 
 fn retrieve_result(vm: &mut Execution) -> Result<Vec<u8>, EraVmError> {
-    let fat_pointer_src0 = FatPointer::decode(vm.get_register(1).value);
-    let range = fat_pointer_src0.start..fat_pointer_src0.start + fat_pointer_src0.len;
-    let mut result: Vec<u8> = vec![0; range.len()];
-    let end: u32 = (range.end).min(
-        (vm.heaps
-            .get(fat_pointer_src0.page)
-            .ok_or(HeapError::ReadOutOfBounds)?
-            .len()) as u32,
-    );
-    for (i, j) in (range.start..end).enumerate() {
-        let current_heap = vm
-            .heaps
-            .get(fat_pointer_src0.page)
-            .ok_or(HeapError::ReadOutOfBounds)?;
-        result[i] = current_heap.read_byte(j);
-    }
+    let ptr = FatPointer::decode(vm.get_register(1).value);
+    let result = vm
+        .heaps
+        .get(ptr.page)
+        .ok_or(HeapError::ReadOutOfBounds)?
+        .read_unaligned_from_pointer(&ptr)?;
     Ok(result)
 }