Merge pull request #3541 from autonomys/xdm_benchmarks

Benchmarks for XDM extension

Author: vedhavyas

crates/subspace-runtime/Cargo.toml

@@ -155,5 +155,6 @@ runtime-benchmarks = [
     "pallet-transporter/runtime-benchmarks",
     "pallet-utility/runtime-benchmarks",
     "sp-consensus-subspace/runtime-benchmarks",
+    "sp-messenger/runtime-benchmarks",
     "sp-runtime/runtime-benchmarks",
 ]

crates/subspace-runtime/src/lib.rs

@@ -754,6 +754,9 @@ impl pallet_messenger::Config for Runtime {
     type OnXDMRewards = OnXDMRewards;
     type MmrHash = mmr::Hash;
     type MmrProofVerifier = MmrProofVerifier;
+    #[cfg(feature = "runtime-benchmarks")]
+    type StorageKeys = sp_messenger::BenchmarkStorageKeys;
+    #[cfg(not(feature = "runtime-benchmarks"))]
     type StorageKeys = StorageKeys;
     type DomainOwner = Domains;
     type HoldIdentifier = HoldIdentifierWrapper;
@@ -763,6 +766,7 @@ impl pallet_messenger::Config for Runtime {
     type MaxOutgoingMessages = MaxOutgoingMessages;
     type MessengerOrigin = pallet_messenger::EnsureMessengerOrigin;
     type NoteChainTransfer = Transporter;
+    type ExtensionWeightInfo = pallet_messenger::extensions::weights::SubstrateWeight<Runtime>;
 }
 
 impl<C> frame_system::offchain::CreateTransactionBase<C> for Runtime
@@ -1259,6 +1263,7 @@ mod benches {
         [pallet_messenger, Messenger]
         [pallet_transporter, Transporter]
         [pallet_subspace_extension, SubspaceExtensionBench::<Runtime>]
+        [pallet_messenger_from_domains_extension, MessengerFromDomainsExtensionBench::<Runtime>]
     );
 }
 
