Add benchmarking for parachain runtime ump pallet

bridges/bin/rialto/node/src/chain_spec.rs

@@ -265,7 +265,7 @@ fn testnet_genesis(
 				// an import since that's a made up number and should be replaced with a constant
 				// obtained by benchmarking anyway.
 				ump_service_total_weight: 4 * 1_000_000_000,
-				max_upward_message_size: 1024 * 1024,
+				max_upward_message_size: 50 * 1024,
 				max_upward_message_num_per_candidate: 5,
 				hrmp_sender_deposit: 0,
 				hrmp_recipient_deposit: 0,

node/service/src/chain_spec.rs

@@ -192,7 +192,7 @@ fn default_parachains_host_configuration(
 		max_upward_queue_size: 1024 * 1024,
 		max_downward_message_size: 1024 * 1024,
 		ump_service_total_weight: 100_000_000_000,
-		max_upward_message_size: 1024 * 1024,
+		max_upward_message_size: 50 * 1024,
 		max_upward_message_num_per_candidate: 5,
 		hrmp_sender_deposit: 0,
 		hrmp_recipient_deposit: 0,

runtime/kusama/src/lib.rs

@@ -1228,6 +1228,7 @@ impl parachains_ump::Config for Runtime {
 		crate::parachains_ump::XcmSink<xcm_executor::XcmExecutor<xcm_config::XcmConfig>, Runtime>;
 	type FirstMessageFactorPercent = FirstMessageFactorPercent;
 	type ExecuteOverweightOrigin = EnsureRoot<AccountId>;
+	type WeightInfo = weights::runtime_parachains_ump::WeightInfo<Runtime>;
 }
 
 impl parachains_dmp::Config for Runtime {}
@@ -1543,6 +1544,7 @@ mod benches {
 		[runtime_parachains::initializer, Initializer]
 		[runtime_parachains::paras_inherent, ParaInherent]
 		[runtime_parachains::paras, Paras]
+		[runtime_parachains::ump, Ump]
 		// Substrate
 		[pallet_balances, Balances]
 		[pallet_bags_list, BagsList]

runtime/kusama/src/weights/mod.rs

@@ -51,3 +51,4 @@ pub mod runtime_parachains_hrmp;
 pub mod runtime_parachains_initializer;
 pub mod runtime_parachains_paras;
 pub mod runtime_parachains_paras_inherent;
+pub mod runtime_parachains_ump;

runtime/kusama/src/weights/runtime_parachains_ump.rs

@@ -0,0 +1,66 @@
+// Copyright 2017-2021 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+//! Autogenerated weights for `runtime_parachains::ump`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2022-01-30, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("kusama-dev"), DB CACHE: 1024
+
+// Executed Command:
+// target/production/polkadot
+// benchmark
+// --chain=kusama-dev
+// --steps=50
+// --repeat=20
+// --pallet=runtime_parachains::ump
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --header=./file_header.txt
+// --output=./runtime/kusama/src/weights/runtime_parachains_ump.rs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::Weight};
+use sp_std::marker::PhantomData;
+
+/// Weight functions for `runtime_parachains::ump`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: frame_system::Config> runtime_parachains::ump::WeightInfo for WeightInfo<T> {
+	fn sink_process_upward_message(s: u32, ) -> Weight {
+		(3_715_000 as Weight)
+			// Standard Error: 0
+			.saturating_add((2_000 as Weight).saturating_mul(s as Weight))
+	}
+	// Storage: Ump NeedsDispatch (r:1 w:1)
+	// Storage: Ump NextDispatchRoundStartWith (r:1 w:1)
+	// Storage: Ump RelayDispatchQueues (r:0 w:1)
+	// Storage: Ump RelayDispatchQueueSize (r:0 w:1)
+	fn clean_ump_after_outgoing() -> Weight {
+		(6_711_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(2 as Weight))
+			.saturating_add(T::DbWeight::get().writes(4 as Weight))
+	}
+	// Storage: Ump Overweight (r:1 w:1)
+	fn service_overweight() -> Weight {
+		(16_427_000 as Weight)
+			.saturating_add(T::DbWeight::get().reads(1 as Weight))
+			.saturating_add(T::DbWeight::get().writes(1 as Weight))
+	}
+}

runtime/parachains/src/configuration.rs

@@ -322,6 +322,8 @@ pub enum InconsistentError<BlockNumber> {
 	},
 	/// `validation_upgrade_delay` is less than or equal 1.
 	ValidationUpgradeDelayIsTooLow { validation_upgrade_delay: BlockNumber },
+	/// Maximum UMP message size (`MAX_UPWARD_MESSAGE_SIZE_BOUND`) exceeded.
+	MaxUpwardMessageSizeExceeded { max_message_size: u32 },
 	/// Maximum number of HRMP outbound channels exceeded.
 	MaxHrmpOutboundChannelsExceeded,
 	/// Maximum number of HRMP inbound channels exceeded.
@@ -388,6 +390,12 @@ where
 			})
 		}
 
