EVM tx cache (#573)

# Motivation

Builder constantly builds different blocks for a slot and most of
transactions are execution over and over with the same result.

Here, we cache execution of transactions and next time we apply tx that
was already executed we only check if state that is currently available
is the same as for the cached result.

# Config
* `simulation_use_random_coinbase: bool` if top of block simulation
should use random coinbase
* `evm_caching_enable: bool` if evm caching should be enabled

# Results

* Cache hit rate: typically around 80-90% of txs are cached and cache
hit rate is around 70-90%

* The speedup for EVM part of execution is huge, verifying tx state and
applying result is much faster than EVM execution, for most txs its
around 10 microseconds while typical execution is around 300
microseconds. There are txs that take multiple milliseconds to execute
and for those time saved is huge.

## Speedup of block fill time.

To measure this I compare average block fill time for the given block of
builder with and without caching. I only look at blocks where average
gas used is the same in both builders.

The speedup of block fill time is distributed like this: average: 2.5x,
median: 2.3x, p10: 1.5x, p90: 3.8x

## Limiting factor

The limiting factor of speedup and cache hit rate are txs that are
always failing when filling block. We execute txs like that only once,
their execution is never cached. Successful txs that we execute over and
over are almost perfectly cached.

# Caveats

I don't recommend enabling it on prod for now because I've seen one root
hash related block simulation error that is hard to explain. Currently
our dev version builder is broken in that part so that might be it.

---------

Co-authored-by: Daniel Xifra <[email protected]>

Author: dvush

crates/rbuilder/src/backtest/build_block/landed_block_from_db.rs

@@ -125,6 +125,7 @@ impl<ConfigType: LiveBuilderConfig>
             self.block_data.winning_bid_trace.proposer_fee_recipient,
             Some(signer),
             Arc::new(MockRootHasher {}),
+            self.config.base_config().evm_caching_enable,
         ))
     }
 

crates/rbuilder/src/backtest/execute.rs

@@ -63,6 +63,7 @@ pub fn backtest_prepare_ctx_for_block<P>(
     blocklist: BlockList,
     sbundle_mergeabe_signers: &[Address],
     builder_signer: Signer,
+    evm_caching_enable: bool,
 ) -> eyre::Result<BacktestBlockInput>
 where
     P: StateProviderFactory + Clone + 'static,
@@ -80,6 +81,7 @@ where
         block_data.winning_bid_trace.proposer_fee_recipient,
         Some(builder_signer),
         Arc::from(provider.root_hasher(parent_num_hash)?),
+        evm_caching_enable,
     );
     backtest_prepare_ctx_for_block_from_building_context(
         ctx,
@@ -145,6 +147,7 @@ where
         blocklist,
         sbundle_mergeabe_signers,
         config.base_config().coinbase_signer()?,
+        config.base_config().evm_caching_enable,
     )?;
 
     let filtered_orders_blocklist_count = sim_errors

crates/rbuilder/src/backtest/restore_landed_orders/resim_landed_block.rs

@@ -53,6 +53,7 @@ where
         suggested_fee_recipient,
         None,
         Arc::from(provider.root_hasher(parent_num_hash)?),
+        false,
     );
 
     let mut local_ctx = ThreadBlockBuildingContext::default();

crates/rbuilder/src/bin/debug-bench-machine.rs

