update to benchmarking v2

pallets/authority-members/src/benchmarking.rs

@@ -17,70 +17,83 @@
 #![cfg(feature = "runtime-benchmarks")]
 
 use super::*;
-
-use frame_benchmarking::benchmarks;
-use frame_system::RawOrigin;
-
 use crate::Pallet;
 
-fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
-    frame_system::Pallet::<T>::assert_has_event(generic_event.into());
-}
+use frame_benchmarking::v2::*;
+use frame_system::RawOrigin;
 
-benchmarks! {
-    where_clause {
+#[benchmarks(
         where
-            T::MemberId: From<u32>,
+            <T as Config>::MemberId: From<u32>,
+)]
+mod benchmarks {
+    use super::*;
+
+    fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+        frame_system::Pallet::<T>::assert_has_event(generic_event.into());
     }
-    go_offline {
+
+    #[benchmark]
+    fn go_offline() {
         let id: T::MemberId = OnlineAuthorities::<T>::get()[0];
         let caller: T::AccountId = Members::<T>::get(id).unwrap().owner_key;
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
-    }: _<T::RuntimeOrigin>(caller_origin)
-    verify {
-        assert_has_event::<T>(Event::<T>::MemberGoOffline{member: id}.into());
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller));
+
+        assert_has_event::<T>(Event::<T>::MemberGoOffline { member: id }.into());
     }
-     go_online {
+
+    #[benchmark]
+    fn go_online() {
         let id: T::MemberId = OnlineAuthorities::<T>::get()[0];
         let caller: T::AccountId = Members::<T>::get(id).unwrap().owner_key;
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
         OnlineAuthorities::<T>::mutate(|ids| {
             ids.retain(|&x| x != id);
         });
         OutgoingAuthorities::<T>::mutate(|ids| {
             ids.retain(|&x| x != id);
         });
-    }: _<T::RuntimeOrigin>(caller_origin)
-    verify {
-        assert_has_event::<T>(Event::<T>::MemberGoOnline{member: id}.into());
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller));
+
+        assert_has_event::<T>(Event::<T>::MemberGoOnline { member: id }.into());
     }
-     set_session_keys {
+
+    #[benchmark]
+    fn set_session_keys() {
         let id: T::MemberId = OnlineAuthorities::<T>::get()[0];
         let caller: T::AccountId = Members::<T>::get(id).unwrap().owner_key;
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
-            let validator_id = T::ValidatorIdOf::convert(caller.clone()).unwrap();
-            let session_keys: T::Keys = pallet_session::NextKeys::<T>::get(validator_id).unwrap();
-        }: _<T::RuntimeOrigin>(caller_origin, session_keys)
-     remove_member {
+        let validator_id = T::ValidatorIdOf::convert(caller.clone()).unwrap();
+        let session_keys: T::Keys = pallet_session::NextKeys::<T>::get(validator_id).unwrap();
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller), session_keys);
+    }
+
+    #[benchmark]
+    fn remove_member() {
         let id: T::MemberId = OnlineAuthorities::<T>::get()[0];
-        let caller_origin = RawOrigin::Root.into();
-        }: _<T::RuntimeOrigin>(caller_origin, id)
-    verify {
-        assert_has_event::<T>(Event::<T>::MemberRemoved{member: id}.into());
+
+        #[extrinsic_call]
+        _(RawOrigin::Root, id);
+
+        assert_has_event::<T>(Event::<T>::MemberRemoved { member: id }.into());
     }
-     remove_member_from_blacklist {
+
+    #[benchmark]
+    fn remove_member_from_blacklist() {
         let id: T::MemberId = OnlineAuthorities::<T>::get()[0];
         Blacklist::<T>::mutate(|blacklist| {
             blacklist.push(id);
         });
-    }: _<T::RuntimeOrigin>(RawOrigin::Root.into(), id)
-    verify {
-        assert_has_event::<T>(Event::<T>::MemberRemovedFromBlacklist{member: id}.into());
+
+        #[extrinsic_call]
+        _(RawOrigin::Root, id);
+
+        assert_has_event::<T>(Event::<T>::MemberRemovedFromBlacklist { member: id }.into());
     }
 
-     impl_benchmark_test_suite!(
-            Pallet,
-            crate::mock::new_test_ext(2),
-            crate::mock::Test
-        );
+    impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(2), crate::mock::Test);
 }

pallets/certification/src/benchmarking.rs

@@ -18,7 +18,7 @@
 
 use super::*;
 
