Batch benchmarks together with * notation. (#5436)

* Batch benchmarks together with `*` notation.

* Fix short structopt conflict

* Return error if `batches` is empty

* Move fast benchmarks macro into `frame_benchmarking` (#5445)

* Move macro into `frame_benchmarking`

* Update docs

* Extra line

* Return error if `batches` is empty

Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com>

substrate/frame/benchmarking/src/utils.rs

@@ -22,13 +22,24 @@ use sp_io::hashing::blake2_256;
 use sp_runtime::RuntimeString;
 
 /// An alphabet of possible parameters to use for benchmarking.
-#[derive(codec::Encode, codec::Decode, Clone, Copy, PartialEq, Debug)]
+#[derive(Encode, Decode, Clone, Copy, PartialEq, Debug)]
 #[allow(missing_docs)]
 #[allow(non_camel_case_types)]
 pub enum BenchmarkParameter {
 	a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z,
 }
 
+/// The results of a single of benchmark.
+#[derive(Encode, Decode, Clone, PartialEq, Debug)]
+pub struct BenchmarkBatch {
+	/// The pallet containing this benchmark.
+	pub pallet: Vec<u8>,
+	/// The extrinsic (or benchmark name) of this benchmark.
+	pub benchmark: Vec<u8>,
+	/// The results from this benchmark.
+	pub results: Vec<BenchmarkResults>,
+}
+
 /// Results from running benchmarks on a FRAME pallet.
 /// Contains duration of the function call in nanoseconds along with the benchmark parameters
 /// used for that benchmark result.
@@ -39,13 +50,13 @@ sp_api::decl_runtime_apis! {
 	pub trait Benchmark {
 		/// Dispatch the given benchmark.
 		fn dispatch_benchmark(
-			module: Vec<u8>,
-			extrinsic: Vec<u8>,
+			pallet: Vec<u8>,
+			benchmark: Vec<u8>,
 			lowest_range_values: Vec<u32>,
 			highest_range_values: Vec<u32>,
 			steps: Vec<u32>,
 			repeat: u32,
-		) -> Result<Vec<BenchmarkResults>, RuntimeString>;
+		) -> Result<Vec<BenchmarkBatch>, RuntimeString>;
 	}
 }
 
@@ -75,19 +86,24 @@ pub trait Benchmarking {
 
 /// The pallet benchmarking trait.
 pub trait Benchmarking<T> {
+	/// Get the benchmarks available for this pallet. Generally there is one benchmark per
+	/// extrinsic, so these are sometimes just called "extrinsics".
+	fn benchmarks() -> Vec<&'static [u8]>;
+
 	/// Run the benchmarks for this pallet.
 	///
 	/// Parameters
-	/// - `extrinsic`: The name of extrinsic function you want to benchmark encoded as bytes.
+	/// - `name`: The name of extrinsic function or benchmark you want to benchmark encoded as
+	///   bytes.
 	/// - `steps`: The number of sample points you want to take across the range of parameters.
 	/// - `lowest_range_values`: The lowest number for each range of parameters.
 	/// - `highest_range_values`: The highest number for each range of parameters.
 	/// - `repeat`: The number of times you want to repeat a benchmark.
 	fn run_benchmark(
-		extrinsic: Vec<u8>,
-		lowest_range_values: Vec<u32>,
-		highest_range_values: Vec<u32>,
-		steps: Vec<u32>,
+		name: &[u8],
+		lowest_range_values: &[u32],
+		highest_range_values: &[u32],
+		steps: &[u32],
 		repeat: u32,
 	) -> Result<Vec<T>, &'static str>;
 }