Use quick_cache on ValueCache and introduce ParkingCache

Author: ndr-ds

Cargo.lock

@@ -67,6 +67,7 @@ linera-storage.workspace = true
 linera-version.workspace = true
 linera-views.workspace = true
 lru.workspace = true
+quick_cache.workspace = true
 papaya = { workspace = true, features = ["serde"] }
 prometheus = { workspace = true, optional = true }
 proptest = { workspace = true, optional = true }

linera-core/Cargo.toml

@@ -36,7 +36,7 @@ use super::{config::ChainWorkerConfig, state::ChainWorkerState, DeliveryNotifier
 use crate::{
     chain_worker::BlockOutcome,
     data_types::{ChainInfoQuery, ChainInfoResponse},
-    value_cache::ValueCache,
+    value_cache::{ParkingCache, ValueCache},
     worker::{NetworkActions, WorkerError},
 };
 
@@ -275,7 +275,7 @@ where
     config: ChainWorkerConfig,
     storage: StorageClient,
     block_values: Arc<ValueCache<CryptoHash, Hashed<Block>>>,
-    execution_state_cache: Arc<ValueCache<CryptoHash, ExecutionStateView<InactiveContext>>>,
+    execution_state_cache: Arc<ParkingCache<CryptoHash, ExecutionStateView<InactiveContext>>>,
     tracked_chains: Option<Arc<sync::RwLock<HashSet<ChainId>>>>,
     delivery_notifier: DeliveryNotifier,
     is_tracked: bool,
@@ -328,7 +328,7 @@ where
         config: ChainWorkerConfig,
         storage: StorageClient,
         block_values: Arc<ValueCache<CryptoHash, Hashed<Block>>>,
-        execution_state_cache: Arc<ValueCache<CryptoHash, ExecutionStateView<InactiveContext>>>,
+        execution_state_cache: Arc<ParkingCache<CryptoHash, ExecutionStateView<InactiveContext>>>,
         tracked_chains: Option<Arc<RwLock<HashSet<ChainId>>>>,
         delivery_notifier: DeliveryNotifier,
         chain_id: ChainId,

linera-core/src/chain_worker/actor.rs

@@ -46,7 +46,7 @@ use tracing::{debug, instrument, trace, warn};
 use super::{ChainWorkerConfig, ChainWorkerRequest, DeliveryNotifier, EventSubscriptionsResult};
 use crate::{
     data_types::{ChainInfo, ChainInfoQuery, ChainInfoResponse, CrossChainRequest},
-    value_cache::ValueCache,
+    value_cache::{ParkingCache, ValueCache},
     worker::{NetworkActions, Notification, Reason, WorkerError},
 };
 
@@ -77,7 +77,7 @@ where
     shared_chain_view: Option<Arc<RwLock<ChainStateView<StorageClient::Context>>>>,
     service_runtime_endpoint: Option<ServiceRuntimeEndpoint>,
     block_values: Arc<ValueCache<CryptoHash, Hashed<Block>>>,
-    execution_state_cache: Arc<ValueCache<CryptoHash, ExecutionStateView<InactiveContext>>>,
+    execution_state_cache: Arc<ParkingCache<CryptoHash, ExecutionStateView<InactiveContext>>>,
     tracked_chains: Option<Arc<sync::RwLock<HashSet<ChainId>>>>,
     delivery_notifier: DeliveryNotifier,
     knows_chain_is_active: bool,
@@ -103,7 +103,7 @@ where
         config: ChainWorkerConfig,
         storage: StorageClient,
         block_values: Arc<ValueCache<CryptoHash, Hashed<Block>>>,
-        execution_state_cache: Arc<ValueCache<CryptoHash, ExecutionStateView<InactiveContext>>>,
+        execution_state_cache: Arc<ParkingCache<CryptoHash, ExecutionStateView<InactiveContext>>>,
         tracked_chains: Option<Arc<sync::RwLock<HashSet<ChainId>>>>,
         delivery_notifier: DeliveryNotifier,
         chain_id: ChainId,
@@ -1458,7 +1458,7 @@ where
                     .await
                     .with_execution_context(ChainExecutionContext::Query)?;
                 self.execution_state_cache
-                    .insert_owned(&requested_block, state);
+                    .insert(&requested_block, state);
                 Ok(outcome)
             } else {
                 tracing::debug!(requested_block = %requested_block, "requested block hash not found in cache, querying committed state");
@@ -1774,7 +1774,7 @@ where
             .await?;
         let block = Block::new(block.clone(), outcome);
         let block_hash = CryptoHash::new(&block);
-        self.execution_state_cache.insert_owned(
+        self.execution_state_cache.insert(
             &block_hash,
             Box::pin(
                 self.chain

linera-core/src/chain_worker/state.rs

@@ -1,7 +1,7 @@
 // Copyright (c) Zefchain Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-use std::{borrow::Cow, collections::BTreeSet};
+use std::borrow::Cow;
 
 use linera_base::{
     crypto::CryptoHash,
@@ -23,7 +23,7 @@ fn test_retrieve_missing_value() {
     let hash = CryptoHash::test_hash("Missing value");
 
     assert!(cache.get(&hash).is_none());
-    assert!(cache.keys::<Vec<_>>().is_empty());
+    assert_eq!(cache.len(), 0);
 }
 
 /// Tests inserting a certificate value in the cache.
@@ -36,7 +36,7 @@ fn test_insert_single_certificate_value() {
     assert!(cache.insert(Cow::Borrowed(&value)));
     assert!(cache.contains(&hash));
     assert_eq!(cache.get(&hash), Some(value));
-    assert_eq!(cache.keys::<BTreeSet<_>>(), BTreeSet::from([hash]));
+    assert_eq!(cache.len(), 1);
 }
 
 /// Tests inserting many certificate values in the cache, one-by-one.
@@ -54,10 +54,7 @@ fn test_insert_many_certificate_values_individually() {
         assert_eq!(cache.get(&value.hash()).as_ref(), Some(value));
     }
 
-    assert_eq!(
-        cache.keys::<BTreeSet<_>>(),
-        BTreeSet::from_iter(values.iter().map(Hashed::hash))
-    );
+    assert_eq!(cache.len(), TEST_CACHE_SIZE);
 }
 
 /// Tests inserting many values in the cache, all-at-once.
@@ -73,10 +70,7 @@ fn test_insert_many_values_together() {
         assert_eq!(cache.get(&value.hash()).as_ref(), Some(value));
     }
 
-    assert_eq!(
-        cache.keys::<BTreeSet<_>>(),
-        BTreeSet::from_iter(values.iter().map(|el| el.hash()))
-    );
+    assert_eq!(cache.len(), TEST_CACHE_SIZE);
 }
 
 /// Tests re-inserting many values in the cache, all-at-once.
@@ -96,97 +90,126 @@ fn test_reinsertion_of_values() {
         assert_eq!(cache.get(&value.hash()).as_ref(), Some(value));
     }
 
-    assert_eq!(
-        cache.keys::<BTreeSet<_>>(),
-        BTreeSet::from_iter(values.iter().map(Hashed::hash))
+    // Re-insertion should not increase the count
+    assert_eq!(cache.len(), TEST_CACHE_SIZE);
+}
+
+/// Tests eviction when cache is full.
+/// Note: quick_cache uses S3-FIFO eviction, so we verify that the cache
+/// doesn't grow unboundedly and eviction occurs.
+#[test]
+fn test_eviction_occurs() {
+    let cache = ValueCache::<CryptoHash, Hashed<Timeout>>::new(TEST_CACHE_SIZE);
+    // Insert more than capacity
+    let values =
+        create_dummy_certificate_values(0..((TEST_CACHE_SIZE as u64) * 2)).collect::<Vec<_>>();
+
+    for value in &values {
+        cache.insert(Cow::Borrowed(value));
+    }
+
+    // Cache size should be bounded by capacity
+    assert!(
+        cache.len() <= TEST_CACHE_SIZE,
+        "Cache size {} exceeds capacity {}",
+        cache.len(),
+        TEST_CACHE_SIZE
+    );
+
+    // Count how many values are still in cache
+    let present_count = values.iter().filter(|v| cache.contains(&v.hash())).count();
+
+    // At least some values should have been evicted
+    assert!(
+        present_count < values.len(),
+        "Cache should have evicted at least some entries"
     );
 }
 
-/// Tests eviction of one entry.
+/// Tests eviction when inserting one more than capacity.
+/// With S3-FIFO, the first inserted item may or may not be evicted (depends on access patterns).
 #[test]
-fn test_one_eviction() {
+fn test_one_over_capacity() {
     let cache = ValueCache::<CryptoHash, Hashed<Timeout>>::new(TEST_CACHE_SIZE);
     let values = create_dummy_certificate_values(0..=(TEST_CACHE_SIZE as u64)).collect::<Vec<_>>();
 
     cache.insert_all(values.iter().map(Cow::Borrowed));
 
-    assert!(!cache.contains(&values[0].hash()));
-    assert!(cache.get(&values[0].hash()).is_none());
-
-    for value in values.iter().skip(1) {
-        assert!(cache.contains(&value.hash()));
-        assert_eq!(cache.get(&value.hash()).as_ref(), Some(value));
-    }
+    // Cache should not exceed capacity
+    assert!(
+        cache.len() <= TEST_CACHE_SIZE,
+        "Cache size {} exceeds capacity {}",
+        cache.len(),
+        TEST_CACHE_SIZE
+    );
 
+    // Exactly one value should have been evicted
+    let present_count = values.iter().filter(|v| cache.contains(&v.hash())).count();
     assert_eq!(
-        cache.keys::<BTreeSet<_>>(),
-        BTreeSet::from_iter(values.iter().skip(1).map(Hashed::hash))
+        present_count, TEST_CACHE_SIZE,
+        "Expected {} items in cache after inserting {} items with capacity {}",
+        TEST_CACHE_SIZE,
+        values.len(),
+        TEST_CACHE_SIZE
     );
 }
 
-/// Tests eviction of the second entry.
+/// Tests that accessing a value affects eviction (values accessed recently are more likely to stay).
+/// S3-FIFO uses frequency-based eviction, so frequently accessed items should survive.
 #[test]
-fn test_eviction_of_second_entry() {
+fn test_access_affects_eviction() {
     let cache = ValueCache::<CryptoHash, Hashed<Timeout>>::new(TEST_CACHE_SIZE);
-    let values = create_dummy_certificate_values(0..=(TEST_CACHE_SIZE as u64)).collect::<Vec<_>>();
+    let values = create_dummy_certificate_values(0..(TEST_CACHE_SIZE as u64)).collect::<Vec<_>>();
 
-    cache.insert_all(values.iter().take(TEST_CACHE_SIZE).map(Cow::Borrowed));
-    cache.get(&values[0].hash());
-    assert!(cache.insert(Cow::Borrowed(&values[TEST_CACHE_SIZE])));
+    // Fill the cache
+    cache.insert_all(values.iter().map(Cow::Borrowed));
 
-    assert!(cache.contains(&values[0].hash()));
-    assert_eq!(cache.get(&values[0].hash()).as_ref(), Some(&values[0]));
+    // Access the first value multiple times to make it "hot"
+    for _ in 0..5 {
+        cache.get(&values[0].hash());
+    }
 
-    assert!(!cache.contains(&values[1].hash()));
-    assert!(cache.get(&values[1].hash()).is_none());
+    // Insert additional values to trigger eviction
+    let extra_values =
+        create_dummy_certificate_values((TEST_CACHE_SIZE as u64)..((TEST_CACHE_SIZE as u64) + 5))
+            .collect::<Vec<_>>();
 
-    for value in values.iter().skip(2) {
-        assert!(cache.contains(&value.hash()));
-        assert_eq!(cache.get(&value.hash()).as_ref(), Some(value));
+    for value in &extra_values {
+        cache.insert(Cow::Borrowed(value));
     }
 
-    assert_eq!(
-        cache.keys::<BTreeSet<_>>(),
-        BTreeSet::from_iter(
-            values
-                .iter()
-                .skip(2)
-                .map(Hashed::hash)
-                .chain(Some(values[0].hash()))
-        )
+    // The frequently accessed first value should still be present
+    assert!(
+        cache.contains(&values[0].hash()),
+        "Frequently accessed value should survive eviction"
     );
 }
 
-/// Tests if reinsertion of the first entry promotes it so that it's not evicted so soon.
+/// Tests that re-inserting a value promotes it in the eviction order.
 #[test]
 fn test_promotion_of_reinsertion() {
     let cache = ValueCache::<CryptoHash, Hashed<Timeout>>::new(TEST_CACHE_SIZE);
-    let values = create_dummy_certificate_values(0..=(TEST_CACHE_SIZE as u64)).collect::<Vec<_>>();
+    let values = create_dummy_certificate_values(0..(TEST_CACHE_SIZE as u64)).collect::<Vec<_>>();
 
-    cache.insert_all(values.iter().take(TEST_CACHE_SIZE).map(Cow::Borrowed));
-    assert!(!cache.insert(Cow::Borrowed(&values[0])));
-    assert!(cache.insert(Cow::Borrowed(&values[TEST_CACHE_SIZE])));
+    // Fill the cache
+    cache.insert_all(values.iter().map(Cow::Borrowed));
 
-    assert!(cache.contains(&values[0].hash()));
-    assert_eq!(cache.get(&values[0].hash()).as_ref(), Some(&values[0]));
+    // Re-insert the first value (this should "promote" it)
+    assert!(!cache.insert(Cow::Borrowed(&values[0])));
 
-    assert!(!cache.contains(&values[1].hash()));
-    assert!(cache.get(&values[1].hash()).is_none());
+    // Insert additional values to trigger eviction
+    let extra_values =
+        create_dummy_certificate_values((TEST_CACHE_SIZE as u64)..((TEST_CACHE_SIZE as u64) + 3))
+            .collect::<Vec<_>>();
 
-    for value in values.iter().skip(2) {
-        assert!(cache.contains(&value.hash()));
-        assert_eq!(cache.get(&value.hash()).as_ref(), Some(value));
+    for value in &extra_values {
+        cache.insert(Cow::Borrowed(value));
     }
 
-    assert_eq!(
-        cache.keys::<BTreeSet<_>>(),
-        BTreeSet::from_iter(
-            values
-                .iter()
-                .skip(2)
-                .map(Hashed::hash)
-                .chain(Some(values[0].hash()))
-        )
+    // The re-inserted first value should still be present
+    assert!(
+        cache.contains(&values[0].hash()),
+        "Re-inserted value should survive eviction"
     );
 }