-use frame_benchmarking::benchmarks;
+use frame_benchmarking::v2::*;
 use frame_system::RawOrigin;
 use sp_runtime::traits::Zero;
 
@@ -27,104 +27,145 @@ use maplit::btreemap;
 
 use crate::Pallet;
 
-fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
-    frame_system::Pallet::<T>::assert_has_event(generic_event.into());
-}
+#[benchmarks(
+        where
+            <T as Config>::IdtyIndex: From<u32>,
+)]
+mod benchmarks {
+    use super::*;
 
-fn add_certs<T: Config>(i: u32, receiver: T::IdtyIndex) -> Result<(), &'static str> {
-    Pallet::<T>::remove_all_certs_received_by(RawOrigin::Root.into(), receiver)?;
-    for j in 1..i {
-        Pallet::<T>::do_add_cert_checked(j.into(), receiver, false)?;
+    fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+        frame_system::Pallet::<T>::assert_has_event(generic_event.into());
     }
-    assert!(
-        CertsByReceiver::<T>::get(receiver).len() as u32 == i - 1,
-        "Certs not added",
-    );
-    Ok(())
-}
 
-benchmarks! {
-    where_clause {
-        where
-            T::IdtyIndex: From<u32>,
+    fn add_certs<T: Config>(i: u32, receiver: T::IdtyIndex) -> Result<(), &'static str> {
+        Pallet::<T>::remove_all_certs_received_by(RawOrigin::Root.into(), receiver)?;
+        for j in 1..i {
+            Pallet::<T>::do_add_cert_checked(j.into(), receiver, false)?;
+        }
+        assert!(
+            CertsByReceiver::<T>::get(receiver).len() as u32 == i - 1,
+            "Certs not added",
+        );
+        Ok(())
     }
-    add_cert {
+
+    #[benchmark]
+    fn add_cert() -> Result<(), BenchmarkError> {
         let issuer: T::IdtyIndex = 1.into();
-        let caller: T::AccountId  = T::IdtyAttr::owner_key(issuer).unwrap();
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
+        let caller: T::AccountId = T::IdtyAttr::owner_key(issuer).unwrap();
         let receiver: T::IdtyIndex = 2.into();
         Pallet::<T>::del_cert(RawOrigin::Root.into(), issuer, receiver)?;
-        let issuer_cert: u32 = StorageIdtyCertMeta::<T>::get(issuer).issued_count;
-        let receiver_cert: u32 = StorageIdtyCertMeta::<T>::get(receiver).received_count;
         frame_system::pallet::Pallet::<T>::set_block_number(T::CertPeriod::get());
-    }: _<T::RuntimeOrigin>(caller_origin, receiver)
-    verify {
-        assert_has_event::<T>(Event::<T>::CertAdded{ issuer, receiver }.into());
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller), receiver);
+
+        assert_has_event::<T>(Event::<T>::CertAdded { issuer, receiver }.into());
+        Ok(())
     }
 
-    renew_cert {
+    #[benchmark]
+    fn renew_cert() -> Result<(), BenchmarkError> {
         let issuer: T::IdtyIndex = 1.into();
-        let caller: T::AccountId  = T::IdtyAttr::owner_key(issuer).unwrap();
-        let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
+        let caller: T::AccountId = T::IdtyAttr::owner_key(issuer).unwrap();
         let receiver: T::IdtyIndex = 2.into();
         Pallet::<T>::del_cert(RawOrigin::Root.into(), issuer, receiver)?;
-        let issuer_cert: u32 = StorageIdtyCertMeta::<T>::get(issuer).issued_count;
-        let receiver_cert: u32 = StorageIdtyCertMeta::<T>::get(receiver).received_count;
         frame_system::pallet::Pallet::<T>::set_block_number(T::CertPeriod::get());
-        Pallet::<T>::add_cert(caller_origin.clone(), receiver)?;
-        frame_system::pallet::Pallet::<T>::set_block_number(T::CertPeriod::get() + T::CertPeriod::get());
-    }: _<T::RuntimeOrigin>(caller_origin, receiver)
-    verify {
-        assert_has_event::<T>(Event::<T>::CertAdded{ issuer, receiver }.into());
+        Pallet::<T>::add_cert(RawOrigin::Signed(caller.clone()).into(), receiver)?;
+        frame_system::pallet::Pallet::<T>::set_block_number(
+            T::CertPeriod::get() + T::CertPeriod::get(),
+        );
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller), receiver);
+
+        assert_has_event::<T>(Event::<T>::CertAdded { issuer, receiver }.into());
+        Ok(())
     }
 
