perf: warm transactions in parallel

crates/engine/tree/src/tree/mod.rs

@@ -28,7 +28,7 @@ use reth_chainspec::EthereumHardforks;
 use reth_consensus::{Consensus, PostExecutionInput};
 use reth_engine_primitives::EngineTypes;
 use reth_errors::{ConsensusError, ProviderResult};
-use reth_evm::execute::BlockExecutorProvider;
+use reth_evm::execute::{BlockExecutorProvider, Executor};
 use reth_payload_builder::PayloadBuilderHandle;
 use reth_payload_primitives::{PayloadAttributes, PayloadBuilder, PayloadBuilderAttributes};
 use reth_payload_validator::ExecutionPayloadValidator;
@@ -2168,14 +2168,36 @@ where
             return Err(e.into())
         }
 
+        let shared_state_provider = Arc::new(state_provider);
+
         trace!(target: "engine::tree", block=?block.num_hash(), "Executing block");
-        let executor = self.executor_provider.executor(StateProviderDatabase::new(&state_provider));
+        let executor =
+            self.executor_provider.executor(StateProviderDatabase::new(&shared_state_provider));
 
         let block_number = block.number;
         let block_hash = block.hash();
         let sealed_block = Arc::new(block.block.clone());
         let block = block.unseal();
 
+        // Execute all transactions in parallel and discard the result
+        for tx in block.body.transactions() {
+            let cloned_state_provider = shared_state_provider.clone();
+            let executor_provider = self.executor_provider.clone();
+            let cloned_tx = tx.clone();
+
+            // modify the block to contain only
+            let mut modified_block = block.clone();
+            modified_block.body.transactions = vec![cloned_tx.clone()];
+
+            std::thread::spawn(move || {
+                info!(target: "engine::tree", tx_hash = ?cloned_tx.hash(), "Spawning thread to execute transaction in parallel");
+                let executor =
+                    executor_provider.executor(StateProviderDatabase::new(&cloned_state_provider));
+                executor.execute((&modified_block, U256::MAX).into()).unwrap();
+                info!(target: "engine::tree", tx_hash = ?cloned_tx.hash(), "Finished executing transaction in parallel");
+            });
+        }
+
         let exec_time = Instant::now();
         let output = self.metrics.executor.execute_metered(executor, (&block, U256::MAX).into())?;
 
@@ -2223,7 +2245,7 @@ where
             result
         } else {
             debug!(target: "engine::tree", block=?sealed_block.num_hash(), persistence_in_progress, "Failed to compute state root in parallel");
-            state_provider.state_root_with_updates(hashed_state.clone())?
+            shared_state_provider.state_root_with_updates(hashed_state.clone())?
         };
 
         if state_root != block.state_root {