PersistedSmtForest

Makefile

@@ -139,6 +139,11 @@ bench-large-smt-rocksdb: ## Run large SMT benchmarks with rocksdb storage
 bench-large-smt-rocksdb-open: ## Run large SMT benchmarks with rocksdb storage and open existing database
 	cargo run --release --features concurrent,hashmaps,rocksdb,executable -- --storage rocksdb --open
 
+.PHONY: bench-persisted-smt-forest
+bench-persisted-smt-forest: ## Run large SMT benchmarks with rocksdb storage
+	cargo run --release --features concurrent,hashmaps,rocksdb,executable -- --storage rocksdb --size 100000 --tree persisted-forest
+
+
 # --- fuzzing --------------------------------------------------------------------------------
 
 .PHONY: fuzz-smt

miden-crypto/Cargo.toml

@@ -41,6 +41,15 @@ harness           = false
 name              = "large-smt"
 required-features = ["rocksdb"]
 
+[[bench]]
+harness = false
+name    = "forest-smt"
+
+[[bench]]
+harness           = false
+name              = "persisted-forest-smt"
+required-features = ["rocksdb"]
+
 [[bench]]
 harness = false
 name    = "store"

miden-crypto/benches/forest-smt.rs

@@ -0,0 +1,66 @@
+use std::hint;
+
+use criterion::{Criterion, criterion_group, criterion_main};
+use miden_crypto::{
+    Word,
+    merkle::{EmptySubtreeRoots, SMT_DEPTH, SmtForest},
+};
+
+mod common;
+use common::{
+    config::{DEFAULT_MEASUREMENT_TIME, DEFAULT_SAMPLE_SIZE},
+    data::{generate_smt_entries_mixed, generate_smt_entries_sequential},
+};
+
+benchmark_with_setup_data! {
+    smt_forest_open,
+    DEFAULT_MEASUREMENT_TIME,
+    DEFAULT_SAMPLE_SIZE,
+    "forest-open",
+    || {
+        let base_entries = generate_smt_entries_sequential(256);
+        let mut forest = SmtForest::new();
+        let empty_root = *EmptySubtreeRoots::entry(SMT_DEPTH, 0);
+        let populated_root = forest.batch_insert(empty_root, base_entries.clone()).unwrap();
+        let keys: Vec<Word> = base_entries.iter().map(|(key, _)| *key).collect();
+
+        (forest, populated_root, keys)
+    },
+    |b: &mut criterion::Bencher, (forest, root, keys): &(SmtForest, Word, Vec<Word>)| {
+        b.iter(|| {
+            for key in keys {
+                let _ = hint::black_box(forest.open(*root, *key));
+            }
+        })
+    },
+}
+
+benchmark_batch! {
+    smt_forest_batch_insert,
+    &[1, 16, 256, 1_024],
+    |b: &mut criterion::Bencher, entry_count: usize| {
+        use criterion::BatchSize;
+
+        let mut base_forest = SmtForest::new();
+        let base_entries = generate_smt_entries_sequential(256);
+        let empty_root = *EmptySubtreeRoots::entry(SMT_DEPTH, 0);
+        let base_root = base_forest.batch_insert(empty_root, base_entries.clone()).unwrap();
+
+        b.iter_batched(
+            || {
+                let forest = base_forest.clone();
+                let entries = generate_smt_entries_mixed(entry_count);
+                (forest, base_root, entries)
+            },
+            |(mut forest, root, entries)| {
+                hint::black_box(forest.batch_insert(root, entries.clone()).unwrap());
+            },
+            BatchSize::LargeInput,
+        );
+    },
+    |size| Some(criterion::Throughput::Elements(size as u64))
+}
+
+criterion_group!(smt_forest_benches, smt_forest_open, smt_forest_batch_insert,);
+
+criterion_main!(smt_forest_benches);

miden-crypto/benches/persisted-forest-smt.rs

@@ -0,0 +1,103 @@
+#![cfg(all(feature = "rocksdb", feature = "std"))]
+
+use std::hint;
+
+use criterion::{BatchSize, Criterion, criterion_group, criterion_main};
+use miden_crypto::{
+    Word,
+    merkle::{EmptySubtreeRoots, PersistedSmtForest, RocksDbForestConfig, SMT_DEPTH},
+};
+use tempfile::TempDir;
+
+mod common;
+use common::{
+    config::{DEFAULT_MEASUREMENT_TIME, DEFAULT_SAMPLE_SIZE},
+    data::{generate_smt_entries_mixed, generate_smt_entries_sequential},
+};
+
+struct PersistedForestOpenContext {
+    temp_dir: TempDir,
+    forest: PersistedSmtForest,
+    root: Word,
+    keys: Vec<Word>,
+}
+
+struct PersistedForestBatchContext {
+    temp_dir: TempDir,
+    forest: PersistedSmtForest,
+    base_root: Word,
+    entries: Vec<(Word, Word)>,
+}
+
+benchmark_with_setup_data! {
+    persisted_smt_forest_open,
+    DEFAULT_MEASUREMENT_TIME,
+    DEFAULT_SAMPLE_SIZE,
+    "persisted-forest-open",
+    || {
+        let temp_dir = tempfile::tempdir().expect("tempdir");
+        let config = RocksDbForestConfig::new(temp_dir.path());
+        let mut forest = PersistedSmtForest::new(config).expect("create persisted forest");
+
+        let base_entries = generate_smt_entries_sequential(256);
+        let empty_root = *EmptySubtreeRoots::entry(SMT_DEPTH, 0);
+        let populated_root = forest.batch_insert(empty_root, base_entries.clone()).unwrap();
+        let keys = base_entries.iter().map(|(key, _)| *key).collect();
+
+        PersistedForestOpenContext {
+            temp_dir,
+            forest,
+            root: populated_root,
+            keys,
+        }
+    },
+    |b: &mut criterion::Bencher, ctx: &PersistedForestOpenContext| {
+        b.iter(|| {
+            for key in &ctx.keys {
+                let _ = hint::black_box(ctx.forest.open(ctx.root, *key));
+            }
+        })
+    },
+}
+
+benchmark_batch! {
+    persisted_smt_forest_batch_insert,
+    &[1, 16, 256, 1_024],
+    |b: &mut criterion::Bencher, entry_count: usize| {
+        b.iter_batched(
+            || {
+                let temp_dir = tempfile::tempdir().expect("tempdir");
+                let config = RocksDbForestConfig::new(temp_dir.path());
+                let mut forest = PersistedSmtForest::new(config).expect("create persisted forest");
+
+                let base_entries = generate_smt_entries_sequential(256);
+                let empty_root = *EmptySubtreeRoots::entry(SMT_DEPTH, 0);
+                let base_root = forest.batch_insert(empty_root, base_entries.clone()).unwrap();
+                let entries = generate_smt_entries_mixed(entry_count);
+
+                PersistedForestBatchContext {
+                    temp_dir,
+                    forest,
+                    base_root,
+                    entries,
+                }
+            },
+            |ctx: PersistedForestBatchContext| {
+                let PersistedForestBatchContext { mut forest, base_root, entries, temp_dir } = ctx;
+                hint::black_box(forest.batch_insert(base_root, entries).unwrap());
+                drop(forest);
+                drop(temp_dir);
+            },
+            BatchSize::LargeInput,
+        );
+    },
+    |size| Some(criterion::Throughput::Elements(size as u64))
+}
+
+criterion_group!(
+    persisted_smt_forest_benches,
+    persisted_smt_forest_open,
+    persisted_smt_forest_batch_insert,
+);
+
+criterion_main!(persisted_smt_forest_benches);