Add tracking of memory use in the caching. (#3635)

## Motivation

The current tracking is limited by the maximal size of the cache.
This is a limited way to control the size of the cache.

## Proposal

Two additional constraints are added:
* A maximal size of the total cache.
* A maximal size of individual entries in the cache.
* Those entries are added to the input parameters of all the relevant
functions.

## Test Plan

The CI.

## Release Plan

Normal release plan.

## Links

None.

Author: MathieuDutSik

CLI.md

@@ -125,7 +125,13 @@ A Byzantine-fault tolerant sidechain with low-latency finality and high throughp
 * `--max-stream-queries <MAX_STREAM_QUERIES>` — The maximal number of simultaneous stream queries to the database
 
   Default value: `10`
-* `--cache-size <CACHE_SIZE>` — The maximal number of entries in the storage cache
+* `--max-cache-size <MAX_CACHE_SIZE>` — The maximal memory used in the storage cache
+
+  Default value: `10000000`
+* `--max-entry-size <MAX_ENTRY_SIZE>` — The maximal size of an entry in the storage cache
+
+  Default value: `1000000`
+* `--max-cache-entries <MAX_CACHE_ENTRIES>` — The maximal number of entries in the storage cache
 
   Default value: `1000`
 * `--retry-delay-ms <RETRY_DELAY>` — Delay increment for retrying to connect to a validator

linera-client/src/client_options.rs

@@ -19,7 +19,7 @@ use linera_base::{
 };
 use linera_core::{client::BlanketMessagePolicy, DEFAULT_GRACE_PERIOD};
 use linera_execution::{ResourceControlPolicy, WasmRuntime, WithWasmDefault as _};
-use linera_views::store::CommonStoreConfig;
+use linera_views::{lru_caching::StorageCacheConfig, store::CommonStoreConfig};
 
 #[cfg(feature = "fs")]
 use crate::config::GenesisConfig;
@@ -112,9 +112,17 @@ pub struct ClientOptions {
     #[arg(long, default_value = "10")]
     pub max_stream_queries: usize,
 
+    /// The maximal memory used in the storage cache.
+    #[arg(long, default_value = "10000000")]
+    pub max_cache_size: usize,
+
+    /// The maximal size of an entry in the storage cache.
+    #[arg(long, default_value = "1000000")]
+    pub max_entry_size: usize,
+
     /// The maximal number of entries in the storage cache.
     #[arg(long, default_value = "1000")]
-    pub cache_size: usize,
+    pub max_cache_entries: usize,
 
     /// Subcommand.
     #[command(subcommand)]
@@ -189,10 +197,15 @@ impl ClientOptions {
     }
 
     fn common_config(&self) -> CommonStoreConfig {
+        let storage_cache_config = StorageCacheConfig {
+            max_cache_size: self.max_cache_size,
+            max_entry_size: self.max_entry_size,
+            max_cache_entries: self.max_cache_entries,
+        };
         CommonStoreConfig {
             max_concurrent_queries: self.max_concurrent_queries,
             max_stream_queries: self.max_stream_queries,
-            cache_size: self.cache_size,
+            storage_cache_config,
         }
     }
 

linera-client/src/storage.rs

@@ -453,7 +453,7 @@ impl StorageConfigNamespace {
                 };
                 let config = ServiceStoreConfig {
                     inner_config,
-                    cache_size: common_config.cache_size,
+                    storage_cache_config: common_config.storage_cache_config,
                 };
                 Ok(StoreConfig::Service(config, namespace))
             }

linera-indexer/lib/src/rocks_db.rs

@@ -5,6 +5,7 @@ use std::path::PathBuf;
 
 use clap::Parser as _;
 use linera_views::{
+    lru_caching::StorageCacheConfig,
     rocks_db::{PathWithGuard, RocksDbSpawnMode, RocksDbStore, RocksDbStoreConfig},
     store::{AdminKeyValueStore, CommonStoreConfig},
 };
@@ -20,28 +21,45 @@ pub struct RocksDbConfig {
     /// RocksDB storage path
     #[arg(long, default_value = "./indexer.db")]
     pub storage: PathBuf,
+
     #[arg(long, default_value = "linera")]
     pub namespace: String,
+
     /// The maximal number of simultaneous queries to the database
     #[arg(long)]
     max_concurrent_queries: Option<usize>,
+
     /// The maximal number of simultaneous stream queries to the database
     #[arg(long, default_value = "10")]
     pub max_stream_queries: usize,
+
+    /// The maximal memory used in the storage cache.
+    #[arg(long, default_value = "10000000")]
+    pub max_cache_size: usize,
+
+    /// The maximal size of an entry in the storage cache.
+    #[arg(long, default_value = "1000000")]
+    pub max_entry_size: usize,
+
     /// The maximal number of entries in the storage cache.
     #[arg(long, default_value = "1000")]
-    cache_size: usize,
+    pub max_cache_entries: usize,
 }
 
 pub type RocksDbRunner = Runner<RocksDbStore, RocksDbConfig>;
 
 impl RocksDbRunner {
     pub async fn load() -> Result<Self, IndexerError> {
         let config = IndexerConfig::<RocksDbConfig>::parse();
+        let storage_cache_config = StorageCacheConfig {
+            max_cache_size: config.client.max_cache_size,
+            max_entry_size: config.client.max_entry_size,
+            max_cache_entries: config.client.max_cache_entries,
+        };
         let common_config = CommonStoreConfig {
             max_concurrent_queries: config.client.max_concurrent_queries,
             max_stream_queries: config.client.max_stream_queries,
-            cache_size: config.client.cache_size,
+            storage_cache_config,
         };
         let path_buf = config.client.storage.as_path().to_path_buf();
         let path_with_guard = PathWithGuard::new(path_buf);

linera-indexer/lib/src/scylla_db.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use linera_views::{
+    lru_caching::StorageCacheConfig,
     scylla_db::{ScyllaDbStore, ScyllaDbStoreConfig},
     store::{AdminKeyValueStore, CommonStoreConfig},
 };
@@ -17,28 +18,45 @@ pub struct ScyllaDbConfig {
     /// ScyllaDB address
     #[arg(long, default_value = "localhost:9042")]
     pub uri: String,
+
     #[arg(long, default_value = "linera")]
     pub table: String,
+
     /// The maximal number of simultaneous queries to the database
     #[arg(long)]
     max_concurrent_queries: Option<usize>,
+
     /// The maximal number of simultaneous stream queries to the database
     #[arg(long, default_value = "10")]
     pub max_stream_queries: usize,
+
+    /// The maximal memory used in the storage cache.
+    #[arg(long, default_value = "10000000")]
+    pub max_cache_size: usize,
+
+    /// The maximal size of an entry in the storage cache.
+    #[arg(long, default_value = "1000000")]
+    pub max_entry_size: usize,
+
     /// The maximal number of entries in the storage cache.
     #[arg(long, default_value = "1000")]
-    cache_size: usize,
+    pub max_cache_entries: usize,
 }
 
 pub type ScyllaDbRunner = Runner<ScyllaDbStore, ScyllaDbConfig>;
 
 impl ScyllaDbRunner {
     pub async fn load() -> Result<Self, IndexerError> {
         let config = <IndexerConfig<ScyllaDbConfig> as clap::Parser>::parse();
+        let storage_cache_config = StorageCacheConfig {
+            max_cache_size: config.client.max_cache_size,
+            max_entry_size: config.client.max_entry_size,
+            max_cache_entries: config.client.max_cache_entries,
+        };
         let common_config = CommonStoreConfig {
             max_concurrent_queries: config.client.max_concurrent_queries,
             max_stream_queries: config.client.max_stream_queries,
-            cache_size: config.client.cache_size,
+            storage_cache_config,
         };
         let namespace = config.client.table.clone();
         let store_config = ScyllaDbStoreConfig::new(config.client.uri.clone(), common_config);

linera-service/src/proxy/main.rs

@@ -27,7 +27,7 @@ use linera_service::util;
 #[cfg(with_metrics)]
 use linera_service::{prometheus_server, pyroscope_server};
 use linera_storage::Storage;
-use linera_views::store::CommonStoreConfig;
+use linera_views::{lru_caching::StorageCacheConfig, store::CommonStoreConfig};
 use tokio::task::JoinSet;
 use tokio_util::sync::CancellationToken;
 use tracing::{error, info, instrument};
@@ -70,9 +70,17 @@ pub struct ProxyOptions {
     #[arg(long, default_value = "10")]
     max_stream_queries: usize,
 
+    /// The maximal memory used in the storage cache.
+    #[arg(long, default_value = "10000000")]
+    pub max_cache_size: usize,
+
+    /// The maximal size of an entry in the storage cache.
+    #[arg(long, default_value = "1000000")]
+    pub max_entry_size: usize,
+
     /// The maximal number of entries in the storage cache.
     #[arg(long, default_value = "1000")]
-    cache_size: usize,
+    pub max_cache_entries: usize,
 
     /// Path to the file describing the initial user chains (aka genesis state)
     #[arg(long = "genesis")]
@@ -395,10 +403,15 @@ fn main() -> Result<()> {
 
 impl ProxyOptions {
     async fn run(&self) -> Result<()> {
+        let storage_cache_config = StorageCacheConfig {
+            max_cache_size: self.max_cache_size,
+            max_entry_size: self.max_entry_size,
+            max_cache_entries: self.max_cache_entries,
+        };
         let common_config = CommonStoreConfig {
             max_concurrent_queries: self.max_concurrent_queries,
             max_stream_queries: self.max_stream_queries,
-            cache_size: self.cache_size,
+            storage_cache_config,
         };
         let full_storage_config = self.storage_config.add_common_config(common_config).await?;
         let genesis_config: GenesisConfig = util::read_json(&self.genesis_config_path)?;

linera-service/src/server.rs

@@ -37,7 +37,7 @@ use linera_service::util;
 #[cfg(with_metrics)]
 use linera_service::{prometheus_server, pyroscope_server};
 use linera_storage::Storage;
-use linera_views::store::CommonStoreConfig;
+use linera_views::{lru_caching::StorageCacheConfig, store::CommonStoreConfig};
 use serde::Deserialize;
 use tokio::task::JoinSet;
 use tokio_util::sync::CancellationToken;
@@ -414,9 +414,17 @@ enum ServerCommand {
         #[arg(long, default_value = "10")]
         max_stream_queries: usize,
 
+        /// The maximal memory used in the storage cache.
+        #[arg(long, default_value = "10000000")]
+        max_cache_size: usize,
+
+        /// The maximal size of an entry in the storage cache.
+        #[arg(long, default_value = "1000000")]
+        max_entry_size: usize,
+
         /// The maximal number of entries in the storage cache.
         #[arg(long, default_value = "1000")]
-        cache_size: usize,
+        max_cache_entries: usize,
     },
 
     /// Act as a trusted third-party and generate all server configurations
@@ -455,9 +463,17 @@ enum ServerCommand {
         #[arg(long, default_value = "10")]
         max_stream_queries: usize,
 
+        /// The maximal memory used in the storage cache.
+        #[arg(long, default_value = "10000000")]
+        max_cache_size: usize,
+
+        /// The maximal size of an entry in the storage cache.
+        #[arg(long, default_value = "1000000")]
+        max_entry_size: usize,
+
         /// The maximal number of entries in the storage cache.
         #[arg(long, default_value = "1000")]
-        cache_size: usize,
+        max_cache_entries: usize,
     },
 
     /// Replaces the configurations of the shards by following the given template.
@@ -567,7 +583,9 @@ async fn run(options: ServerOptions) {
             max_loaded_chains,
             max_concurrent_queries,
             max_stream_queries,
-            cache_size,
+            max_cache_size,
+            max_entry_size,
+            max_cache_entries,
         } => {
             linera_version::VERSION_INFO.log();
 
@@ -585,10 +603,15 @@ async fn run(options: ServerOptions) {
                 max_loaded_chains,
             };
             let wasm_runtime = wasm_runtime.with_wasm_default();
+            let storage_cache_config = StorageCacheConfig {
+                max_cache_size,
+                max_entry_size,
+                max_cache_entries,
+            };
             let common_config = CommonStoreConfig {
                 max_concurrent_queries,
                 max_stream_queries,
-                cache_size,
+                storage_cache_config,
             };
             let full_storage_config = storage_config
                 .add_common_config(common_config)
@@ -647,14 +670,21 @@ async fn run(options: ServerOptions) {
             genesis_config_path,
             max_concurrent_queries,
             max_stream_queries,
-            cache_size,
+            max_cache_size,
+            max_entry_size,
+            max_cache_entries,
         } => {
             let genesis_config: GenesisConfig =
                 util::read_json(&genesis_config_path).expect("Failed to read initial chain config");
+            let storage_cache_config = StorageCacheConfig {
+                max_cache_size,
+                max_entry_size,
+                max_cache_entries,
+            };
             let common_config = CommonStoreConfig {
                 max_concurrent_queries,
                 max_stream_queries,
-                cache_size,
+                storage_cache_config,
             };
             let full_storage_config = storage_config
                 .add_common_config(common_config)

linera-views/src/backends/dynamo_db.rs

@@ -1199,7 +1199,7 @@ impl DynamoDbStoreConfig {
         };
         DynamoDbStoreConfig {
             inner_config,
-            cache_size: common_config.cache_size,
+            storage_cache_config: common_config.storage_cache_config,
         }
     }
 }

linera-views/src/backends/indexed_db.rs

@@ -13,6 +13,7 @@ use thiserror::Error;
 use crate::{
     batch::{Batch, WriteOperation},
     common::get_upper_bound_option,
+    lru_caching::DEFAULT_STORAGE_CACHE_CONFIG,
     store::{
         CommonStoreConfig, KeyValueStoreError, LocalAdminKeyValueStore, LocalReadableKeyValueStore,
         LocalWritableKeyValueStore, WithError,
@@ -27,12 +28,12 @@ pub struct IndexedDbStoreConfig {
 }
 
 impl IndexedDbStoreConfig {
-    /// Creates a `IndexedDbStoreConfig`. `max_concurrent_queries` and `cache_size` are not used.
+    /// Creates a `IndexedDbStoreConfig`. `max_concurrent_queries` and `storage_cache_config` are not used.
     pub fn new(max_stream_queries: usize) -> Self {
         let common_config = CommonStoreConfig {
             max_concurrent_queries: None,
             max_stream_queries,
-            cache_size: 1000,
+            storage_cache_config: DEFAULT_STORAGE_CACHE_CONFIG,
         };
         Self { common_config }
     }