feat(dursto): benchmark ERC-20 transactions

kurtisc · kurtisc · commit 3720be8bbeed · 2025-12-15T17:25:41.000Z
diff --git a/durable-storage/Cargo.toml b/durable-storage/Cargo.toml
@@ -19,6 +19,7 @@ rocksdb.workspace = true
 tempfile.workspace = true
 thiserror.workspace = true
 tokio.workspace = true
+rand.workspace = true
 
 [dev-dependencies]
 blake3.workspace = true
@@ -33,3 +34,8 @@ bench = []
 name = "avl_tree"
 harness = false
 required-features = ["bench"]
+
+[[bench]]
+name = "database"
+harness = false
+required-features = ["bench"]
diff --git a/durable-storage/benches/avl_tree.rs b/durable-storage/benches/avl_tree.rs
@@ -2,16 +2,16 @@
 // SPDX-License-Identifier: MIT
 
 use std::collections::BTreeMap;
-use std::collections::HashSet;
 use std::time::Duration;
 
 use bytes::Bytes;
 use criterion::Criterion;
 use criterion::criterion_group;
 use criterion::criterion_main;
-use octez_riscv_durable_storage::merkle_layer::KEY_MAX_SIZE;
 use octez_riscv_durable_storage::merkle_layer::Key;
 use octez_riscv_durable_storage::merkle_layer::tree::Avl;
+use octez_riscv_durable_storage::random::generate_keys;
+use octez_riscv_durable_storage::random::generate_random_bytes;
 use rand::prelude::*;
 
 const KEY_COUNT: usize = 10_000_000;
@@ -24,31 +24,7 @@ pub enum Operation {
     Delete(Key),
 }
 