@@ -1781,6 +1786,7 @@ impl_runtime_apis! {
             use frame_system_benchmarking::Pallet as SystemBench;
             use baseline::Pallet as BaselineBench;
             use pallet_subspace::extensions::benchmarking::Pallet as SubspaceExtensionBench;
+            use pallet_messenger::extensions::benchmarking_from_domains::Pallet as MessengerFromDomainsExtensionBench;
 
             let mut list = Vec::<BenchmarkList>::new();
             list_benchmarks!(list, extra);
@@ -1799,6 +1805,7 @@ impl_runtime_apis! {
             use frame_system_benchmarking::Pallet as SystemBench;
             use baseline::Pallet as BaselineBench;
             use pallet_subspace::extensions::benchmarking::Pallet as SubspaceExtensionBench;
+            use pallet_messenger::extensions::benchmarking_from_domains::Pallet as MessengerFromDomainsExtensionBench;
 
             use frame_support::traits::WhitelistedStorageKeys;
             let whitelist: Vec<TrackedStorageKey> = AllPalletsWithSystem::whitelisted_storage_keys();

domains/client/block-preprocessor/src/lib.rs

@@ -501,6 +501,11 @@ where
         let bundle_estimated_weight = bundle.estimated_weight();
         let mut maybe_invalid_bundle_type = None;
 
+        // Note: It is okay to use stateless here since all the bundle checks currently do not
+        // require state. But of any checks in the future requires a state read that was part of the
+        // genesis ex: `SelfChainId`, stateless runtime will panic.
+        // So ideal to set the genesis storage as fraud proof already have access to that and would be
+        // no different in terms of verification on both the sides
         let stateless_runtime_api = self.stateless_runtime_api(parent_domain_hash)?;
         let consensus_runtime_api = self.consensus_client.runtime_api();
 

domains/pallets/messenger/src/extensions.rs

@@ -1,26 +1,36 @@
 //! Extensions for unsigned general extrinsics
 
+#[cfg(feature = "runtime-benchmarks")]
+pub mod benchmarking_from_consensus;
+#[cfg(feature = "runtime-benchmarks")]
+pub mod benchmarking_from_domains;
+pub mod weights;
+mod weights_from_consensus;
+mod weights_from_domains;
+
+use crate::extensions::weights::{FromConsensusWeightInfo, FromDomainWeightInfo};
 use crate::pallet::Call as MessengerCall;
 use crate::{
-    Call, Config, Origin, Pallet as Messenger, ValidatedRelayMessage, XDM_TRANSACTION_LONGEVITY,
+    Call, Config, ExtensionWeightInfo, Origin, Pallet as Messenger, ValidatedRelayMessage,
+    XDM_TRANSACTION_LONGEVITY,
 };
 use core::cmp::Ordering;
-use frame_support::pallet_prelude::{PhantomData, TypeInfo};
+use frame_support::pallet_prelude::{PhantomData, TypeInfo, Weight};
 use frame_support::RuntimeDebugNoBound;
 use frame_system::pallet_prelude::RuntimeCallFor;
 use parity_scale_codec::{Decode, Encode};
 use scale_info::prelude::fmt;
-use sp_messenger::messages::{Message, Nonce};
+use sp_messenger::messages::{Message, Nonce, Proof};
 use sp_messenger::MAX_FUTURE_ALLOWED_NONCES;
-use sp_runtime::impl_tx_ext_default;
 use sp_runtime::traits::{
     AsSystemOriginSigner, DispatchInfoOf, DispatchOriginOf, Dispatchable, Implication,
-    TransactionExtension, ValidateResult,
+    PostDispatchInfoOf, TransactionExtension, ValidateResult,
 };
 use sp_runtime::transaction_validity::{
     InvalidTransaction, TransactionSource, TransactionValidityError, ValidTransaction,
     ValidTransactionBuilder,
 };
+use sp_runtime::DispatchResult;
 use sp_subspace_mmr::MmrProofVerifier;
 
 /// Trait to convert Runtime call to possible Messenger call.
@@ -40,6 +50,12 @@ pub enum Val<T: Config + fmt::Debug> {
     ValidatedRelayMessage(ValidatedRelayMessage<T>),
 }
 
+/// Data passed from prepare to post_dispatch.
+#[derive(RuntimeDebugNoBound)]
+pub enum Pre {
+    Refund(Weight),
+}
+
 /// Extensions for pallet-messenger unsigned extrinsics.
 #[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
 pub struct MessengerExtension<Runtime>(PhantomData<Runtime>);
@@ -182,7 +198,7 @@ where
     fn do_prepare(
         call: &MessengerCall<Runtime>,
         val: ValidatedRelayMessage<Runtime>,
-    ) -> Result<(), TransactionValidityError> {
+    ) -> Result<Pre, TransactionValidityError> {
         let ValidatedRelayMessage {
             message,
             should_init_channel,
@@ -194,15 +210,94 @@ where
             return Err(InvalidTransaction::Future.into());
         }
 
-        match call {
-            Call::relay_message { .. } => {
-                Messenger::<Runtime>::pre_dispatch_relay_message(message, should_init_channel)
+        let pre = match call {
+            Call::relay_message { msg } => {
+                Messenger::<Runtime>::pre_dispatch_relay_message(message, should_init_channel)?;
+                if should_init_channel {
+                    // if this is a channel init,
+                    // there is no further refund of weight
+                    Pre::Refund(Weight::zero())
+                } else {
+                    match msg.proof {
+                        Proof::Consensus { .. } => Pre::Refund(Self::refund_weight_for_consensus()),
+                        Proof::Domain { .. } => Pre::Refund(Self::refund_weight_for_domains()),
+                    }
+                }
             }
             Call::relay_message_response { .. } => {
-                Messenger::<Runtime>::pre_dispatch_relay_message_response(message)
+                Messenger::<Runtime>::pre_dispatch_relay_message_response(message)?;
+                // no refund for relay response message.
+                Pre::Refund(Weight::zero())
             }
-            _ => Err(InvalidTransaction::Call.into()),
-        }
+            _ => return Err(InvalidTransaction::Call.into()),
+        };
+
+        Ok(pre)
+    }
+
+    fn do_calculate_weight(call: &RuntimeCallFor<Runtime>) -> Weight
+    where
+        RuntimeCallFor<Runtime>: MaybeMessengerCall<Runtime>,
+        Runtime: Config,
+    {
+        let messenger_call = match call.maybe_messenger_call() {
+            Some(messenger_call) => messenger_call,
+            None => return Weight::zero(),
+        };
+
+        let (dst_chain_id, verification_weight) = match messenger_call {
+            Call::relay_message { msg } => (
+                msg.dst_chain_id,
+                match msg.proof {
+                    Proof::Consensus { .. } => {
+                        Runtime::ExtensionWeightInfo::from_consensus_relay_message().max(
+                            Runtime::ExtensionWeightInfo::from_consensus_relay_message_channel_open(
+                            ),
+                        )
+                    }
+                    Proof::Domain { .. } => {
+                        Runtime::ExtensionWeightInfo::from_domains_relay_message_channel_open()
+                            .max(Runtime::ExtensionWeightInfo::from_domains_relay_message())
+                    }
+                },
+            ),
+            Call::relay_message_response { msg } => (
+                msg.dst_chain_id,
+                match msg.proof {
+                    Proof::Consensus { .. } => {
+                        Runtime::ExtensionWeightInfo::from_consensus_relay_message_response()
+                    }
+                    Proof::Domain { .. } => {
+                        Runtime::ExtensionWeightInfo::from_domains_relay_message_response()
+                    }
+                },
+            ),
+            _ => return Weight::zero(),
+        };
+
+        let mmr_proof_weight = if dst_chain_id.is_consensus_chain() {
+            Runtime::ExtensionWeightInfo::mmr_proof_verification_on_consensus()
+        } else {
+            Runtime::ExtensionWeightInfo::mmr_proof_verification_on_domain()
+        };
+
+        mmr_proof_weight.saturating_add(verification_weight)
+    }
+
+    fn refund_weight_for_consensus() -> Weight {
+        let min = Runtime::ExtensionWeightInfo::from_consensus_relay_message_channel_open()
+            .min(Runtime::ExtensionWeightInfo::from_consensus_relay_message());
+        let max = Runtime::ExtensionWeightInfo::from_consensus_relay_message_channel_open()
+            .max(Runtime::ExtensionWeightInfo::from_consensus_relay_message());
+        max.saturating_sub(min)
+    }
+
+    fn refund_weight_for_domains() -> Weight {
+        let min = Runtime::ExtensionWeightInfo::from_domains_relay_message_channel_open()
+            .min(Runtime::ExtensionWeightInfo::from_domains_relay_message());
+        let max = Runtime::ExtensionWeightInfo::from_domains_relay_message_channel_open()
+            .max(Runtime::ExtensionWeightInfo::from_domains_relay_message());
+        max.saturating_sub(min)
     }
 }
 
@@ -216,7 +311,11 @@ where
     const IDENTIFIER: &'static str = "MessengerExtension";
     type Implicit = ();
     type Val = Val<Runtime>;
-    type Pre = ();
+    type Pre = Pre;
+
+    fn weight(&self, call: &RuntimeCallFor<Runtime>) -> Weight {
+        Self::do_calculate_weight(call)
+    }
 
     fn validate(
         &self,
@@ -259,13 +358,22 @@ where
             (Some(messenger_call), Val::ValidatedRelayMessage(validated_relay_message)) => {
                 Self::do_prepare(messenger_call, validated_relay_message)
             }
-            // return Ok for the rest of the call types
-            (_, _) => Ok(()),
+            // return Ok for the rest of the call types and nothing to refund here as
+            // non XDM calls will have zero weight from this extension.
+            (_, _) => Ok(Pre::Refund(Weight::zero())),
         }
     }
 
-    // TODO: need benchmarking for this extension.
-    impl_tx_ext_default!(RuntimeCallFor<Runtime>; weight);
+    fn post_dispatch_details(
+        pre: Self::Pre,
+        _info: &DispatchInfoOf<RuntimeCallFor<Runtime>>,
+        _post_info: &PostDispatchInfoOf<RuntimeCallFor<Runtime>>,
+        _len: usize,
+        _result: &DispatchResult,
+    ) -> Result<Weight, TransactionValidityError> {
+        let Pre::Refund(weight) = pre;
+        Ok(weight)
+    }
 }
 
 /// Extensions for pallet-messenger unsigned extrinsics with trusted MMR verification.