-    del_cert {
+    #[benchmark]
+    fn del_cert() -> Result<(), BenchmarkError> {
         let issuer: T::IdtyIndex = 1.into();
         let receiver: T::IdtyIndex = 2.into();
         // try to add cert if missing, else ignore
         // this depends on initial data
-        let _ = Pallet::<T>::do_add_cert_checked(issuer, receiver, false);
-        let receiver_cert: u32 = StorageIdtyCertMeta::<T>::get(receiver).received_count;
-        let issuer_cert: u32 = StorageIdtyCertMeta::<T>::get(issuer).issued_count;
-    }: _<T::RuntimeOrigin>(RawOrigin::Root.into(), issuer, receiver)
-    verify {
-        assert_has_event::<T>(Event::<T>::CertRemoved{ issuer,  receiver, expiration: false }.into());
+        Pallet::<T>::do_add_cert_checked(issuer, receiver, false)?;
+
+        #[extrinsic_call]
+        _(RawOrigin::Root, issuer, receiver);
+
+        assert_has_event::<T>(
+            Event::<T>::CertRemoved {
+                issuer,
+                receiver,
+                expiration: false,
+            }
+            .into(),
+        );
+        Ok(())
     }
 
-    remove_all_certs_received_by {
+    #[benchmark]
+    fn remove_all_certs_received_by(i: Linear<2, 1_000>) -> Result<(), BenchmarkError> {
         let receiver: T::IdtyIndex = 0.into();
-        let i in 2..1000 => add_certs::<T>(i, receiver)?;
-    }: _<T::RuntimeOrigin>(RawOrigin::Root.into(),  receiver)
-    verify {
-        assert!(CertsByReceiver::<T>::get(receiver).is_empty() );
+        add_certs::<T>(i, receiver)?;
+
+        #[extrinsic_call]
+        _(RawOrigin::Root, receiver);
+
+        assert!(CertsByReceiver::<T>::get(receiver).is_empty());
+        Ok(())
     }
 
-    on_initialize {
+    #[benchmark]
+    fn on_initialize() {
         assert!(CertsRemovableOn::<T>::try_get(BlockNumberFor::<T>::zero()).is_err());
-    }: {Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());}
 
-    do_remove_cert_noop {
-    }: {Pallet::<T>::do_remove_cert(100.into(), 101.into(), Some(BlockNumberFor::<T>::zero()));}
+        #[block]
+        {
+            Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());
+        }
+    }
+
+    #[benchmark]
+    fn do_remove_cert_noop() {
+        #[block]
+        {
+            Pallet::<T>::do_remove_cert(100.into(), 101.into(), Some(BlockNumberFor::<T>::zero()));
+        }
+    }
 
-    do_remove_cert {
+    #[benchmark]
+    fn do_remove_cert() -> Result<(), BenchmarkError> {
         let issuer: T::IdtyIndex = 1.into();
         let receiver: T::IdtyIndex = 0.into();
         Pallet::<T>::do_remove_cert(issuer, receiver, None);
         Pallet::<T>::do_add_cert_checked(issuer, receiver, false)?;
-        let issuer_cert: u32 = StorageIdtyCertMeta::<T>::get(issuer).issued_count;
-        let receiver_cert: u32 = StorageIdtyCertMeta::<T>::get(receiver).received_count;
         let block_number = T::ValidityPeriod::get();
         frame_system::pallet::Pallet::<T>::set_block_number(block_number);
-    }: {Pallet::<T>::do_remove_cert(issuer, receiver, Some(block_number));}
-    verify {
-        assert_has_event::<T>(Event::<T>::CertRemoved{ issuer,  receiver, expiration: true }.into());
+
+        #[block]
+        {
+            Pallet::<T>::do_remove_cert(issuer, receiver, Some(block_number));
+        }
+
+        assert_has_event::<T>(
+            Event::<T>::CertRemoved {
+                issuer,
+                receiver,
+                expiration: true,
+            }
+            .into(),
+        );
+        Ok(())
     }
 
     impl_benchmark_test_suite!(
         Pallet,
         crate::mock::new_test_ext(crate::mock::DefaultCertificationConfig {
-        apply_cert_period_at_genesis: true,
-        certs_by_receiver: btreemap![
+            apply_cert_period_at_genesis: true,
+            certs_by_receiver: btreemap![
                 0 => btreemap![
                     1 => Some(7),
                     2 => Some(9),
@@ -133,7 +174,7 @@ benchmarks! {
                     0 => Some(10),
                     2 => Some(3),
                 ],
-            ] ,
+            ],
         }),
         crate::mock::Test
     );