trim chain

Author: roberto-bayardo

storage/src/qmdb/benches/chained_growth.rs

@@ -6,27 +6,40 @@
 //! Timed: do `batches` more merkleize + apply iterations on top of the pre-built chain, with a
 //! single random update per batch so each overlay covers a tiny fraction of chunks.
 
-use crate::common::{dispatch_arm, make_fixed_value, Digest};
+use crate::common::{make_fixed_value, Digest, WRITE_BUFFER_SIZE};
 use commonware_cryptography::{Hasher, Sha256};
 use commonware_runtime::{
     benchmarks::{context, tokio},
+    buffer::paged::CacheRef,
     tokio::{Config, Context},
+    BufferPooler, ThreadPooler,
 };
 use commonware_storage::{
-    merkle::{self, mmb::Family as Mmb},
+    journal::contiguous::fixed::Config as FConfig,
+    merkle::{self, journaled, mmb::Family as Mmb},
     qmdb::{
         any::traits::{DbAny, MerkleizedBatch as _, UnmerkleizedBatch as _},
         current::{ordered::fixed::Db as OCFixed, unordered::fixed::Db as UCFixed},
     },
     translator::EightCap,
 };
+use commonware_utils::{NZUsize, NZU16, NZU64};
 use criterion::{criterion_group, Criterion};
 use rand::{rngs::StdRng, RngCore, SeedableRng};
 use std::{
     hint::black_box,
+    num::{NonZeroU16, NonZeroU64, NonZeroUsize},
     time::{Duration, Instant},
 };
 
+// -- Config (mirrors merkleize bench) --
+
+const ITEMS_PER_BLOB: NonZeroU64 = NZU64!(10_000_000);
+const THREADS: NonZeroUsize = NZUsize!(8);
+const PAGE_SIZE: NonZeroU16 = NZU16!(4096);
+const LARGE_PAGE_CACHE_SIZE: NonZeroUsize = NZUsize!(131_072);
+const PARTITION: &str = "bench-chained-growth";
+
 const SMALL_CHUNK_SIZE: usize = 32;
 const LARGE_CHUNK_SIZE: usize = 256;
 
@@ -35,6 +48,42 @@ type CurOFix32Mmb = OCFixed<Mmb, Context, Digest, Digest, Sha256, EightCap, SMAL
 type CurUFix256Mmb = UCFixed<Mmb, Context, Digest, Digest, Sha256, EightCap, LARGE_CHUNK_SIZE>;
 type CurOFix256Mmb = OCFixed<Mmb, Context, Digest, Digest, Sha256, EightCap, LARGE_CHUNK_SIZE>;
 
+fn merkle_cfg(ctx: &(impl BufferPooler + ThreadPooler), pc: CacheRef) -> journaled::Config {
+    journaled::Config {
+        journal_partition: format!("journal-{PARTITION}"),
+        metadata_partition: format!("metadata-{PARTITION}"),
+        items_per_blob: ITEMS_PER_BLOB,
+        write_buffer: WRITE_BUFFER_SIZE,
+        thread_pool: Some(ctx.create_thread_pool(THREADS).unwrap()),
+        page_cache: pc,
+    }
+}
+
+fn fix_log_cfg(pc: CacheRef) -> FConfig {
+    FConfig {
+        partition: format!("log-journal-{PARTITION}"),
+        items_per_blob: ITEMS_PER_BLOB,
+        page_cache: pc,
+        write_buffer: WRITE_BUFFER_SIZE,
+    }
+}
+
+fn pc(ctx: &impl BufferPooler) -> CacheRef {
+    CacheRef::from_pooler(ctx, PAGE_SIZE, LARGE_PAGE_CACHE_SIZE)
+}
+
+fn cur_fix_cfg(
+    ctx: &(impl BufferPooler + ThreadPooler),
+) -> commonware_storage::qmdb::current::FixedConfig<EightCap> {
+    let pc = pc(ctx);
+    commonware_storage::qmdb::current::FixedConfig {
+        merkle_config: merkle_cfg(ctx, pc.clone()),
+        journal_config: fix_log_cfg(pc),
+        grafted_metadata_partition: format!("grafted-metadata-{PARTITION}"),
+        translator: EightCap,
+    }
+}
+
 /// Number of pre-populated keys in the seeded database.
 const NUM_KEYS: u64 = 1_000_000;
 
