Benchmark Timestamp Pallet (#4891)

* Add selected_benchmark! macro.

* Use selected_benchmark! in Identity pallet.

* Implement timestamp pallet benchmark.

* Fix some nits.

* Bump impl_version.

substrate/bin/node/runtime/src/lib.rs

@@ -82,7 +82,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
 	// implementation changes and behavior does not, then leave spec_version as
 	// is and increment impl_version.
 	spec_version: 216,
-	impl_version: 0,
+	impl_version: 1,
 	apis: RUNTIME_API_VERSIONS,
 };
 
@@ -813,6 +813,7 @@ impl_runtime_apis! {
 		{
 			match module.as_slice() {
 				b"pallet-identity" | b"identity" => Identity::run_benchmark(extrinsic, steps, repeat).ok(),
+				b"pallet-timestamp" | b"timestamp" => Timestamp::run_benchmark(extrinsic, steps, repeat).ok(),
 				_ => return None,
 			}
 		}

substrate/frame/identity/src/benchmarking.rs

@@ -20,7 +20,7 @@ use super::*;
 
 use frame_system::RawOrigin;
 use sp_io::hashing::blake2_256;
-use sp_runtime::{BenchmarkResults, BenchmarkParameter};
+use sp_runtime::{BenchmarkResults, BenchmarkParameter, selected_benchmark};
 use sp_runtime::traits::{Bounded, Benchmarking, BenchmarkingSetup, Dispatchable};
 
 use crate::Module as Identity;
@@ -514,7 +514,7 @@ impl<T: Trait> BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>> for
 }
 
 // The list of available benchmarks for this pallet.
-enum SelectedBenchmark {
+selected_benchmark!(
 	AddRegistrar,
 	SetIdentity,
 	SetSubs,
@@ -525,46 +525,8 @@ enum SelectedBenchmark {
 	SetAccountId,
 	SetFields,
 	ProvideJudgement,
-	KillIdentity,
-}
-
-// Allow us to select a benchmark from the list of available benchmarks.
-
-impl<T: Trait> BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>> for SelectedBenchmark {
-	fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)> {
-		match self {
-			Self::AddRegistrar => <AddRegistrar as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::components(&AddRegistrar),
-			Self::SetIdentity => <SetIdentity as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::components(&SetIdentity),
-			Self::SetSubs => <SetSubs as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::components(&SetSubs),
-			Self::ClearIdentity => <ClearIdentity as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::components(&ClearIdentity),
-			Self::RequestJudgement => <RequestJudgement as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::components(&RequestJudgement),
-			Self::CancelRequest => <CancelRequest as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::components(&CancelRequest),
-			Self::SetFee => <SetFee as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::components(&SetFee),
-			Self::SetAccountId => <SetAccountId as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::components(&SetAccountId),
-			Self::SetFields => <SetFields as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::components(&SetFields),
-			Self::ProvideJudgement => <ProvideJudgement as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::components(&ProvideJudgement),
-			Self::KillIdentity => <KillIdentity as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::components(&KillIdentity),
-		}
-	}
-
-	fn instance(&self, components: &[(BenchmarkParameter, u32)])
-		-> Result<(crate::Call<T>, RawOrigin<T::AccountId>), &'static str>
-	{
-		match self {
-			Self::AddRegistrar => <AddRegistrar as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::instance(&AddRegistrar, components),
-			Self::SetIdentity => <SetIdentity as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::instance(&SetIdentity, components),
-			Self::SetSubs => <SetSubs as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::instance(&SetSubs, components),
-			Self::ClearIdentity => <ClearIdentity as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::instance(&ClearIdentity, components),
-			Self::RequestJudgement => <RequestJudgement as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::instance(&RequestJudgement, components),
-			Self::CancelRequest => <CancelRequest as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::instance(&CancelRequest, components),
-			Self::SetFee => <SetFee as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::instance(&SetFee, components),
-			Self::SetAccountId => <SetAccountId as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::instance(&SetAccountId, components),
-			Self::SetFields => <SetFields as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::instance(&SetFields, components),
-			Self::ProvideJudgement => <ProvideJudgement as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::instance(&ProvideJudgement, components),
-			Self::KillIdentity => <KillIdentity as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::instance(&KillIdentity, components),
-		}
-	}
-}
+	KillIdentity
+);
 
 impl<T: Trait> Benchmarking<BenchmarkResults> for Module<T> {
 	fn run_benchmark(extrinsic: Vec<u8>, steps: u32, repeat: u32) -> Result<Vec<BenchmarkResults>, &'static str> {

substrate/frame/timestamp/Cargo.toml

@@ -9,6 +9,7 @@ license = "GPL-3.0"
 serde = { version = "1.0.101", optional = true }
 codec = { package = "parity-scale-codec", version = "1.0.0", default-features = false, features = ["derive"] }
 sp-std = { version = "2.0.0", default-features = false, path = "../../primitives/std" }
+sp-io = { version = "2.0.0", default-features = false, path = "../../primitives/io" }
 sp-runtime = { version = "2.0.0", default-features = false, path = "../../primitives/runtime" }
 sp-inherents = { version = "2.0.0", default-features = false, path = "../../primitives/inherents" }
 frame-support = { version = "2.0.0", default-features = false, path = "../support" }

substrate/frame/timestamp/src/benchmarking.rs

@@ -0,0 +1,105 @@
+// Copyright 2020 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Timestamp pallet benchmarking.
+
+use super::*;
+
+use sp_std::prelude::*;
+
+use frame_system::RawOrigin;
+use sp_runtime::{BenchmarkResults, BenchmarkParameter, selected_benchmark};
+use sp_runtime::traits::{Benchmarking, BenchmarkingSetup, Dispatchable};
+
+/// Benchmark `set` extrinsic.
+struct Set;
+impl<T: Trait> BenchmarkingSetup<T, Call<T>, RawOrigin<T::AccountId>> for Set {
+	fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)> {
+		vec![
+			// Current time ("Now")
+			(BenchmarkParameter::N, 1, 100),
+		]
+	}
+
+	fn instance(&self, components: &[(BenchmarkParameter, u32)])
+		-> Result<(Call<T>, RawOrigin<T::AccountId>), &'static str>
+	{
+		let user_origin = RawOrigin::None;
+		let now = components.iter().find(|&c| c.0 == BenchmarkParameter::N).unwrap().1;
+
+		// Return the `set` call
+		Ok((Call::<T>::set(now.into()), user_origin))
+	}
+}
+
+selected_benchmark!(Set);
+
+impl<T: Trait> Benchmarking<BenchmarkResults> for Module<T> {
+	fn run_benchmark(extrinsic: Vec<u8>, steps: u32, repeat: u32) -> Result<Vec<BenchmarkResults>, &'static str> {
+		// Map the input to the selected benchmark.
+		let selected_benchmark = match extrinsic.as_slice() {
+			b"set" => SelectedBenchmark::Set,
+			_ => return Err("Could not find extrinsic."),
+		};
+		
+		// Warm up the DB
+		sp_io::benchmarking::commit_db();
+		sp_io::benchmarking::wipe_db();
+
+		let components = <SelectedBenchmark as BenchmarkingSetup<T, crate::Call<T>, RawOrigin<T::AccountId>>>::components(&selected_benchmark);
+		let mut results: Vec<BenchmarkResults> = Vec::new();
+
+		// Select the component we will be benchmarking. Each component will be benchmarked.
+		for (name, low, high) in components.iter() {
+			// Create up to `STEPS` steps for that component between high and low.
+			let step_size = ((high - low) / steps).max(1);
+			let num_of_steps = (high - low) / step_size;
+			for s in 0..num_of_steps {
+				// This is the value we will be testing for component `name`
+				let component_value = low + step_size * s;
+
+				// Select the mid value for all the other components.
+				let c: Vec<(BenchmarkParameter, u32)> = components.iter()
+					.map(|(n, l, h)|
+						(*n, if n == name { component_value } else { (h - l) / 2 + l })
+					).collect();
+
+				// Run the benchmark `repeat` times.
+				for _ in 0..repeat {
+					// Set up the externalities environment for the setup we want to benchmark.
+					let (call, caller) = <SelectedBenchmark as BenchmarkingSetup<
+						T,
+						Call<T>,
+						RawOrigin<T::AccountId>,
+					>>::instance(&selected_benchmark, &c)?;
+					// Commit the externalities to the database, flushing the DB cache.
+					// This will enable worst case scenario for reading from the database.
+					sp_io::benchmarking::commit_db();
+					// Run the benchmark.
+					let start = sp_io::benchmarking::current_time();
+					call.dispatch(caller.into())?;
+					let finish = sp_io::benchmarking::current_time();
+					let elapsed = finish - start;
+					results.push((c.clone(), elapsed));
+					// Wipe the DB back to the genesis state.
+					sp_io::benchmarking::wipe_db();
+				}
+			}
+		}
+
+		return Ok(results);
+	}
+}

