Skip to content

Commit

Permalink
accounts-db: Sampled LRU eviction
Browse files Browse the repository at this point in the history 
Instead of rigid LRU eviction, perform sampled LRU eviction.

Sampled LRU eviction takes K random keys and picks the one with the
lowest update timestamp. This way, even though the evicted element is
not always the oldest in the whole cache, removes the necessity of
maintaining a queue and reduces the contention caused by locking the
queue.

The K parameter is configurable, but the best performing value so far
was 16 and it's used as the default one.

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.

To address that, add a new benchmark group which measures time spent on
concurrent writes and reads on a full cache (where each write causes
eviction). To reduce the noise coming from other parts of accounts-db,
use only the cache in that benchmark.

The result of that benchmark with the old rigid LRU evction mechamism,
for 128 read and write threads, is:

```
cache_eviction/cache_eviction/128
                        time:   [20.737 s 20.936 s 21.138 s]
```

With sampled LRU eviction (K=16), it improves to:

```
cache_eviction/cache_eviction_k_16/128
                        time:   [7.6609 s 7.7177 s 7.7847 s]
```
  • Loading branch information
@vadorovsky
vadorovsky committed Dec 10, 2024
1 parent 3c2150c commit afbf23f
Show file tree
Hide file tree
Showing 3 changed files with 261 additions and 195 deletions.
189 changes: 98 additions & 91 deletions accounts-db/benches/bench_read_only_accounts_cache.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,6 +25,7 @@ const NUM_READERS_WRITERS: &[usize] = &[
// 32 cores.
// 32, 64, 128
];
const EVICT_SAMPLE_SIZES: &[usize] = &[1, 2, 4, 8, 10, 16, 32];

/// Benchmarks the read-only cache eviction mechanism. It does so by performing
/// multithreaded reads and writes on a full cache. Each write triggers
Expand All @@ -37,106 +38,112 @@ fn bench_cache_eviction(c: &mut Criterion) {

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,
));
for evict_sample_size in EVICT_SAMPLE_SIZES {
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,
*evict_sample_size,
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 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);

// 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);
// Fill up the cache.
let slot = 0;
for (pubkey, account) in storable_accounts {
cache.store(*pubkey, slot, account);
}

// 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));
// 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(),
)
})
.unwrap()
});
.take(NUM_NEW_ACCOUNTS_PER_THREAD);

// 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);
// 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(
format!("cache_eviction_k_{evict_sample_size}"),
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()
});
})
.unwrap()
});

for writer_handle in writer_handles {
writer_handle.join().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();
stop_reader.store(true, Ordering::Relaxed);
for reader_handle in reader_handles {
reader_handle.join().unwrap();
}
}
}
}
Expand Down
9 changes: 9 additions & 0 deletions accounts-db/src/accounts_db.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -499,6 +499,7 @@ pub const ACCOUNTS_DB_CONFIG_FOR_TESTING: AccountsDbConfig = AccountsDbConfig {
shrink_paths: None,
shrink_ratio: DEFAULT_ACCOUNTS_SHRINK_THRESHOLD_OPTION,
read_cache_limit_bytes: None,
read_cache_evict_sample_size: None,
write_cache_limit_bytes: None,
ancient_append_vec_offset: None,
ancient_storage_ideal_size: None,
Expand All @@ -525,6 +526,7 @@ pub const ACCOUNTS_DB_CONFIG_FOR_BENCHMARKS: AccountsDbConfig = AccountsDbConfig
shrink_paths: None,
shrink_ratio: DEFAULT_ACCOUNTS_SHRINK_THRESHOLD_OPTION,
read_cache_limit_bytes: None,
read_cache_evict_sample_size: None,
write_cache_limit_bytes: None,
ancient_append_vec_offset: None,
ancient_storage_ideal_size: None,
Expand Down Expand Up @@ -649,6 +651,7 @@ pub struct AccountsDbConfig {
/// The low and high watermark sizes for the read cache, in bytes.
/// If None, defaults will be used.
pub read_cache_limit_bytes: Option<(usize, usize)>,
pub read_cache_evict_sample_size: Option<usize>,
pub write_cache_limit_bytes: Option<u64>,
/// if None, ancient append vecs are set to ANCIENT_APPEND_VEC_DEFAULT_OFFSET
/// Some(offset) means include slots up to (max_slot - (slots_per_epoch - 'offset'))
Expand Down Expand Up @@ -1896,6 +1899,8 @@ impl AccountsDb {
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;

const DEFAULT_READ_ONLY_CACHE_EVICT_SAMPLE_SIZE: usize = 16;

pub fn default_for_tests() -> Self {
Self::new_single_for_tests()
}
Expand Down Expand Up @@ -1977,6 +1982,9 @@ impl AccountsDb {
Self::DEFAULT_MAX_READ_ONLY_CACHE_DATA_SIZE_LO,
Self::DEFAULT_MAX_READ_ONLY_CACHE_DATA_SIZE_HI,
));
let read_cache_evict_sample_size = accounts_db_config
.read_cache_evict_sample_size
.unwrap_or(Self::DEFAULT_READ_ONLY_CACHE_EVICT_SAMPLE_SIZE);

// Increase the stack for foreground threads
// rayon needs a lot of stack
Expand Down Expand Up @@ -2032,6 +2040,7 @@ impl AccountsDb {
read_only_accounts_cache: ReadOnlyAccountsCache::new(
read_cache_size.0,
read_cache_size.1,
read_cache_evict_sample_size,
Self::READ_ONLY_CACHE_MS_TO_SKIP_LRU_UPDATE,
),
write_cache_limit_bytes: accounts_db_config.write_cache_limit_bytes,
Expand Down
Loading

0 comments on commit afbf23f

Please sign in to comment.