Skip to content

Commit 83c8e65

Browse files
jpraynaudjpraynaud
committed
refactor: enhance MKMap benchmarks
1 parent a6d2f6a commit 83c8e65

File tree

2 files changed

+93
-78
lines changed

2 files changed

+93
-78
lines changed

‎mithril-common/benches/merkle_map.rs‎

Lines changed: 86 additions & 78 deletions
Original file line numberDiff line numberDiff line change
@@ -2,49 +2,60 @@ use std::ops::Range;
22

33
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
44
use mithril_common::{
5-
crypto_helper::{MKMap, MKMapProof, MKTree},
5+
crypto_helper::{MKMap, MKMapNode, MKMapProof, MKTree},
66
entities::BlockRange,
7-
signable_builder,
87
};
98

10-
const K: usize = 1_000;
11-
const M: usize = 1_000 * K;
12-
const TOTAL_LEAVES_BENCHES: &[usize] = &[K, 10 * K, 100 * K, M, 10 * M];
13-
const BLOCK_RANGE_LENGTH_BENCH: u64 = signable_builder::BLOCK_RANGE_LENGTH;
9+
const K: u64 = 1_000;
10+
const M: u64 = 1_000 * K;
11+
const B: u64 = 1_000 * M;
12+
const TOTAL_TRANSACTIONS_BENCHES: &[u64] = &[
13+
K,
14+
10 * K,
15+
100 * K,
16+
M,
17+
10 * M,
18+
50 * M,
19+
100 * M,
20+
250 * M,
21+
500 * M,
22+
B,
23+
];
24+
const BLOCK_RANGE_LENGTH_BENCH: u64 = 15;
25+
const TOTAL_TRANSACTIONS_PER_BLOCK: u64 = 50;
1426

