Tree hash benches (#486)

* Add initial tree hash benches

* Add tree hash example

* Use lazy static in tree hash benches

eth2/utils/tree_hash/Cargo.toml

@@ -4,9 +4,15 @@ version = "0.1.0"
 authors = ["Paul Hauner <paul@paulhauner.com>"]
 edition = "2018"
 
+[[bench]]
+name = "benches"
+harness = false
+
 [dev-dependencies]
+criterion = "0.2"
 rand = "0.7"
 tree_hash_derive = { path = "../tree_hash_derive" }
+types = { path = "../../types" }
 
 [dependencies]
 ethereum-types = "0.5"

eth2/utils/tree_hash/benches/benches.rs

@@ -0,0 +1,56 @@
+#[macro_use]
+extern crate lazy_static;
+
+use criterion::Criterion;
+use criterion::{black_box, criterion_group, criterion_main, Benchmark};
+use tree_hash::TreeHash;
+use types::test_utils::{generate_deterministic_keypairs, TestingBeaconStateBuilder};
+use types::{BeaconState, EthSpec, Keypair, MainnetEthSpec, MinimalEthSpec};
+
+lazy_static! {
+    static ref KEYPAIRS: Vec<Keypair> = { generate_deterministic_keypairs(300_000) };
+}
+
+fn build_state<T: EthSpec>(validator_count: usize) -> BeaconState<T> {
+    let (state, _keypairs) = TestingBeaconStateBuilder::from_keypairs(
+        KEYPAIRS[0..validator_count].to_vec(),
+        &T::default_spec(),
+    )
+    .build();
+
+    assert_eq!(state.validators.len(), validator_count);
+    assert_eq!(state.balances.len(), validator_count);
+    assert!(state.previous_epoch_attestations.is_empty());
+    assert!(state.current_epoch_attestations.is_empty());
+    assert!(state.eth1_data_votes.is_empty());
+    assert!(state.historical_roots.is_empty());
+
+    state
+}
+
+fn bench_suite<T: EthSpec>(c: &mut Criterion, spec_desc: &str, validator_count: usize) {
+    let state = build_state::<T>(validator_count);
+
+    c.bench(
+        &format!("{}/{}_validators", spec_desc, validator_count),
+        Benchmark::new("genesis_state", move |b| {
+            b.iter_batched_ref(
+                || state.clone(),
+                |state| black_box(state.tree_hash_root()),
+                criterion::BatchSize::SmallInput,
+            )
+        })
+        .sample_size(10),
+    );
+}
+
+fn all_benches(c: &mut Criterion) {
+    bench_suite::<MinimalEthSpec>(c, "minimal", 100_000);
+    bench_suite::<MinimalEthSpec>(c, "minimal", 300_000);
+
+    bench_suite::<MainnetEthSpec>(c, "mainnet", 100_000);
+    bench_suite::<MainnetEthSpec>(c, "mainnet", 300_000);
+}
+
+criterion_group!(benches, all_benches,);
+criterion_main!(benches);

eth2/utils/tree_hash/examples/flamegraph_beacon_state.rs

@@ -0,0 +1,35 @@
+use tree_hash::TreeHash;
+use types::test_utils::TestingBeaconStateBuilder;
+use types::{BeaconState, EthSpec, MainnetEthSpec};
+
+const TREE_HASH_LOOPS: usize = 1_000;
+const VALIDATOR_COUNT: usize = 1_000;
+
+fn build_state<T: EthSpec>(validator_count: usize) -> BeaconState<T> {
+    let (state, _keypairs) = TestingBeaconStateBuilder::from_default_keypairs_file_if_exists(
+        validator_count,
+        &T::default_spec(),
+    )
+    .build();
+
+    assert_eq!(state.validators.len(), validator_count);
+    assert_eq!(state.balances.len(), validator_count);
+    assert!(state.previous_epoch_attestations.is_empty());
+    assert!(state.current_epoch_attestations.is_empty());
+    assert!(state.eth1_data_votes.is_empty());
+    assert!(state.historical_roots.is_empty());
+
+    state
+}
+
+fn main() {
+    let state = build_state::<MainnetEthSpec>(VALIDATOR_COUNT);
+
+    // This vec is an attempt to ensure the compiler doesn't optimize-out the hashing.
+    let mut vec = Vec::with_capacity(TREE_HASH_LOOPS);
+
+    for _ in 0..TREE_HASH_LOOPS {
+        let root = state.tree_hash_root();
+        vec.push(root[0]);
+    }
+}