add internal repeats

frame/benchmarking/src/lib.rs

@@ -771,6 +771,7 @@ macro_rules! impl_benchmark {
 				c: &[($crate::BenchmarkParameter, u32)],
 				whitelist: &[$crate::TrackedStorageKey],
 				verify: bool,
+				internal_repeats: u32,
 			) -> Result<$crate::Vec<$crate::BenchmarkResults>, &'static str> {
 				// Map the input to the selected benchmark.
 				let extrinsic = $crate::sp_std::str::from_utf8(extrinsic)
@@ -789,88 +790,89 @@ macro_rules! impl_benchmark {
 				whitelist.push(whitelisted_caller_key.into());
 				$crate::benchmarking::set_whitelist(whitelist);
 
-				// Set up the externalities environment for the setup we want to
-				// benchmark.
-				let closure_to_benchmark = <
-					SelectedBenchmark as $crate::BenchmarkingSetup<T $(, $instance)?>
-				>::instance(&selected_benchmark, c, verify)?;
+				let mut results: $crate::Vec<$crate::BenchmarkResults> = $crate::Vec::new();
 
-				// Set the block number to at least 1 so events are deposited.
-				if $crate::Zero::is_zero(&frame_system::Pallet::<T>::block_number()) {
-					frame_system::Pallet::<T>::set_block_number(1u32.into());
-				}
+				for i in 0 .. internal_repeats.max(1) {
 
-				// Commit the externalities to the database, flushing the DB cache.
-				// This will enable worst case scenario for reading from the database.
-				$crate::benchmarking::commit_db();
+					// Set up the externalities environment for the setup we want to
+					// benchmark.
+					let closure_to_benchmark = <
+						SelectedBenchmark as $crate::BenchmarkingSetup<T $(, $instance)?>
+					>::instance(&selected_benchmark, c, verify)?;
 
-				// Reset the read/write counter so we don't count operations in the setup process.
-				$crate::benchmarking::reset_read_write_count();
+					// Set the block number to at least 1 so events are deposited.
+					if $crate::Zero::is_zero(&frame_system::Pallet::<T>::block_number()) {
+						frame_system::Pallet::<T>::set_block_number(1u32.into());
+					}
 
-				let mut results: $crate::Vec<$crate::BenchmarkResults> = $crate::Vec::new();
+					// Commit the externalities to the database, flushing the DB cache.
+					// This will enable worst case scenario for reading from the database.
+					$crate::benchmarking::commit_db();
 
-				// TODO internal repeats here
+					// Reset the read/write counter so we don't count operations in the setup process.
+					$crate::benchmarking::reset_read_write_count();
 
-				// Time the extrinsic logic.
-				$crate::log::trace!(
-					target: "benchmark",
-					"Start Benchmark: {:?}", c
-				);
+					// Time the extrinsic logic.
+					$crate::log::trace!(
+						target: "benchmark",
+						"Start Benchmark: {:?}", c
+					);
 
-				let start_pov = $crate::benchmarking::proof_size();
-				let start_extrinsic = $crate::benchmarking::current_time();
+					let start_pov = $crate::benchmarking::proof_size();
+					let start_extrinsic = $crate::benchmarking::current_time();
 
-				closure_to_benchmark()?;
+					closure_to_benchmark()?;
 
-				let finish_extrinsic = $crate::benchmarking::current_time();
-				let end_pov = $crate::benchmarking::proof_size();
+					let finish_extrinsic = $crate::benchmarking::current_time();
+					let end_pov = $crate::benchmarking::proof_size();
 
-				// Calculate the diff caused by the benchmark.
-				let elapsed_extrinsic = finish_extrinsic.saturating_sub(start_extrinsic);
-				let diff_pov = match (start_pov, end_pov) {
-					(Some(start), Some(end)) => end.saturating_sub(start),
-					_ => Default::default(),
-				};
+					// Calculate the diff caused by the benchmark.
+					let elapsed_extrinsic = finish_extrinsic.saturating_sub(start_extrinsic);
+					let diff_pov = match (start_pov, end_pov) {
+						(Some(start), Some(end)) => end.saturating_sub(start),
+						_ => Default::default(),
+					};
 
-				// Commit the changes to get proper write count
-				$crate::benchmarking::commit_db();
-				$crate::log::trace!(
-					target: "benchmark",
-					"End Benchmark: {} ns", elapsed_extrinsic
-				);
-				let read_write_count = $crate::benchmarking::read_write_count();
-				$crate::log::trace!(
-					target: "benchmark",
-					"Read/Write Count {:?}", read_write_count
-				);
+					// Commit the changes to get proper write count
+					$crate::benchmarking::commit_db();
+					$crate::log::trace!(
+						target: "benchmark",
+						"End Benchmark: {} ns", elapsed_extrinsic
+					);
+					let read_write_count = $crate::benchmarking::read_write_count();
+					$crate::log::trace!(
+						target: "benchmark",
+						"Read/Write Count {:?}", read_write_count
+					);
 
-				// Time the storage root recalculation.
-				let start_storage_root = $crate::benchmarking::current_time();
-				$crate::storage_root();
-				let finish_storage_root = $crate::benchmarking::current_time();
-				let elapsed_storage_root = finish_storage_root - start_storage_root;
+					// Time the storage root recalculation.
+					let start_storage_root = $crate::benchmarking::current_time();
+					$crate::storage_root();
+					let finish_storage_root = $crate::benchmarking::current_time();
+					let elapsed_storage_root = finish_storage_root - start_storage_root;
 
-				let skip_meta = [ $( stringify!($name_skip_meta).as_ref() ),* ];
-				let read_and_written_keys = if (&skip_meta).contains(&extrinsic) {
-					$crate::vec![(b"Skipped Metadata".to_vec(), 0, 0, false)]
-				} else {
-					$crate::benchmarking::get_read_and_written_keys()
-				};
+					let skip_meta = [ $( stringify!($name_skip_meta).as_ref() ),* ];
+					let read_and_written_keys = if (&skip_meta).contains(&extrinsic) {
+						$crate::vec![(b"Skipped Metadata".to_vec(), 0, 0, false)]
+					} else {
+						$crate::benchmarking::get_read_and_written_keys()
+					};
 
-				results.push($crate::BenchmarkResults {
-					components: c.to_vec(),
-					extrinsic_time: elapsed_extrinsic,
-					storage_root_time: elapsed_storage_root,
-					reads: read_write_count.0,
-					repeat_reads: read_write_count.1,
-					writes: read_write_count.2,
-					repeat_writes: read_write_count.3,
-					proof_size: diff_pov,
-					keys: read_and_written_keys,
-				});
+					results.push($crate::BenchmarkResults {
+						components: c.to_vec(),
+						extrinsic_time: elapsed_extrinsic,
+						storage_root_time: elapsed_storage_root,
+						reads: read_write_count.0,
+						repeat_reads: read_write_count.1,
+						writes: read_write_count.2,
+						repeat_writes: read_write_count.3,
+						proof_size: diff_pov,
+						keys: read_and_written_keys,
+					});
 
-				// Wipe the DB back to the genesis state.
-				$crate::benchmarking::wipe_db();
+					// Wipe the DB back to the genesis state.
+					$crate::benchmarking::wipe_db();
+				}
 
 				return Ok(results);
 			}