@@ -78,19 +127,20 @@ const CURRENT_VARIANTS: [CurrentVariant; 4] = [
 /// Construct a Current database for `$variant`, bind it as `$db`, and execute `$body`.
 macro_rules! with_current_db {
     ($ctx:expr, $variant:expr, |mut $db:ident| $body:expr) => {{
+        macro_rules! init_db {
+            ($DbType:ty) => {{
+                #[allow(unused_mut)]
+                let mut $db = <$DbType>::init($ctx.clone(), cur_fix_cfg(&$ctx))
+                    .await
+                    .unwrap();
+                $body
+            }};
+        }
         match $variant {
-            CurrentVariant::UnorderedFixed32 => {
-                dispatch_arm!($ctx, $db, $body, CurUFix32Mmb, cur_fix_cfg)
-            }
-            CurrentVariant::OrderedFixed32 => {
-                dispatch_arm!($ctx, $db, $body, CurOFix32Mmb, cur_fix_cfg)
-            }
-            CurrentVariant::UnorderedFixed256 => {
-                dispatch_arm!($ctx, $db, $body, CurUFix256Mmb, cur_fix_cfg)
-            }
-            CurrentVariant::OrderedFixed256 => {
-                dispatch_arm!($ctx, $db, $body, CurOFix256Mmb, cur_fix_cfg)
-            }
+            CurrentVariant::UnorderedFixed32 => init_db!(CurUFix32Mmb),
+            CurrentVariant::OrderedFixed32 => init_db!(CurOFix32Mmb),
+            CurrentVariant::UnorderedFixed256 => init_db!(CurUFix256Mmb),
+            CurrentVariant::OrderedFixed256 => init_db!(CurOFix256Mmb),
         }
     }};
 }

storage/src/qmdb/current/batch.rs

@@ -767,6 +767,78 @@ pub(crate) struct BitmapBatchLayer<const N: usize> {
 
 impl<const N: usize> BitmapBatch<N> {
     const CHUNK_SIZE_BITS: u64 = BitMap::<N>::CHUNK_SIZE_BITS;
+
+    /// Walk to the terminal [`SharedBitmap`] at the bottom of the chain.
+    fn shared(&self) -> &Arc<SharedBitmap<N>> {
+        let mut current = self;
+        loop {
+            match current {
+                Self::Base(s) => return s,
+                Self::Layer(layer) => current = &layer.parent,
+            }
+        }
+    }
+
+    /// Return a chain equivalent to `self` with any `Layer` whose overlay is now fully committed
+    /// replaced by a direct reference to the committed bitmap. Since `apply_batch` commits
+    /// contiguous prefixes, committed `Layer`s are always at the bottom of the chain.
+    fn trim_committed(&self) -> Self {
+        // Fast path: if already Base, nothing to do
+        if let Self::Base(_) = self {
+            return self.clone();
+        }
+
+        let shared = self.shared();
+        let committed = shared.read().len();
+
+        let mut current = self;
+        let mut uncommitted = 0;
+        while let Self::Layer(layer) = current {
+            if layer.overlay.len <= committed {
+                break;
+            }
+            uncommitted += 1;
+            current = &layer.parent;
+        }
+
+        // Top layer is already committed
+        if uncommitted == 0 {
+            return Self::Base(Arc::clone(shared));
+        }
+
+        // No layer is committed; keep the whole chain
+        if let Self::Base(_) = current {
+            return self.clone();
+        }
+
+        // Fast path for exactly 1 uncommitted layer (common in chained growth)
+        if uncommitted == 1 {
+            if let Self::Layer(layer) = self {
+                return Self::Layer(Arc::new(BitmapBatchLayer {
+                    parent: Self::Base(Arc::clone(shared)),
+                    overlay: Arc::clone(&layer.overlay),
+                }));
+            }
+        }
+
+        let mut kept = Vec::with_capacity(uncommitted);
+        current = self;
+        for _ in 0..uncommitted {
+            if let Self::Layer(layer) = current {
+                kept.push(Arc::clone(&layer.overlay));
+                current = &layer.parent;
+            }
+        }
+
+        let mut result = Self::Base(Arc::clone(shared));
+        for overlay in kept.into_iter().rev() {
+            result = Self::Layer(Arc::new(BitmapBatchLayer {
+                parent: result,
+                overlay,
+            }));
+        }
+        result
+    }
 }
 
 impl<const N: usize> BitmapReadable<N> for BitmapBatch<N> {
@@ -861,7 +933,7 @@ where
         UnmerkleizedBatch::new(
             self.inner.new_batch::<H>(),
             Arc::clone(&self.grafted),
-            self.bitmap.clone(),
+            self.bitmap.trim_committed(),
         )
     }
 

storage/src/qmdb/current/db.rs

@@ -668,9 +668,11 @@ where
         // 6. Apply overlays in place under the write lock.
         {
             let mut guard = self.status.write();
+            if let Some(newest) = overlays.first() {
+                guard.extend_to(newest.len);
+            }
+            let pruned = guard.pruned_chunks();
             for overlay in overlays.into_iter().rev() {
-                guard.extend_to(overlay.len);
-                let pruned = guard.pruned_chunks();
                 for (&idx, chunk) in &overlay.chunks {
                     if idx >= pruned {
                         guard.set_chunk_by_index(idx, chunk);