mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-16 08:38:26 +00:00
more refactoring
This commit is contained in:
parent
00339b0c5f
commit
e4e5e6c390
3 changed files with 36 additions and 46 deletions
|
|
@ -417,12 +417,6 @@ impl BasisCache {
|
|||
if let Some(dict_entry) = basis.dicts.get(dict) {
|
||||
// see if we need to make a kcache entry
|
||||
if let Some(kcache) = dict_entry.keys.get(key) {
|
||||
if kcache.descriptor_index.is_none() {
|
||||
// index hasn't been allocated yet, if we don't have extra space in an already allocated page, we'll need a new one
|
||||
if (DK_PER_VPAGE - dict_entry.key_count as usize % DK_PER_VPAGE) == 0 {
|
||||
pages_needed += 1;
|
||||
};
|
||||
}
|
||||
// now check for data reservations
|
||||
if reserved < SMALL_CAPACITY {
|
||||
// it's probably going in the small pool.
|
||||
|
|
@ -839,19 +833,6 @@ impl BasisCacheEntry {
|
|||
for (key_name, key) in dict.keys.iter_mut() {
|
||||
log::info!("merging in key {}", key_name);
|
||||
if !key.clean {
|
||||
// allocate a key index if one hasn't already been allocated
|
||||
if key.descriptor_index.is_none() {
|
||||
if let Some(new_index) = dict.get_free_key_index() {
|
||||
key.descriptor_index = Some(new_index);
|
||||
// if the new index is outside the currently known set, raise the search extent for the brute-force search
|
||||
if new_index.get() > dict.last_disk_key_index {
|
||||
dict.last_disk_key_index = new_index.get();
|
||||
}
|
||||
} else {
|
||||
log::error!("Dictionary {} ran out of key capacity during sync", name);
|
||||
return Err(Error::new(ErrorKind::OutOfMemory, "Dict ran out of key slots"));
|
||||
}
|
||||
}
|
||||
if key.descriptor_vaddr(dict_offset) >= cur_vpage &&
|
||||
key.descriptor_vaddr(dict_offset) < next_vpage {
|
||||
// key is within the current page, add it to the target list
|
||||
|
|
@ -871,12 +852,7 @@ impl BasisCacheEntry {
|
|||
for (&src, dst) in key_desc.deref().iter().zip(dk_entry.data.iter_mut()) {
|
||||
*dst = src;
|
||||
}
|
||||
if let Some(dk_index) = key.descriptor_index {
|
||||
dk_vpage.elements[dk_index.get() as usize % DK_PER_VPAGE] = Some(dk_entry);
|
||||
} else {
|
||||
log::error!("Dictionary {} ran out of key capacity during sync", name);
|
||||
return Err(Error::new(ErrorKind::OutOfMemory, "Dict ran out of key slots"));
|
||||
}
|
||||
dk_vpage.elements[key.descriptor_index.get() as usize % DK_PER_VPAGE] = Some(dk_entry);
|
||||
}
|
||||
key.clean = true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -209,7 +209,7 @@ impl DictCacheEntry {
|
|||
reserved: keydesc.reserved,
|
||||
flags: keydesc.flags,
|
||||
age: keydesc.age,
|
||||
descriptor_index: Some(NonZeroU32::new(try_entry as u32).unwrap()),
|
||||
descriptor_index: NonZeroU32::new(try_entry as u32).unwrap(),
|
||||
clean: true,
|
||||
data: None,
|
||||
};
|
||||
|
|
@ -280,7 +280,7 @@ impl DictCacheEntry {
|
|||
reserved: keydesc.reserved,
|
||||
flags: keydesc.flags,
|
||||
age: keydesc.age,
|
||||
descriptor_index: Some(NonZeroU32::new(try_entry as u32).unwrap()),
|
||||
descriptor_index: NonZeroU32::new(try_entry as u32).unwrap(),
|
||||
clean: true,
|
||||
data: None,
|
||||
};
|
||||
|
|
@ -503,13 +503,18 @@ impl DictCacheEntry {
|
|||
for &b in data {
|
||||
alloc_data.push(b);
|
||||
}
|
||||
let descriptor_index = if let Some(di) = self.get_free_key_index() {
|
||||
di
|
||||
} else {
|
||||
return Err(Error::new(ErrorKind::OutOfMemory, "Ran out of key indices in dictionary"));
|
||||
};
|
||||
let kcache = KeyCacheEntry {
|
||||
start: self.index as u64 * SMALL_POOL_START + SMALL_POOL_START,
|
||||
len: (data.len() + offset) as u64,
|
||||
reserved: reservation as u64,
|
||||
flags: kf,
|
||||
age: 0,
|
||||
descriptor_index: None,
|
||||
descriptor_index,
|
||||
clean: false,
|
||||
data: Some(KeyCacheData::Small(KeySmallData{
|
||||
clean: false,
|
||||
|
|
@ -529,13 +534,18 @@ impl DictCacheEntry {
|
|||
});
|
||||
let mut kf = KeyFlags(0);
|
||||
kf.set_valid(true);
|
||||
let descriptor_index = if let Some(di) = self.get_free_key_index() {
|
||||
di
|
||||
} else {
|
||||
return Err(Error::new(ErrorKind::OutOfMemory, "Ran out of key indices in dictionary"));
|
||||
};
|
||||
let kcache = KeyCacheEntry {
|
||||
start: large_alloc_ptr.as_u64(),
|
||||
len: (data.len() + offset) as u64,
|
||||
reserved: reservation.as_u64(),
|
||||
flags: kf,
|
||||
age: 0,
|
||||
descriptor_index: None,
|
||||
descriptor_index,
|
||||
clean: false,
|
||||
data: None, // no caching implemented yet for large keys
|
||||
};
|
||||
|
|
@ -571,6 +581,7 @@ impl DictCacheEntry {
|
|||
self.ensure_key_entry(hw, v2p_map, cipher, name_str);
|
||||
let name = String::from(name_str);
|
||||
let mut need_rebuild = false;
|
||||
let mut need_free_key: Option<u32> = None;
|
||||
if let Some(kcache) = self.keys.get_mut(&name) {
|
||||
if let Some(small_index) = small_storage_index_from_key(kcache, self.index) {
|
||||
// handle the small pool case
|
||||
|
|
@ -598,18 +609,17 @@ impl DictCacheEntry {
|
|||
}
|
||||
}
|
||||
}
|
||||
// free up the key index in the dictionary
|
||||
if let Some(index) = kcache.descriptor_index {
|
||||
self.put_free_key_index(index.get());
|
||||
} else {
|
||||
// this should be a rare case; later on we can change this warn to a debug, but print something as a bread crumb to future me...
|
||||
log::warn!("Key cache descriptor was none -- should only happen in the case of a key that was removed before it was synchronized to disk");
|
||||
}
|
||||
if need_rebuild {
|
||||
// no stable "retain" api, so we have to clear the heap and rebuild it https://github.com/rust-lang/rust/issues/71503
|
||||
self.rebuild_free_pool();
|
||||
}
|
||||
need_free_key = Some(kcache.descriptor_index.get());
|
||||
}
|
||||
// free up the key index in the dictionary, if necessary
|
||||
if let Some(key_to_free) = need_free_key {
|
||||
self.put_free_key_index(key_to_free);
|
||||
}
|
||||
if need_rebuild {
|
||||
// no stable "retain" api, so we have to clear the heap and rebuild it https://github.com/rust-lang/rust/issues/71503
|
||||
self.rebuild_free_pool();
|
||||
}
|
||||
|
||||
// we don't remove the cache entry, because it hasn't been synchronized to disk.
|
||||
// at this point:
|
||||
// - in-memory representation will return an entry, but with its valid flag set to false.
|
||||
|
|
@ -629,7 +639,7 @@ impl DictCacheEntry {
|
|||
if !ksp.clean {
|
||||
for keyname in &ksp.contents {
|
||||
let kce = self.keys.get(keyname).expect("data allocated but no index entry");
|
||||
if kce.descriptor_index.is_none() {
|
||||
if kce.flags.unresolved() {
|
||||
data_estimate += SMALL_CAPACITY - ksp.avail as usize;
|
||||
index_estimate += 1;
|
||||
}
|
||||
|
|
@ -704,7 +714,7 @@ impl DictCacheEntry {
|
|||
pub(crate) fn sync_large_pool(&self) {
|
||||
}
|
||||
|
||||
pub(crate) fn get_free_key_index(&self) -> Option<NonZeroU32> {
|
||||
pub(crate) fn get_free_key_index(&mut self) -> Option<NonZeroU32> {
|
||||
if let Some(free_key) = self.free_keys.borrow_mut().pop() {
|
||||
let index = free_key.start;
|
||||
if free_key.run > 0 {
|
||||
|
|
@ -715,6 +725,10 @@ impl DictCacheEntry {
|
|||
}
|
||||
)
|
||||
}
|
||||
if index > self.last_disk_key_index {
|
||||
// if the new index is outside the currently known set, raise the search extent for the brute-force search
|
||||
self.last_disk_key_index = index;
|
||||
}
|
||||
NonZeroU32::new(index as u32)
|
||||
} else {
|
||||
log::warn!("Ran out of dict index space");
|
||||
|
|
|
|||
|
|
@ -79,7 +79,7 @@ pub(crate) struct KeyCacheEntry {
|
|||
pub(crate) flags: KeyFlags,
|
||||
pub(crate) age: u32,
|
||||
/// the current on-disk index of the KeyCacheEntry item, enumerated as "0" being the Dict descriptor and "1" being the first valid key
|
||||
pub(crate) descriptor_index: Option<NonZeroU32>,
|
||||
pub(crate) descriptor_index: NonZeroU32,
|
||||
/// indicates if the descriptor cache entry is currently synchronized with what's on disk. Does not imply anything about the data,
|
||||
/// but if the `data` field is None then there is nothing to in cache to be dirtied.
|
||||
pub(crate) clean: bool,
|
||||
|
|
@ -90,15 +90,15 @@ pub(crate) struct KeyCacheEntry {
|
|||
impl KeyCacheEntry {
|
||||
/// Given a base offset of the dictionary containing the key, compute the starting VirtAddr of the key itself.
|
||||
pub(crate) fn descriptor_vaddr(&self, dict_offset: VirtAddr) -> VirtAddr {
|
||||
VirtAddr::new(dict_offset.get() + ((self.descriptor_index.unwrap().get() as u64) * DK_STRIDE as u64)).unwrap()
|
||||
VirtAddr::new(dict_offset.get() + ((self.descriptor_index.get() as u64) * DK_STRIDE as u64)).unwrap()
|
||||
}
|
||||
/// Computes the modular position of the KeyDescriptor within a vpage.
|
||||
pub(crate) fn descriptor_modulus(&self) -> usize {
|
||||
(self.descriptor_index.unwrap().get() as usize) % (VPAGE_SIZE / DK_STRIDE)
|
||||
(self.descriptor_index.get() as usize) % (VPAGE_SIZE / DK_STRIDE)
|
||||
}
|
||||
/// Computes the vpage offset as measured from the start of the dictionary storage region
|
||||
pub(crate) fn descriptor_vpage_num(&self) -> usize {
|
||||
(self.descriptor_index.unwrap().get() as usize) / (VPAGE_SIZE / DK_STRIDE)
|
||||
(self.descriptor_index.get() as usize) / (VPAGE_SIZE / DK_STRIDE)
|
||||
}
|
||||
/// returns the list of large-pool virtual pages belonging to this entry, if any.
|
||||
pub(crate) fn large_pool_vpages(&self) -> Vec::<VirtAddr> {
|
||||
|
|
|
|||
Loading…
Reference in a new issue