add access timestamp to StateCacheEntry

storage/aptosdb/src/state_store/mod.rs

@@ -859,22 +859,26 @@ impl StateStore {
                 }
 
                 // TODO(aldenhu): cache changes here, should consume it.
+                // Use dummy access_time_secs = 0, since `cache` is not going to persist.
                 let old_entry = cache
                     .insert(
                         (*key).clone(),
-                        StateCacheEntry::from_state_update_ref(update),
+                        StateCacheEntry::from_state_update_ref(update, 0),
                     )
                     .unwrap_or_else(|| {
                         // n.b. all updated state items must be read and recorded in the state cache,
                         // otherwise we can't calculate the correct usage. The is_untracked() hack
                         // is to allow some db tests without real execution layer to pass.
                         assert!(ignore_state_cache_miss, "Must cache read.");
-                        StateCacheEntry::NonExistent
+                        StateCacheEntry::NonExistent {
+                            access_time_secs: 0,
+                        }
                     });
 
                 if let StateCacheEntry::Value {
                     version: old_version,
                     value: _,
+                    access_time_secs: _,
                 } = old_entry
                 {
                     // The value at `old_version` can be pruned once the pruning window hits

storage/storage-interface/Cargo.toml

@@ -16,6 +16,7 @@ rust-version = { workspace = true }
 anyhow = { workspace = true }
 aptos-crypto = { workspace = true }
 aptos-experimental-layered-map = { workspace = true }
+aptos-infallible = { workspace = true }
 aptos-metrics-core = { workspace = true }
 aptos-scratchpad = { workspace = true }
 aptos-secure-net = { workspace = true }

storage/storage-interface/src/state_store/state_view/cached_state_view.rs

@@ -13,6 +13,7 @@ use crate::{
     DbReader,
 };
 use anyhow::Result;
+use aptos_infallible::duration_since_epoch;
 use aptos_metrics_core::TimerHelper;
 use aptos_types::{
     state_store::{
@@ -87,6 +88,9 @@ pub struct CachedStateView {
 
     /// State values (with update versions) read across the lifetime of the state view.
     memorized: ShardedStateCache,
+
+    /// access timestamp for uncached entries
+    access_time_secs: u32,
 }
 
 impl Debug for CachedStateView {
@@ -115,6 +119,7 @@ impl CachedStateView {
             reader,
             memorized: ShardedStateCache::new_empty(state.version()),
             speculative: state.into_delta(persisted_state),
+            access_time_secs: duration_since_epoch().as_secs() as u32,
         }
     }
 
@@ -127,6 +132,7 @@ impl CachedStateView {
             reader: Arc::new(DummyDbReader),
             memorized: ShardedStateCache::new_empty(None),
             speculative: state.make_delta(state),
+            access_time_secs: 0,
         }
     }
 
@@ -172,6 +178,7 @@ impl CachedStateView {
             reader: _,
             speculative: _,
             memorized,
+            access_time_secs: _,
         } = self;
 
         memorized
@@ -184,14 +191,17 @@ impl CachedStateView {
     fn get_uncached(&self, state_key: &StateKey) -> Result<StateCacheEntry> {
         let ret = if let Some(update) = self.speculative.get_state_update(state_key) {
             // found in speculative state, can be either a new value or a deletion
-            update.to_state_value_with_version()
+            update.to_state_value_with_version(self.access_time_secs)
         } else if let Some(base_version) = self.base_version() {
-            StateCacheEntry::from_tuple_opt(
+            StateCacheEntry::from_db_tuple_opt(
                 self.reader
                     .get_state_value_with_version_by_version(state_key, base_version)?,
+                self.access_time_secs,
             )
         } else {
-            StateCacheEntry::NonExistent
+            StateCacheEntry::NonExistent {
+                access_time_secs: self.access_time_secs,
+            }
         };
 
         Ok(ret)

storage/storage-interface/src/state_store/versioned_state_value.rs

@@ -12,12 +12,13 @@ pub struct StateUpdate {
 }
 
 impl StateUpdate {
-    pub fn to_state_value_with_version(&self) -> StateCacheEntry {
+    pub fn to_state_value_with_version(&self, access_time_secs: u32) -> StateCacheEntry {
         use StateCacheEntry::*;
 
         match &self.value {
-            None => NonExistent,
+            None => NonExistent { access_time_secs },
             Some(value) => Value {
+                access_time_secs,
                 version: self.version,
                 value: value.clone(),
             },
@@ -44,62 +45,57 @@ impl<'kv> StateUpdateRef<'kv> {
 
 #[derive(Clone, Debug)]
 pub enum StateCacheEntry {
-    /// Not indicating if the value ever existed and deleted.
-    NonExistent,
+    /// NOT indicating whether the value never existed or deleted.
+    NonExistent { access_time_secs: u32 },
     /// A creation or modification.
-    Value { version: Version, value: StateValue },
+    Value {
+        access_time_secs: u32,
+        version: Version,
+        value: StateValue,
+    },
 }
 
 impl StateCacheEntry {
     // TODO(aldenhu): update DbReader interface to return this type directly.
-    pub fn from_tuple_opt(tuple_opt: Option<(Version, StateValue)>) -> Self {
+    pub fn from_db_tuple_opt(
+        tuple_opt: Option<(Version, StateValue)>,
+        access_time_secs: u32,
+    ) -> Self {
         match tuple_opt {
-            None => Self::NonExistent,
-            Some((version, value)) => Self::Value { version, value },
-        }
-    }
-
-    pub fn from_state_write_ref(version: Version, value_opt: Option<&StateValue>) -> Self {
-        match value_opt {
-            None => Self::NonExistent,
-            Some(value) => Self::Value {
+            None => Self::NonExistent { access_time_secs },
+            Some((version, value)) => Self::Value {
+                access_time_secs,
                 version,
-                value: value.clone(),
+                value,
             },
         }
     }
 
-    pub fn from_state_update_ref(state_update_ref: &StateUpdateRef) -> Self {
+    pub fn from_state_update_ref(state_update_ref: &StateUpdateRef, access_time_secs: u32) -> Self {
         match state_update_ref.value {
-            None => Self::NonExistent,
+            None => Self::NonExistent { access_time_secs },
             Some(value) => Self::Value {
+                access_time_secs,
                 version: state_update_ref.version,
                 value: value.clone(),
             },
         }
     }
 
-    pub fn as_state_value_opt(&self) -> Option<&StateValue> {
-        match self {
-            Self::NonExistent => None,
-            Self::Value { value, .. } => Some(value),
-        }
-    }
-
     pub fn to_state_value_opt(&self) -> Option<StateValue> {
         self.state_value_ref_opt().cloned()
     }
 
     pub fn state_value_ref_opt(&self) -> Option<&StateValue> {
         match self {
-            Self::NonExistent => None,
+            Self::NonExistent { .. } => None,
             Self::Value { value, .. } => Some(value),
         }
     }
 
     pub fn into_state_value_opt(self) -> Option<StateValue> {
         match self {
-            Self::NonExistent => None,
+            Self::NonExistent { .. } => None,
             Self::Value { value, .. } => Some(value),
         }
     }