substrate/frame/timestamp/src/lib.rs

@@ -90,6 +90,8 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
+mod benchmarking;
+
 use sp_std::{result, cmp};
 use sp_inherents::{ProvideInherent, InherentData, InherentIdentifier};
 use frame_support::{Parameter, decl_storage, decl_module};

substrate/primitives/runtime/src/traits.rs

@@ -1333,6 +1333,55 @@ pub trait BenchmarkingSetup<T, Call, RawOrigin> {
 	fn instance(&self, components: &[(BenchmarkParameter, u32)]) -> Result<(Call, RawOrigin), &'static str>;
 }
 
+/// Creates a `SelectedBenchmark` enum implementing `BenchmarkingSetup`.
+///
+/// Every variant must implement [`BenchmarkingSetup`](crate::traits::BenchmarkingSetup).
+///
+/// ```nocompile
+///
+/// struct Transfer;
+/// impl BenchmarkingSetup for Transfer { ... }
+///
+/// struct SetBalance;
+/// impl BenchmarkingSetup for SetBalance { ... }
+///
+/// selected_benchmark!(Transfer, SetBalance);
+/// ```
+#[macro_export]
+macro_rules! selected_benchmark {
+	($($bench:ident),*) => {
+		// The list of available benchmarks for this pallet.
+		enum SelectedBenchmark {
+			$( $bench, )*
+		}
+
+		// Allow us to select a benchmark from the list of available benchmarks.
+		impl<T: Trait> $crate::traits::BenchmarkingSetup<T, Call<T>, RawOrigin<T::AccountId>> for SelectedBenchmark {
+			fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)> {
+				match self {
+					$( Self::$bench => <$bench as $crate::traits::BenchmarkingSetup<
+						T,
+						Call<T>,
+						RawOrigin<T::AccountId>,
+					>>::components(&$bench), )*
+				}
+			}
+
+			fn instance(&self, components: &[(BenchmarkParameter, u32)])
+				-> Result<(Call<T>, RawOrigin<T::AccountId>), &'static str>
+			{
+				match self {
+					$( Self::$bench => <$bench as $crate::traits::BenchmarkingSetup<
+						T,
+						Call<T>,
+						RawOrigin<T::AccountId>,
+					>>::instance(&$bench, components), )*
+				}
+			}
+		}
+	};
+}
+
 #[cfg(test)]
 mod tests {
 	use super::*;