accounts-db: Benchmark cache evictions

The already existing `concurrent_{read,scan}_write` benchmarks are not
sufficient for benchmarking the eviction and evaluating what kind of
eviction policy performs the best, because they don't fill up the cache,
so eviction never happens.

Add a new benchmark, which starts measuring the concurrent reads and
writes on a full cache.

Author: vadorovsky

accounts-db/Cargo.toml

@@ -103,6 +103,10 @@ harness = false
 name = "bench_hashing"
 harness = false
 
+[[bench]]
+name = "bench_read_only_accounts_cache"
+harness = false
+
 [[bench]]
 name = "bench_serde"
 harness = false

accounts-db/benches/bench_read_only_accounts_cache.rs

@@ -0,0 +1,145 @@
+#![feature(test)]
+
+extern crate test;
+
+use {
+    criterion::{criterion_group, criterion_main, BenchmarkId, Criterion},
+    rand::{rngs::SmallRng, seq::SliceRandom, SeedableRng},
+    solana_accounts_db::{
+        accounts_db::AccountsDb, read_only_accounts_cache::ReadOnlyAccountsCache,
+    },
+    solana_sdk::account::{Account, ReadableAccount},
+    std::{
+        sync::{
+            atomic::{AtomicBool, Ordering},
+            Arc,
+        },
+        thread::Builder,
+    },
+};
+
+const NUM_READERS_WRITERS: &[usize] = &[
+    8,
+    16,
+    // These parameters are likely to freeze your computer, if it has less than
+    // 32 cores.
+    // 32, 64, 128
+];
+
+/// Benchmarks the read-only cache eviction mechanism. It does so by performing
+/// multithreaded reads and writes on a full cache. Each write triggers
+/// eviction. Background reads add more contention.
+fn bench_cache_eviction(c: &mut Criterion) {
+    /// Number of 1 MiB accounts needed to initially fill the cache.
+    const NUM_ACCOUNTS_INIT: usize = 410;
+    /// Number of accounts used in the benchmarked writes (per thread).
+    const NUM_NEW_ACCOUNTS_PER_THREAD: usize = 512;
+
+    let mut group = c.benchmark_group("cache_eviction");
+
+    for num_readers_writers in NUM_READERS_WRITERS {
+        let cache = Arc::new(ReadOnlyAccountsCache::new(
+            AccountsDb::DEFAULT_MAX_READ_ONLY_CACHE_DATA_SIZE_LO,
+            AccountsDb::DEFAULT_MAX_READ_ONLY_CACHE_DATA_SIZE_HI,
+            AccountsDb::READ_ONLY_CACHE_MS_TO_SKIP_LRU_UPDATE,
+        ));
+
+        // Prepare accounts for the cache fillup.
+        let pubkeys: Vec<_> = std::iter::repeat_with(solana_sdk::pubkey::new_rand)
+            .take(NUM_ACCOUNTS_INIT)
+            .collect();
+        let accounts_data = std::iter::repeat(
+            Account {
+                lamports: 1,
+                // 1 MiB
+                data: vec![1; 1024 * 1024],
+                ..Default::default()
+            }
+            .to_account_shared_data(),
+        )
+        .take(NUM_ACCOUNTS_INIT);
+        let storable_accounts = pubkeys.iter().zip(accounts_data);
+
+        // Fill up the cache.
+        let slot = 0;
+        for (pubkey, account) in storable_accounts {
+            cache.store(*pubkey, slot, account);
+        }
+
+        // Prepare accounts for the new writes.
+        let new_storable_accounts = std::iter::repeat_with(solana_sdk::pubkey::new_rand)
+            .map(|pubkey| {
+                (
+                    pubkey,
+                    Account {
+                        lamports: 1,
+                        // 1 MiB
+                        data: vec![1; 1024 * 1024],
+                        ..Default::default()
+                    }
+                    .to_account_shared_data(),
+                )
+            })
+            .take(NUM_NEW_ACCOUNTS_PER_THREAD);
+
+        // Spawn the reader threads in the background.
+        let stop_reader = Arc::new(AtomicBool::new(false));
+        let reader_handles = (0..*num_readers_writers).map(|i| {
+            let cache = cache.clone();
+            let pubkeys = pubkeys.clone();
+            let stop_reader = stop_reader.clone();
+            Builder::new()
+                .name(format!("reader{i:02}"))
+                .spawn({
+                    move || {
+                        // Continuously read random accounts.
+                        let mut rng = SmallRng::seed_from_u64(i as u64);
+                        while !stop_reader.load(Ordering::Relaxed) {
+                            let pubkey = pubkeys.choose(&mut rng).unwrap();
+                            test::black_box(cache.load(*pubkey, slot));
+                        }
+                    }
+                })
+                .unwrap()
+        });
+
+        // Benchmark reads and writes on a full cache, trigerring eviction on each
+        // write.
+        let slot = 1;
+        group.sample_size(10);
+        group.bench_function(
+            BenchmarkId::new("cache_eviction", num_readers_writers),
+            |b| {
+                b.iter(|| {
+                    // Perform the writes.
+                    let writer_handles = (0..*num_readers_writers).map(|i| {
+                        let cache = cache.clone();
+                        let new_storable_accounts = new_storable_accounts.clone();
+                        Builder::new()
+                            .name(format!("writer{i:02}"))
+                            .spawn({
+                                move || {
+                                    for (pubkey, account) in new_storable_accounts {
+                                        cache.store(pubkey, slot, account);
+                                    }
+                                }
+                            })
+                            .unwrap()
+                    });
+
+                    for writer_handle in writer_handles {
+                        writer_handle.join().unwrap();
+                    }
+                })
+            },
+        );
+
+        stop_reader.store(true, Ordering::Relaxed);
+        for reader_handle in reader_handles {
+            reader_handle.join().unwrap();
+        }
+    }
+}
+
+criterion_group!(benches, bench_cache_eviction);
+criterion_main!(benches);

