From 024f6deea7d6a76e05f3122cead2205b5d32ba2f Mon Sep 17 00:00:00 2001 From: Andrew Morris Date: Thu, 26 Oct 2023 19:03:23 +1100 Subject: [PATCH] Rename things and test cleanup in array_0_1 --- storage/src/memory_backend.rs | 4 +- storage/src/sled_backend.rs | 4 +- storage/src/storage.rs | 74 ++++++++++++++++++----------------- storage/src/tests.rs | 31 ++++++++++----- 4 files changed, 65 insertions(+), 48 deletions(-) diff --git a/storage/src/memory_backend.rs b/storage/src/memory_backend.rs index 13c77d7..0c3f6c6 100644 --- a/storage/src/memory_backend.rs +++ b/storage/src/memory_backend.rs @@ -37,11 +37,11 @@ pub struct MemoryStorageHandle<'a> { } impl<'a, E> StorageBackendHandle<'a, E> for MemoryStorageHandle<'a> { - fn read(&self, key: StoragePtr) -> Result>, E> { + fn read_bytes(&self, key: StoragePtr) -> Result>, E> { Ok(self.storage.data.get(&key.data).cloned()) } - fn write(&mut self, key: StoragePtr, data: Option>) -> Result<(), E> { + fn write_bytes(&mut self, key: StoragePtr, data: Option>) -> Result<(), E> { match data { Some(data) => self.storage.data.insert(key.data, data), None => self.storage.data.remove(&key.data), diff --git a/storage/src/sled_backend.rs b/storage/src/sled_backend.rs index ff67b10..89b5ba6 100644 --- a/storage/src/sled_backend.rs +++ b/storage/src/sled_backend.rs @@ -49,7 +49,7 @@ pub struct SledBackendHandle<'a> { impl<'a, E> StorageBackendHandle<'a, sled::transaction::ConflictableTransactionError> for SledBackendHandle<'a> { - fn read( + fn read_bytes( &self, key: StoragePtr, ) -> Result>, sled::transaction::ConflictableTransactionError> { @@ -57,7 +57,7 @@ impl<'a, E> StorageBackendHandle<'a, sled::transaction::ConflictableTransactionE Ok(value) } - fn write( + fn write_bytes( &mut self, key: StoragePtr, data: Option>, diff --git a/storage/src/storage.rs b/storage/src/storage.rs index e6b8f5c..8e98d40 100644 --- a/storage/src/storage.rs +++ b/storage/src/storage.rs @@ -11,13 +11,13 @@ pub struct Storage { } pub trait StorageBackendHandle<'a, E> { - fn read(&self, key: StoragePtr) -> Result>, E>; - fn write(&mut self, key: StoragePtr, data: Option>) -> Result<(), E>; + fn read_bytes(&self, key: StoragePtr) -> Result>, E>; + fn write_bytes(&mut self, key: StoragePtr, data: Option>) -> Result<(), E>; } pub trait StorageOps { - fn read_t Deserialize<'de>>(&mut self, key: StoragePtr) -> Result, E>; - fn write_t(&mut self, key: StoragePtr, data: Option<&T>) -> Result<(), E>; + fn read Deserialize<'de>>(&mut self, key: StoragePtr) -> Result, E>; + fn write(&mut self, key: StoragePtr, data: Option<&T>) -> Result<(), E>; fn inc_ref(&mut self, key: StorageEntryPtr) -> Result<(), E>; fn dec_ref(&mut self, key: StorageEntryPtr) -> Result<(), E>; @@ -30,8 +30,8 @@ impl<'a, Handle, E> StorageOps for Handle where Handle: StorageBackendHandle<'a, E>, { - fn read_t Deserialize<'de>>(&mut self, key: StoragePtr) -> Result, E> { - let data = match self.read(key)? { + fn read Deserialize<'de>>(&mut self, key: StoragePtr) -> Result, E> { + let data = match self.read_bytes(key)? { Some(data) => data, None => return Ok(None), }; @@ -39,23 +39,23 @@ where Ok(Some(bincode::deserialize(&data).unwrap())) } - fn write_t(&mut self, key: StoragePtr, data: Option<&T>) -> Result<(), E> { - self.write(key, data.map(|data| bincode::serialize(&data).unwrap())) + fn write(&mut self, key: StoragePtr, data: Option<&T>) -> Result<(), E> { + self.write_bytes(key, data.map(|data| bincode::serialize(&data).unwrap())) } fn inc_ref(&mut self, key: StorageEntryPtr) -> Result<(), E> { - let mut entry = match self.read_t(key)? { + let mut entry = match self.read(key)? { Some(entry) => entry, None => panic!("Key does not exist"), }; entry.ref_count += 1; - self.write_t(key, Some(&entry)) + self.write(key, Some(&entry)) } fn dec_ref(&mut self, key: StorageEntryPtr) -> Result<(), E> { - let mut entry = match self.read_t(key)? { + let mut entry = match self.read(key)? { Some(entry) => entry, None => panic!("Key does not exist"), }; @@ -67,19 +67,19 @@ where self.dec_ref(*key)?; } - self.write(key, None) + self.write_bytes(key, None) } else { - self.write_t(key, Some(&entry)) + self.write(key, Some(&entry)) } } fn get_head(&mut self, ptr: StorageHeadPtr) -> Result, E> { - let key = match self.read_t(ptr)? { + let key = match self.read(ptr)? { Some(key) => key, None => return Ok(None), }; - let data = match self.read(key)? { + let data = match self.read_bytes(key)? { Some(data) => data, None => panic!("Head points to non-existent key"), }; @@ -94,7 +94,7 @@ where fn set_head(&mut self, ptr: StorageHeadPtr, value: Option<&StorageVal>) -> Result<(), E> { if let Some(value) = value { let key = StoragePtr::random(&mut thread_rng()); - self.write(key, Some(bincode::serialize(&value.serialize()).unwrap()))?; + self.write_bytes(key, Some(bincode::serialize(&value.serialize()).unwrap()))?; { // TODO: Performance: Identify overlapping keys and cancel out the inc+dec @@ -103,18 +103,18 @@ where self.inc_ref(*subkey)?; } - if let Some(old_key) = self.read_t(ptr)? { + if let Some(old_key) = self.read(ptr)? { self.dec_ref(old_key)?; } } - self.write_t(ptr, Some(&key)) + self.write(ptr, Some(&key)) } else { - if let Some(old_key) = self.read_t(ptr)? { + if let Some(old_key) = self.read(ptr)? { self.dec_ref(old_key)?; } - self.write_t(ptr, None) + self.write(ptr, None) } } } @@ -148,34 +148,29 @@ impl Storage { pub fn store_tmp(&mut self, value: &StorageVal) -> Result> { self.sb.transaction(|sb| { - let key = StoragePtr::random(&mut thread_rng()); - sb.write(key, Some(bincode::serialize(value).unwrap()))?; - - let tmp_count = sb.read_t(tmp_count_ptr())?.unwrap_or(0); - - sb.write(tmp_at_ptr(tmp_count), Some(key.to_bytes()))?; + let tmp_count = sb.read(tmp_count_ptr())?.unwrap_or(0); + let tmp_ptr = tmp_at_ptr(tmp_count); + sb.set_head(tmp_ptr, Some(value))?; - sb.write( + sb.write_bytes( tmp_count_ptr(), Some(bincode::serialize(&(tmp_count + 1)).unwrap()), )?; + let key = sb + .read(tmp_ptr)? + .unwrap_or_else(|| panic!("Missing tmp key")); + Ok(key) }) } pub fn clear_tmp(&mut self) -> Result<(), SB::Error<()>> { self.sb.transaction(|sb| { - let tmp_count = sb.read_t(tmp_count_ptr())?.unwrap_or(0); + let tmp_count = sb.read(tmp_count_ptr())?.unwrap_or(0); for i in 0..tmp_count { - let tmp_key = tmp_at_ptr(i); - - let entry_ptr = sb - .read_t(tmp_key)? - .unwrap_or_else(|| panic!("Missing tmp key")); - - sb.dec_ref(entry_ptr)?; + sb.set_head(tmp_at_ptr(i), None)?; } sb.write(tmp_count_ptr(), None)?; @@ -183,6 +178,15 @@ impl Storage { Ok(()) }) } + + pub(crate) fn get_ref_count( + &mut self, + key: StorageEntryPtr, + ) -> Result, SB::Error<()>> { + self + .sb + .transaction(|sb| Ok(sb.read(key)?.map(|entry| entry.ref_count))) + } } #[derive(Serialize, Deserialize)] diff --git a/storage/src/tests.rs b/storage/src/tests.rs index 1582cbc..8c879b4 100644 --- a/storage/src/tests.rs +++ b/storage/src/tests.rs @@ -58,15 +58,28 @@ mod tests_ { }) .unwrap(); - // storage - // .set_head( - // b"test", - // Some(&StorageVal { - // point: StoragePoint::Array(Rc::new(vec![StoragePoint::Ref(0), StoragePoint::Ref(1)])), - // refs: Rc::new(vec![key0, key1]), - // }), - // ) - // .unwrap(); + storage + .set_head( + storage_head_ptr(b"test"), + Some(&StorageVal { + point: StoragePoint::Array(Rc::new(vec![StoragePoint::Ref(0), StoragePoint::Ref(1)])), + refs: Rc::new(vec![key0, key1]), + }), + ) + .unwrap(); + + assert_eq!(storage.get_ref_count(key0).unwrap(), Some(2)); + assert_eq!(storage.get_ref_count(key1).unwrap(), Some(2)); + + storage.clear_tmp().unwrap(); + + assert_eq!(storage.get_ref_count(key0).unwrap(), Some(1)); + assert_eq!(storage.get_ref_count(key1).unwrap(), Some(1)); + + storage.set_head(storage_head_ptr(b"test"), None).unwrap(); + + assert_eq!(storage.get_ref_count(key0).unwrap(), None); + assert_eq!(storage.get_ref_count(key1).unwrap(), None); } run(impl_, impl_);