@@ -349,10 +457,11 @@ where
     const IDENTIFIER: &'static str = "MessengerTrustedMmrExtension";
     type Implicit = ();
     type Val = Val<Runtime>;
-    type Pre = ();
+    type Pre = Pre;
 
-    // TODO: need benchmarking for this extension.
-    impl_tx_ext_default!(RuntimeCallFor<Runtime>; weight);
+    fn weight(&self, call: &RuntimeCallFor<Runtime>) -> Weight {
+        MessengerExtension::<Runtime>::do_calculate_weight(call)
+    }
 
     fn validate(
         &self,
@@ -396,7 +505,18 @@ where
                 MessengerExtension::<Runtime>::do_prepare(messenger_call, validated_relay_message)
             }
             // return Ok for the rest of the call types
-            (_, _) => Ok(()),
+            (_, _) => Ok(Pre::Refund(Weight::zero())),
         }
     }
+
+    fn post_dispatch_details(
+        pre: Self::Pre,
+        _info: &DispatchInfoOf<RuntimeCallFor<Runtime>>,
+        _post_info: &PostDispatchInfoOf<RuntimeCallFor<Runtime>>,
+        _len: usize,
+        _result: &DispatchResult,
+    ) -> Result<Weight, TransactionValidityError> {
+        let Pre::Refund(weight) = pre;
+        Ok(weight)
+    }
 }