accounts-db/src/accounts_db.rs

@@ -1889,12 +1889,12 @@ impl AccountsDb {
     pub const DEFAULT_ACCOUNTS_HASH_CACHE_DIR: &'static str = "accounts_hash_cache";
 
     // read only cache does not update lru on read of an entry unless it has been at least this many ms since the last lru update
-    const READ_ONLY_CACHE_MS_TO_SKIP_LRU_UPDATE: u32 = 100;
+    pub const READ_ONLY_CACHE_MS_TO_SKIP_LRU_UPDATE: u32 = 100;
 
     // The default high and low watermark sizes for the accounts read cache.
     // If the cache size exceeds MAX_SIZE_HI, it'll evict entries until the size is <= MAX_SIZE_LO.
-    const DEFAULT_MAX_READ_ONLY_CACHE_DATA_SIZE_LO: usize = 400 * 1024 * 1024;
-    const DEFAULT_MAX_READ_ONLY_CACHE_DATA_SIZE_HI: usize = 410 * 1024 * 1024;
+    pub const DEFAULT_MAX_READ_ONLY_CACHE_DATA_SIZE_LO: usize = 400 * 1024 * 1024;
+    pub const DEFAULT_MAX_READ_ONLY_CACHE_DATA_SIZE_HI: usize = 410 * 1024 * 1024;
 
     pub fn default_for_tests() -> Self {
         Self::new_single_for_tests()

accounts-db/src/lib.rs

@@ -32,7 +32,7 @@ mod file_io;
 pub mod hardened_unpack;
 pub mod partitioned_rewards;
 pub mod pubkey_bins;
-mod read_only_accounts_cache;
+pub mod read_only_accounts_cache;
 mod rolling_bit_field;
 pub mod secondary_index;
 pub mod shared_buffer_reader;

accounts-db/src/read_only_accounts_cache.rs

@@ -66,7 +66,7 @@ struct AtomicReadOnlyCacheStats {
 }
 
 #[derive(Debug)]
-pub(crate) struct ReadOnlyAccountsCache {
+pub struct ReadOnlyAccountsCache {
     cache: Arc<DashMap<ReadOnlyCacheKey, ReadOnlyAccountCacheEntry>>,
     /// When an item is first entered into the cache, it is added to the end of
     /// the queue. Also each time an entry is looked up from the cache it is
@@ -93,7 +93,7 @@ pub(crate) struct ReadOnlyAccountsCache {
 }
 
 impl ReadOnlyAccountsCache {
-    pub(crate) fn new(
+    pub fn new(
         max_data_size_lo: usize,
         max_data_size_hi: usize,
         ms_to_skip_lru_update: u32,
@@ -137,7 +137,7 @@ impl ReadOnlyAccountsCache {
         }
     }
 
-    pub(crate) fn load(&self, pubkey: Pubkey, slot: Slot) -> Option<AccountSharedData> {
+    pub fn load(&self, pubkey: Pubkey, slot: Slot) -> Option<AccountSharedData> {
         let (account, load_us) = measure_us!({
             let mut found = None;
             if let Some(entry) = self.cache.get(&pubkey) {
@@ -175,7 +175,7 @@ impl ReadOnlyAccountsCache {
         CACHE_ENTRY_SIZE + account.data().len()
     }
 
-    pub(crate) fn store(&self, pubkey: Pubkey, slot: Slot, account: AccountSharedData) {
+    pub fn store(&self, pubkey: Pubkey, slot: Slot, account: AccountSharedData) {
         let measure_store = Measure::start("");
         self.highest_slot_stored.fetch_max(slot, Ordering::Release);
         let account_size = Self::account_size(&account);