Introduce MaxParachainBlockWeight and related functionality

cumulus/pallets/parachain-system/Cargo.toml

@@ -15,6 +15,7 @@ workspace = true
 array-bytes = { workspace = true }
 bytes = { workspace = true }
 codec = { features = ["derive"], workspace = true }
+derive-where = { workspace = true }
 environmental = { workspace = true }
 hashbrown = { workspace = true }
 impl-trait-for-tuples = { workspace = true }
@@ -42,6 +43,7 @@ sp-version = { workspace = true }
 
 # Polkadot
 polkadot-parachain-primitives = { features = ["wasm-api"], workspace = true }
+polkadot-primitives = { workspace = true }
 polkadot-runtime-parachains = { workspace = true }
 xcm = { workspace = true }
 xcm-builder = { workspace = true }
@@ -52,6 +54,9 @@ cumulus-primitives-core = { workspace = true }
 cumulus-primitives-parachain-inherent = { workspace = true }
 cumulus-primitives-proof-size-hostfunction = { workspace = true }
 
+# For building docs
+docify = { workspace = true }
+
 [dev-dependencies]
 assert_matches = { workspace = true }
 futures = { workspace = true }
@@ -60,15 +65,16 @@ rand = { workspace = true, default-features = true }
 rstest = { workspace = true }
 trie-standardmap = { workspace = true }
 
-
 # Substrate
+frame-executive = { workspace = true }
 sc-consensus = { workspace = true }
 sp-api = { workspace = true, default-features = true }
 sp-consensus-slots = { workspace = true, default-features = true }
 sp-crypto-hashing = { workspace = true, default-features = true }
 sp-keyring = { workspace = true, default-features = true }
 sp-tracing = { workspace = true, default-features = true }
 sp-version = { workspace = true, default-features = true }
+
 # Cumulus
 cumulus-test-client = { workspace = true }
 cumulus-test-relay-sproof-builder = { workspace = true, default-features = true }