@@ -74,6 +74,7 @@ async fn main() -> eyre::Result<()> {
         suggested_fee_recipient,
         None,
         Arc::from(provider_factory.root_hasher(parent_num_hash)?),
+        config.base_config().evm_caching_enable,
     );
 
     let state_provider = Arc::<dyn StateProvider>::from(

crates/rbuilder/src/bin/dummy-builder.rs

@@ -113,6 +113,8 @@ async fn main() -> eyre::Result<()> {
         orderpool_sender,
         orderpool_receiver,
         sbundle_merger_selected_signers: Default::default(),
+        evm_caching_enable: false,
+        simulation_use_random_coinbase: true,
     };
 
     let ctrlc = tokio::spawn(async move {

crates/rbuilder/src/building/cached_reads.rs

@@ -9,17 +9,19 @@ use std::sync::{
     atomic::{AtomicU64, Ordering},
     Arc,
 };
+
+use ahash::RandomState;
 use tracing::info;
 
 /// Database cache shared bewteen multiple threads.
 /// It should be created for unique parent block.
 #[derive(Debug, Clone, Default)]
 pub struct SharedCachedReads {
-    pub account_info: DashMap<Address, Option<AccountInfo>>,
-    pub storage: DashMap<(Address, U256), U256>,
+    pub account_info: DashMap<Address, Option<AccountInfo>, RandomState>,
+    pub storage: DashMap<(Address, U256), U256, RandomState>,
 
-    pub code_by_hash: DashMap<B256, Bytecode>,
-    pub block_hash: DashMap<u64, B256>,
+    pub code_by_hash: DashMap<B256, Bytecode, RandomState>,
+    pub block_hash: DashMap<u64, B256, RandomState>,
 
     pub local_hit_count: Arc<AtomicU64>,
     pub local_miss_count: Arc<AtomicU64>,

crates/rbuilder/src/building/mod.rs

@@ -49,6 +49,7 @@ use std::{
 };
 use thiserror::Error;
 use time::OffsetDateTime;
+use tx_sim_cache::TxExecutionCache;
 
 pub mod block_orders;
 pub mod builders;
@@ -65,6 +66,7 @@ pub mod precompile_cache;
 pub mod sim;
 pub mod testing;
 pub mod tracers;
+pub mod tx_sim_cache;
 
 pub use self::{
     block_orders::*, builders::mock_block_building_helper::MockRootHasher, built_block_trace::*,
@@ -94,6 +96,7 @@ pub struct BlockBuildingContext {
     pub root_hasher: Arc<dyn RootHasher>,
     pub payload_id: InternalPayloadId,
     pub shared_cached_reads: Arc<SharedCachedReads>,
+    pub tx_execution_cache: Arc<TxExecutionCache>,
 }
 
 impl BlockBuildingContext {
@@ -111,6 +114,7 @@ impl BlockBuildingContext {
         spec_id: Option<SpecId>,
         root_hasher: Arc<dyn RootHasher>,
         payload_id: InternalPayloadId,
+        evm_caching_enable: bool,
     ) -> Option<BlockBuildingContext> {
         let attributes = EthPayloadBuilderAttributes::try_new(
             attributes.data.parent_block_hash,
@@ -178,6 +182,7 @@ impl BlockBuildingContext {
             root_hasher,
             payload_id,
             shared_cached_reads: Default::default(),
+            tx_execution_cache: Arc::new(TxExecutionCache::new(evm_caching_enable)),
         })
     }
 
@@ -194,6 +199,7 @@ impl BlockBuildingContext {
         suggested_fee_recipient: Address,
         builder_signer: Option<Signer>,
         root_hasher: Arc<dyn RootHasher>,
+        evm_caching_enable: bool,
     ) -> BlockBuildingContext {
         let block_number = onchain_block.header.number;
 
@@ -262,6 +268,7 @@ impl BlockBuildingContext {
             root_hasher,
             payload_id: 0,
             shared_cached_reads: Default::default(),
+            tx_execution_cache: Arc::new(TxExecutionCache::new(evm_caching_enable)),
         }
     }
 
@@ -278,6 +285,7 @@ impl BlockBuildingContext {
             Default::default(),
             Default::default(),
             Arc::new(MockRootHasher {}),
+            false,
         )
     }
 
@@ -415,7 +423,7 @@ pub enum InsertPayoutTxErr {
     NoSigner,
 }
 
-#[derive(Error, Debug)]
+#[derive(Error, Debug, PartialEq, Eq)]
 pub enum ExecutionError {
     #[error("Order error: {0}")]
     OrderError(#[from] OrderErr),

crates/rbuilder/src/building/order_commit.rs

@@ -2,6 +2,7 @@ use super::{
     cached_reads::{CachedDB, LocalCachedReads, SharedCachedReads},
     create_payout_tx,
     tracers::SimulationTracer,
+    tx_sim_cache::{CachedExecutionResult, EVMRecordingDatabase},
     BlockBuildingContext, EstimatePayoutGasErr, ThreadBlockBuildingContext,
 };
 use crate::{
@@ -20,6 +21,7 @@ use ahash::HashSet;
 use alloy_consensus::{constants::KECCAK_EMPTY, Transaction};
 use alloy_eips::eip4844::{DATA_GAS_PER_BLOB, MAX_DATA_GAS_PER_BLOCK};
 use alloy_primitives::{Address, B256, U256};
+use itertools::Itertools;
 use reth::revm::database::StateProviderDatabase;
 use reth_errors::ProviderError;
 use reth_evm::{Evm, EvmEnv};
@@ -194,7 +196,7 @@ pub struct TransactionOk {
     pub receipt: Receipt,
 }
 
-#[derive(Error, Debug)]
+#[derive(Error, Debug, Clone, PartialEq, Eq)]
 pub enum TransactionErr {
     #[error("Invalid transaction: {0:?}")]
     InvalidTransaction(InvalidTransaction),
@@ -223,7 +225,7 @@ pub struct BundleOk {
     pub original_order_ids: Vec<OrderId>,
 }
 
-#[derive(Error, Debug)]
+#[derive(Error, Debug, PartialEq, Eq)]
 pub enum BundleErr {
     #[error("Invalid transaction, hash: {0:?}, err: {1}")]
     InvalidTransaction(B256, TransactionErr),
@@ -284,7 +286,7 @@ pub struct OrderOk {
     pub used_state_trace: Option<UsedStateTrace>,
 }
 
-#[derive(Error, Debug)]
+#[derive(Error, Debug, PartialEq, Eq)]
 pub enum OrderErr {
     #[error("Transaction error: {0}")]
     Transaction(#[from] TransactionErr),
@@ -436,34 +438,75 @@ impl<'a, 'b, 'c, 'd, Tracer: SimulationTracer> PartialBlockFork<'a, 'b, 'c, 'd,
         // evm start
         // ====================================================
 
-        let used_state_tracer = self.tracer.as_ref().and_then(|tracer| {
-            if tracer.should_collect_used_state_trace() {
+        // this is set to true when user of the commit_* function wants to have used state trace,
+        // on the other hand we always record used state trace when doing evm caching we just can skip showing it
+        let is_recording_used_state = self
+            .tracer
+            .as_ref()
+            .map(|t| t.should_collect_used_state_trace())
+            .unwrap_or_default();
+        let caching_result = self.ctx.tx_execution_cache.get_cached_result(
+            db.as_mut(),
+            tx.hash(),
+            &self.ctx.evm_env.block_env.beneficiary,
+        )?;
+
+        let cached_used_state_trace;
+        let (res, used_state_trace) = if let Some(result) = caching_result.result {
+            cached_used_state_trace = Some(caching_result.used_state_trace);
+            (result, cached_used_state_trace.as_ref().map(|t| t.as_ref()))
+        } else {
+            let used_state_tracer = if is_recording_used_state || caching_result.should_cache {
                 self.tmp_used_state_tracer.clear();
                 Some(&mut self.tmp_used_state_tracer)
             } else {
                 None
+            };
+
+            let mut db = EVMRecordingDatabase::new(db.as_mut(), caching_result.should_cache);
+
+            let res = execute_evm(
+                &self.ctx.evm_factory,
+                self.ctx.evm_env.clone(),
+                tx_with_blobs,
+                used_state_tracer,
+                &mut db,
+                &self.ctx.blocklist,
+            )?;
+
+            if caching_result.should_cache {
+                self.ctx
+                    .tx_execution_cache
+                    .store_result(CachedExecutionResult {
+                        tx_hash: *tx.hash(),
+                        coinbase: self.ctx.evm_env.block_env.beneficiary,
+                        recorded_trace: db.recorded_trace,
+                        result: res.clone(),
+                        used_state_trace: Arc::new(self.tmp_used_state_tracer.clone()),
+                    });
             }
-        });
 
-        let res = execute_evm(
-            &self.ctx.evm_factory,
-            self.ctx.evm_env.clone(),
-            tx_with_blobs,
-            used_state_tracer,
-            db.as_mut(),
-            &self.ctx.blocklist,
-        )?;
-        let res = match res {
-            Ok(res) => res,
-            Err(err) => return Ok(Err(err)),
+            let used_state_tracer = if is_recording_used_state {
+                Some(&self.tmp_used_state_tracer)
+            } else {
+                None
+            };
+            (res, used_state_tracer)
         };
 
         // evm end
         // ====================================================
 
+        let res = match res {
+            Ok(res) => res,
+            Err(err) => return Ok(Err(err)),
+        };
+
         if let Some(tracer) = &mut self.tracer {
             tracer.add_gas_used(res.result.gas_used());
-            tracer.add_used_state_trace(&self.tmp_used_state_tracer);
+            if let (true, Some(t)) = (is_recording_used_state, used_state_trace) {
+                tracer.add_used_state_trace(t)
+            }
         }
 
         db.as_mut().commit(res.state);
@@ -798,7 +841,7 @@ impl<'a, 'b, 'c, 'd, Tracer: SimulationTracer> PartialBlockFork<'a, 'b, 'c, 'd,
         let mut insert = res.bundle_ok;
 
         // now pay all kickbacks
-        for (to, payout) in res.payouts_promissed.into_iter() {
+        for (to, payout) in res.payouts_promissed.into_iter().sorted_by_key(|(a, _)| *a) {
             if let Err(err) = self.insert_refund_payout_tx(payout, to, gas_reserved, &mut insert)? {
                 return Ok(Err(err));
             }

crates/rbuilder/src/building/payout_tx.rs

@@ -43,6 +43,20 @@ pub enum PayoutTxErr {
     NoSigner,
 }
 
+impl PartialEq for PayoutTxErr {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (PayoutTxErr::Reth(_), PayoutTxErr::Reth(_)) => true,
+            (PayoutTxErr::SignError(a), PayoutTxErr::SignError(b)) => a == b,
+            (PayoutTxErr::EvmError(_), PayoutTxErr::EvmError(_)) => true,
+            (PayoutTxErr::NoSigner, PayoutTxErr::NoSigner) => true,
+            _ => false,
+        }
+    }
+}
+
+impl Eq for PayoutTxErr {}
+
 pub fn insert_test_payout_tx(
     to: Address,
     ctx: &BlockBuildingContext,
@@ -95,6 +109,22 @@ pub enum EstimatePayoutGasErr {
     #[error("Failed to estimate gas limit")]
     FailedToEstimate,
 }
+
+impl PartialEq for EstimatePayoutGasErr {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (EstimatePayoutGasErr::Reth(_), EstimatePayoutGasErr::Reth(_)) => true,
+            (EstimatePayoutGasErr::PayoutTxErr(a), EstimatePayoutGasErr::PayoutTxErr(b)) => a == b,
+            (EstimatePayoutGasErr::FailedToEstimate, EstimatePayoutGasErr::FailedToEstimate) => {
+                true
+            }
+            _ => false,
+        }
+    }
+}
+
+impl Eq for EstimatePayoutGasErr {}
+
 pub fn estimate_payout_gas_limit(
     to: Address,
     ctx: &BlockBuildingContext,
@@ -192,6 +222,7 @@ mod tests {
             proposer,
             Some(signer),
             Arc::new(MockRootHasher {}),
+            false,
         );
         let mut state = BlockState::new(provider_factory.latest().unwrap());
         let mut local_ctx = ThreadBlockBuildingContext::default();