use block-wide allocation

Author: iovoid

crates/vm/backends/levm/mod.rs

@@ -18,6 +18,7 @@ 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};
@@ -91,18 +92,24 @@ impl LEVM {
     ) -> Result<BlockExecutionResult, EvmError> {
         Self::prepare_block(block, db, vm_type)?;
 
+        let mut shared_stack_pool = Vec::with_capacity(1024);
+        for _ in 0..1024 {
+            shared_stack_pool.push(Stack::default())
+        }
+
         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(
+            let report = Self::execute_tx_in_block(
                 tx,
                 tx_sender,
                 &block.header,
                 db,
-                vm_type
+                vm_type,
+                &mut shared_stack_pool,
             )?;
             LEVM::send_state_transitions_tx(&merkleizer, db, queue_length)?;
 
@@ -221,6 +228,26 @@ 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, stack_pool);
+        let result = vm.execute().map_err(VMError::into);
+        std::mem::swap(&mut vm.stack, stack_pool);
+        result
+    }
+
     pub fn undo_last_tx(db: &mut GeneralizedDatabase) -> Result<(), EvmError> {
         db.undo_last_transaction()?;
         Ok(())

crates/vm/levm/src/vm.rs

@@ -309,7 +309,7 @@ pub struct VM<'a> {
     /// The current call frame.
     pub current_call_frame: CallFrame,
     /// Stack allocations, call_frame.depth points to the index
-    pub stack: Box<[Stack; 1025]>,
+    pub stack: Vec<Stack>,
     pub env: Environment,
     pub substate: Substate,
     pub db: &'a mut GeneralizedDatabase,
@@ -344,13 +344,6 @@ impl<'a> VM<'a> {
 
         let fork = env.config.fork;
 
-        let mut stack = Box::new_uninit_slice(1025);
-        for i in 0..1025 {
-            stack[i].write(Stack::default());
-        }
-        #[expect(unsafe_code)]
-        let stack = unsafe { stack.assume_init().try_into().unwrap() };
-
         let mut vm = Self {
             call_frames: Vec::new(),
             substate,
@@ -378,7 +371,7 @@ impl<'a> VM<'a> {
                 0,
                 Memory::default(),
             ),
-            stack,
+            stack: Vec::new(),
             env,
             opcode_table: VM::build_opcode_table(fork),
         };
@@ -412,6 +405,9 @@ impl<'a> VM<'a> {
 
     /// Executes a whole external transaction. Performing validations at the beginning.
     pub fn execute(&mut self) -> Result<ExecutionReport, VMError> {
+        while self.stack.len() < 1024 {
+            self.stack.push(Stack::default());
+        }
         if let Err(e) = self.prepare_execution() {
             // Restore cache to state previous to this Tx execution because this Tx is invalid.
             self.restore_cache_state()?;