feat: add SizeTrackingLruCache for tracking cache size metrics

Cargo.toml

@@ -92,6 +92,7 @@ fvm_ipld_encoding = "0.5.3"
 fvm_shared2 = { package = "fvm_shared", version = "~2.11" }
 fvm_shared3 = { package = "fvm_shared", version = "~3.13", features = ["proofs"] }
 fvm_shared4 = { package = "fvm_shared", version = "~4.7", features = ["proofs"] }
+get-size2 = { version = "0.5", features = ["derive"] }
 gethostname = "1"
 git-version = "0.3"
 group = "0.13"

src/db/blockstore_with_read_cache.rs

@@ -3,16 +3,13 @@
 
 use cid::Cid;
 use fvm_ipld_blockstore::Blockstore;
-use lru::LruCache;
-use parking_lot::Mutex;
-use std::{
-    num::NonZeroUsize,
-    sync::{
-        Arc,
-        atomic::{self, AtomicUsize},
-    },
+use std::sync::{
+    Arc,
+    atomic::{self, AtomicUsize},
 };
 
+use crate::utils::{cache::SizeTrackingLruCache, get_size};
+
 pub trait BlockstoreReadCache {
     fn get(&self, k: &Cid) -> Option<Vec<u8>>;
 
@@ -23,50 +20,23 @@ pub trait BlockstoreReadCache {
     fn size_in_bytes(&self) -> usize;
 }
 
-pub struct LruBlockstoreReadCache {
-    lru: Mutex<LruCache<Cid, Vec<u8>>>,
-    size_in_bytes: AtomicUsize,
-}
-
-impl LruBlockstoreReadCache {
-    pub fn new(cap: NonZeroUsize) -> Self {
-        Self {
-            lru: Mutex::new(LruCache::new(cap)),
-            size_in_bytes: AtomicUsize::default(),
-        }
-    }
-}
+pub type LruBlockstoreReadCache = SizeTrackingLruCache<get_size::CidWrapper, Vec<u8>>;
 
-impl BlockstoreReadCache for LruBlockstoreReadCache {
+impl BlockstoreReadCache for SizeTrackingLruCache<get_size::CidWrapper, Vec<u8>> {
     fn get(&self, k: &Cid) -> Option<Vec<u8>> {
-        self.lru.lock().get(k).cloned()
+        self.get_cloned(&get_size::CidWrapper(*k))
     }
 
     fn put(&self, k: Cid, block: Vec<u8>) {
-        let block_size = block.len();
-        if let Some((_, old_block)) = self.lru.lock().push(k, block) {
-            let old_block_size = old_block.len();
-            if block_size >= old_block_size {
-                self.size_in_bytes
-                    .fetch_add(block_size - old_block_size, atomic::Ordering::Relaxed);
-            } else {
-                self.size_in_bytes
-                    .fetch_sub(old_block_size - block_size, atomic::Ordering::Relaxed);
-            }
-        } else {
-            self.size_in_bytes.fetch_add(
-                std::mem::size_of::<Cid>() + block_size,
-                atomic::Ordering::Relaxed,
-            );
-        }
+        self.push(k.into(), block);
     }
 
     fn len(&self) -> usize {
-        self.lru.lock().len()
+        self.len()
     }
 
     fn size_in_bytes(&self) -> usize {
-        self.size_in_bytes.load(atomic::Ordering::Relaxed)
+        self.size_in_bytes()
     }
 }
 
@@ -213,7 +183,10 @@ mod tests {
             mem_db.put_keyed(&key, &record).unwrap();
             records.push((key, record));
         }
-        let cache = Arc::new(LruBlockstoreReadCache::new(CACHE_SIZE.try_into().unwrap()));
+        let cache = Arc::new(LruBlockstoreReadCache::new_without_metrics_registry(
+            "test_blockstore_read_cache".into(),
+            CACHE_SIZE.try_into().unwrap(),
+        ));
         let db = BlockstoreWithReadCache::new(
             mem_db.clone(),
             cache.clone(),

src/rpc/methods/f3.rs

@@ -20,8 +20,8 @@ use crate::{
     chain::index::ResolveNullTipset,
     chain_sync::TipsetValidator,
     db::{
-        BlockstoreReadCache as _, BlockstoreReadCacheStats as _, BlockstoreWithReadCache,
-        DefaultBlockstoreReadCacheStats, LruBlockstoreReadCache,
+        BlockstoreReadCacheStats as _, BlockstoreWithReadCache, DefaultBlockstoreReadCacheStats,
+        LruBlockstoreReadCache,
     },
     libp2p::{NetRPCMethods, NetworkMessage},
     lotus_json::HasLotusJson as _,
@@ -166,10 +166,11 @@ impl GetPowerTable {
     ) -> anyhow::Result<Vec<F3PowerEntry>> {
         // The RAM overhead on mainnet is ~14MiB
         const BLOCKSTORE_CACHE_CAP: usize = 65536;
-        static BLOCKSTORE_CACHE: LazyLock<Arc<LruBlockstoreReadCache>> = LazyLock::new(|| {
-            Arc::new(LruBlockstoreReadCache::new(
+        static BLOCKSTORE_CACHE: LazyLock<LruBlockstoreReadCache> = LazyLock::new(|| {
+            LruBlockstoreReadCache::new_with_default_metrics_registry(
+                "get_powertable_cache".into(),
                 BLOCKSTORE_CACHE_CAP.try_into().expect("Infallible"),
-            ))
+            )
         });
         let db = BlockstoreWithReadCache::new(
             ctx.store_owned(),