use single allocation for vm stack

Author: iovoid

crates/vm/backends/levm/mod.rs

@@ -18,7 +18,6 @@ use ethrex_common::{
     },
 };
 use ethrex_levm::EVMConfig;
-use ethrex_levm::call_frame::Stack;
 use ethrex_levm::constants::{SYS_CALL_GAS_LIMIT, TX_BASE_COST};
 use ethrex_levm::db::gen_db::GeneralizedDatabase;
 use ethrex_levm::errors::{InternalError, TxValidationError};
@@ -92,21 +91,18 @@ impl LEVM {
     ) -> Result<BlockExecutionResult, EvmError> {
         Self::prepare_block(block, db, vm_type)?;
 
-        let mut shared_stack_pool = Vec::with_capacity(1024);
-
         let mut receipts = Vec::new();
         let mut cumulative_gas_used = 0;
 
         for (tx, tx_sender) in block.body.get_transactions_with_sender().map_err(|error| {
             EvmError::Transaction(format!("Couldn't recover addresses with error: {error}"))
         })? {
-            let report = Self::execute_tx_in_block(
+            let report = Self::execute_tx(
                 tx,
                 tx_sender,
                 &block.header,
                 db,
-                vm_type,
-                &mut shared_stack_pool,
+                vm_type
             )?;
             LEVM::send_state_transitions_tx(&merkleizer, db, queue_length)?;
 
@@ -225,26 +221,6 @@ impl LEVM {
         vm.execute().map_err(VMError::into)
     }
 
-    pub fn execute_tx_in_block(
-        // The transaction to execute.
-        tx: &Transaction,
-        // The transactions recovered address
-        tx_sender: Address,
-        // The block header for the current block.
-        block_header: &BlockHeader,
-        db: &mut GeneralizedDatabase,
-        vm_type: VMType,
-        stack_pool: &mut Vec<Stack>,
-    ) -> Result<ExecutionReport, EvmError> {
-        let env = Self::setup_env(tx, tx_sender, block_header, db, vm_type)?;
-        let mut vm = VM::new(env, db, tx, LevmCallTracer::disabled(), vm_type)?;
-
-        std::mem::swap(&mut vm.stack_pool, stack_pool);
-        let result = vm.execute().map_err(VMError::into);
-        std::mem::swap(&mut vm.stack_pool, stack_pool);
-        result
-    }
-
     pub fn undo_last_tx(db: &mut GeneralizedDatabase) -> Result<(), EvmError> {
         db.undo_last_transaction()?;
         Ok(())

crates/vm/levm/runner/src/main.rs

@@ -162,9 +162,8 @@ fn main() {
 
     // Set initial stack and memory
     info!("Setting initial stack: {:?}", runner_input.initial_stack);
-    let stack = &mut vm.current_call_frame.stack;
     for elem in runner_input.initial_stack {
-        stack.push(&[elem]).expect("Stack Overflow");
+        vm.current_stack().push(&[elem]).expect("Stack Overflow");
     }
     info!(
         "Setting initial memory: 0x{:x}",
@@ -186,15 +185,16 @@ fn main() {
     }
 
     // Print final stack and memory
-    let callframe = vm.current_call_frame;
+    let stack_depth = vm.current_stack().offset;
     info!(
         "Final Stack (bottom to top): {:?}",
-        &callframe.stack.values[callframe.stack.offset..]
+        &vm.current_stack().values[stack_depth..]
             .iter()
             .rev()
             .map(|value| format!("0x{:x}", value))
             .collect::<Vec<_>>()
     );
+    let callframe = vm.current_call_frame;
     let final_memory: Vec<u8> = callframe.memory.buffer.borrow()[0..callframe.memory.len].to_vec();
     info!("Final Memory: 0x{}", hex::encode(final_memory));
 

crates/vm/levm/src/call_frame.rs

@@ -23,7 +23,7 @@ use std::{collections::HashMap, fmt};
 /// [`pop`](Self::pop) methods support working with multiple elements instead of a single one,
 /// reducing the number of checks performed on the stack.
 pub struct Stack {
-    pub values: Box<[U256; STACK_LIMIT]>,
+    pub values: [U256; STACK_LIMIT],
     pub offset: usize,
 }
 
@@ -194,7 +194,7 @@ impl Stack {
 impl Default for Stack {
     fn default() -> Self {
         Self {
-            values: Box::new([U256::zero(); STACK_LIMIT]),
+            values: [U256::zero(); STACK_LIMIT],
             offset: STACK_LIMIT,
         }
     }
@@ -243,7 +243,6 @@ pub struct CallFrame {
     pub bytecode: Code,
     /// Value sent along the transaction
     pub msg_value: U256,
-    pub stack: Stack,
     pub memory: Memory,
     /// Data sent along the transaction. Empty in CREATE transactions.
     pub calldata: Bytes,
@@ -323,7 +322,6 @@ impl CallFrame {
         is_create: bool,
         ret_offset: usize,
         ret_size: usize,
-        stack: Stack,
         memory: Memory,
     ) -> Self {
         // Note: Do not use ..Default::default() because it has runtime cost.
@@ -344,7 +342,6 @@ impl CallFrame {
             is_create,
             ret_offset,
             ret_size,
-            stack,
             memory,
             call_frame_backup: CallFrameBackup::default(),
             output: Bytes::default(),

crates/vm/levm/src/opcode_handlers/arithmetic.rs

@@ -11,63 +11,63 @@ use ethrex_common::{U256, U512};
 impl<'a> VM<'a> {
     // ADD operation
     pub fn op_add(&mut self) -> Result<OpcodeResult, VMError> {
-        let current_call_frame = &mut self.current_call_frame;
-        current_call_frame.increase_consumed_gas(gas_cost::ADD)?;
+        self.current_call_frame
+            .increase_consumed_gas(gas_cost::ADD)?;
 
-        let [augend, addend] = *current_call_frame.stack.pop()?;
+        let [augend, addend] = *self.current_stack().pop()?;
         let sum = augend.overflowing_add(addend).0;
-        current_call_frame.stack.push1(sum)?;
+        self.current_stack().push1(sum)?;
 
         Ok(OpcodeResult::Continue)
     }
 
     // SUB operation
     pub fn op_sub(&mut self) -> Result<OpcodeResult, VMError> {
-        let current_call_frame = &mut self.current_call_frame;
-        current_call_frame.increase_consumed_gas(gas_cost::SUB)?;
+        self.current_call_frame
+            .increase_consumed_gas(gas_cost::SUB)?;
 
-        let [minuend, subtrahend] = *current_call_frame.stack.pop()?;
+        let [minuend, subtrahend] = *self.current_stack().pop()?;
         let difference = minuend.overflowing_sub(subtrahend).0;
-        current_call_frame.stack.push1(difference)?;
+        self.current_stack().push1(difference)?;
 
         Ok(OpcodeResult::Continue)
     }
 
     // MUL operation
     pub fn op_mul(&mut self) -> Result<OpcodeResult, VMError> {
-        let current_call_frame = &mut self.current_call_frame;
-        current_call_frame.increase_consumed_gas(gas_cost::MUL)?;
+        self.current_call_frame
+            .increase_consumed_gas(gas_cost::MUL)?;
 
-        let [multiplicand, multiplier] = *current_call_frame.stack.pop()?;
+        let [multiplicand, multiplier] = *self.current_stack().pop()?;
         let product = multiplicand.overflowing_mul(multiplier).0;
-        current_call_frame.stack.push1(product)?;
+        self.current_stack().push1(product)?;
 
         Ok(OpcodeResult::Continue)
     }
 
     // DIV operation
     pub fn op_div(&mut self) -> Result<OpcodeResult, VMError> {
-        let current_call_frame = &mut self.current_call_frame;
-        current_call_frame.increase_consumed_gas(gas_cost::DIV)?;
+        self.current_call_frame
+            .increase_consumed_gas(gas_cost::DIV)?;
 
-        let [dividend, divisor] = *current_call_frame.stack.pop()?;
+        let [dividend, divisor] = *self.current_stack().pop()?;
         let Some(quotient) = dividend.checked_div(divisor) else {
-            current_call_frame.stack.push_zero()?;
+            self.current_stack().push_zero()?;
             return Ok(OpcodeResult::Continue);
         };
-        current_call_frame.stack.push1(quotient)?;
+        self.current_stack().push1(quotient)?;
 
         Ok(OpcodeResult::Continue)
     }
 
     // SDIV operation
     pub fn op_sdiv(&mut self) -> Result<OpcodeResult, VMError> {
-        let current_call_frame = &mut self.current_call_frame;
-        current_call_frame.increase_consumed_gas(gas_cost::SDIV)?;
+        self.current_call_frame
+            .increase_consumed_gas(gas_cost::SDIV)?;
 
-        let [dividend, divisor] = *current_call_frame.stack.pop()?;
+        let [dividend, divisor] = *self.current_stack().pop()?;
         if divisor.is_zero() || dividend.is_zero() {
-            current_call_frame.stack.push_zero()?;
+            self.current_stack().push_zero()?;
             return Ok(OpcodeResult::Continue);
         }
 
@@ -86,34 +86,34 @@ impl<'a> VM<'a> {
             None => U256::zero(),
         };
 
-        current_call_frame.stack.push1(quotient)?;
+        self.current_stack().push1(quotient)?;
 
         Ok(OpcodeResult::Continue)
     }
 
     // MOD operation
     pub fn op_mod(&mut self) -> Result<OpcodeResult, VMError> {
-        let current_call_frame = &mut self.current_call_frame;
-        current_call_frame.increase_consumed_gas(gas_cost::MOD)?;
+        self.current_call_frame
+            .increase_consumed_gas(gas_cost::MOD)?;
 
-        let [dividend, divisor] = *current_call_frame.stack.pop()?;
+        let [dividend, divisor] = *self.current_stack().pop()?;
 
         let remainder = dividend.checked_rem(divisor).unwrap_or_default();
 
-        current_call_frame.stack.push1(remainder)?;
+        self.current_stack().push1(remainder)?;
 
         Ok(OpcodeResult::Continue)
     }
 
     // SMOD operation
     pub fn op_smod(&mut self) -> Result<OpcodeResult, VMError> {
-        let current_call_frame = &mut self.current_call_frame;
-        current_call_frame.increase_consumed_gas(gas_cost::SMOD)?;
+        self.current_call_frame
+            .increase_consumed_gas(gas_cost::SMOD)?;
 
-        let [unchecked_dividend, unchecked_divisor] = *current_call_frame.stack.pop()?;
+        let [unchecked_dividend, unchecked_divisor] = *self.current_stack().pop()?;
 
         if unchecked_divisor.is_zero() || unchecked_dividend.is_zero() {
-            current_call_frame.stack.push_zero()?;
+            self.current_stack().push_zero()?;
             return Ok(OpcodeResult::Continue);
         }
 
@@ -123,7 +123,7 @@ impl<'a> VM<'a> {
         let unchecked_remainder = match dividend.checked_rem(divisor) {
             Some(remainder) => remainder,
             None => {
-                current_call_frame.stack.push_zero()?;
+                self.current_stack().push_zero()?;
                 return Ok(OpcodeResult::Continue);
             }
         };
@@ -134,20 +134,20 @@ impl<'a> VM<'a> {
             unchecked_remainder
         };
 
-        current_call_frame.stack.push1(remainder)?;
+        self.current_stack().push1(remainder)?;
 
         Ok(OpcodeResult::Continue)
     }
 
     // ADDMOD operation
     pub fn op_addmod(&mut self) -> Result<OpcodeResult, VMError> {
-        let current_call_frame = &mut self.current_call_frame;
-        current_call_frame.increase_consumed_gas(gas_cost::ADDMOD)?;
+        self.current_call_frame
+            .increase_consumed_gas(gas_cost::ADDMOD)?;
 
-        let [augend, addend, modulus] = *current_call_frame.stack.pop()?;
+        let [augend, addend, modulus] = *self.current_stack().pop()?;
 
         if modulus.is_zero() {
-            current_call_frame.stack.push_zero()?;
+            self.current_stack().push_zero()?;
             return Ok(OpcodeResult::Continue);
         }
 
@@ -170,20 +170,20 @@ impl<'a> VM<'a> {
             .try_into()
             .expect("can't fail because we applied % mod where mod is a U256 value");
 
-        current_call_frame.stack.push1(sum_mod)?;
+        self.current_stack().push1(sum_mod)?;
 
         Ok(OpcodeResult::Continue)
     }
 
     // MULMOD operation
     pub fn op_mulmod(&mut self) -> Result<OpcodeResult, VMError> {
-        let current_call_frame = &mut self.current_call_frame;
-        current_call_frame.increase_consumed_gas(gas_cost::MULMOD)?;
+        self.current_call_frame
+            .increase_consumed_gas(gas_cost::MULMOD)?;
 
-        let [multiplicand, multiplier, modulus] = *current_call_frame.stack.pop()?;
+        let [multiplicand, multiplier, modulus] = *self.current_stack().pop()?;
 
         if modulus.is_zero() || multiplicand.is_zero() || multiplier.is_zero() {
-            current_call_frame.stack.push_zero()?;
+            self.current_stack().push_zero()?;
             return Ok(OpcodeResult::Continue);
         }
 
@@ -203,35 +203,34 @@ impl<'a> VM<'a> {
             .try_into()
             .expect("can't fail because we applied % mod where mod is a U256 value");
 
-        current_call_frame.stack.push1(product_mod)?;
+        self.current_stack().push1(product_mod)?;
 
         Ok(OpcodeResult::Continue)
     }
 
     // EXP operation
     pub fn op_exp(&mut self) -> Result<OpcodeResult, VMError> {
-        let current_call_frame = &mut self.current_call_frame;
-        let [base, exponent] = *current_call_frame.stack.pop()?;
+        let [base, exponent] = *self.current_stack().pop()?;
 
         let gas_cost = gas_cost::exp(exponent)?;
 
-        current_call_frame.increase_consumed_gas(gas_cost)?;
+        self.current_call_frame.increase_consumed_gas(gas_cost)?;
 
         let power = base.overflowing_pow(exponent).0;
-        current_call_frame.stack.push1(power)?;
+        self.current_stack().push1(power)?;
 
         Ok(OpcodeResult::Continue)
     }
 
     // SIGNEXTEND operation
     pub fn op_signextend(&mut self) -> Result<OpcodeResult, VMError> {
-        let current_call_frame = &mut self.current_call_frame;
-        current_call_frame.increase_consumed_gas(gas_cost::SIGNEXTEND)?;
+        self.current_call_frame
+            .increase_consumed_gas(gas_cost::SIGNEXTEND)?;
 
-        let [byte_size_minus_one, value_to_extend] = *current_call_frame.stack.pop()?;
+        let [byte_size_minus_one, value_to_extend] = *self.current_stack().pop()?;
 
         if byte_size_minus_one > U256::from(31) {
-            current_call_frame.stack.push1(value_to_extend)?;
+            self.current_stack().push1(value_to_extend)?;
             return Ok(OpcodeResult::Continue);
         }
 
@@ -255,7 +254,7 @@ impl<'a> VM<'a> {
                 value_to_extend | !mask
             };
 
-            current_call_frame.stack.push1(result)?;
+            self.current_stack().push1(result)?;
 
             Ok(OpcodeResult::Continue)
         }
@@ -265,10 +264,9 @@ impl<'a> VM<'a> {
         self.current_call_frame
             .increase_consumed_gas(gas_cost::CLZ)?;
 
-        let value = self.current_call_frame.stack.pop1()?;
+        let value = self.current_stack().pop1()?;
 
-        self.current_call_frame
-            .stack
+        self.current_stack()
             .push1(U256::from(value.leading_zeros()))?;
 
         Ok(OpcodeResult::Continue)