Reuse VM memory across executions

CHANGELOG.md

@@ -9,15 +9,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 - [#1886](https://github.com/FuelLabs/fuel-core/pull/1886): Use ref to `Block` in validation code
 - [#1876](https://github.com/FuelLabs/fuel-core/pull/1876): Updated benchmark to include the worst scenario for `CROO` opcode. Also include consensus parameters in bench output.
-
-### Changed
-
 - [#1879](https://github.com/FuelLabs/fuel-core/pull/1879): Return the old behaviour for the `discovery_works` test.
 - [#1848](https://github.com/FuelLabs/fuel-core/pull/1848): Added `version` field to the `Block` and `BlockHeader` GraphQL entities. Added corresponding `version` field to the `Block` and `BlockHeader` client types in `fuel-core-client`.
-
-### Changed
-
 - [#1873](https://github.com/FuelLabs/fuel-core/pull/1873/): Separate dry runs from block production in executor code, remove `ExecutionKind` and `ExecutionType`, remove `thread_block_transaction` concept, remove `PartialBlockComponent` type, refactor away `inner` functions.
+- [#1888](https://github.com/FuelLabs/fuel-core/pull/1888): optimization: Reuse VM memory across executions.
 
 ## [Version 0.26.0]
 

Cargo.toml

@@ -133,3 +133,6 @@ itertools = { version = "0.12", default-features = false }
 insta = "1.8"
 tempfile = "3.4"
 tikv-jemallocator = "0.5"
+
+[patch.crates-io]
+fuel-vm-private = { package = "fuel-vm", git = "https://github.com/FuelLabs/fuel-vm", branch = "dento/memory-reset" }

crates/services/executor/src/executor.rs

@@ -5,7 +5,9 @@ use crate::{
         TransactionsSource,
     },
     refs::ContractRef,
+    vm_pool,
 };
+use core::mem;
 use fuel_core_storage::{
     column::Column,
     kv_store::KeyValueInspect,
@@ -1414,11 +1416,6 @@ where
             coinbase_contract_id,
         );
 
-        let mut vm = Interpreter::with_storage(
-            vm_db,
-            InterpreterParams::new(gas_price, &self.consensus_params),
-        );
-
         let gas_costs = self.consensus_params.gas_costs();
         let fee_params = self.consensus_params.fee_params();
 
@@ -1430,33 +1427,61 @@ where
             .collect();
         let ready_tx = checked_tx.into_ready(gas_price, gas_costs, fee_params)?;
 
-        let vm_result: StateTransition<_> = vm
+        let mut vm = Interpreter::with_storage(
+            vm_db,
+            InterpreterParams::new(gas_price, &self.consensus_params),
+        );
+
+        // We get memory from the pool and are careful to return it there when done
+        *vm.memory_mut() = vm_pool::get_vm_memory();
+
+        // This returns the VM memory to the pool to before returning
+        macro_rules! recycling_try {
+            ($expr:expr) => {
+                match $expr {
+                    Ok(val) => val,
+                    Err(e) => {
+                        vm_pool::recycle_vm_memory(mem::take(vm.memory_mut()));
+                        return Err(e.into())
+                    }
+                }
+            };
+        }
+
+        let vm_result: StateTransition<_> = recycling_try!(vm
             .transact(ready_tx)
             .map_err(|error| ExecutorError::VmExecution {
                 error: error.to_string(),
                 transaction_id: tx_id,
-            })?
-            .into();
+            }))
+        .into();
         let reverted = vm_result.should_revert();
 
         let (state, mut tx, receipts): (_, Tx, _) = vm_result.into_inner();
         #[cfg(debug_assertions)]
         {
-            tx.precompute(&self.consensus_params.chain_id())?;
+            recycling_try!(tx.precompute(&self.consensus_params.chain_id()));
             debug_assert_eq!(tx.id(&self.consensus_params.chain_id()), tx_id);
         }
 
-        Self::update_input_used_gas(predicate_gas_used, tx_id, &mut tx)?;
+        recycling_try!(Self::update_input_used_gas(
+            predicate_gas_used,
+            tx_id,
+            &mut tx
+        ));
 
         // We always need to update inputs with storage state before execution,
         // because VM zeroes malleable fields during the execution.
-        self.compute_inputs(tx.inputs_mut(), storage_tx)?;
+        recycling_try!(self.compute_inputs(tx.inputs_mut(), storage_tx));
 
         // only commit state changes if execution was a success
         if !reverted {
             self.log_backtrace(&vm, &receipts);
+            vm_pool::recycle_vm_memory(mem::take(vm.memory_mut()));
             let changes = sub_block_db_commit.into_changes();
             storage_tx.commit_changes(changes)?;
+        } else {
+            vm_pool::recycle_vm_memory(mem::take(vm.memory_mut()));
         }
 
         self.update_tx_outputs(storage_tx, tx_id, &mut tx)?;

crates/services/executor/src/lib.rs

@@ -1,11 +1,12 @@
 #![deny(clippy::arithmetic_side_effects)]
 #![deny(clippy::cast_possible_truncation)]
 #![deny(unused_crate_dependencies)]
-#![deny(warnings)]
+// #![deny(warnings)]
 
 pub mod executor;
 pub mod ports;
 pub mod refs;
+mod vm_pool;
 
 #[cfg(test)]
 fuel_core_trace::enable_tracing!();

crates/services/executor/src/vm_pool.rs

@@ -0,0 +1,39 @@
+use std::cell::RefCell;
+
+use fuel_core_types::fuel_vm::interpreter::Memory;
+
+thread_local! {
+    static POOL: RefCell<Vec<Memory>> = RefCell::new(Vec::new());
+}
+
+/// Gets a new VM memory instance from the pool.
+pub(crate) fn get_vm_memory() -> Memory {
+    POOL.with(|pool| {
+        let mut pool = pool.borrow_mut();
+        pool.pop().unwrap_or_else(Memory::new)
+    })
+}
+
+/// Recycles a VM memory instance back into the pool.
+pub(crate) fn recycle_vm_memory(mut mem: Memory) {
+    POOL.with(|pool| {
+        mem.reset();
+        let mut pool = pool.borrow_mut();
+        pool.push(mem);
+    })
+}
+
+#[test]
+fn test_vm_pool() {
+    let mut mem = get_vm_memory();
+    mem.grow_stack(1024).expect("Unable to grow stack");
+    mem.write_bytes_noownerchecks(0, [1, 2, 3, 4])
+        .expect("Unable to write stack");
+    let ptr1 = mem.stack_raw() as *const _ as *const u8 as usize;
+    recycle_vm_memory(mem);
+
+    // Make sure we get the same memory allocation back
+    let mem = get_vm_memory();
+    let ptr2 = mem.stack_raw() as *const _ as *const u8 as usize;
+    assert_eq!(ptr1, ptr2);
+}