@@ -1321,6 +1323,7 @@ macro_rules! add_benchmark {
 			benchmark,
 			selected_components,
 			verify,
+			internal_repeats,
 		} = config;
 		if &pallet[..] == &name_string[..] {
 			$batches.push($crate::BenchmarkBatch {
@@ -1332,6 +1335,7 @@ macro_rules! add_benchmark {
 					&selected_components[..],
 					whitelist,
 					*verify,
+					*internal_repeats,
 				).map_err(|e| {
 					$crate::show_benchmark_debug_info(
 						instance_string,

frame/benchmarking/src/utils.rs

@@ -103,6 +103,8 @@ pub struct BenchmarkConfig {
 	pub selected_components: Vec<(BenchmarkParameter, u32)>,
 	/// Enable an extra benchmark iteration which runs the verification logic for a benchmark.
 	pub verify: bool,
+	/// Number of times to repeat benchmark within the Wasm environment. (versus in the client)
+	pub internal_repeats: u32,
 }
 
 /// A list of benchmarks available for a particular pallet and instance.
@@ -231,6 +233,7 @@ pub trait Benchmarking<T> {
 		selected_components: &[(BenchmarkParameter, u32)],
 		whitelist: &[TrackedStorageKey],
 		verify: bool,
+		internal_repeats: u32,
 	) -> Result<Vec<T>, &'static str>;
 }
 

utils/frame/benchmarking-cli/src/command.rs

@@ -229,6 +229,7 @@ impl BenchmarkCmd {
 							&extrinsic.clone(),
 							&selected_components.clone(),
 							true, // run verification code
+							1,    // no need to do internal repeats
 						)
 							.encode(),
 						extensions(),
@@ -255,6 +256,7 @@ impl BenchmarkCmd {
 							&extrinsic.clone(),
 							&selected_components.clone(),
 							false, // dont run verification code for final values
+							self.internal_repeat,
 						)
 							.encode(),
 						extensions(),

utils/frame/benchmarking-cli/src/lib.rs

@@ -54,6 +54,10 @@ pub struct BenchmarkCmd {
 	#[structopt(short, long, default_value = "1")]
 	pub repeat: u32,
 
+	/// Select how many repetitions of this benchmark should run.
+	#[structopt(short, long, default_value = "1")]
+	pub internal_repeat: u32,
+
 	/// Print the raw results.
 	#[structopt(long = "raw")]
 	pub raw_data: bool,