+		if self.max_upward_message_size > crate::ump::MAX_UPWARD_MESSAGE_SIZE_BOUND {
+			return Err(MaxUpwardMessageSizeExceeded {
+				max_message_size: self.max_upward_message_size,
+			})
+		}
+
 		if self.hrmp_max_parachain_outbound_channels > crate::hrmp::HRMP_MAX_OUTBOUND_CHANNELS_BOUND
 		{
 			return Err(MaxHrmpOutboundChannelsExceeded)

runtime/parachains/src/mock.rs

@@ -230,6 +230,7 @@ impl crate::ump::Config for Test {
 	type UmpSink = TestUmpSink;
 	type FirstMessageFactorPercent = FirstMessageFactorPercent;
 	type ExecuteOverweightOrigin = frame_system::EnsureRoot<AccountId>;
+	type WeightInfo = crate::ump::TestWeightInfo;
 }
 
 impl crate::hrmp::Config for Test {

runtime/parachains/src/ump.rs

@@ -28,6 +28,15 @@ use xcm::latest::Outcome;
 
 pub use pallet::*;
 
+/// Maximum value that `config.max_upward_message_size` can be set to
+///
+/// This is used for benchmarking sanely bounding relevant storate items. It is expected from the `configurations`
+/// pallet to check these values before setting.
+pub const MAX_UPWARD_MESSAGE_SIZE_BOUND: u32 = 50 * 1024;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+
 #[cfg(test)]
 pub(crate) mod tests;
 
@@ -99,29 +108,38 @@ impl<XcmExecutor: xcm::latest::ExecuteXcm<C::Call>, C: Config> UmpSink for XcmSi
 		};
 
 		let id = upward_message_id(&data[..]);
-		let maybe_msg = VersionedXcm::<C::Call>::decode_all_with_depth_limit(
+		let maybe_msg_and_weight = VersionedXcm::<C::Call>::decode_all_with_depth_limit(
 			xcm::MAX_XCM_DECODE_DEPTH,
 			&mut data,
 		)
-		.map(Xcm::<C::Call>::try_from);
-		match maybe_msg {
+		.map(|xcm| {
+			(
+				Xcm::<C::Call>::try_from(xcm),
+				// NOTE: We are overestimating slightly here.
+				// The benchmark is timing this whole function with different message sizes and a NOOP extrinsic to
+				// measure the size-dependent weight. But as we use the weight funtion **in** the benchmarked funtion we
+				// are taking call and control-flow overhead into account twice.
+				<C as Config>::WeightInfo::sink_process_upward_message(data.len() as u32),
+			)
+		});
+		match maybe_msg_and_weight {
 			Err(_) => {
 				Pallet::<C>::deposit_event(Event::InvalidFormat(id));
 				Ok(0)
 			},
-			Ok(Err(())) => {
+			Ok((Err(()), weight_used)) => {
 				Pallet::<C>::deposit_event(Event::UnsupportedVersion(id));
-				Ok(0)
+				Ok(weight_used)
 			},
-			Ok(Ok(xcm_message)) => {
+			Ok((Ok(xcm_message), weight_used)) => {
 				let xcm_junction = Junction::Parachain(origin.into());
 				let outcome = XcmExecutor::execute_xcm(xcm_junction, xcm_message, max_weight);
 				match outcome {
 					Outcome::Error(XcmError::WeightLimitReached(required)) => Err((id, required)),
 					outcome => {
-						let weight_used = outcome.weight_used();
+						let outcome_weight = outcome.weight_used();
 						Pallet::<C>::deposit_event(Event::ExecutedUpward(id, outcome));
-						Ok(weight_used)
+						Ok(weight_used.saturating_add(outcome_weight))
 					},
 				}
 			},
@@ -165,6 +183,29 @@ impl fmt::Debug for AcceptanceCheckErr {
 	}
 }
 
+/// Weight information of this pallet.
+pub trait WeightInfo {
+	fn service_overweight() -> Weight;
+	fn sink_process_upward_message(s: u32) -> Weight;
+	fn clean_ump_after_outgoing() -> Weight;
+}
+
+/// fallback implementation
+pub struct TestWeightInfo;
+impl WeightInfo for TestWeightInfo {
+	fn service_overweight() -> Weight {
+		Weight::MAX
+	}
+
+	fn sink_process_upward_message(_msg_size: u32) -> Weight {
+		Weight::MAX
+	}
+
+	fn clean_ump_after_outgoing() -> Weight {
+		Weight::MAX
+	}
+}
+
 #[frame_support::pallet]
 pub mod pallet {
 	use super::*;
@@ -192,6 +233,9 @@ pub mod pallet {
 
 		/// Origin which is allowed to execute overweight messages.
 		type ExecuteOverweightOrigin: EnsureOrigin<Self::Origin>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
 	}
 
 	#[pallet::event]
@@ -303,7 +347,7 @@ pub mod pallet {
 		///
 		/// Events:
 		/// - `OverweightServiced`: On success.
-		#[pallet::weight(weight_limit.saturating_add(1_000_000))]
+		#[pallet::weight(weight_limit.saturating_add(<T as Config>::WeightInfo::service_overweight()))]
 		pub fn service_overweight(
 			origin: OriginFor<T>,
 			index: OverweightIndex,
@@ -317,7 +361,7 @@ pub mod pallet {
 				.map_err(|_| Error::<T>::WeightOverLimit)?;
 			Overweight::<T>::remove(index);
 			Self::deposit_event(Event::OverweightServiced(index, used));
-			Ok(Some(used.saturating_add(1_000_000)).into())
+			Ok(Some(used.saturating_add(<T as Config>::WeightInfo::service_overweight())).into())
 		}
 	}
 }
@@ -336,20 +380,22 @@ impl<T: Config> Pallet<T> {
 	pub(crate) fn initializer_on_new_session(
 		_notification: &initializer::SessionChangeNotification<T::BlockNumber>,
 		outgoing_paras: &[ParaId],
-	) {
-		Self::perform_outgoing_para_cleanup(outgoing_paras);
+	) -> Weight {
+		Self::perform_outgoing_para_cleanup(outgoing_paras)
 	}
 
 	/// Iterate over all paras that were noted for offboarding and remove all the data
 	/// associated with them.
-	fn perform_outgoing_para_cleanup(outgoing: &[ParaId]) {
+	fn perform_outgoing_para_cleanup(outgoing: &[ParaId]) -> Weight {
+		let mut weight: Weight = 0;
 		for outgoing_para in outgoing {
-			Self::clean_ump_after_outgoing(outgoing_para);
+			weight = weight.saturating_add(Self::clean_ump_after_outgoing(outgoing_para));
 		}
+		weight
 	}
 
 	/// Remove all relevant storage items for an outgoing parachain.
-	fn clean_ump_after_outgoing(outgoing_para: &ParaId) {
+	pub(crate) fn clean_ump_after_outgoing(outgoing_para: &ParaId) -> Weight {
 		<Self as Store>::RelayDispatchQueueSize::remove(outgoing_para);
 		<Self as Store>::RelayDispatchQueues::remove(outgoing_para);
 
@@ -366,6 +412,8 @@ impl<T: Config> Pallet<T> {
 		<Self as Store>::NextDispatchRoundStartWith::mutate(|v| {
 			*v = v.filter(|p| p == outgoing_para)
 		});
+
+		<T as Config>::WeightInfo::clean_ump_after_outgoing()
 	}
 
 	/// Check that all the upward messages sent by a candidate pass the acceptance criteria. Returns