Criterion bench: state_provider_builder reuse

lines.png

state_provider_builder.rs

//! Benchmark for state provider builder reuse.

#![allow(missing_docs)]

use alloy_consensus::Header;
use alloy_primitives::B256;
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
use reth_engine_tree::tree::StateProviderBuilder;
use reth_ethereum_primitives::EthPrimitives;
use reth_provider::{test_utils::MockEthProvider, HeaderProvider};
use std::hint::black_box;

fn build_builder(
    provider: &MockEthProvider<EthPrimitives>,
    hash: B256,
) -> StateProviderBuilder<EthPrimitives, MockEthProvider<EthPrimitives>> {
    let header = provider.header(hash).expect("header lookup failed");
    assert!(header.is_some(), "missing header for hash");
    StateProviderBuilder::new(provider.clone(), hash, None)
}

fn bench_state_provider_builder(c: &mut Criterion) {
    let provider = MockEthProvider::<EthPrimitives>::new();
    let hash = B256::from([0x11u8; 32]);
    let header = Header { number: 1, ..Header::default() };
    provider.add_header(hash, header);

    let mut group = c.benchmark_group("state_provider_builder_reuse");

    group.bench_with_input(BenchmarkId::new("single_lookup", 1), &hash, |b, hash| {
        b.iter(|| {
            let builder = build_builder(&provider, *hash);
            black_box(builder);
        });
    });

    group.bench_with_input(BenchmarkId::new("double_lookup", 2), &hash, |b, hash| {
        b.iter(|| {
            let first = build_builder(&provider, *hash);
            let second = build_builder(&provider, *hash);
            black_box((first, second));
        });
    });

    group.finish();
}

criterion_group!(benches, bench_state_provider_builder);
criterion_main!(benches);

state_provider_builder_bench.md

state_provider_builder Bench (Criterion)

Command:

cargo bench -p reth-engine-tree --bench state_provider_builder

TL;DR

• One lookup: ~67.46 ns
• Two lookups: ~168.69 ns (~2.5x slower)
• Reusing the provider builder removes the second lookup + builder construction on the hot path.

Results

Benchmark	Mean	Notes
single_lookup/1	67.457 ns	1 lookup + builder creation
double_lookup/2	168.69 ns	2 lookups + 2 builders

Interpretation

• Double lookup costs ~2.5x single lookup in this microbench.
• Reusing the provider builder removes the second lookup + builder construction on the hot path.

Raw output excerpt:

state_provider_builder_reuse/single_lookup/1
                        time:   [67.378 ns 67.457 ns 67.543 ns]

state_provider_builder_reuse/double_lookup/2
                        time:   [168.54 ns 168.69 ns 168.83 ns]

violin.png

violin.svg