wip

substrate/frame/contracts/src/benchmarking/call_builder.rs

@@ -179,20 +179,24 @@ macro_rules! call_builder(
 	};
 );
 
+#[macro_export]
+macro_rules! memory(
+	($($bytes:expr,)*) => {
+		 vec![]
+		    .into_iter()
+		    $(.chain($bytes))*
+		    .collect::<Vec<_>>()
+	};
+);
+
 #[macro_export]
 macro_rules! build_runtime(
-	// ($runtime:ident, $memory:ident: $val:expr) => {
-	// 	$crate::build_runtime!($runtime, _contract, $memory: $val);
-	// };
 	($runtime:ident, $memory:ident: [$($segment:expr,)*]) => {
 		$crate::build_runtime!($runtime, _contract, $memory: [$($segment,)*]);
 	};
-	($runtime:ident, $contract:ident, $memory:ident: [$($segment:expr,)*]) => {
+	($runtime:ident, $contract:ident, $memory:ident: [$($bytes:expr,)*]) => {
 		$crate::build_runtime!($runtime, $contract);
-		let mut $memory = vec![]
-			.into_iter()
-			$(.chain($segment))*
-			.collect::<Vec<_>>();
+		let mut $memory = $crate::memory!($($bytes,)*);
 	};
 	($runtime:ident, $contract:ident) => {
 		let mut setup = CallSetup::<T>::default();

substrate/frame/contracts/src/benchmarking/code.rs

@@ -317,53 +317,12 @@ impl<T: Config> WasmModule<T> {
 		}
 		.into()
 	}
-
-	/// Creates a wasm module that calls the imported hash function named `name` `repeat` times
-	/// with an input of size `data_size`. Hash functions have the signature
-	/// (input_ptr: u32, input_len: u32, output_ptr: u32) -> ()
-	pub fn hasher(name: &'static str, repeat: u32, data_size: u32) -> Self {
-		ModuleDefinition {
-			memory: Some(ImportedMemory::max::<T>()),
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name,
-				params: vec![ValueType::I32, ValueType::I32, ValueType::I32],
-				return_type: None,
-			}],
-			call_body: Some(body::repeated(
-				repeat,
-				&[
-					Instruction::I32Const(0),                // input_ptr
-					Instruction::I32Const(data_size as i32), // input_len
-					Instruction::I32Const(0),                // output_ptr
-					Instruction::Call(0),
-				],
-			)),
-			..Default::default()
-		}
-		.into()
-	}
 }
 
 /// Mechanisms to generate a function body that can be used inside a `ModuleDefinition`.
 pub mod body {
 	use super::*;
 
-	/// When generating contract code by repeating a Wasm sequence, it's sometimes necessary
-	/// to change those instructions on each repetition. The variants of this enum describe
-	/// various ways in which this can happen.
-	pub enum DynInstr {
-		/// Insert the associated instruction.
-		Regular(Instruction),
-		/// Insert a I32Const with incrementing value for each insertion.
-		/// (start_at, increment_by)
-		Counter(u32, u32),
-	}
-
-	pub fn plain(instructions: Vec<Instruction>) -> FuncBody {
-		FuncBody::new(Vec::new(), Instructions::new(instructions))
-	}
-
 	pub fn repeated(repetitions: u32, instructions: &[Instruction]) -> FuncBody {
 		repeated_with_locals(&[], repetitions, instructions)
 	}
@@ -397,24 +356,6 @@ pub mod body {
 		instructions.push(Instruction::End);
 		FuncBody::new(locals.to_vec(), Instructions::new(instructions))
 	}
-
-	pub fn repeated_dyn(repetitions: u32, mut instructions: Vec<DynInstr>) -> FuncBody {
-		// We need to iterate over indices because we cannot cycle over mutable references
-		let body = (0..instructions.len())
-			.cycle()
-			.take(instructions.len() * usize::try_from(repetitions).unwrap())
-			.flat_map(|idx| match &mut instructions[idx] {
-				DynInstr::Regular(instruction) => vec![instruction.clone()],
-				DynInstr::Counter(offset, increment_by) => {
-					let current = *offset;
-					*offset += *increment_by;
-					vec![Instruction::I32Const(current as i32)]
-				},
-			})
-			.chain(sp_std::iter::once(Instruction::End))
-			.collect();
-		FuncBody::new(Vec::new(), Instructions::new(body))
-	}
 }
 
 /// The maximum amount of pages any contract is allowed to have according to the current `Schedule`.