refactor: enhance readability of MKTree and MKMap benchmarks

Author: jpraynaud

mithril-common/Cargo.toml

@@ -15,7 +15,7 @@ crate-type = ["lib", "cdylib", "staticlib"]
 [[bench]]
 name = "digester"
 harness = false
-required-features = ["full"]
+required-features = ["fs"]
 
 [[bench]]
 name = "merkle_tree"
@@ -100,7 +100,7 @@ reqwest = { version = "0.11.23", features = ["json"] }
 slog-async = "2.8.0"
 slog-scope = "4.4.0"
 slog-term = "2.9.0"
-tokio = { version = "1.35.1", features = ["macros", "time"] }
+tokio = { version = "1.35.1", features = ["macros", "rt-multi-thread", "time"] }
 
 [build-dependencies]
 mithril-build-script = { path = "../internal/mithril-build-script", version = "=0.1.3" }

mithril-common/benches/merkle_map.rs

@@ -6,6 +6,7 @@ use mithril_common::{
     entities::BlockRange,
 };
 
+// Shortcuts for magnitudes: K for thousand, M for million, B for billion
 const K: u64 = 1_000;
 const M: u64 = 1_000 * K;
 const B: u64 = 1_000 * M;
@@ -31,16 +32,16 @@ fn generate_block_ranges_nodes_iterator(
     block_range_length: u64,
     max_uncompressed_block_ranges: u64,
 ) -> impl Iterator<Item = (BlockRange, MKMapNode<BlockRange>)> {
-    let total_block_ranges =
-        total_transactions / (total_transactions_per_block * block_range_length);
+    let total_transactions_per_block_range = total_transactions_per_block * block_range_length;
+    let total_block_ranges = total_transactions / total_transactions_per_block_range;
     assert!(
         total_block_ranges > 0,
         "total_block_ranges should be strictly greater than 0"
     );
     (0..total_block_ranges).map(move |block_range_index| {
         let block_range = BlockRange::new(
-            block_range_index * total_transactions_per_block * block_range_length,
-            (block_range_index + 1) * total_transactions_per_block * block_range_length,
+            block_range_index * total_transactions_per_block_range,
+            (block_range_index + 1) * total_transactions_per_block_range,
         );
         let mk_map_node = if block_range_index < max_uncompressed_block_ranges {
             let leaves = <Range<u64> as Clone>::clone(&block_range)
@@ -71,36 +72,35 @@ fn generate_merkle_map_compressed(
 fn generate_merkle_map_root(
     block_ranges_nodes_iterator: impl Iterator<Item = (BlockRange, MKMapNode<BlockRange>)>,
     mk_map_compressed: &MKMap<BlockRange, MKMapNode<BlockRange>>,
-) -> MKMapProof<BlockRange> {
-    let (mk_map_key_to_prove, mk_map_node_to_prove) =
-        &block_ranges_nodes_iterator.take(1).collect::<Vec<_>>()[0];
-    let mktree_to_prove = if let MKMapNode::Tree(mktree_to_prove) = mk_map_node_to_prove {
-        mktree_to_prove
-    } else {
-        panic!("Expected MKMapNode::Tree");
-    };
-    let leaves_to_prove = mktree_to_prove
-        .leaves()
-        .into_iter()
-        .take(1)
-        .collect::<Vec<_>>();
-    let mut mk_map_compressed = mk_map_compressed.clone();
-    mk_map_compressed
-        .insert(
-            mk_map_key_to_prove.to_owned(),
-            mk_map_node_to_prove.to_owned(),
-        )
-        .unwrap();
-    mk_map_compressed.compute_proof(&leaves_to_prove).unwrap()
+) -> MKMapNode<BlockRange> {
+    let total_full_mk_tree = 1;
+    let (mk_map, _) = generate_merkle_map(
+        block_ranges_nodes_iterator,
+        mk_map_compressed,
+        total_full_mk_tree,
+    );
+
+    mk_map.compute_root().unwrap().into()
 }
 
 fn generate_merkle_map_proof(
     block_ranges_nodes_iterator: impl Iterator<Item = (BlockRange, MKMapNode<BlockRange>)>,
     mk_map_compressed: &MKMap<BlockRange, MKMapNode<BlockRange>>,
     total_proofs: u64,
 ) -> MKMapProof<BlockRange> {
+    let (mk_map, leaves_to_prove_all) =
+        generate_merkle_map(block_ranges_nodes_iterator, mk_map_compressed, total_proofs);
+
+    mk_map.compute_proof(&leaves_to_prove_all).unwrap()
+}
+
+fn generate_merkle_map(
+    block_ranges_nodes_iterator: impl Iterator<Item = (BlockRange, MKMapNode<BlockRange>)>,
+    mk_map_compressed: &MKMap<BlockRange, MKMapNode<BlockRange>>,
+    total_proofs: u64,
+) -> (MKMap<BlockRange, MKMapNode<BlockRange>>, Vec<MKTreeNode>) {
     let mut leaves_to_prove_all: Vec<MKTreeNode> = vec![];
-    let mut mk_map_compressed = mk_map_compressed.clone();
+    let mut mk_map = mk_map_compressed.clone();
     for (mk_map_key_to_prove, mk_map_node_to_prove) in &block_ranges_nodes_iterator
         .take(total_proofs as usize)
         .collect::<Vec<_>>()
@@ -116,16 +116,15 @@ fn generate_merkle_map_proof(
             .take(1)
             .collect::<Vec<_>>();
         leaves_to_prove_all.extend(leaves_to_prove);
-        mk_map_compressed
+        mk_map
             .insert(
                 mk_map_key_to_prove.to_owned(),
                 mk_map_node_to_prove.to_owned(),
             )
             .unwrap();
     }
-    mk_map_compressed
-        .compute_proof(&leaves_to_prove_all)
-        .unwrap()
+
+    (mk_map, leaves_to_prove_all)
 }
 
 fn create_merkle_map_root_benches(c: &mut Criterion) {
@@ -161,7 +160,7 @@ fn create_merkle_map_root_benches(c: &mut Criterion) {
 
 fn create_merkle_map_proof_benches(c: &mut Criterion) {
     let mut group = c.benchmark_group(format!(
-        "create_merkle_map_proof_(blocks_ranges_length={BLOCK_RANGE_LENGTH_BENCH},txs_per_block={TOTAL_TRANSACTIONS_PER_BLOCK},txs_per_proof={MAX_TRANSACTIONS_PER_PROOF_BENCH})"
+        "create_merkle_map_proof(blocks_ranges_length={BLOCK_RANGE_LENGTH_BENCH},txs_per_block={TOTAL_TRANSACTIONS_PER_BLOCK},txs_per_proof={MAX_TRANSACTIONS_PER_PROOF_BENCH})"
     ));
     for total_leaves in TOTAL_TRANSACTIONS_BENCHES.iter() {
         let mk_trees_by_block_range_iterator = generate_block_ranges_nodes_iterator(
@@ -197,14 +196,14 @@ fn create_merkle_map_proof_benches(c: &mut Criterion) {
 
 fn verify_merkle_map_proof_benches(c: &mut Criterion) {
     let mut group = c.benchmark_group(format!(
-        "verify_merkle_map_proof_(blocks_ranges_length={BLOCK_RANGE_LENGTH_BENCH},txs_per_block={TOTAL_TRANSACTIONS_PER_BLOCK},txs_per_proof={MAX_TRANSACTIONS_PER_PROOF_BENCH})"
+        "verify_merkle_map_proof(blocks_ranges_length={BLOCK_RANGE_LENGTH_BENCH},txs_per_block={TOTAL_TRANSACTIONS_PER_BLOCK},txs_per_proof={MAX_TRANSACTIONS_PER_PROOF_BENCH})"
     ));
     for total_leaves in TOTAL_TRANSACTIONS_BENCHES.iter() {
         let mk_trees_by_block_range_iterator = generate_block_ranges_nodes_iterator(
             *total_leaves,
             TOTAL_TRANSACTIONS_PER_BLOCK,
             BLOCK_RANGE_LENGTH_BENCH,
-            1,
+            MAX_TRANSACTIONS_PER_PROOF_BENCH,
         );
         let mk_map_compressed = generate_merkle_map_compressed(mk_trees_by_block_range_iterator);
         let mk_trees_by_block_range_iterator = generate_block_ranges_nodes_iterator(
@@ -232,7 +231,7 @@ fn verify_merkle_map_proof_benches(c: &mut Criterion) {
 
 criterion_group!(
     name = benches;
-    config = Criterion::default().sample_size(10);
+    config = Criterion::default().sample_size(100);
     targets =
         create_merkle_map_root_benches,
         create_merkle_map_proof_benches,

mithril-common/benches/merkle_tree.rs

@@ -1,6 +1,7 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use mithril_common::crypto_helper::{MKTree, MKTreeNode};
 
+// Shortcuts for magnitudes: K for thousand, M for million
 const K: usize = 1_000;
 const M: usize = 1_000 * K;
 const TOTAL_LEAVES_BENCHES: &[usize] = &[K, 10 * K, 100 * K, M, 10 * M];
@@ -70,6 +71,9 @@ fn verify_merkle_tree_proof_benches(c: &mut Criterion) {
 criterion_group!(
     name=benches;
     config = Criterion::default().sample_size(10);
-    targets=create_merkle_tree_root_benches,create_merkle_tree_proof_benches,verify_merkle_tree_proof_benches
+    targets=
+      create_merkle_tree_root_benches,
+      create_merkle_tree_proof_benches,
+      verify_merkle_tree_proof_benches
 );
 criterion_main!(benches);