default dl for benchmarking

more dl for tests

dl for tests to max

deposit_limit fix in instantiate bench

fix instantiate bench

fix instantiate benchmark

fix instantiate bench again

remove dbg

fix seal bench again

fixing it still

seal_instantiate zero deposit

less runs to check if deposit enough

try

try 2

try 3

try 4

frame/contracts/src/benchmarking/mod.rs

@@ -1771,17 +1771,17 @@ benchmarks! {
 	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, bytes)
 
 	// We assume that every instantiate sends at least the minimum balance.
-	// This is a slow call: We redeuce the number of runs.
+	// This is a slow call: we reduce the number of runs.
 	#[pov_mode = Measured]
 	seal_instantiate {
-		let r in 0 .. API_BENCHMARK_RUNS / 2;
+		let r in 1 .. API_BENCHMARK_RUNS / 2;
 		let hashes = (0..r)
 			.map(|i| {
 				let code = WasmModule::<T>::from(ModuleDefinition {
 					memory: Some(ImportedMemory::max::<T>()),
 					call_body: Some(body::plain(vec![
-						// we need to add this in order to make contracts unique
-						// so that they can be deployed from the same sender
+						// We need to add this in order to make contracts unique,
+						// so that they can be deployed from the same sender.
 						Instruction::I32Const(i as i32),
 						Instruction::Drop,
 						Instruction::End,
@@ -1794,21 +1794,16 @@ benchmarks! {
 			.collect::<Result<Vec<_>, &'static str>>()?;
 		let hash_len = hashes.get(0).map(|x| x.encode().len()).unwrap_or(0);
 		let hashes_bytes = hashes.iter().flat_map(|x| x.encode()).collect::<Vec<_>>();
-		let hashes_len = hashes_bytes.len();
+		let hashes_len = &hashes_bytes.len();
 		let value = Pallet::<T>::min_balance();
 		assert!(value > 0u32.into());
 		let value_bytes = value.encode();
 		let value_len = BalanceOf::<T>::max_encoded_len();
-		// Set an own deposit limit for every call
-		let deposit_limit: u32 = (u32::MAX - 100).into();
-		let deposit_bytes = deposit_limit.to_le_bytes().to_vec();
 		let addr_len = T::AccountId::max_encoded_len();
-		// offsets where to place static data in contract memory
-		let value_offset = 0;
-		let hashes_offset = value_offset + value_len;
+		// Offsets where to place static data in contract memory.
+		let hashes_offset = value_len;
 		let addr_len_offset = hashes_offset + hashes_len;
-		let deposit_offset = addr_len_offset + addr_len;
-		let addr_offset = deposit_offset + 4;
+		let addr_offset = addr_len_offset + addr_len;
 		let code = WasmModule::<T>::from(ModuleDefinition {
 			memory: Some(ImportedMemory::max::<T>()),
 			imported_functions: vec![ImportedFunction {
@@ -1833,7 +1828,7 @@ benchmarks! {
 			}],
 			data_segments: vec![
 				DataSegment {
-					offset: value_offset as u32,
+					offset: 0,
 					value: value_bytes,
 				},
 				DataSegment {
@@ -1844,17 +1839,13 @@ benchmarks! {
 					offset: addr_len_offset as u32,
 					value: addr_len.to_le_bytes().into(),
 				},
-				DataSegment {
-					offset: addr_offset as u32,
-					value: deposit_bytes,
-				},
 			],
 			call_body: Some(body::repeated_dyn(r, vec![
 				Counter(hashes_offset as u32, hash_len as u32), // code_hash_ptr
 				Regular(Instruction::I64Const(0)), // ref_time weight
 				Regular(Instruction::I64Const(0)), // proof_size weight
-				Regular(Instruction::I32Const(deposit_offset as i32)),  // deposit limit ptr
-				Regular(Instruction::I32Const(value_offset as i32)), // value_ptr
+				Regular(Instruction::I32Const(SENTINEL as i32)), // deposit limit ptr: use parent's limit
+				Regular(Instruction::I32Const(0)), // value_ptr
 				Regular(Instruction::I32Const(0)), // input_data_ptr
 				Regular(Instruction::I32Const(0)), // input_data_len
 				Regular(Instruction::I32Const(addr_offset as i32)), // address_ptr
@@ -1884,7 +1875,7 @@ benchmarks! {
 				return Err("Expected that contract does not exist at this point.".into());
 			}
 		}
-	}: call(origin, callee, 0u32.into(), Weight::MAX, Some(BalanceOf::<T>::from(u32::MAX).into()), vec![])
+	}: call(origin, callee, 0u32.into(), Weight::MAX, None, vec![])
 	verify {
 		for addr in &addresses {
 			ContractInfoOf::<T>::get(&addr)

frame/contracts/src/tests.rs

@@ -344,8 +344,8 @@ parameter_types! {
 	};
 	pub static DepositPerByte: BalanceOf<Test> = 1;
 	pub const DepositPerItem: BalanceOf<Test> = 2;
-	// We need this one set high enough for running benchmarks.
-	pub const DefaultDepositLimit: BalanceOf<Test> = 10_000_000;
+	// We set it to maximum for running benchmarks
+	pub const DefaultDepositLimit: BalanceOf<Test> = Balance::max_value();
 }
 
 impl Convert<Weight, BalanceOf<Self>> for Test {

frame/contracts/src/wasm/runtime.rs

@@ -1579,9 +1579,8 @@ pub mod env {
 	/// - `input_data_len`: length of the input data buffer.
 	/// - `address_ptr`: a pointer where the new account's address is copied to. `SENTINEL` means
 	///   not to copy.
-	/// - `address_len_ptr`: in-out pointer to where the length of the buffer is read from and the
-	///   actual length is written to.
-	/// - `output_ptr`: a pointer where the output buffer is copied to.  `SENTINEL` means not to
+	/// - `address_len_ptr`: pointer to where put the length of the address.
+	/// - `output_ptr`: a pointer where the output buffer is copied to. `SENTINEL` means not to
 	///   copy.
 	/// - `output_len_ptr`: in-out pointer to where the length of the buffer is read from and the
 	///   actual length is written to.