perf: add lru cache for load_executed_tipset to speed up hot queries

src/rpc/methods/eth.rs

@@ -500,10 +500,7 @@ impl Block {
             let ExecutedTipset {
                 state_root,
                 executed_messages,
-            } = ctx
-                .state_manager
-                .load_executed_tipset_without_events(&tipset)
-                .await?;
+            } = ctx.state_manager.load_executed_tipset(&tipset).await?;
             let has_transactions = !executed_messages.is_empty();
             let state_tree = ctx.state_manager.get_state_tree(&state_root)?;
 
@@ -1419,10 +1416,7 @@ async fn get_block_receipts<DB: Blockstore + Send + Sync + 'static>(
     let ExecutedTipset {
         state_root,
         executed_messages,
-    } = ctx
-        .state_manager
-        .load_executed_tipset_without_events(&ts_ref)
-        .await?;
+    } = ctx.state_manager.load_executed_tipset(&ts_ref).await?;
 
     // Load the state tree
     let state_tree = ctx.state_manager.get_state_tree(&state_root)?;
@@ -1933,10 +1927,7 @@ async fn eth_fee_history<B: Blockstore + Send + Sync + 'static>(
         let base_fee = &ts.block_headers().first().parent_base_fee;
         let ExecutedTipset {
             executed_messages, ..
-        } = ctx
-            .state_manager
-            .load_executed_tipset_without_events(&ts)
-            .await?;
+        } = ctx.state_manager.load_executed_tipset(&ts).await?;
         let mut tx_gas_rewards = Vec::with_capacity(executed_messages.len());
         for ExecutedMessage {
             message, receipt, ..

src/shim/executor.rs

@@ -22,7 +22,7 @@ use fvm_shared4::receipt::Receipt as Receipt_v4;
 use fvm2::executor::ApplyRet as ApplyRet_v2;
 use fvm3::executor::ApplyRet as ApplyRet_v3;
 use fvm4::executor::ApplyRet as ApplyRet_v4;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use spire_enum::prelude::delegated_enum;
 use std::borrow::Borrow as _;
 
@@ -79,7 +79,7 @@ impl ApplyRet {
 // Note: it's impossible to properly derive Deserialize.
 // To deserialize into `Receipt`, refer to `fn get_parent_receipt`
 #[delegated_enum(impl_conversions)]
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum Receipt {
     V2(Receipt_v2),
@@ -225,7 +225,7 @@ impl ActorEvent {
 
 /// Event with extra information stamped by the FVM.
 #[delegated_enum(impl_conversions)]
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum StampedEvent {
     V3(StampedEvent_v3),

src/state_manager/mod.rs

@@ -54,7 +54,8 @@ use crate::shim::{
 use crate::state_manager::cache::TipsetStateCache;
 use crate::state_manager::chain_rand::draw_randomness;
 use crate::state_migration::run_state_migrations;
-use crate::utils::get_size::GetSize;
+use crate::utils::cache::SizeTrackingLruCache;
+use crate::utils::get_size::{GetSize, vec_heap_size_helper};
 use ahash::{HashMap, HashMapExt};
 use anyhow::{Context as _, bail, ensure};
 use bls_signatures::{PublicKey as BlsPublicKey, Serialize as _};
@@ -78,6 +79,7 @@ use rayon::prelude::ParallelBridge;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::ops::RangeInclusive;
+use std::sync::LazyLock;
 use std::time::Duration;
 use std::{num::NonZeroUsize, sync::Arc};
 use tokio::sync::{RwLock, broadcast::error::RecvError};
@@ -93,26 +95,40 @@ type CidPair = (Cid, Cid);
 ///
 /// Includes the executed message itself, the execution receipt, and
 /// optional events emitted by the actor during execution.
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ExecutedMessage {
     pub message: ChainMessage,
     pub receipt: Receipt,
     pub events: Option<Vec<StampedEvent>>,
 }
 
+impl GetSize for ExecutedMessage {
+    fn get_heap_size(&self) -> usize {
+        self.message.get_heap_size()
+            + self.receipt.get_heap_size()
+            + self
+                .events
+                .as_ref()
+                .map(vec_heap_size_helper)
+                .unwrap_or_default()
+    }
+}
+
 /// Aggregated execution result for a tipset.
 ///
 /// `state_root` is the resulting state tree root after message execution
 /// and `executed_messages` contains per-message execution details.
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ExecutedTipset {
     pub state_root: Cid,
     pub executed_messages: Vec<ExecutedMessage>,
 }
 
-/// Options controlling how `load_executed_tipset` fetches extra execution data.
-///
-/// `include_events` toggles whether event logs are loaded from receipts.
-pub struct LoadExecutedTipsetOptions {
-    pub include_events: bool,
+impl GetSize for ExecutedTipset {
+    fn get_heap_size(&self) -> usize {
+        // state_root(Cid) has no heap allocation, so we only calculate the heap size of executed_messages
+        vec_heap_size_helper(&self.executed_messages)
+    }
 }
 
 #[derive(Debug, Default, Clone, GetSize)]
@@ -471,48 +487,36 @@ where
             .await
     }
 
-    /// Load an executed tipset, including message receipts and state root,
-    /// without loading event logs from receipts.
-    pub async fn load_executed_tipset_without_events(
-        self: &Arc<Self>,
-        ts: &Tipset,
-    ) -> anyhow::Result<ExecutedTipset> {
-        let receipt_ts = self.chain_store().load_child_tipset(ts).ok();
-        self.load_executed_tipset_inner(
-            ts,
-            receipt_ts.as_ref(),
-            LoadExecutedTipsetOptions {
-                include_events: false,
-            },
-        )
-        .await
-    }
-
-    /// Load an executed tipset, including message receipts and state root,
-    /// with event logs loaded when available.
+    /// Load an executed tipset, including state root, message receipts and events with caching.
     pub async fn load_executed_tipset(
         self: &Arc<Self>,
         ts: &Tipset,
     ) -> anyhow::Result<ExecutedTipset> {
+        // A tipset key should always map to a deterministic state output, so it's safe to cache the entire executed tipset with the same key.
+        static CACHE: LazyLock<SizeTrackingLruCache<TipsetKey, ExecutedTipset>> =
+            LazyLock::new(|| {
+                SizeTrackingLruCache::new_with_metrics(
+                    "executed_tipset".into(),
+                    nonzero!(1024usize),
+                )
+            });
+        if let Some(cached) = CACHE.get_cloned(ts.key()) {
+            return Ok(cached);
+        }
         let receipt_ts = self.chain_store().load_child_tipset(ts).ok();
-        self.load_executed_tipset_inner(
-            ts,
-            receipt_ts.as_ref(),
-            LoadExecutedTipsetOptions {
-                include_events: true,
-            },
-        )
-        .await
+        let result = self
+            .load_executed_tipset_inner(ts, receipt_ts.as_ref())
+            .await?;
+        CACHE.push(ts.key().clone(), result.clone());
+        Ok(result)
     }
 
     async fn load_executed_tipset_inner(
         self: &Arc<Self>,
         msg_ts: &Tipset,
         // when `msg_ts` is the current head, `receipt_ts` is `None`
         receipt_ts: Option<&Tipset>,
-        options: LoadExecutedTipsetOptions,
     ) -> anyhow::Result<ExecutedTipset> {
-        let LoadExecutedTipsetOptions { include_events } = options;
         if let Some(receipt_ts) = receipt_ts {
             anyhow::ensure!(
                 msg_ts.key() == receipt_ts.parents(),
@@ -546,7 +550,7 @@ where
         );
         let mut executed_messages = Vec::with_capacity(messages.len());
         for (message, receipt) in messages.into_iter().zip(receipts.into_iter()) {
-            let events = if include_events && let Some(events_root) = receipt.events_root() {
+            let events = if let Some(events_root) = receipt.events_root() {
                 Some(
                     match StampedEvent::get_events(self.cs.blockstore(), &events_root) {
                         Ok(events) => events,

src/utils/get_size/mod.rs

@@ -35,6 +35,10 @@ macro_rules! impl_vec_alike_heap_size_helper {
     };
 }
 
+pub fn vec_heap_size_helper<T: GetSize>(v: &Vec<T>) -> usize {
+    impl_vec_alike_heap_size_helper!(v, T)
+}
+
 pub fn vec_heap_size_with_fn_helper<T>(v: &Vec<T>, get_heap_size: impl Fn(&T) -> usize) -> usize {
     impl_vec_alike_heap_size_with_fn_helper!(v, T, std::mem::size_of::<T>, get_heap_size)
 }