feat: set up codspeed (#13372)

crates/trie/sparse/Cargo.toml

@@ -41,6 +41,19 @@ proptest-arbitrary-interop.workspace = true
 proptest.workspace = true
 rand.workspace = true
 
+[features]
+test-utils = [
+    "reth-primitives-traits/test-utils",
+    "reth-trie/test-utils",
+    "reth-trie-common/test-utils",
+]
+arbitrary = [
+    "reth-primitives-traits/arbitrary",
+    "reth-trie-common/arbitrary",
+    "alloy-primitives/arbitrary",
+    "smallvec/arbitrary",
+]
+
 [[bench]]
 name = "root"
 harness = false

crates/trie/sparse/benches/rlp_node.rs

@@ -1,6 +1,4 @@
-#![allow(missing_docs, unreachable_pub)]
-
-use std::time::{Duration, Instant};
+#![allow(missing_docs)]
 
 use alloy_primitives::{B256, U256};
 use criterion::{criterion_group, criterion_main, Criterion};
@@ -11,7 +9,7 @@ use reth_testing_utils::generators;
 use reth_trie::Nibbles;
 use reth_trie_sparse::RevealedSparseTrie;
 
-pub fn update_rlp_node_level(c: &mut Criterion) {
+fn update_rlp_node_level(c: &mut Criterion) {
     let mut rng = generators::rng();
 
     let mut group = c.benchmark_group("update rlp node level");
@@ -53,20 +51,11 @@ pub fn update_rlp_node_level(c: &mut Criterion) {
                 group.bench_function(
                     format!("size {size} | updated {updated_leaves}% | depth {depth}"),
                     |b| {
-                        // Use `iter_custom` to avoid measuring clones and drops
-                        b.iter_custom(|iters| {
-                            let mut elapsed = Duration::ZERO;
-
-                            let mut cloned = sparse.clone();
-                            for _ in 0..iters {
-                                let start = Instant::now();
-                                cloned.update_rlp_node_level(depth);
-                                elapsed += start.elapsed();
-                                cloned = sparse.clone();
-                            }
-
-                            elapsed
-                        })
+                        b.iter_batched_ref(
+                            || sparse.clone(),
+                            |cloned| cloned.update_rlp_node_level(depth),
+                            criterion::BatchSize::PerIteration,
+                        )
                     },
                 );
             }

crates/trie/sparse/benches/root.rs

@@ -1,4 +1,4 @@
-#![allow(missing_docs, unreachable_pub)]
+#![allow(missing_docs)]
 
 use alloy_primitives::{map::B256HashMap, B256, U256};
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
@@ -15,11 +15,17 @@ use reth_trie::{
 use reth_trie_common::{HashBuilder, Nibbles};
 use reth_trie_sparse::SparseTrie;
 
-pub fn calculate_root_from_leaves(c: &mut Criterion) {
+fn calculate_root_from_leaves(c: &mut Criterion) {
     let mut group = c.benchmark_group("calculate root from leaves");
     group.sample_size(20);
 
     for size in [1_000, 5_000, 10_000, 100_000] {
+        // Too slow.
+        #[allow(unexpected_cfgs)]
+        if cfg!(codspeed) && size > 5_000 {
+            continue;
+        }
+
         let state = generate_test_data(size);
 
         // hash builder
@@ -29,6 +35,7 @@ pub fn calculate_root_from_leaves(c: &mut Criterion) {
                     hb.add_leaf(Nibbles::unpack(key), &alloy_rlp::encode_fixed_size(value));
                 }
                 hb.root();
+                hb
             })
         });
 
@@ -44,19 +51,32 @@ pub fn calculate_root_from_leaves(c: &mut Criterion) {
                         .unwrap();
                 }
                 sparse.root().unwrap();
+                sparse
             })
         });
     }
 }
 
-pub fn calculate_root_from_leaves_repeated(c: &mut Criterion) {
+fn calculate_root_from_leaves_repeated(c: &mut Criterion) {
     let mut group = c.benchmark_group("calculate root from leaves repeated");
     group.sample_size(20);
 
     for init_size in [1_000, 10_000, 100_000] {
+        // Too slow.
+        #[allow(unexpected_cfgs)]
+        if cfg!(codspeed) && init_size > 10_000 {
+            continue;
+        }
+
         let init_state = generate_test_data(init_size);
 
         for update_size in [100, 1_000, 5_000, 10_000] {
+            // Too slow.
+            #[allow(unexpected_cfgs)]
+            if cfg!(codspeed) && update_size > 1_000 {
+                continue;
+            }
+
             for num_updates in [1, 3, 5, 10] {
                 let updates =
                     (0..num_updates).map(|_| generate_test_data(update_size)).collect::<Vec<_>>();