Rename Compact types (#610)

firewood/benches/hashops.rs

@@ -8,7 +8,7 @@ use firewood::{
     db::{BatchOp, DbConfig},
     merkle::{Bincode, Merkle, TrieHash, TRIE_HASH_LEN},
     shale::{
-        compact::{CompactHeader, CompactSpace},
+        compact::{ChunkHeader, Store},
         disk_address::DiskAddress,
         in_mem::InMemLinearStore,
         LinearStore, ObjCache, Storable, StoredView,
@@ -96,14 +96,14 @@ fn bench_merkle<const N: usize>(criterion: &mut Criterion) {
 
                     #[allow(clippy::unwrap_used)]
                     let merkle_payload_header_ref = StoredView::ptr_to_obj(
-                        &InMemLinearStore::new(2 * CompactHeader::SERIALIZED_LEN, 9),
+                        &InMemLinearStore::new(2 * ChunkHeader::SERIALIZED_LEN, 9),
                         merkle_payload_header,
-                        CompactHeader::SERIALIZED_LEN,
+                        ChunkHeader::SERIALIZED_LEN,
                     )
                     .unwrap();
 
                     #[allow(clippy::unwrap_used)]
-                    let store = CompactSpace::new(
+                    let store = Store::new(
                         InMemLinearStore::new(TEST_MEM_SIZE, 0),
                         InMemLinearStore::new(TEST_MEM_SIZE, 1),
                         merkle_payload_header_ref,

firewood/benches/shale-bench.rs

@@ -5,7 +5,7 @@ use criterion::{
     black_box, criterion_group, criterion_main, profiler::Profiler, Bencher, Criterion,
 };
 use firewood::shale::{
-    compact::{CompactHeader, CompactSpaceHeader},
+    compact::{ChunkHeader, StoreHeader},
     disk_address::DiskAddress,
     in_mem::InMemLinearStore,
     LinearStore, Obj, StoredView,
@@ -81,8 +81,8 @@ fn get_view<C: LinearStore>(b: &mut Bencher, mut cached: C) {
 fn serialize<T: LinearStore>(m: &T) {
     let compact_header_obj: DiskAddress = DiskAddress::from(0x0);
     #[allow(clippy::unwrap_used)]
-    let _: Obj<CompactSpaceHeader> =
-        StoredView::ptr_to_obj(m, compact_header_obj, CompactHeader::SERIALIZED_LEN).unwrap();
+    let _: Obj<StoreHeader> =
+        StoredView::ptr_to_obj(m, compact_header_obj, ChunkHeader::SERIALIZED_LEN).unwrap();
 }
 
 fn bench_cursors(c: &mut Criterion) {

firewood/src/db.rs

@@ -22,7 +22,7 @@ use crate::{
 use crate::{
     merkle,
     shale::{
-        self, compact::CompactSpaceHeader, disk_address::DiskAddress, LinearStore, Obj, ShaleError,
+        self, compact::StoreHeader, disk_address::DiskAddress, LinearStore, Obj, ShaleError,
         SpaceId, Storable, StoredView,
     },
 };
@@ -118,7 +118,7 @@ struct DbParams {
 }
 
 #[derive(Clone, Debug)]
-/// Necessary linear space instances bundled for a `CompactSpace`.
+/// Necessary linear space instances bundled for a `Store`.
 struct SubUniverse<T> {
     meta: T,
     payload: T,
@@ -616,7 +616,7 @@ impl Db {
         let meta: StoreRevMut = base.merkle.meta.clone().into();
         let payload: StoreRevMut = base.merkle.payload.clone().into();
 
-        // get references to the DbHeader and the CompactSpaceHeader
+        // get references to the DbHeader and the StoreHeader
         // for free space management
         let db_header_ref = Db::get_db_header_ref(&meta)?;
         let merkle_payload_header_ref =
@@ -656,7 +656,7 @@ impl Db {
         // The header consists of three parts:
         // DbParams
         // DbHeader (just a pointer to the sentinel)
-        // CompactSpaceHeader for future allocations
+        // StoreHeader for future allocations
         let (params, hdr, csh);
         let header_bytes: Vec<u8> = {
             params = DbParams {
@@ -677,10 +677,10 @@ impl Db {
             bytemuck::bytes_of(&hdr)
         })
         .chain({
-            // write out the CompactSpaceHeader
+            // write out the StoreHeader
             let space_reserved =
                 NonZeroUsize::new(SPACE_RESERVED as usize).expect("SPACE_RESERVED is non-zero");
-            csh = CompactSpaceHeader::new(space_reserved, space_reserved);
+            csh = StoreHeader::new(space_reserved, space_reserved);
             bytemuck::bytes_of(&csh)
         })
         .copied()
@@ -700,7 +700,7 @@ impl Db {
         let db_header: DiskAddress = DiskAddress::from(offset);
         offset += DbHeader::MSIZE as usize;
         let merkle_payload_header: DiskAddress = DiskAddress::from(offset);
-        offset += CompactSpaceHeader::SERIALIZED_LEN as usize;
+        offset += StoreHeader::SERIALIZED_LEN as usize;
         assert!(offset <= SPACE_RESERVED as usize);
 
         let mut merkle_meta_store = StoreRevMut::new(cached_space.merkle.meta.clone());
@@ -710,7 +710,7 @@ impl Db {
             #[allow(clippy::unwrap_used)]
             merkle_meta_store.write(
                 merkle_payload_header.into(),
-                &shale::to_dehydrated(&shale::compact::CompactSpaceHeader::new(
+                &shale::to_dehydrated(&shale::compact::StoreHeader::new(
                     NonZeroUsize::new(SPACE_RESERVED as usize).unwrap(),
                     #[allow(clippy::unwrap_used)]
                     NonZeroUsize::new(SPACE_RESERVED as usize).unwrap(),
@@ -752,12 +752,12 @@ impl Db {
     fn get_payload_header_ref<K: LinearStore>(
         meta_ref: &K,
         header_offset: u64,
-    ) -> Result<Obj<CompactSpaceHeader>, DbError> {
+    ) -> Result<Obj<StoreHeader>, DbError> {
         let payload_header = DiskAddress::from(header_offset as usize);
         StoredView::ptr_to_obj(
             meta_ref,
             payload_header,
-            shale::compact::CompactHeader::SERIALIZED_LEN,
+            shale::compact::ChunkHeader::SERIALIZED_LEN,
         )
         .map_err(Into::into)
     }
@@ -768,7 +768,7 @@ impl Db {
     }
 
     fn new_revision<K: LinearStore, T: Into<K>>(
-        header_refs: (Obj<DbHeader>, Obj<CompactSpaceHeader>),
+        header_refs: (Obj<DbHeader>, Obj<StoreHeader>),
         merkle: (T, T),
         payload_regn_nbit: u64,
         payload_max_walk: u64,
@@ -777,7 +777,7 @@ impl Db {
         // TODO: This should be a compile time check
         const DB_OFFSET: u64 = Db::PARAM_SIZE;
         let merkle_offset = DB_OFFSET + DbHeader::MSIZE;
-        assert!(merkle_offset + CompactSpaceHeader::SERIALIZED_LEN <= SPACE_RESERVED);
+        assert!(merkle_offset + StoreHeader::SERIALIZED_LEN <= SPACE_RESERVED);
 
         let mut db_header_ref = header_refs.0;
         let merkle_payload_header_ref = header_refs.1;
@@ -786,7 +786,7 @@ impl Db {
         let merkle_payload = merkle.1.into();
 
         #[allow(clippy::unwrap_used)]
-        let merkle_space = shale::compact::CompactSpace::new(
+        let merkle_space = shale::compact::Store::new(
             merkle_meta,
             merkle_payload,
             merkle_payload_header_ref,

firewood/src/merkle.rs

@@ -1,7 +1,7 @@
 // Copyright (C) 2023, Ava Labs, Inc. All rights reserved.
 // See the file LICENSE.md for licensing terms.
 use crate::nibbles::Nibbles;
-use crate::shale::compact::CompactSpace;
+use crate::shale::compact::Store;
 use crate::shale::LinearStore;
 use crate::shale::{self, disk_address::DiskAddress, ObjWriteSizeError, ShaleError};
 use crate::storage::{StoreRevMut, StoreRevShared};
@@ -67,7 +67,7 @@ macro_rules! write_node {
 
 #[derive(Debug)]
 pub struct Merkle<S, T> {
-    store: CompactSpace<Node, S>,
+    store: Store<Node, S>,
     phantom: PhantomData<T>,
 }
 
@@ -101,7 +101,7 @@ where
     T: BinarySerde,
     EncodedNode<T>: serde::Serialize + serde::Deserialize<'de>,
 {
-    pub const fn new(store: CompactSpace<Node, S>) -> Self {
+    pub const fn new(store: Store<Node, S>) -> Self {
         Self {
             store,
             phantom: PhantomData,
@@ -1417,7 +1417,7 @@ mod tests {
         let compact_header = DiskAddress::null();
         dm.write(
             compact_header.into(),
-            &shale::to_dehydrated(&shale::compact::CompactSpaceHeader::new(
+            &shale::to_dehydrated(&shale::compact::StoreHeader::new(
                 std::num::NonZeroUsize::new(RESERVED).unwrap(),
                 std::num::NonZeroUsize::new(RESERVED).unwrap(),
             ))
@@ -1427,16 +1427,16 @@ mod tests {
         let compact_header = shale::StoredView::ptr_to_obj(
             &dm,
             compact_header,
-            shale::compact::CompactHeader::SERIALIZED_LEN,
+            shale::compact::ChunkHeader::SERIALIZED_LEN,
         )
         .unwrap();
         let mem_meta = dm;
         let mem_payload = InMemLinearStore::new(0x10000, 0x1);
 
         let cache = shale::ObjCache::new(1);
         let space =
-            shale::compact::CompactSpace::new(mem_meta, mem_payload, compact_header, cache, 10, 16)
-                .expect("CompactSpace init fail");
+            shale::compact::Store::new(mem_meta, mem_payload, compact_header, cache, 10, 16)
+                .expect("Store init fail");
 
         Merkle::new(space)
     }

firewood/src/merkle/node.rs

@@ -4,7 +4,7 @@
 use crate::{
     logger::trace,
     merkle::nibbles_to_bytes_iter,
-    shale::{compact::CompactSpace, disk_address::DiskAddress, LinearStore, ShaleError, Storable},
+    shale::{compact::Store, disk_address::DiskAddress, LinearStore, ShaleError, Storable},
 };
 use bincode::{Error, Options};
 use bitflags::bitflags;
@@ -81,7 +81,7 @@ impl NodeType {
         }
     }
 
-    pub fn encode<S: LinearStore>(&self, store: &CompactSpace<Node, S>) -> Vec<u8> {
+    pub fn encode<S: LinearStore>(&self, store: &Store<Node, S>) -> Vec<u8> {
         match &self {
             NodeType::Leaf(n) => n.encode(),
             NodeType::Branch(n) => n.encode(store),
@@ -201,21 +201,18 @@ impl Node {
         })
     }
 
-    pub(super) fn get_encoded<S: LinearStore>(&self, store: &CompactSpace<Node, S>) -> &[u8] {
+    pub(super) fn get_encoded<S: LinearStore>(&self, store: &Store<Node, S>) -> &[u8] {
         self.encoded.get_or_init(|| self.inner.encode(store))
     }
 
-    pub(super) fn get_root_hash<S: LinearStore>(&self, store: &CompactSpace<Node, S>) -> &TrieHash {
+    pub(super) fn get_root_hash<S: LinearStore>(&self, store: &Store<Node, S>) -> &TrieHash {
         self.root_hash.get_or_init(|| {
             self.set_dirty(true);
             TrieHash(Keccak256::digest(self.get_encoded(store)).into())
         })
     }
 
-    fn is_encoded_longer_than_hash_len<S: LinearStore>(
-        &self,
-        store: &CompactSpace<Node, S>,
-    ) -> bool {
+    fn is_encoded_longer_than_hash_len<S: LinearStore>(&self, store: &Store<Node, S>) -> bool {
         *self
             .is_encoded_longer_than_hash_len
             .get_or_init(|| self.get_encoded(store).len() >= TRIE_HASH_LEN)

firewood/src/merkle/node/branch.rs

@@ -5,7 +5,7 @@ use super::Node;
 use crate::{
     merkle::{nibbles_to_bytes_iter, to_nibble_array, Path},
     nibbles::Nibbles,
-    shale::{compact::CompactSpace, DiskAddress, LinearStore, ShaleError, Storable},
+    shale::{compact::Store, DiskAddress, LinearStore, ShaleError, Storable},
 };
 use bincode::{Error, Options};
 use serde::de::Error as DeError;
@@ -111,7 +111,7 @@ impl BranchNode {
         })
     }
 
-    pub(super) fn encode<S: LinearStore>(&self, store: &CompactSpace<Node, S>) -> Vec<u8> {
+    pub(super) fn encode<S: LinearStore>(&self, store: &Store<Node, S>) -> Vec<u8> {
         // path + children + value
         let mut list = <[Vec<u8>; Self::MSIZE]>::default();
 

firewood/src/merkle_util.rs

@@ -52,7 +52,7 @@ where
         #[allow(clippy::unwrap_used)]
         dm.write(
             compact_header.into(),
-            &shale::to_dehydrated(&shale::compact::CompactSpaceHeader::new(
+            &shale::to_dehydrated(&shale::compact::StoreHeader::new(
                 NonZeroUsize::new(RESERVED).unwrap(),
                 #[allow(clippy::unwrap_used)]
                 NonZeroUsize::new(RESERVED).unwrap(),
@@ -64,16 +64,16 @@ where
         let compact_header = StoredView::ptr_to_obj(
             &dm,
             compact_header,
-            shale::compact::CompactHeader::SERIALIZED_LEN,
+            shale::compact::ChunkHeader::SERIALIZED_LEN,
         )
         .unwrap();
         let mem_meta = dm;
         let mem_payload = InMemLinearStore::new(compact_size, 0x1);
 
         let cache = shale::ObjCache::new(1);
         let space =
-            shale::compact::CompactSpace::new(mem_meta, mem_payload, compact_header, cache, 10, 16)
-                .expect("CompactSpace init fail");
+            shale::compact::Store::new(mem_meta, mem_payload, compact_header, cache, 10, 16)
+                .expect("Store init fail");
 
         let merkle = Merkle::new(space);
         #[allow(clippy::unwrap_used)]