update budget computation

frame/contracts/src/benchmarking/mod.rs

@@ -219,18 +219,6 @@ benchmarks! {
 		ContractInfo::<T>::process_deletion_queue_batch(Weight::MAX)
 	}
 
-	#[pov_mode = Measured]
-	on_initialize_per_queue_item {
-		let q in 0..1024;
-		for i in 0 .. q {
-			let instance = Contract::<T>::with_index(i, WasmModule::dummy(), vec![])?;
-			instance.info()?.queue_trie_for_deletion()?;
-			ContractInfoOf::<T>::remove(instance.account_id);
-		}
-	}: {
-		ContractInfo::<T>::process_deletion_queue_batch(Weight::MAX)
-	}
-
 	// This benchmarks the additional weight that is charged when a contract is executed the
 	// first time after a new schedule was deployed: For every new schedule a contract needs
 	// to re-run the instrumentation once.
@@ -239,6 +227,7 @@ benchmarks! {
 		let c in 0 .. Perbill::from_percent(49).mul_ceil(T::MaxCodeLen::get());
 		let WasmModule { code, hash, .. } = WasmModule::<T>::sized(c, Location::Call);
 		Contracts::<T>::store_code_raw(code, whitelisted_caller())?;
+
 		let schedule = T::Schedule::get();
 		let mut gas_meter = GasMeter::new(Weight::MAX);
 		let mut module = PrefabWasmModule::from_storage(hash, &schedule, &mut gas_meter)?;
@@ -3020,8 +3009,8 @@ benchmarks! {
 	print_schedule {
 		#[cfg(feature = "std")]
 		{
-			let empty_queue_throughput = ContractInfo::<T>::deletion_budget(0, Weight::MAX);
-			let full_queue_throughput = ContractInfo::<T>::deletion_budget(1024, Weight::MAX);
+			let empty_queue_throughput = ContractInfo::<T>::deletion_budget(Weight::MAX);
+			let full_queue_throughput = ContractInfo::<T>::deletion_budget(Weight::MAX);
 			println!("{:#?}", Schedule::<T>::default());
 			println!("###############################################");
 			println!("Lazy deletion weight per key: {}", empty_queue_throughput.0);

frame/contracts/src/lib.rs

@@ -904,10 +904,9 @@ pub mod pallet {
 	/// A pair of monotonic counters used to track the latest contract marked for deletion
 	/// and the latest deleted contract in DeletionQueueMap.
 	///
-	/// These two nonces let us keep track of the length of the queue, so we can calculate the
-	/// weight of the deletion budget, additionally, when we iterate the map to remove contracts, we
-	/// simply use the `delete_nonce` counter and  don't pay the cost of an extra call to
-	/// `sp_io::storage::next_key` to lookup the next entry in the map
+	/// When we iterate the map to remove contracts, we simply use the `delete_nonce` counter and
+	/// don't pay the cost of an extra call to `sp_io::storage::next_key` to lookup the next entry
+	/// in the map
 	#[pallet::storage]
 	pub(crate) type DeletionQueueNonces<T: Config> = StorageValue<_, DeletionQueue<T>, ValueQuery>;
 }

frame/contracts/src/storage.rs

@@ -212,19 +212,15 @@ impl<T: Config> ContractInfo<T> {
 	/// Calculates the weight that is necessary to remove one key from the trie and how many
 	/// of those keys can be deleted from the deletion queue given the supplied queue length
 	/// and weight limit.
-	pub fn deletion_budget(queue_len: u32, weight_limit: Weight) -> (Weight, u32) {
+	pub fn deletion_budget(weight_limit: Weight) -> (Weight, u32) {
 		let base_weight = T::WeightInfo::on_process_deletion_queue_batch();
-		let weight_per_queue_item = T::WeightInfo::on_initialize_per_queue_item(1) -
-			T::WeightInfo::on_initialize_per_queue_item(0);
 		let weight_per_key = T::WeightInfo::on_initialize_per_trie_key(1) -
 			T::WeightInfo::on_initialize_per_trie_key(0);
-		let decoding_weight = weight_per_queue_item.saturating_mul(queue_len as u64);
 
 		// `weight_per_key` being zero makes no sense and would constitute a failure to
 		// benchmark properly. We opt for not removing any keys at all in this case.
 		let key_budget = weight_limit
 			.saturating_sub(base_weight)
-			.saturating_sub(decoding_weight)
 			.checked_div_per_component(&weight_per_key)
 			.unwrap_or(0) as u32;
 
@@ -236,14 +232,12 @@ impl<T: Config> ContractInfo<T> {
 	/// It returns the amount of weight used for that task.
 	pub fn process_deletion_queue_batch(weight_limit: Weight) -> Weight {
 		let mut queue = <DeletionQueue<T>>::load();
-		let queue_len = queue.len();
 
-		if queue_len == 0 {
+		if queue.is_empty() {
 			return Weight::zero()
 		}
 
-		let (weight_per_key, mut remaining_key_budget) =
-			Self::deletion_budget(queue_len, weight_limit);
+		let (weight_per_key, mut remaining_key_budget) = Self::deletion_budget(weight_limit);
 
 		// We want to check whether we have enough weight to decode the queue before
 		// proceeding. Too little weight for decoding might happen during runtime upgrades
@@ -396,8 +390,8 @@ impl<T: Config> DeletionQueue<T> {
 	}
 
 	/// The number of contracts marked for deletion.
-	fn len(&self) -> u32 {
-		self.insert_nonce.wrapping_sub(self.delete_nonce)
+	fn is_empty(&self) -> bool {
+		self.insert_nonce.wrapping_sub(self.delete_nonce) == 0
 	}
 
 	/// Insert a contract in the deletion queue.
@@ -409,7 +403,7 @@ impl<T: Config> DeletionQueue<T> {
 
 	/// Fetch the next contract to be deleted.
 	fn next(&mut self) -> Option<DeletionQueueEntry<T>> {
-		if self.len() == 0 {
+		if self.is_empty() {
 			return None
 		}
 

frame/contracts/src/tests.rs

@@ -2032,7 +2032,7 @@ fn lazy_removal_partial_remove_works() {
 	// We create a contract with some extra keys above the weight limit
 	let extra_keys = 7u32;
 	let weight_limit = Weight::from_parts(5_000_000_000, 0);
-	let (_, max_keys) = ContractInfo::<Test>::deletion_budget(1, weight_limit);
+	let (_, max_keys) = ContractInfo::<Test>::deletion_budget(weight_limit);
 	let vals: Vec<_> = (0..max_keys + extra_keys)
 		.map(|i| (blake2_256(&i.encode()), (i as u32), (i as u32).encode()))
 		.collect();
@@ -2210,7 +2210,7 @@ fn lazy_removal_does_not_use_all_weight() {
 		.account_id;
 
 		let info = get_contract(&addr);
-		let (weight_per_key, max_keys) = ContractInfo::<Test>::deletion_budget(1, weight_limit);
+		let (weight_per_key, max_keys) = ContractInfo::<Test>::deletion_budget(weight_limit);
 
 		// We create a contract with one less storage item than we can remove within the limit
 		let vals: Vec<_> = (0..max_keys - 1)