@@ -84,11 +90,13 @@ std = [
 	"cumulus-primitives-proof-size-hostfunction/std",
 	"environmental/std",
 	"frame-benchmarking/std",
+	"frame-executive/std",
 	"frame-support/std",
 	"frame-system/std",
 	"log/std",
 	"pallet-message-queue/std",
 	"polkadot-parachain-primitives/std",
+	"polkadot-primitives/std",
 	"polkadot-runtime-parachains/std",
 	"scale-info/std",
 	"sp-api/std",
@@ -116,13 +124,15 @@ runtime-benchmarks = [
 	"frame-system/runtime-benchmarks",
 	"pallet-message-queue/runtime-benchmarks",
 	"polkadot-parachain-primitives/runtime-benchmarks",
+	"polkadot-primitives/runtime-benchmarks",
 	"polkadot-runtime-parachains/runtime-benchmarks",
 	"sp-runtime/runtime-benchmarks",
 	"xcm-builder/runtime-benchmarks",
 	"xcm/runtime-benchmarks",
 ]
 
 try-runtime = [
+	"frame-executive/try-runtime",
 	"frame-support/try-runtime",
 	"frame-system/try-runtime",
 	"pallet-message-queue/try-runtime",

cumulus/pallets/parachain-system/src/benchmarking.rs

@@ -20,12 +20,33 @@
 #![cfg(feature = "runtime-benchmarks")]
 
 use super::*;
-use crate::parachain_inherent::InboundDownwardMessages;
-use cumulus_primitives_core::{relay_chain::Hash as RelayHash, InboundDownwardMessage};
+use crate::{
+	block_weight::{
+		BlockWeightMode, DynamicMaxBlockWeight, MaxParachainBlockWeight, FULL_CORE_WEIGHT,
+	},
+	parachain_inherent::InboundDownwardMessages,
+};
+use cumulus_primitives_core::{
+	relay_chain::Hash as RelayHash, BundleInfo, CoreInfo, InboundDownwardMessage,
+};
 use frame_benchmarking::v2::*;
-use sp_runtime::traits::BlakeTwo256;
+use frame_support::{
+	dispatch::{DispatchInfo, PostDispatchInfo},
+	weights::constants::WEIGHT_REF_TIME_PER_SECOND,
+};
+use frame_system::RawOrigin;
+use sp_core::ConstU32;
+use sp_runtime::traits::{BlakeTwo256, DispatchTransaction, Dispatchable};
 
-#[benchmarks]
+fn has_use_full_core_digest<T: Config>() -> bool {
+	let digest = frame_system::Pallet::<T>::digest();
+	CumulusDigestItem::contains_use_full_core(&digest)
+}
+
+#[benchmarks(where
+	T: Send + Sync,
+    T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+)]
 mod benchmarks {
 	use super::*;
 
@@ -64,6 +85,184 @@ mod benchmarks {
 		head
 	}
 
+	/// The worst-case scenario for the block weight transaction extension.
+	///
+	/// Before executing an extrinsic `FractionOfCore` is set, changed to `PotentialFullCore` and
+	/// post dispatch switches to `FullCore`.
+	#[benchmark]
+	fn block_weight_tx_extension_max_weight() -> Result<(), BenchmarkError> {
+		let caller = account("caller", 0, 0);
+
+		frame_system::Pallet::<T>::note_inherents_applied();
+
+		frame_system::Pallet::<T>::set_extrinsic_index(1);
+
+		frame_system::Pallet::<T>::deposit_log(
+			BundleInfo { index: 0, maybe_last: false }.to_digest_item(),
+		);
+		frame_system::Pallet::<T>::deposit_log(
+			CoreInfo {
+				selector: 0.into(),
+				claim_queue_offset: 0.into(),
+				number_of_cores: 1.into(),
+			}
+			.to_digest_item(),
+		);
+		let target_weight = MaxParachainBlockWeight::<T, ConstU32<4>>::target_block_weight();
+
+		let info = DispatchInfo {
+			// The weight needs to be more than the target weight.
+			call_weight: target_weight
+				.saturating_add(Weight::from_parts(WEIGHT_REF_TIME_PER_SECOND, 0)),
+			extension_weight: Weight::zero(),
+			class: DispatchClass::Normal,
+			..Default::default()
+		};
+		let call: T::RuntimeCall = frame_system::Call::remark { remark: vec![] }.into();
+		let post_info = PostDispatchInfo { actual_weight: None, pays_fee: Default::default() };
+		let len = 0_usize;
+
+		crate::BlockWeightMode::<T>::put(BlockWeightMode::fraction_of_core(None));
+
+		let ext = DynamicMaxBlockWeight::<T, (), ConstU32<4>>::new(());
+
+		#[block]
+		{
+			ext.test_run(RawOrigin::Signed(caller).into(), &call, &info, len, 0, |_| {
+				// Normally this is done by `CheckWeight`
+				frame_system::Pallet::<T>::register_extra_weight_unchecked(
+					info.call_weight,
+					DispatchClass::Normal,
+				);
+				Ok(post_info)
+			})
+			.unwrap()
+			.unwrap();
+		}
+
+		assert_eq!(crate::BlockWeightMode::<T>::get().unwrap(), BlockWeightMode::full_core());
+		assert!(has_use_full_core_digest::<T>());
+		assert_eq!(MaxParachainBlockWeight::<T, ConstU32<4>>::get(), FULL_CORE_WEIGHT);
+
+		Ok(())
+	}
+
+	/// A benchmark that assumes that an extrinsic was executed with `FractionOfCore` set.
+	#[benchmark]
+	fn block_weight_tx_extension_stays_fraction_of_core() -> Result<(), BenchmarkError> {
+		let caller = account("caller", 0, 0);
+
+		frame_system::Pallet::<T>::note_inherents_applied();
+
+		frame_system::Pallet::<T>::set_extrinsic_index(1);
+
+		frame_system::Pallet::<T>::deposit_log(
+			BundleInfo { index: 0, maybe_last: false }.to_digest_item(),
+		);
+		frame_system::Pallet::<T>::deposit_log(
+			CoreInfo {
+				selector: 0.into(),
+				claim_queue_offset: 0.into(),
+				number_of_cores: 1.into(),
+			}
+			.to_digest_item(),
+		);
+		let target_weight = MaxParachainBlockWeight::<T, ConstU32<4>>::target_block_weight();
+
+		let info = DispatchInfo {
+			call_weight: Weight::from_parts(1024, 1024),
+			extension_weight: Weight::zero(),
+			class: DispatchClass::Normal,
+			..Default::default()
+		};
+		let call: T::RuntimeCall = frame_system::Call::remark { remark: vec![] }.into();
+		let post_info = PostDispatchInfo { actual_weight: None, pays_fee: Default::default() };
+		let len = 0_usize;
+
+		crate::BlockWeightMode::<T>::put(BlockWeightMode::fraction_of_core(None));
+
+		let ext = DynamicMaxBlockWeight::<T, (), ConstU32<4>>::new(());
+
+		#[block]
+		{
+			ext.test_run(RawOrigin::Signed(caller).into(), &call, &info, len, 0, |_| {
+				// Normally this is done by `CheckWeight`
+				frame_system::Pallet::<T>::register_extra_weight_unchecked(
+					info.call_weight,
+					DispatchClass::Normal,
+				);
+				Ok(post_info)
+			})
+			.unwrap()
+			.unwrap();
+		}
+
+		assert_eq!(
+			crate::BlockWeightMode::<T>::get().unwrap(),
+			BlockWeightMode::fraction_of_core(Some(1))
+		);
+		assert!(!has_use_full_core_digest::<T>());
+		assert_eq!(MaxParachainBlockWeight::<T, ConstU32<4>>::get(), target_weight);
+
+		Ok(())
+	}
+
+	/// A benchmark that assumes that `FullCore` was set already before executing an extrinsic.
+	#[benchmark]
+	fn block_weight_tx_extension_full_core() -> Result<(), BenchmarkError> {
+		let caller = account("caller", 0, 0);
+
+		frame_system::Pallet::<T>::set_block_number(1u32.into());
+
+		frame_system::Pallet::<T>::note_inherents_applied();
+
+		frame_system::Pallet::<T>::set_extrinsic_index(1);
+
+		frame_system::Pallet::<T>::deposit_log(
+			BundleInfo { index: 0, maybe_last: false }.to_digest_item(),
+		);
+		frame_system::Pallet::<T>::deposit_log(
+			CoreInfo {
+				selector: 0.into(),
+				claim_queue_offset: 0.into(),
+				number_of_cores: 1.into(),
+			}
+			.to_digest_item(),
+		);
+
+		let info = DispatchInfo {
+			call_weight: Weight::from_parts(1024, 1024),
+			extension_weight: Weight::zero(),
+			class: DispatchClass::Normal,
+			..Default::default()
+		};
+		let call: T::RuntimeCall = frame_system::Call::remark { remark: vec![] }.into();
+		let post_info = PostDispatchInfo { actual_weight: None, pays_fee: Default::default() };
+		let len = 0_usize;
+
+		crate::BlockWeightMode::<T>::put(BlockWeightMode::full_core());
+
+		let ext = DynamicMaxBlockWeight::<T, (), ConstU32<4>>::new(());
+
+		#[block]
+		{
+			ext.test_run(RawOrigin::Signed(caller).into(), &call, &info, len, 0, |_| {
+				// Normally this is done by `CheckWeight`
+				frame_system::Pallet::<T>::register_extra_weight_unchecked(
+					info.call_weight,
+					DispatchClass::Normal,
+				);
+				Ok(post_info)
+			})
+			.unwrap()
+			.unwrap();
+		}
+
+		assert_eq!(crate::BlockWeightMode::<T>::get().unwrap(), BlockWeightMode::full_core());
+
+		Ok(())
+	}
+
 	impl_benchmark_test_suite! {
 		Pallet,
 		crate::mock::new_test_ext(),