Benchmark Ethereum Pallet

modules/ethereum/src/benchmarking.rs

@@ -16,12 +16,17 @@
 
 use super::*;
 
-use crate::test_utils::{build_custom_header, build_genesis_header, validator_utils::*};
+use crate::finality::FinalityAncestor;
+use crate::test_utils::{build_custom_header, build_genesis_header, insert_header, validator_utils::*, HeaderBuilder};
 
 use frame_benchmarking::benchmarks;
 use frame_system::RawOrigin;
-use primitives::U256;
+use primitives::{Address, U256};
 
+// We want to try and benchmark scenario which are going to cause a lot for work for our runtime.
+// Some of the ones which we should test that are still missing are:
+//    - Importing a header with transaction receipts
+//    - An import which causes a chain re-org
 benchmarks! {
 	_ { }
 
@@ -33,7 +38,7 @@ benchmarks! {
 	import_unsigned_header_best_case {
 		let n in 1..1000;
 
-		// initialize storage with some initial header
+		// Initialize storage with some initial header
 		let initial_header = build_genesis_header(&validator(0));
 		let initial_header_hash = initial_header.compute_hash();
 		let initial_difficulty = initial_header.difficulty;
@@ -55,6 +60,163 @@ benchmarks! {
 
 	}: import_unsigned_header(RawOrigin::None, header, None)
 	verify {
-		assert_eq!(BridgeStorage::<T>::new().best_block().0.number, 1);
+		let storage = BridgeStorage::<T>::new();
+		assert_eq!(storage.best_block().0.number, 1);
+		assert_eq!(storage.finalized_block().number, 0);
+	}
+
+	// Our goal with this bench is to try and see the effect that finalizing difference ranges of
+	// blocks has on our import time. As such we need to make sure that we keep the number of
+	// validators fixed while changing the number blocks finalized (the complixity parameter) by
+	// importing the last header.
+	import_unsigned_finality {
+		// Our complexity parameter, n, will represent the number of blocks imported before
+		// finalization.
+		//
+		// For two validators this is only going to work for even numbers...
+		let n in 4..10;
+
+		// This should remain fixed for the bench.
+		let num_validators: u32 = 2;
+
+		let mut storage = BridgeStorage::<T>::new();
+
+		// Initialize storage with some initial header
+		let initial_header = build_genesis_header(&validator(0));
+		let initial_header_hash = initial_header.compute_hash();
+		let initial_difficulty = initial_header.difficulty;
+		let initial_validators = validators_addresses(num_validators as usize);
+
+		initialize_storage::<T>(
+			&initial_header,
+			initial_difficulty,
+			&initial_validators,
+		);
+
+		let mut headers = Vec::new();
+		let mut ancestry: Vec<FinalityAncestor<Option<Address>>> = Vec::new(); // Is this needed?
+		let mut parent = initial_header.clone();
+
+		// Q: Is this a sketchy way of "delaying" finality, or should I be manually editing the
+		// "step" of the new blocks?
+		for i in 1..=n {
+			let header = build_custom_header(
+				&validator(0),
+				&parent,
+				|mut header| {
+					header
+				},
+			);
+
+			let id = header.compute_id();
+			insert_header(&mut storage, header.clone());
+			ancestry.push(FinalityAncestor {
+				id: header.compute_id(),
+				submitter: None,
+				signers: vec![header.author].into_iter().collect(),
+			});
+			headers.push(header.clone());
+			parent = header;
+		}
+
+		// NOTE: I should look into using `sign_by_set()`
+		let last_header = headers.last().unwrap().clone();
+		let last_authority = validator(1);
+
+		// Need to make sure that the header we're going to import hasn't been inserted
+		// into storage already
+		let header = build_custom_header(
+			&last_authority,
+			&last_header,
+			|mut header| {
+				header
+			},
+		);
+	}: import_unsigned_header(RawOrigin::None, header, None)
+	verify {
+		let storage = BridgeStorage::<T>::new();
+		assert_eq!(storage.best_block().0.number, (n + 1) as u64);
+		assert_eq!(storage.finalized_block().number, n as u64);
+	}
+
+	// The default pruning range is 10 blocks behind. We'll start with this for the bench, but we
+	// should move to a "dynamic" strategy based off the complexity parameter
+	//
+	// Look at `headers_are_pruned_during_import()` test from `import.rs`
+	//
+	// So it looks like we're constrained by: MAX_BLOCKS_TO_PRUNE_IN_SINGLE_IMPORT= 8
+	//
+	// So it doesn't matter how we set the pruning window or how many blocks we build because at the
+	// end of the day we can only prune that many blocks
+	import_unsigned_pruning {
+		// The default pruning strategy is to keep 10 headers, so let's build more than 10
+		let n in 10..20;
+
+		let mut storage = BridgeStorage::<T>::new();
+
+		// TODO: Wrap this so we don't repeat so much between benches
+		// Initialize storage with some initial header
+		let initial_header = build_genesis_header(&validator(0));
+		let initial_header_hash = initial_header.compute_hash();
+		let initial_difficulty = initial_header.difficulty;
+		let validators = validators(3);
+
+		initialize_storage::<T>(
+			&initial_header,
+			initial_difficulty,
+			&validators_addresses(3),
+		);
+
+		// Want to prune eligible blocks between [0, 10)
+		BlocksToPrune::put(PruningRange {
+			oldest_unpruned_block: 0,
+			oldest_block_to_keep: 10,
+		});
+
+		let mut parent = initial_header;
+		for i in 1..=n {
+			let header = HeaderBuilder::with_parent(&parent).sign_by_set(&validators);
+			let id = header.compute_id();
+			insert_header(&mut storage, header.clone());
+			parent = header;
+		}
+
+		let header = HeaderBuilder::with_parent(&parent).sign_by_set(&validators);
+	}: import_unsigned_header(RawOrigin::None, header, None)
+	verify {
+		let storage = BridgeStorage::<T>::new();
+		assert_eq!(storage.best_block().0.number, (n + 1) as u64);
+
+		// We're limited to pruning only 8 blocks per import
+		assert!(HeadersByNumber::get(&0).is_none());
+		assert!(HeadersByNumber::get(&7).is_none());
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::mock::{run_test, TestRuntime};
+	use frame_support::assert_ok;
+
+	#[test]
+	fn insert_unsigned_header_best_case() {
+		run_test(2, |_| {
+			assert_ok!(test_benchmark_import_unsigned_header_best_case::<TestRuntime>());
+		});
+	}
+
+	#[test]
+	fn insert_unsigned_header_finality() {
+		run_test(1, |_| {
+			assert_ok!(test_benchmark_import_unsigned_finality::<TestRuntime>());
+		});
+	}
+
+	#[test]
+	fn insert_unsigned_header_pruning() {
+		run_test(1, |_| {
+			assert_ok!(test_benchmark_import_unsigned_pruning::<TestRuntime>());
+		});
 	}
 }

modules/ethereum/src/lib.rs

@@ -463,7 +463,7 @@ decl_storage! {
 			// the initial blocks should be selected so that:
 			// 1) it doesn't signal validators changes;
 			// 2) there are no scheduled validators changes from previous blocks;
-			// 3) (implied) all direct children of initial block are authred by the same validators set.
+			// 3) (implied) all direct children of initial block are authored by the same validators set.
 
 			assert!(
 				!config.initial_validators.is_empty(),
@@ -563,6 +563,7 @@ impl<T: Trait> BridgeStorage<T> {
 		// start pruning blocks
 		let begin = new_pruning_range.oldest_unpruned_block;
 		let end = new_pruning_range.oldest_block_to_keep;
+		frame_support::debug::trace!(target: "runtime", "Pruning blocks in range [{}..{})", begin, end);
 		for number in begin..end {
 			// if we can't prune anything => break
 			if max_blocks_to_prune == 0 {
@@ -588,6 +589,11 @@ impl<T: Trait> BridgeStorage<T> {
 
 			// we have pruned all headers at number
 			new_pruning_range.oldest_unpruned_block = number + 1;
+			frame_support::debug::trace!(
+				target: "runtime",
+				"Oldest unpruned PoA header is now: {}",
+				new_pruning_range.oldest_unpruned_block,
+			);
 		}
 
 		// update pruning range in storage

modules/ethereum/src/mock.rs

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity Bridges Common.  If not, see <http://www.gnu.org/licenses/>.
 
-pub use crate::test_utils::{validator_utils::*, HeaderBuilder, GAS_LIMIT};
+pub use crate::test_utils::{insert_header, validator_utils::*, HeaderBuilder, GAS_LIMIT};
 pub use primitives::signatures::secret_to_address;
 
 use crate::finality::FinalityVotes;
@@ -149,20 +149,6 @@ pub fn run_test_with_genesis<T>(genesis: Header, total_validators: usize, test:
 	})
 }
 
-/// Insert unverified header into storage.
-pub fn insert_header<S: Storage>(storage: &mut S, header: Header) {
-	storage.insert_header(HeaderToImport {
-		context: storage.import_context(None, &header.parent_hash).unwrap(),
-		is_best: true,
-		id: header.compute_id(),
-		header,
-		total_difficulty: 0.into(),
-		enacted_change: None,
-		scheduled_change: None,
-		finality_votes: FinalityVotes::default(),
-	});
-}
-
 /// Pruning strategy that keeps 10 headers behind best block.
 pub struct KeepSomeHeadersBehindBest(pub u64);
 

modules/ethereum/src/test_utils.rs

@@ -21,7 +21,9 @@
 //!
 //! On the other hand, they may be used directly by the bechmarking module.
 
+use crate::finality::FinalityVotes;
 use crate::verification::calculate_score;
+use crate::{HeaderToImport, Storage};
 
 use primitives::{
 	rlp_encode,
@@ -206,6 +208,20 @@ where
 	custom_header.sign_by(author)
 }
 
+/// Insert unverified header into storage.
+pub fn insert_header<S: Storage>(storage: &mut S, header: Header) {
+	storage.insert_header(HeaderToImport {
+		context: storage.import_context(None, &header.parent_hash).unwrap(),
+		is_best: true,
+		id: header.compute_id(),
+		header,
+		total_difficulty: 0.into(),
+		enacted_change: None,
+		scheduled_change: None,
+		finality_votes: FinalityVotes::default(),
+	});
+}
+
 pub mod validator_utils {
 	use super::*;