-fn generate_byte_vector(rng: &mut impl Rng, length: usize) -> Vec<u8> {
-    let mut ret = vec![0u8; length];
-    rng.fill(ret.as_mut_slice());
-    ret
-}
-
-fn generate_keys(rng: &mut impl Rng, length: usize) -> Vec<Key> {
-    let mut tmp: HashSet<Key> = HashSet::new();
-    while tmp.len() < length {
-        let key_length = rng.random_range(1..KEY_MAX_SIZE);
-        tmp.insert(
-            Key::new(generate_byte_vector(rng, key_length).as_slice())
-                .expect("The key should be created"),
-        );
-    }
-    tmp.into_iter().collect()
-}
-
-fn get_random_data(rng: &mut impl Rng) -> Bytes {
-    let length: usize = rng.random_range(1..20);
-    let bytes = generate_byte_vector(rng, length);
-    Bytes::from(bytes)
-}
-
-fn get_operations_batch(rng: &mut impl Rng, keys: &[Key], batch_size: usize) -> Vec<Operation> {
+fn get_operations_batch(mut rng: &mut impl Rng, keys: &[Key], batch_size: usize) -> Vec<Operation> {
     (0..batch_size)
         .map(|_| {
             let key: Key = keys
@@ -57,7 +33,7 @@ fn get_operations_batch(rng: &mut impl Rng, keys: &[Key], batch_size: usize) ->
                 .clone();
             match rng.random_range(0..3) {
                 0 => Operation::Get(key),
-                1 => Operation::Upsert(key, get_random_data(rng)),
+                1 => Operation::Upsert(key, generate_random_bytes(&mut rng, 1..20).into()),
                 _ => Operation::Delete(key),
             }
         })
@@ -75,7 +51,7 @@ fn bench_avl_tree_operations(c: &mut Criterion) {
     // Setting up the tree
     let mut tree = Avl::default();
     for key in &keys[..keys.len() / 2] {
-        tree.set(key, get_random_data(&mut rng));
+        tree.set(key, generate_random_bytes(&mut rng, 1..20).into());
     }
 
     c.bench_function("Bench AVL tree with operations", |b| {
@@ -111,7 +87,7 @@ fn reference(c: &mut Criterion) {
 
     let mut tree = BTreeMap::<Key, Bytes>::new();
     for key in &keys[..keys.len() / 2] {
-        tree.insert(key.clone(), get_random_data(&mut rng));
+        tree.insert(key.clone(), generate_random_bytes(&mut rng, 1..20).into());
     }
 
     c.bench_function("BTreeMap reference", |b| {
diff --git a/durable-storage/benches/database.rs b/durable-storage/benches/database.rs
@@ -0,0 +1,184 @@
+use std::hint::black_box;
+
+use bytes::Bytes;
+use criterion::BatchSize;
+use criterion::Criterion;
+use criterion::criterion_group;
+use criterion::criterion_main;
+use octez_riscv_durable_storage::database::Database;
+use octez_riscv_durable_storage::merkle_layer::Key;
+use octez_riscv_durable_storage::persistence_layer::utils::TestableTmpdir;
+use octez_riscv_durable_storage::random::generate_keys;
+use octez_riscv_durable_storage::random::generate_random_bytes;
+use octez_riscv_durable_storage::repo::DirectoryManager;
+use rand::prelude::*;
+use rand::rng;
+use tokio::runtime::Handle;
+
+struct BenchmarkState {
+    database: Database,
+    large_read_buffer: Vec<u8>,
+    large_read_choices: Vec<usize>,
+    prepopulated_large_node_keys: Vec<Key>,
+    prepopulated_node_keys: Vec<Key>,
+    prepopulated_values: Vec<Bytes>,
+    small_read_buffer: Vec<u8>,
+    small_read_choices: Vec<usize>,
+    small_write_choices: Vec<(usize, usize)>,
+}
+
+impl BenchmarkState {
+    fn clone_with(&self, handle: &Handle, repo: &DirectoryManager) -> Self {
+        Self {
+            database: self
+                .database
+                .try_clone_with(handle, repo)
+                .expect("Cloning the database should work"),
+            large_read_buffer: vec![0u8; LARGE_READ_MIN_SIZE],
+            large_read_choices: self.large_read_choices.clone(),
+            prepopulated_large_node_keys: self.prepopulated_large_node_keys.clone(),
+            prepopulated_node_keys: self.prepopulated_node_keys.clone(),
+            prepopulated_values: self.prepopulated_values.clone(),
+            small_read_buffer: vec![0u8; SMALL_READ_SIZE],
+            small_read_choices: self.small_read_choices.clone(),
+            small_write_choices: self.small_write_choices.clone(),
+        }
+    }
+}
+
+const BLOCK_FREQUENCY: usize = 5_000;
+const ERC_20_TRANSACTIONS: usize = 10_000;
+const LARGE_READ_MIN_SIZE: usize = 48000;
+const LARGE_READ_MAX_SIZE: usize = LARGE_READ_MIN_SIZE * 2;
+const PREPOPULATED_LARGE_NODE_KEYS_COUNT: usize = 100;
+const PREPOPULATED_NODE_KEYS_COUNT: usize = 1_000_000 - PREPOPULATED_LARGE_NODE_KEYS_COUNT;
+const SMALL_READS: usize = 19;
+const SMALL_READ_SIZE: usize = 32;
+const SMALL_WRITES: usize = 20;
+
+fn setup_benchmark_state(handle: &Handle, repo: &DirectoryManager) -> BenchmarkState {
+    let mut database = Database::try_new(handle, repo).expect("Creating a database should succeed");
+    let mut rng = rng();
+
+    const VALUES_COUNT: usize = 100;
+    let mut prepopulated_node_keys = Vec::with_capacity(PREPOPULATED_NODE_KEYS_COUNT);
+    let mut prepopulated_large_node_keys = Vec::with_capacity(PREPOPULATED_LARGE_NODE_KEYS_COUNT);
+    let mut prepopulated_values = Vec::with_capacity(VALUES_COUNT);
+
+    // Pre-populate a small number of values of random small sizes
+    for _ in 0..VALUES_COUNT {
+        let value = Bytes::from(generate_random_bytes(&mut rng, 1..32));
+        prepopulated_values.push(value);
+    }
+
+    // Pre-populate the database with a large number of random keys with small values
+    let keys = generate_keys(&mut rng, PREPOPULATED_NODE_KEYS_COUNT);
+    for key in keys {
+        let value = prepopulated_values
+            .choose(&mut rng)
+            .expect("The value should exist");
+        database.write(key.clone(), 0, value.clone()).ok();
+        prepopulated_node_keys.push(key);
+    }
+
+    // Pre-populate the database with a small number of random keys with large values
+    let keys = generate_keys(&mut rng, PREPOPULATED_LARGE_NODE_KEYS_COUNT);
+    for key in keys {
+        let value = Bytes::from(generate_random_bytes(
+            &mut rng,
+            LARGE_READ_MIN_SIZE..LARGE_READ_MAX_SIZE,
+        ));
+        database.write(key.clone(), 0, value).ok();
+        prepopulated_large_node_keys.push(key);
+    }
+
+    let large_read_choices = (0..ERC_20_TRANSACTIONS)
+        .map(|_| rng.random_range(0..prepopulated_large_node_keys.len()))
+        .collect();
+
+    let small_read_choices = (0..ERC_20_TRANSACTIONS * SMALL_READS)
+        .map(|_| rng.random_range(0..prepopulated_node_keys.len()))
+        .collect();
+
+    let small_write_choices = (0..ERC_20_TRANSACTIONS * SMALL_WRITES)
+        .map(|_| {
+            (
+                rng.random_range(0..prepopulated_node_keys.len()),
+                rng.random_range(0..prepopulated_values.len()),
+            )
+        })
+        .collect();
+
+    BenchmarkState {
+        database,
+        large_read_buffer: vec![0u8; LARGE_READ_MAX_SIZE],
+        large_read_choices,
+        prepopulated_large_node_keys,
+        prepopulated_node_keys,
+        prepopulated_values,
+        small_read_buffer: vec![0u8; SMALL_READ_SIZE],
+        small_read_choices,
+        small_write_choices,
+    }
+}
+
+#[inline(never)]
+fn bench_run(mut state: BenchmarkState) {
+    let large_node_keys = &state.prepopulated_large_node_keys;
+    let node_keys = &state.prepopulated_node_keys;
+    let values = &state.prepopulated_values;
+
+    for i in 0..ERC_20_TRANSACTIONS {
+        let key = &large_node_keys[state.large_read_choices[i]];
+        state
+            .database
+            .read(key, 0, &mut state.large_read_buffer)
+            .expect("The read should succeed");
+
+        for _ in 0..SMALL_READS {
+            let key = &node_keys[state.small_read_choices[i]];
+            state
+                .database
+                .read(key, 0, &mut state.small_read_buffer)
+                .expect("The read should succeed");
+        }
+
+        for _ in 0..SMALL_WRITES {
+            let key = node_keys[state.small_write_choices[i].0].clone();
+            let value = values[state.small_write_choices[i].1].clone();
+            state
+                .database
+                .write(key, 0, value)
+                .expect("The read should succeed");
+        }
+
+        if i % BLOCK_FREQUENCY == 0 {
+            black_box(state.database.hash());
+        }
+    }
+}
+
+fn database_benchmark(c: &mut Criterion) {
+    let runtime = tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(2)
+        .build()
+        .expect("Creating a Tokio runtime should succeed");
+
+    let tmpdir = TestableTmpdir::new();
+    let repo = DirectoryManager::new(tmpdir.path()).expect("Failed to create directory manager");
+    let initial_state = setup_benchmark_state(runtime.handle(), &repo);
+
+    let setup = || initial_state.clone_with(runtime.handle(), &repo);
+
+    let mut group = c.benchmark_group("ERC-20");
+    group.sample_size(10);
+    group.measurement_time(std::time::Duration::from_secs(40));
+    group.bench_function("10_000-transactions", |b| {
+        b.iter_batched(setup, bench_run, BatchSize::SmallInput)
+    });
+
+    group.finish();
+}
+
+criterion_group!(benches, database_benchmark);
+criterion_main!(benches);
diff --git a/durable-storage/src/database.rs b/durable-storage/src/database.rs
@@ -65,24 +65,17 @@ impl Database {
     }
 
     /// Obtain, and possibly calculate, the root hash of the database>
-    #[cfg_attr(not(test), expect(dead_code, reason = "Implemented in RV-827"))]
-    pub(crate) fn hash(&self) -> blake3::Hash {
+    pub fn hash(&self) -> blake3::Hash {
         self.merkle.hash()
     }
 
-    #[cfg_attr(not(test), expect(dead_code, reason = "Implemented in RV-827"))]
     /// Read a portion of the value associated with the provided key. The read data will be written
     /// into `data`. `offset` specifies from where in the associated value to start reading.
     ///
     /// Fails if:
     ///  - The key does not exist.
     ///  - The offset is larger than the length of the associated value.
-    pub(crate) fn read(
-        &self,
-        key: &Key,
-        offset: usize,
-        data: &mut [u8],
-    ) -> Result<usize, DatabaseError> {
+    pub fn read(&self, key: &Key, offset: usize, data: &mut [u8]) -> Result<usize, DatabaseError> {
         let value = self.persistent.get(key.as_ref())?;
         let value_ref = value.as_ref();
 
@@ -98,31 +91,21 @@ impl Database {
         Ok(bytes_to_copy)
     }
 
-    #[cfg_attr(
-        not(test),
-        expect(dead_code, reason = "Used in RV-828 and integration of the registry")
-    )]
     /// Try to construct a new Database
     pub fn try_new(handle: &Handle, repo: &DirectoryManager) -> Result<Self, DatabaseError> {
         let persistent: Arc<PersistenceLayer> = PersistenceLayer::new(repo)?.into();
         let merkle = MerkleWorker::new(handle, persistent.clone())?;
         Ok(Self { persistent, merkle })
     }
 
-    #[cfg_attr(not(test), expect(dead_code, reason = "Implemented in RV-827"))]
     /// Modify the value associated with the provided key. `offset` specifies from where to start
     /// writing within the associated value, appending if it is equal to the length. Non-existent
     /// keys have the implicit length 0, so they are writeable.
     ///
     /// Fails if:
     ///  - The offset is non-zero and the key does not exist.
     ///  - The offset is larger than the length of the associated value.
-    pub(crate) fn write(
-        &mut self,
-        key: Key,
-        offset: usize,
-        data: Bytes,
-    ) -> Result<usize, DatabaseError> {
+    pub fn write(&mut self, key: Key, offset: usize, data: Bytes) -> Result<usize, DatabaseError> {
         if offset != 0 {
             let value = None;
             // TODO : Implement [`MerkleLayer::node::get_mut`] in RV-827
@@ -135,7 +118,6 @@ impl Database {
         }
     }
 
-    #[expect(dead_code, reason = "Used in RV-828 and integration of the registry")]
     /// Try to create a cheap clone of the Database.
     pub fn try_clone_with(
         &self,
diff --git a/durable-storage/src/lib.rs b/durable-storage/src/lib.rs
@@ -26,26 +26,23 @@
 //! - **Persistence layer**: Responsible for actually persisting the basic get, set, delete
 //!   operations on disk.
 
-mod database;
 cfg_if::cfg_if! {
     if #[cfg(feature = "bench")] {
+        pub mod database;
         pub mod merkle_layer;
+        pub mod merkle_worker;
+        pub mod persistence_layer;
+        pub mod repo;
+        pub mod random;
     } else {
+        #[cfg_attr(not(test), expect(dead_code, reason = "Incomplete"))]
+        mod database;
         #[cfg_attr(not(test), expect(dead_code, reason = "Incomplete"))]
         mod merkle_layer;
+        mod merkle_worker;
+        #[cfg_attr(not(test), expect(dead_code, reason = "Incomplete"))]
+        pub(crate) mod persistence_layer;
+        #[cfg_attr(not(test), expect(dead_code, reason = "Incomplete"))]
+        mod repo;
     }
 }
-mod merkle_worker;
-#[cfg_attr(
-    not(any(test, feature = "bench")),
-    expect(
-        dead_code,
-        reason = "Database will use the persistence layer in RV-808"
-    )
-)]
-pub(crate) mod persistence_layer;
-#[cfg_attr(
-    not(any(test, feature = "bench")),
-    expect(dead_code, reason = "Incomplete")
-)]
-mod repo;
diff --git a/durable-storage/src/merkle_worker.rs b/durable-storage/src/merkle_worker.rs
diff --git a/durable-storage/src/random.rs b/durable-storage/src/random.rs
