benchmarks updated, tests pass

frame/contracts/src/benchmarking/code.rs

@@ -24,18 +24,15 @@
 //! we define this simple definition of a contract that can be passed to `create_code` that
 //! compiles it down into a `WasmModule` that can be used as a contract's code.
 
-use crate::{Config, Determinism};
+use crate::Config;
 use frame_support::traits::Get;
 use sp_runtime::traits::Hash;
 use sp_std::{borrow::ToOwned, prelude::*};
-use wasm_instrument::{
-	gas_metering,
-	parity_wasm::{
-		builder,
-		elements::{
-			self, BlockType, CustomSection, External, FuncBody, Instruction, Instructions, Module,
-			Section, ValueType,
-		},
+use wasm_instrument::parity_wasm::{
+	builder,
+	elements::{
+		self, BlockType, CustomSection, External, FuncBody, Instruction, Instructions, Module,
+		Section, ValueType,
 	},
 };
 
@@ -240,15 +237,9 @@ impl<T: Config> From<ModuleDefinition> for WasmModule<T> {
 }
 
 impl<T: Config> WasmModule<T> {
-	/// Uses the supplied wasm module and instruments it when requested.
-	pub fn instrumented(code: &[u8], inject_gas: bool) -> Self {
-		let module = {
-			let mut module = Module::from_bytes(code).unwrap();
-			if inject_gas {
-				module = inject_gas_metering::<T>(module);
-			}
-			module
-		};
+	/// Uses the supplied wasm module.
+	pub fn from_code(code: &[u8]) -> Self {
+		let module = Module::from_bytes(code).unwrap();
 		let limits = *module
 			.import_section()
 			.unwrap()
@@ -367,6 +358,7 @@ impl<T: Config> WasmModule<T> {
 		.into()
 	}
 
+	#[allow(dead_code)]
 	pub fn unary_instr(instr: Instruction, repeat: u32) -> Self {
 		use body::DynInstr::{RandomI64Repeated, Regular};
 		ModuleDefinition {
@@ -379,6 +371,7 @@ impl<T: Config> WasmModule<T> {
 		.into()
 	}
 
+	#[allow(dead_code)]
 	pub fn binary_instr(instr: Instruction, repeat: u32) -> Self {
 		use body::DynInstr::{RandomI64Repeated, Regular};
 		ModuleDefinition {
@@ -399,6 +392,7 @@ pub mod body {
 	/// 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.
+	#[allow(dead_code)]
 	pub enum DynInstr {
 		/// Insert the associated instruction.
 		Regular(Instruction),
@@ -499,6 +493,7 @@ pub mod body {
 	}
 
 	/// Replace the locals of the supplied `body` with `num` i64 locals.
+	#[allow(dead_code)]
 	pub fn inject_locals(body: &mut FuncBody, num: u32) {
 		use self::elements::Local;
 		*body.locals_mut() = vec![Local::new(num, ValueType::I64)];
@@ -509,10 +504,3 @@ pub mod body {
 pub fn max_pages<T: Config>() -> u32 {
 	T::Schedule::get().limits.memory_pages
 }
-
-fn inject_gas_metering<T: Config>(module: Module) -> Module {
-	let schedule = T::Schedule::get();
-	let gas_rules = schedule.rules(Determinism::Enforced);
-	let backend = gas_metering::host_function::Injector::new("seal0", "gas");
-	gas_metering::inject(module, backend, &gas_rules).unwrap()
-}

frame/contracts/src/benchmarking/mod.rs

@@ -40,10 +40,9 @@ use frame_support::{pallet_prelude::StorageVersion, weights::Weight};
 use frame_system::RawOrigin;
 use sp_runtime::{
 	traits::{Bounded, Hash},
-	Perbill,
 };
 use sp_std::prelude::*;
-use wasm_instrument::parity_wasm::elements::{BlockType, BrTableData, Instruction, ValueType};
+use wasm_instrument::parity_wasm::elements::{BlockType, Instruction, ValueType};
 
 /// How many runs we do per API benchmark.
 ///
@@ -218,7 +217,7 @@ benchmarks! {
 	// This benchmarks the v9 migration step. (update codeStorage)
 	#[pov_mode = Measured]
 	v9_migration_step {
-		let c in 0 .. Perbill::from_percent(49).mul_ceil(T::MaxCodeLen::get());
+		let c in 0 .. T::MaxCodeLen::get();
 		v9::store_old_dummy_code::<T>(c as usize);
 		let mut m = v9::Migration::<T>::default();
 	}: {
@@ -329,14 +328,9 @@ benchmarks! {
 	// `c`: Size of the code in bytes.
 	// `i`: Size of the input in bytes.
 	// `s`: Size of the salt in bytes.
-	//
-	// # Note
-	//
-	// We cannot let `c` grow to the maximum code size because the code is not allowed
-	// to be larger than the maximum size **after instrumentation**.
 	#[pov_mode = Measured]
 	instantiate_with_code {
-		let c in 0 .. Perbill::from_percent(49).mul_ceil(T::MaxCodeLen::get());
+		let c in 0 .. T::MaxCodeLen::get();
 		let i in 0 .. code::max_pages::<T>() * 64 * 1024;
 		let s in 0 .. code::max_pages::<T>() * 64 * 1024;
 		let input = vec![42u8; i as usize];
@@ -426,14 +420,9 @@ benchmarks! {
 	// This constructs a contract that is maximal expensive to instrument.
 	// It creates a maximum number of metering blocks per byte.
 	// `c`: Size of the code in bytes.
-	//
-	// # Note
-	//
-	// We cannot let `c` grow to the maximum code size because the code is not allowed
-	// to be larger than the maximum size **after instrumentation**.
 	#[pov_mode = Measured]
 	upload_code {
-		let c in 0 .. Perbill::from_percent(49).mul_ceil(T::MaxCodeLen::get());
+		let c in 0 .. T::MaxCodeLen::get();
 		let caller = whitelisted_caller();
 		T::Currency::make_free_balance_be(&caller, caller_funding::<T>());
 		let WasmModule { code, hash, .. } = WasmModule::<T>::sized(c, Location::Call);
@@ -717,27 +706,6 @@ benchmarks! {
 		let origin = RawOrigin::Signed(instance.caller.clone());
 	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
 
-	#[pov_mode = Measured]
-	seal_gas {
-		let r in 0 .. API_BENCHMARK_RUNS;
-		let code = WasmModule::<T>::from(ModuleDefinition {
-			imported_functions: vec![ImportedFunction {
-				module: "seal0",
-				name: "gas",
-				params: vec![ValueType::I64],
-				return_type: None,
-			}],
-			call_body: Some(body::repeated(r, &[
-				Instruction::I64Const(42),
-				Instruction::Call(0),
-			])),
-			.. Default::default()
-		});
-		let instance = Contract::<T>::new(code, vec![])?;
-		let origin = RawOrigin::Signed(instance.caller.clone());
-
-	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
-
 	#[pov_mode = Measured]
 	seal_input {
 		let r in 0 .. API_BENCHMARK_RUNS;
@@ -1032,7 +1000,7 @@ benchmarks! {
 		// or maximum allowed debug buffer size, whichever is less.
 		let i in 0 .. (T::Schedule::get().limits.memory_pages * 64 * 1024).min(T::MaxDebugBufferLen::get());
 		// We benchmark versus messages containing printable ASCII codes.
-		// About 1Kb goes to the instrumented contract code instructions,
+		// About 1Kb goes to the contract code instructions,
 		// whereas all the space left we use for the initialization of the debug messages data.
 		let message = (0 .. T::MaxCodeLen::get() - 1024).zip((32..127).cycle()).map(|i| i.1).collect::<Vec<_>>();
 		let code = WasmModule::<T>::from(ModuleDefinition {
@@ -2467,21 +2435,16 @@ benchmarks! {
 	}: {}
 
 	// Execute one erc20 transfer using the ink! erc20 example contract.
-	//
-	// `g` is used to enable gas instrumentation to compare the performance impact of
-	// that instrumentation at runtime.
 	#[extra]
 	#[pov_mode = Measured]
 	ink_erc20_transfer {
-		let g in 0 .. 1;
-		let gas_metering = g != 0;
 		let code = load_benchmark!("ink_erc20");
 		let data = {
 			let new: ([u8; 4], BalanceOf<T>) = ([0x9b, 0xae, 0x9d, 0x5e], 1000u32.into());
 			new.encode()
 		};
 		let instance = Contract::<T>::new(
-			WasmModule::instrumented(code, gas_metering), data,
+			WasmModule::from_code(code), data,
 		)?;
 		let data = {
 			let transfer: ([u8; 4], AccountIdOf<T>, BalanceOf<T>) = (
@@ -2507,14 +2470,9 @@ benchmarks! {
 	}
 
 	// Execute one erc20 transfer using the open zeppelin erc20 contract compiled with solang.
-	//
-	// `g` is used to enable gas instrumentation to compare the performance impact of
-	// that instrumentation at runtime.
 	#[extra]
 	#[pov_mode = Measured]
 	solang_erc20_transfer {
-		let g in 0 .. 1;
-		let gas_metering = g != 0;
 		let code = include_bytes!("../../benchmarks/solang_erc20.wasm");
 		let caller = account::<T::AccountId>("instantiator", 0, 0);
 		let mut balance = [0u8; 32];
@@ -2530,7 +2488,7 @@ benchmarks! {
 			new.encode()
 		};
 		let instance = Contract::<T>::with_caller(
-			caller, WasmModule::instrumented(code, gas_metering), data,
+			caller, WasmModule::from_code(code), data,
 		)?;
 		balance[0] = 1;
 		let data = {

frame/contracts/src/benchmarking/sandbox.rs

@@ -15,11 +15,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-/// ! For instruction benchmarking we do no instantiate a full contract but merely the
-/// ! sandbox to execute the wasm code. This is because we do not need the full
+/// ! For instruction benchmarking we do not instantiate a full contract but merely the
+/// ! sandbox to execute the Wasm code. This is because we do not need the full
 /// ! environment that provides the seal interface as imported functions.
 use super::{code::WasmModule, Config};
-use crate::wasm::{AllowDeprecatedInterface, AllowUnstableInterface, Environment};
+use crate::wasm::{AllowDeprecatedInterface, AllowUnstableInterface, Environment, WasmBlob};
 use wasmi::{errors::LinkerError, Func, Linker, StackLimits, Store};
 
 /// Minimal execution environment without any imported functions.
@@ -37,14 +37,15 @@ impl Sandbox {
 
 impl<T: Config> From<&WasmModule<T>> for Sandbox {
 	/// Creates an instance from the supplied module and supplies as much memory
-	/// to the instance as the module declares as imported.
+	/// to the instance as the module declares as imported. Sets the execution engine fuel level
+	/// to `u64::MAX`.
 	fn from(module: &WasmModule<T>) -> Self {
 		let memory = module
 			.memory
 			.as_ref()
 			.map(|mem| (mem.min_pages, mem.max_pages))
 			.unwrap_or((0, 0));
-		let (store, _memory, instance) = WasmBlob::<T>::instantiate::<EmptyEnv, _>(
+		let (mut store, _memory, instance) = WasmBlob::<T>::instantiate::<EmptyEnv, _>(
 			&module.code,
 			(),
 			memory,
@@ -53,6 +54,12 @@ impl<T: Config> From<&WasmModule<T>> for Sandbox {
 			AllowDeprecatedInterface::No,
 		)
 		.expect("Failed to create benchmarking Sandbox instance");
+
+		// Set fuel for wasmi execution.
+		store
+			.add_fuel(u64::MAX)
+			.expect("We've set up engine to fuel consuming mode; qed");
+
 		let entry_point = instance.get_export(&store, "call").unwrap().into_func().unwrap();
 		Self { entry_point, store }
 	}

frame/contracts/src/wasm/mod.rs

@@ -362,8 +362,8 @@ impl<T: Config> WasmBlob<T> {
 		schedule: &Schedule<T>,
 		owner: T::AccountId,
 	) -> DispatchResult {
-		let (executable, owner_info) = Self::from_code_unchecked(code, schedule, owner)?;
-		store_code(executable, false)
+		let executable = Self::from_code_unchecked(code, schedule, owner)?;
+		Self::store_code(executable, false)
 	}
 
 	/// Create the module without checking the passed code.