Add debug messages to TestingBeaconStateBuilder

eth2/state_processing/benches/bench_block_processing.rs

@@ -1,5 +1,6 @@
 use criterion::Criterion;
 use criterion::{black_box, Benchmark};
+use log::debug;
 use ssz::TreeHash;
 use state_processing::{
     per_block_processing,
@@ -107,6 +108,10 @@ fn build_block(state: &mut BeaconState, keypairs: &[Keypair], spec: &ChainSpec)
     let mut validators_iter = (0..keypairs.len() as u64).into_iter();
 
     // Insert the maximum possible number of `ProposerSlashing` objects.
+    debug!(
+        "Inserting {} proposer slashings...",
+        spec.max_proposer_slashings
+    );
     for _ in 0..spec.max_proposer_slashings {
         let validator_index = validators_iter.next().expect("Insufficient validators.");
 
@@ -119,6 +124,10 @@ fn build_block(state: &mut BeaconState, keypairs: &[Keypair], spec: &ChainSpec)
     }
 
     // Insert the maximum possible number of `AttesterSlashing` objects
+    debug!(
+        "Inserting {} attester slashings...",
+        spec.max_attester_slashings
+    );
     for _ in 0..spec.max_attester_slashings {
         let mut attesters: Vec<u64> = vec![];
         let mut secret_keys: Vec<&SecretKey> = vec![];
@@ -134,17 +143,20 @@ fn build_block(state: &mut BeaconState, keypairs: &[Keypair], spec: &ChainSpec)
     }
 
     // Insert the maximum possible number of `Attestation` objects.
+    debug!("Inserting {} attestations...", spec.max_attestations);
     let all_secret_keys: Vec<&SecretKey> = keypairs.iter().map(|keypair| &keypair.sk).collect();
     builder
         .fill_with_attestations(state, &all_secret_keys, spec)
         .unwrap();
 
     // Insert the maximum possible number of `Deposit` objects.
+    debug!("Inserting {} deposits...", spec.max_deposits);
     for i in 0..spec.max_deposits {
         builder.insert_deposit(32_000_000_000, state.deposit_index + i, state, spec);
     }
 
     // Insert the maximum possible number of `Exit` objects.
+    debug!("Inserting {} exits...", spec.max_voluntary_exits);
     for _ in 0..spec.max_voluntary_exits {
         let validator_index = validators_iter.next().expect("Insufficient validators.");
 
@@ -157,6 +169,7 @@ fn build_block(state: &mut BeaconState, keypairs: &[Keypair], spec: &ChainSpec)
     }
 
     // Insert the maximum possible number of `Transfer` objects.
+    debug!("Inserting {} transfers...", spec.max_transfers);
     for _ in 0..spec.max_transfers {
         let validator_index = validators_iter.next().expect("Insufficient validators.");
 

eth2/state_processing/benches/benches.rs

@@ -1,6 +1,7 @@
 use criterion::Benchmark;
 use criterion::Criterion;
 use criterion::{criterion_group, criterion_main};
+use env_logger::{Builder, Env};
 use types::test_utils::TestingBeaconStateBuilder;
 use types::*;
 
@@ -9,50 +10,17 @@ mod bench_epoch_processing;
 
 pub const VALIDATOR_COUNT: usize = 300_032;
 
+// `LOG_LEVEL == "debug"` gives logs, but they're very noisy and slow down benching.
+pub const LOG_LEVEL: &str = "";
+
 pub fn state_processing(c: &mut Criterion) {
+    if LOG_LEVEL != "" {
+        Builder::from_env(Env::default().default_filter_or(LOG_LEVEL)).init();
+    }
+
     bench_block_processing::bench_block_processing_n_validators(c, VALIDATOR_COUNT);
     bench_epoch_processing::bench_epoch_processing_n_validators(c, VALIDATOR_COUNT);
 }
 
-pub fn key_loading(c: &mut Criterion) {
-    let validator_count = 1000;
-
-    c.bench(
-        &format!("{}_validators", validator_count),
-        Benchmark::new("generated", move |b| {
-            b.iter_batched(
-                || (),
-                |_| {
-                    TestingBeaconStateBuilder::from_deterministic_keypairs(
-                        validator_count,
-                        &ChainSpec::foundation(),
-                    )
-                },
-                criterion::BatchSize::SmallInput,
-            )
-        })
-        .sample_size(10),
-    );
-
-    // Note: path needs to be relative to where cargo is executed from.
-    c.bench(
-        &format!("{}_validators", validator_count),
-        Benchmark::new("from_file", move |b| {
-            b.iter_batched(
-                || (),
-                |_| {
-                    TestingBeaconStateBuilder::from_default_keypairs_file_if_exists(
-                        validator_count,
-                        &ChainSpec::foundation(),
-                    )
-                },
-                criterion::BatchSize::SmallInput,
-            )
-        })
-        .sample_size(10),
-    );
-}
-
-// criterion_group!(benches, state_processing, key_loading);
-criterion_group!(benches, key_loading);
+criterion_group!(benches, state_processing);
 criterion_main!(benches);