From 87efc267f17619b201303fbde9224622af68177d Mon Sep 17 00:00:00 2001 From: bunnie Date: Fri, 17 Jun 2022 02:01:30 +0800 Subject: [PATCH] add PDDB backpressure items (#109 partial) --- services/pddb/src/backend/basis.rs | 100 +++++++++++++++++++++++- services/pddb/src/backend/dictionary.rs | 59 +++++++++++--- services/pddb/src/backend/key.rs | 17 ++++ 3 files changed, 166 insertions(+), 10 deletions(-) diff --git a/services/pddb/src/backend/basis.rs b/services/pddb/src/backend/basis.rs index 3a1571b5a..72b986fa8 100644 --- a/services/pddb/src/backend/basis.rs +++ b/services/pddb/src/backend/basis.rs @@ -144,6 +144,7 @@ use std::iter::IntoIterator; use std::collections::{BinaryHeap, HashMap, HashSet}; use std::io::{Result, Error, ErrorKind}; use std::cmp::Reverse; +use std::cmp::Ordering; use core::num::NonZeroU32; pub(crate) const SMALL_POOL_START: u64 = 0x0000_003F_8000_0000; @@ -245,10 +246,15 @@ impl DerefMut for BasisRoot { pub(crate) struct BasisCache { /// the cache entries themselves cache: Vec::, + /// ticktimer reference, for managing atimes + pub(crate) tt: ticktimer_server::Ticktimer, } impl BasisCache { pub(crate) fn new() -> Self { - BasisCache { cache: Vec::new() } + BasisCache { + cache: Vec::new(), + tt: ticktimer_server::Ticktimer::new().unwrap(), + } } fn select_basis(&mut self, basis_name: Option<&str>) -> Option { if self.cache.len() == 0 { @@ -314,6 +320,7 @@ impl BasisCache { small_pool: Vec::::new(), small_pool_free: BinaryHeap::::new(), aad: my_aad, + tt: ticktimer_server::Ticktimer::new().unwrap(), }; log::debug!("adding dictionary {}", name); basis.dicts.insert(String::from(name), dict_cache); @@ -418,6 +425,7 @@ impl BasisCache { if let Some(dict_entry) = basis.dicts.get_mut(dict) { if dict_entry.ensure_key_entry(hw, &mut basis.v2p_map, &basis.cipher, key) { let kcache = dict_entry.keys.get_mut(key).expect("Entry was assured, but then not there!"); + kcache.set_atime(self.tt.elapsed_ms()); // the key exists, *and* there's sufficient space for the data if kcache.start < SMALL_POOL_END { // small pool fetch @@ -964,7 +972,97 @@ impl BasisCache { self.basis_unmount(hw, &basis).ok(); } } + + /// returns a relative measure of cache size. It is not absolutely accurate as + /// overhead is not accounted for, but the actual data cached is relatively correct. + pub(crate) fn cache_size(&mut self) -> usize { + let mut total_size = 0; + for basis in self.cache.iter() { + for dict in basis.dicts.values() { + for key in dict.keys.values() { + total_size += key.size(); + } + } + } + total_size + } + /// attempts to prune `target_bytes` out of the cached data set + pub(crate) fn cache_prune(&mut self, hw: &mut PddbOs, target_bytes: usize) -> usize { + let mut pruned = 0; + // this does it a "dumb" way, but at least it's sort of obvious how it works + // 0. sync the basis and dictionaries to disk, so that removing cache entries are guaranteed not to be problematic. + // 1. iterate through all the known keys, creating a sorted heap of fully-specified keys (basis/dict/key) + // sorted by access time + // 2. evict keys with the oldest access time, until target_bytes is hit. + self.sync(hw, None).unwrap(); + + let mut candidates = BinaryHeap::new(); + for basis in self.cache.iter() { + for (dict_name, dict) in basis.dicts.iter() { + for (key_name, key) in dict.keys.iter() { + candidates.push(Reverse( + KeyAge { + atime: key.atime(), + _size: key.size(), + key: key_name.to_string(), + dict: dict_name.to_string(), + basis: basis.name.to_string(), + } + )); + } + } + } + + loop { + if let Some(Reverse(ka)) = candidates.pop() { + for basis in self.cache.iter_mut() { + if basis.name == ka.basis { + match basis.dicts.get_mut(&ka.dict) { + Some(dentry) => { + let freed = dentry.evict_keycache_entry(&ka.key); + log::debug!("pruned {} bytes from atime {} / total {}", freed, ka.atime, pruned); + pruned += freed; + if pruned >= target_bytes { + return pruned; + } + } + _ => {} + } + } + } + } else { + break; + } + } + pruned + } } +// Revise this to use references instead of allocations once we've refactored the interior mutability +// issues with the PDDB. +struct KeyAge { + atime: u64, + // currently unused but collected in case we want to use it in the future + _size: usize, + key: String, + dict: String, + basis: String, +} +impl Ord for KeyAge { + fn cmp(&self, other: &Self) -> Ordering { + self.atime.cmp(&other.atime) + } +} +impl PartialOrd for KeyAge { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} +impl PartialEq for KeyAge { + fn eq(&self, other: &Self) -> bool { + self.atime == other.atime + } +} +impl Eq for KeyAge {} /// This is the RAM cached copy of a basis as maintained in the PDDB. pub(crate) struct BasisCacheEntry { diff --git a/services/pddb/src/backend/dictionary.rs b/services/pddb/src/backend/dictionary.rs index 5996da44a..b234dbeb8 100644 --- a/services/pddb/src/backend/dictionary.rs +++ b/services/pddb/src/backend/dictionary.rs @@ -59,6 +59,8 @@ pub(crate) struct DictCacheEntry { pub(crate) small_pool_free: BinaryHeap, /// copy of our AAD, for convenience pub(crate) aad: Vec::, + /// ticktimer reference, for managing atimes + pub(crate) tt: ticktimer_server::Ticktimer, } impl DictCacheEntry { pub fn new(dict: Dictionary, index: usize, aad: &Vec) -> DictCacheEntry { @@ -80,6 +82,7 @@ impl DictCacheEntry { small_pool: Vec::::new(), small_pool_free: BinaryHeap::::new(), aad: my_aad, + tt: ticktimer_server::Ticktimer::new().unwrap(), } } /// Populates cache entries, reporting the maximum extent of large alloc data seen so far. @@ -157,6 +160,7 @@ impl DictCacheEntry { descriptor_index: NonZeroU32::new(try_entry as u32).unwrap(), clean: true, data: None, + atime: self.tt.elapsed_ms(), }; let kname = std::str::from_utf8(&keydesc.name.data[..keydesc.name.len as usize]).expect("key is not valid utf-8"); let key_exists_and_valid = @@ -259,6 +263,7 @@ impl DictCacheEntry { descriptor_index: NonZeroU32::new(try_entry as u32).unwrap(), clean: true, data: None, + atime: self.tt.elapsed_ms(), }; self.keys.insert(kname.to_string(), kcache); self.try_fill_small_key(hw, v2p_map, cipher, &mut data_cache, &kname); @@ -297,13 +302,25 @@ impl DictCacheEntry { } let ksp = &mut self.small_pool[pool_index]; if !ksp.clean { - ksp.contents.push(key_name.to_string()); - assert!(kcache.reserved >= kcache.len, "Reserved amount is less than length, this is an error!"); - assert!(kcache.reserved <= VPAGE_SIZE as u64, "Reserved amount is not appropriate for the small pool. Logic error in prior PDDB operation!"); - log::trace!("avail: {} reserved: {}", ksp.avail, kcache.reserved); - assert!((ksp.avail as u64) >= kcache.reserved, "Total amount allocated to a small pool chunk is incorrect; suspect logic error in prior PDDB operation!"); - ksp.avail -= kcache.reserved as u16; - // note: small_pool_free is updated only after all the entries have been read in + if !ksp.contents.contains(&key_name.to_string()) { + log::trace!("creating ksp entry for {}", key_name); + ksp.contents.push(key_name.to_string()); + assert!(kcache.reserved >= kcache.len, "Reserved amount is less than length, this is an error!"); + assert!(kcache.reserved <= VPAGE_SIZE as u64, "Reserved amount is not appropriate for the small pool. Logic error in prior PDDB operation!"); + log::trace!("avail: {} reserved: {}", ksp.avail, kcache.reserved); + assert!((ksp.avail as u64) >= kcache.reserved, "Total amount allocated to a small pool chunk is incorrect; suspect logic error in prior PDDB operation!"); + ksp.avail -= kcache.reserved as u16; + // note: small_pool_free is updated only after all the entries have been read in + } else { + // if the entry was previously created, don't update the metadata. + // This might not be the best place for this note, but, as a reminder to myself, + // the small pool code is written assuming you scan through all the keys and fill it + // into RAM at least once. Once you've done that, you can evict cached data to free up some + // space, but it's sort of dumb that you have to do that in the first place. This is going to + // lead to a crisis once the small pool data exceeds the available RAM -- which isn't too far from now. + // This will be tracked in issue #109. + log::trace!("refilling data only for {}", key_name); + } // now grab the *data* referred to by this key. Maybe this is a "bad" idea -- this can really eat up RAM fast to hold // all the small pool data right away, but let's give it a try and see how it works. Later on we can always skip this. @@ -357,6 +374,7 @@ impl DictCacheEntry { self.clean = false; if self.ensure_key_entry(hw, v2p_map, cipher, name) { let kcache = self.keys.get_mut(name).expect("Entry was assured, but then not there!"); + kcache.set_atime(self.tt.elapsed_ms()); kcache.clean = false; // the update isn't going to fit in the reserved space, remove it, and re-insert it with an entirely new entry. if kcache.reserved < (data.len() + offset) as u64 { @@ -620,7 +638,8 @@ impl DictCacheEntry { data: Some(KeyCacheData::Small(KeySmallData{ clean: false, data: alloc_data - })) + })), + atime: self.tt.elapsed_ms(), }; self.keys.insert(name.to_string(), kcache); self.key_count += 1; @@ -649,6 +668,7 @@ impl DictCacheEntry { descriptor_index, clean: false, data: None, // no caching implemented yet for large keys + atime: self.tt.elapsed_ms(), }; self.keys.insert(name.to_string(), kcache); self.key_count += 1; @@ -668,7 +688,7 @@ impl DictCacheEntry { Ok(large_alloc_ptr) } #[allow(dead_code)] - pub fn key_contains(&mut self, name: &str) -> bool { + pub fn key_contains(&self, name: &str) -> bool { self.keys.contains_key(&String::from(name)) } @@ -969,6 +989,27 @@ impl DictCacheEntry { basis: basis_name.to_string(), } } + + /// removes a key cache entry from a dictionary cache, returning the amount of space liberated with + /// the eviction. 0 means the key was either 0-sized, or it could not be evicted (possibly + /// because it was dirty; you need to call sync before evicting anything from the cache) + pub(crate) fn evict_keycache_entry(&mut self, key: &str) -> usize { + if let Some(kcache) = self.keys.get_mut(key) { + // if the cache entry is dirty, abort + if kcache.flags.valid() && !kcache.clean { + return 0; + } + if kcache.data.is_some() { + let pruned = kcache.size(); + kcache.data.take(); // this effectively frees up the key cache data + pruned + } else { + 0 + } + } else { + 0 + } + } } /// converts a dictionary index -- which is a 1-offset number of dictionaries -- plus a key diff --git a/services/pddb/src/backend/key.rs b/services/pddb/src/backend/key.rs index 2111ef4f2..d7951cb5a 100644 --- a/services/pddb/src/backend/key.rs +++ b/services/pddb/src/backend/key.rs @@ -97,6 +97,8 @@ pub(crate) struct KeyCacheEntry { pub(crate) reserved: u64, pub(crate) flags: KeyFlags, pub(crate) age: u32, + /// this is an ephemeral time since boot, not commited to disk, used only for deciding which entries to evict + pub(crate) atime: u64, /// the current on-disk index of the KeyCacheEntry item, enumerated as "0" being the Dict descriptor and /// "1" being the first valid key. This is used to find the location of the key's metadata as stored on disk; /// it has nothing to do with where the data itself is stored (that's derived from `start`). @@ -132,6 +134,21 @@ impl KeyCacheEntry { } vpages } + /// returns a rough measure of the amount of data consumed by a given entry. It's not meant to + /// be absolutely accurate, but it should give an accurate impression of the relative size of + /// different cache entries. This metric is used to help decide which entries to discard. + pub(crate) fn size(&self) -> usize { + let data_size = match &self.data { + None => 0, + Some(kcd) => match kcd { + KeyCacheData::Small(ksd) => ksd.data.len(), + KeyCacheData::Large(kld) => kld.data.len(), + } + }; + core::mem::size_of::() + data_size + } + pub(crate) fn atime(&self) -> u64 { self.atime } + pub(crate) fn set_atime(&mut self, atime: u64) { self.atime = atime; } } pub (crate) enum KeyCacheData {