15-
fn generate_merkle_trees_by_block_range_iterator(
16-
total_leaves: usize,
27+
fn generate_block_ranges_nodes_iterator(
28+
total_transactions: u64,
29+
total_transactions_per_block: u64,
1730
block_range_length: u64,
18-
) -> impl Iterator<Item = (BlockRange, MKTree)> {
19-
(0..total_leaves as u64 / block_range_length).map(move |block_range_index| {
31+
max_uncompressed_block_ranges: u64,
32+
) -> impl Iterator<Item = (BlockRange, MKMapNode<BlockRange>)> {
33+
let total_block_ranges =
34+
total_transactions / (total_transactions_per_block * block_range_length);
35+
(0..total_block_ranges).map(move |block_range_index| {
2036
let block_range = BlockRange::new(
21-
block_range_index * block_range_length,
22-
(block_range_index + 1) * block_range_length,
37+
block_range_index * total_transactions_per_block * block_range_length,
38+
(block_range_index + 1) * total_transactions_per_block * block_range_length,
2339
);
24-
let leaves = <Range<u64> as Clone>::clone(&block_range)
25-
.map(|leaf_index| leaf_index.to_string())
26-
.collect::<Vec<_>>();
27-
let merkle_tree_block_range = MKTree::new(&leaves).unwrap();
40+
let mk_map_node = if block_range_index < max_uncompressed_block_ranges {
41+
let leaves = <Range<u64> as Clone>::clone(&block_range)
42+
.map(|leaf_index| leaf_index.to_string())
43+
.collect::<Vec<_>>();
44+
let merkle_tree_block_range = MKTree::new(&leaves).unwrap();
45+
merkle_tree_block_range.into()
46+
} else {
47+
MKMapNode::TreeNode(block_range.to_string().into())
48+
};
2849

29-
(block_range, merkle_tree_block_range)
50+
(block_range, mk_map_node)
3051
})
3152
}
3253

33-
fn generate_merkle_map(
34-
mk_trees_by_block_range_iterator: impl Iterator<Item = (BlockRange, MKTree)>,
35-
) -> MKMap<BlockRange> {
36-
let mut mk_map = MKMap::new(&[]).unwrap();
37-
for (block_range, mk_tree) in mk_trees_by_block_range_iterator {
38-
mk_map.insert(block_range, mk_tree.into()).unwrap();
39-
}
40-
mk_map
41-
}
42-
4354
fn generate_merkle_map_compressed(
44-
mk_trees_by_block_range_iterator: impl Iterator<Item = (BlockRange, MKTree)>,
55+
block_ranges_nodes_iterator: impl Iterator<Item = (BlockRange, MKMapNode<BlockRange>)>,
4556
) -> MKMap<BlockRange> {
4657
let mut mk_map = MKMap::new(&[]).unwrap();
47-
for (block_range, mk_tree) in mk_trees_by_block_range_iterator {
58+
for (block_range, mk_tree) in block_ranges_nodes_iterator {
4859
mk_map
4960
.insert(block_range, mk_tree.compute_root().unwrap().into())
5061
.unwrap();
@@ -53,12 +64,17 @@ fn generate_merkle_map_compressed(
5364
}
5465

5566
fn generate_merkle_map_proof(
56-
mk_trees_by_block_range_iterator: impl Iterator<Item = (BlockRange, MKTree)>,
67+
block_ranges_nodes_iterator: impl Iterator<Item = (BlockRange, MKMapNode<BlockRange>)>,
5768
mk_map_compressed: &MKMap<BlockRange>,
5869
) -> MKMapProof<BlockRange> {
59-
let (mk_map_key_to_prove, mk_map_tree_to_prove) =
60-
&mk_trees_by_block_range_iterator.take(1).collect::<Vec<_>>()[0];
61-
let leaves_to_prove = mk_map_tree_to_prove
70+
let (mk_map_key_to_prove, mk_map_node_to_prove) =
71+
&block_ranges_nodes_iterator.take(1).collect::<Vec<_>>()[0];
72+
let mktree_to_prove = if let MKMapNode::Tree(mktree_to_prove) = mk_map_node_to_prove {
73+
mktree_to_prove
74+
} else {
75+
panic!("Expected MKMapNode::TreeNode");
76+
};
77+
let leaves_to_prove = mktree_to_prove
6278
.leaves()
6379
.into_iter()
6480
.take(1)
@@ -67,43 +83,23 @@ fn generate_merkle_map_proof(
6783
mk_map_compressed
6884
.insert(
6985
mk_map_key_to_prove.to_owned(),
70-
mk_map_tree_to_prove.to_owned().into(),
86+
mk_map_node_to_prove.to_owned(),
7187
)
7288
.unwrap();
7389
mk_map_compressed.compute_proof(&leaves_to_prove).unwrap()
7490
}
7591

76-
fn create_merkle_map_benches(c: &mut Criterion) {
77-
let mut group = c.benchmark_group(format!(
78-
"create_merkle_map_ranges_{BLOCK_RANGE_LENGTH_BENCH}_blocks"
79-
));
80-
for total_leaves in TOTAL_LEAVES_BENCHES.iter() {
81-
group.bench_with_input(
82-
BenchmarkId::from_parameter(total_leaves),
83-
total_leaves,
84-
|b, &_total_leaves| {
85-
b.iter(|| {
86-
let mk_trees_by_block_range_iterator =
87-
generate_merkle_trees_by_block_range_iterator(
88-
*total_leaves,
89-
BLOCK_RANGE_LENGTH_BENCH,
90-
);
91-
let mk_map = generate_merkle_map(mk_trees_by_block_range_iterator);
92-
mk_map.compute_root().unwrap();
93-
});
94-
},
95-
);
96-
}
97-
group.finish();
98-
}
99-
10092
fn create_merkle_map_compressed_benches(c: &mut Criterion) {
10193
let mut group = c.benchmark_group(format!(
102-
"create_merkle_map_compressed_ranges_{BLOCK_RANGE_LENGTH_BENCH}_blocks"
94+
"create_merkle_map_compressed(blocks_ranges_length={BLOCK_RANGE_LENGTH_BENCH},txs_per_block={TOTAL_TRANSACTIONS_PER_BLOCK})"
10395
));
104-
for total_leaves in TOTAL_LEAVES_BENCHES.iter() {
105-
let mk_trees_by_block_range_iterator =
106-
generate_merkle_trees_by_block_range_iterator(*total_leaves, BLOCK_RANGE_LENGTH_BENCH);
96+
for total_leaves in TOTAL_TRANSACTIONS_BENCHES.iter() {
97+
let mk_trees_by_block_range_iterator = generate_block_ranges_nodes_iterator(
98+
*total_leaves,
99+
TOTAL_TRANSACTIONS_PER_BLOCK,
100+
BLOCK_RANGE_LENGTH_BENCH,
101+
1,
102+
);
107103
let mk_map_compressed = generate_merkle_map_compressed(mk_trees_by_block_range_iterator);
108104
group.bench_with_input(
109105
BenchmarkId::from_parameter(total_leaves),
@@ -121,23 +117,28 @@ fn create_merkle_map_compressed_benches(c: &mut Criterion) {
121117

122118
fn create_merkle_map_proof_benches(c: &mut Criterion) {
123119
let mut group = c.benchmark_group(format!(
124-
"create_merkle_map_proof_ranges_{BLOCK_RANGE_LENGTH_BENCH}_blocks"
120+
"create_merkle_map_proof_(blocks_ranges_length={BLOCK_RANGE_LENGTH_BENCH},txs_per_block={TOTAL_TRANSACTIONS_PER_BLOCK})"
125121
));
126-
for total_leaves in TOTAL_LEAVES_BENCHES.iter() {
127-
let mk_trees_by_block_range_iterator =
128-
generate_merkle_trees_by_block_range_iterator(*total_leaves, BLOCK_RANGE_LENGTH_BENCH);
122+
for total_leaves in TOTAL_TRANSACTIONS_BENCHES.iter() {
123+
let mk_trees_by_block_range_iterator = generate_block_ranges_nodes_iterator(
124+
*total_leaves,
125+
TOTAL_TRANSACTIONS_PER_BLOCK,
126+
BLOCK_RANGE_LENGTH_BENCH,
127+
1,
128+
);
129129
let mk_map_compressed = generate_merkle_map_compressed(mk_trees_by_block_range_iterator);
130130

131131
group.bench_with_input(
132132
BenchmarkId::from_parameter(total_leaves),
133133
total_leaves,
134134
|b, &_total_leaves| {
135135
b.iter(|| {
136-
let mk_trees_by_block_range_iterator =
137-
generate_merkle_trees_by_block_range_iterator(
138-
*total_leaves,
139-
BLOCK_RANGE_LENGTH_BENCH,
140-
);
136+
let mk_trees_by_block_range_iterator = generate_block_ranges_nodes_iterator(
137+
*total_leaves,
138+
TOTAL_TRANSACTIONS_PER_BLOCK,
139+
BLOCK_RANGE_LENGTH_BENCH,
140+
1,
141+
);
141142
generate_merkle_map_proof(mk_trees_by_block_range_iterator, &mk_map_compressed);
142143
});
143144
},
@@ -148,14 +149,22 @@ fn create_merkle_map_proof_benches(c: &mut Criterion) {
148149

149150
fn verify_merkle_map_proof_benches(c: &mut Criterion) {
150151
let mut group = c.benchmark_group(format!(
151-
"verify_merkle_map_proof_ranges_{BLOCK_RANGE_LENGTH_BENCH}_blocks"
152+
"verify_merkle_map_proof_(blocks_ranges_length={BLOCK_RANGE_LENGTH_BENCH},txs_per_block={TOTAL_TRANSACTIONS_PER_BLOCK})"
152153
));
153-
for total_leaves in TOTAL_LEAVES_BENCHES.iter() {
154-
let mk_trees_by_block_range_iterator =
155-
generate_merkle_trees_by_block_range_iterator(*total_leaves, BLOCK_RANGE_LENGTH_BENCH);
154+
for total_leaves in TOTAL_TRANSACTIONS_BENCHES.iter() {
155+
let mk_trees_by_block_range_iterator = generate_block_ranges_nodes_iterator(
156+
*total_leaves,
157+
TOTAL_TRANSACTIONS_PER_BLOCK,
158+
BLOCK_RANGE_LENGTH_BENCH,
159+
1,
160+
);
156161
let mk_map_compressed = generate_merkle_map_compressed(mk_trees_by_block_range_iterator);
157-
let mk_trees_by_block_range_iterator =
158-
generate_merkle_trees_by_block_range_iterator(*total_leaves, BLOCK_RANGE_LENGTH_BENCH);
162+
let mk_trees_by_block_range_iterator = generate_block_ranges_nodes_iterator(
163+
*total_leaves,
164+
TOTAL_TRANSACTIONS_PER_BLOCK,
165+
BLOCK_RANGE_LENGTH_BENCH,
166+
1,
167+
);
159168
let mk_map_proof =
160169
generate_merkle_map_proof(mk_trees_by_block_range_iterator, &mk_map_compressed);
161170

@@ -174,7 +183,6 @@ criterion_group!(
174183
name = benches;
175184
config = Criterion::default().sample_size(10);
176185
targets =
177-
create_merkle_map_benches,
178186
create_merkle_map_compressed_benches,
179187
create_merkle_map_proof_benches,
180188
verify_merkle_map_proof_benches

‎mithril-common/src/entities/block_range.rs‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@ use anyhow::anyhow;
22
use serde::{Deserialize, Serialize};
33
use std::{
44
cmp::Ordering,
5+
fmt::{Display, Formatter, Result},
56
ops::{Deref, Range},
67
};
78

@@ -46,6 +47,12 @@ impl BlockRange {
4647
}
4748
}
4849

50+
impl Display for BlockRange {
51+
fn fmt(&self, f: &mut Formatter) -> Result {
52+
write!(f, "[{},{}[", self.inner_range.start, self.inner_range.end)
53+
}
54+
}
55+
4956
impl Deref for BlockRange {
5057
type Target = Range<u64>;
5158

0 commit comments

Comments
 (0)