Skip to content
Snippets Groups Projects
Unverified Commit 1143537b authored by bgallois's avatar bgallois
Browse files

update to benchmarking v2

parent 93853b2d
No related branches found
No related tags found
No related merge requests found
Pipeline #35771 passed
Stage: labels
    Stage: quality
      Stage: build
        Stage: tests
          This commit is part of merge request !236. Comments created here will be created in the context of that merge request.
          Expand all Hide whitespace changes
          Inline Side-by-side
          pallets/authority-members/src/benchmarking.rs
          + 52
          − 39
          View file @ 1143537b
          ......@@ -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
          + 103
          − 65
          View file @ 1143537b
          ......@@ -18,122 +18,160 @@
          use super::*;
          use frame_benchmarking::benchmarks;
          use frame_benchmarking::v2::*;
          use frame_system::RawOrigin;
          use sp_runtime::traits::Zero;
          #[cfg(test)]
          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());
          #[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![
          0 => btreemap![
          apply_cert_period_at_genesis: true,
          certs_by_receiver: maplit::btreemap![
          0 => maplit::btreemap![
          1 => Some(7),
          2 => Some(9),
          ],
          1 => btreemap![
          1 => maplit::btreemap![
          0 => Some(10),
          2 => Some(3),
          ],
          ] ,
          ],
          }),
          crate::mock::Test
          );
          ......
          pallets/distance/src/benchmarking.rs
          + 125
          − 67
          View file @ 1143537b
          ......@@ -19,7 +19,7 @@
          use super::*;
          use codec::Encode;
          use frame_benchmarking::benchmarks;
          use frame_benchmarking::v2::*;
          use frame_support::traits::{Currency, OnFinalize};
          use frame_system::pallet_prelude::BlockNumberFor;
          use frame_system::RawOrigin;
          ......@@ -29,92 +29,150 @@ use sp_runtime::Perbill;
          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());
          }
          fn populate_pool<T: Config>(i: u32) -> Result<(), &'static str> {
          EvaluationPool0::<T>::mutate(|current_pool| -> Result<(), &'static str> {
          for j in 0..i {
          current_pool
          .evaluations
          .try_push((j, median::MedianAcc::new()))
          .map_err(|_| Error::<T>::QueueFull)?;
          }
          Ok(())
          })
          }
          benchmarks! {
          where_clause {
          #[benchmarks(
          where
          T: pallet_balances::Config, T::Balance: From<u64>,
          T: pallet_balances::Config,
          T::Balance: From<u64>,
          BlockNumberFor<T>: 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());
          }
          // request distance evaluation
          request_distance_evaluation {
          fn populate_pool<T: Config>(i: u32) -> Result<(), &'static str> {
          EvaluationPool0::<T>::mutate(|current_pool| -> Result<(), &'static str> {
          for j in 0..i {
          current_pool
          .evaluations
          .try_push((j, median::MedianAcc::new()))
          .map_err(|_| Error::<T>::QueueFull)?;
          }
          Ok(())
          })
          }
          #[benchmark]
          fn request_distance_evaluation() {
          let idty = T::IdtyIndex::one();
          let caller: T::AccountId = pallet_identity::Identities::<T>::get(idty).unwrap().owner_key;
          let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
          let _ = <Balances<T> as Currency<_>>::make_free_balance_be(&caller, T::Balance::max_value());
          }: _<T::RuntimeOrigin>(caller_origin.clone())
          verify {
          assert!(PendingEvaluationRequest::<T>::get(idty) == Some(caller.clone()), "Request not added");
          assert_has_event::<T>(Event::<T>::EvaluationRequested { idty_index: idty, who: caller }.into());
          let caller: T::AccountId = pallet_identity::Identities::<T>::get(idty)
          .unwrap()
          .owner_key;
          let _ =
          <Balances<T> as Currency<_>>::make_free_balance_be(&caller, T::Balance::max_value());
          #[extrinsic_call]
          _(RawOrigin::Signed(caller.clone()));
          assert!(
          PendingEvaluationRequest::<T>::get(idty) == Some(caller.clone()),
          "Request not added"
          );
          assert_has_event::<T>(
          Event::<T>::EvaluationRequested {
          idty_index: idty,
          who: caller,
          }
          .into(),
          );
          }
          // request distance evaluation for
          request_distance_evaluation_for {
          #[benchmark]
          fn request_distance_evaluation_for() {
          let idty = T::IdtyIndex::one();
          let caller: T::AccountId = pallet_identity::Identities::<T>::get(idty).unwrap().owner_key;
          let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
          let _ = <Balances<T> as Currency<_>>::make_free_balance_be(&caller, T::Balance::max_value());
          let target = 2u32;
          let caller: T::AccountId = pallet_identity::Identities::<T>::get(idty)
          .unwrap()
          .owner_key;
          <Balances<T> as Currency<_>>::make_free_balance_be(&caller, T::Balance::max_value());
          let target: T::IdtyIndex = 2u32;
          // set target status since targeted distance evaluation only allowed for unvalidated
          pallet_identity::Identities::<T>::mutate(target,
          |idty_val| idty_val.as_mut().unwrap().status = pallet_identity::IdtyStatus::Unvalidated);
          }: _<T::RuntimeOrigin>(caller_origin.clone(), target)
          verify {
          assert!(PendingEvaluationRequest::<T>::get(target) == Some(caller.clone()), "Request not added");
          assert_has_event::<T>(Event::<T>::EvaluationRequested { idty_index: target, who: caller }.into());
          pallet_identity::Identities::<T>::mutate(target, |idty_val| {
          idty_val.as_mut().unwrap().status = pallet_identity::IdtyStatus::Unvalidated
          });
          #[extrinsic_call]
          _(RawOrigin::Signed(caller.clone()), target);
          assert!(
          PendingEvaluationRequest::<T>::get(target) == Some(caller.clone()),
          "Request not added"
          );
          assert_has_event::<T>(
          Event::<T>::EvaluationRequested {
          idty_index: target,
          who: caller,
          }
          .into(),
          );
          }
          // update evaluation
          update_evaluation {
          #[benchmark]
          fn update_evaluation(i: Linear<1, MAX_EVALUATIONS_PER_SESSION>) -> Result<(), BenchmarkError> {
          let digest_data = sp_consensus_babe::digests::PreDigest::SecondaryPlain(
          sp_consensus_babe::digests::SecondaryPlainPreDigest { authority_index: 0u32, slot: Default::default() });
          sp_consensus_babe::digests::SecondaryPlainPreDigest {
          authority_index: 0u32,
          slot: Default::default(),
          },
          );
          // A BABE digest item is needed to check authorship
          let digest = sp_runtime::DigestItem::PreRuntime(*b"BABE", digest_data.encode());
          let _ = <frame_system::Pallet<T>>::deposit_log(digest);
          <frame_system::Pallet<T>>::deposit_log(digest);
          populate_pool::<T>(i)?;
          #[extrinsic_call]
          _(
          RawOrigin::None,
          ComputationResult {
          distances: vec![Perbill::one(); i as usize],
          },
          );
          Ok(())
          }
          #[benchmark]
          fn force_update_evaluation(
          i: Linear<1, MAX_EVALUATIONS_PER_SESSION>,
          ) -> Result<(), BenchmarkError> {
          let idty = T::IdtyIndex::one();
          let caller: T::AccountId = pallet_identity::Identities::<T>::get(idty).unwrap().owner_key;
          let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
          let i in 1 .. MAX_EVALUATIONS_PER_SESSION => populate_pool::<T>(i)?;
          }: _<T::RuntimeOrigin>(RawOrigin::None.into(), ComputationResult{distances: vec![Perbill::one(); i as usize]})
          // force update evaluation
          force_update_evaluation {
          let idty = T::IdtyIndex::one();
          let caller: T::AccountId = pallet_identity::Identities::<T>::get(idty).unwrap().owner_key;
          let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
          let i in 1 .. MAX_EVALUATIONS_PER_SESSION => populate_pool::<T>(i)?;
          }: _<T::RuntimeOrigin>(RawOrigin::Root.into(), caller.clone(), ComputationResult{distances: vec![Perbill::one(); i as usize]})
          // force valid distance status
          force_valid_distance_status {
          let caller: T::AccountId = pallet_identity::Identities::<T>::get(idty)
          .unwrap()
          .owner_key;
          populate_pool::<T>(i)?;
          #[extrinsic_call]
          _(
          RawOrigin::Root,
          caller,
          ComputationResult {
          distances: vec![Perbill::one(); i as usize],
          },
          );
          Ok(())
          }
          #[benchmark]
          fn force_valid_distance_status() {
          let idty = T::IdtyIndex::one();
          let caller: T::AccountId = pallet_identity::Identities::<T>::get(idty).unwrap().owner_key;
          }: _<T::RuntimeOrigin>(RawOrigin::Root.into(), idty)
          verify {
          #[extrinsic_call]
          _(RawOrigin::Root, idty);
          assert_has_event::<T>(Event::<T>::EvaluatedValid { idty_index: idty }.into());
          }
          // on finalize
          on_finalize {
          #[benchmark]
          fn on_finalize() {
          DidUpdate::<T>::set(true);
          }: { Pallet::<T>::on_finalize(Default::default()); }
          verify {
          #[block]
          {
          Pallet::<T>::on_finalize(Default::default());
          }
          assert!(!DidUpdate::<T>::get());
          }
          ......
          pallets/duniter-account/src/benchmarking.rs
          + 118
          − 52
          View file @ 1143537b
          ......@@ -18,73 +18,139 @@
          use super::*;
          use frame_benchmarking::{account, benchmarks, whitelisted_caller};
          use frame_benchmarking::v2::*;
          use frame_support::sp_runtime::{traits::One, Saturating};
          use frame_support::traits::{Currency, Get};
          use frame_support::traits::Currency;
          use frame_system::RawOrigin;
          use pallet_provide_randomness::OnFilledRandomness;
          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]
          mod benchmarks {
          use super::*;
          fn create_pending_accounts<T: Config>(
          i: u32,
          is_balance: bool,
          is_sufficient: bool,
          ) -> Result<(), &'static str> {
          for _ in 0..i {
          let caller: T::AccountId = whitelisted_caller();
          if is_balance {
          let existential_deposit = T::ExistentialDeposit::get();
          let balance = existential_deposit.saturating_mul((200u32).into());
          let _ = <pallet_balances::Pallet<T> as Currency<T::AccountId>>::make_free_balance_be(
          &caller, balance,
          );
          } else {
          assert!(
          frame_system::Pallet::<T>::get(&caller).free
          < T::NewAccountPrice::get() + T::ExistentialDeposit::get()
          );
          }
          if is_sufficient {
          frame_system::Pallet::<T>::inc_sufficients(&caller);
          } else {
          assert!(frame_system::Pallet::<T>::sufficients(&caller) == 0);
          fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
          frame_system::Pallet::<T>::assert_has_event(generic_event.into());
          }
          fn create_pending_accounts<T: Config>(
          i: u32,
          is_balance: bool,
          is_sufficient: bool,
          ) -> Result<(), &'static str> {
          for _ in 0..i {
          let caller: T::AccountId = whitelisted_caller();
          if is_balance {
          let existential_deposit = T::ExistentialDeposit::get();
          let balance = existential_deposit.saturating_mul((200u32).into());
          let _ =
          <pallet_balances::Pallet<T> as Currency<T::AccountId>>::make_free_balance_be(
          &caller, balance,
          );
          } else {
          assert!(
          frame_system::Pallet::<T>::get(&caller).free
          < T::NewAccountPrice::get() + T::ExistentialDeposit::get()
          );
          }
          if is_sufficient {
          frame_system::Pallet::<T>::inc_sufficients(&caller);
          } else {
          assert!(frame_system::Pallet::<T>::sufficients(&caller) == 0);
          }
          PendingNewAccounts::<T>::insert(caller, ());
          }
          PendingNewAccounts::<T>::insert(caller, ());
          Ok(())
          }
          Ok(())
          }
          benchmarks! {
          unlink_identity {
          #[benchmark]
          fn unlink_identity() {
          let account = account("Alice", 1, 1);
          let origin = frame_system::RawOrigin::Signed(account);
          }: _<T::RuntimeOrigin>(origin.into())
          on_initialize_sufficient {
          let i in 0 .. T::MaxNewAccountsPerBlock::get() => create_pending_accounts::<T>(i, false, true)?;
          }: { Pallet::<T>::on_initialize(BlockNumberFor::<T>::one()); }
          on_initialize_with_balance {
          let i in 0 .. T::MaxNewAccountsPerBlock::get() => create_pending_accounts::<T>(i, true, false)?;
          }: { Pallet::<T>::on_initialize(BlockNumberFor::<T>::one()); }
          on_initialize_no_balance {
          let i in 0 .. T::MaxNewAccountsPerBlock::get() => create_pending_accounts::<T>(i, false, false)?;
          }: { Pallet::<T>::on_initialize(BlockNumberFor::<T>::one()); }
          on_filled_randomness_pending {
          #[extrinsic_call]
          _(RawOrigin::Signed(account));
          }
          #[benchmark]
          fn on_initialize_sufficient(
          i: Linear<0, { T::MaxNewAccountsPerBlock::get() }>,
          ) -> Result<(), BenchmarkError> {
          create_pending_accounts::<T>(i, false, true)?;
          #[block]
          {
          Pallet::<T>::on_initialize(BlockNumberFor::<T>::one());
          }
          Ok(())
          }
          #[benchmark]
          fn on_initialize_with_balance(
          i: Linear<0, { T::MaxNewAccountsPerBlock::get() }>,
          ) -> Result<(), BenchmarkError> {
          create_pending_accounts::<T>(i, true, false)?;
          #[block]
          {
          Pallet::<T>::on_initialize(BlockNumberFor::<T>::one());
          }
          Ok(())
          }
          #[benchmark]
          fn on_initialize_no_balance(
          i: Linear<0, { T::MaxNewAccountsPerBlock::get() }>,
          ) -> Result<(), BenchmarkError> {
          create_pending_accounts::<T>(i, false, false)?;
          #[block]
          {
          Pallet::<T>::on_initialize(BlockNumberFor::<T>::one());
          }
          Ok(())
          }
          #[benchmark]
          fn on_filled_randomness_pending() {
          let caller: T::AccountId = whitelisted_caller();
          let randomness = H256(T::AccountIdToSalt::convert(caller.clone()));
          let request_id = pallet_provide_randomness::Pallet::<T>::force_request(pallet_provide_randomness::RandomnessType::RandomnessFromTwoEpochsAgo, randomness);
          let request_id = pallet_provide_randomness::Pallet::<T>::force_request(
          pallet_provide_randomness::RandomnessType::RandomnessFromTwoEpochsAgo,
          randomness,
          );
          PendingRandomIdAssignments::<T>::insert(request_id, caller.clone());
          }: { Pallet::<T>::on_filled_randomness(request_id, randomness); }
          verify {
          assert_has_event::<T>(Event::<T>::RandomIdAssigned { who: caller, random_id: randomness }.into());
          #[block]
          {
          Pallet::<T>::on_filled_randomness(request_id, randomness);
          }
          assert_has_event::<T>(
          Event::<T>::RandomIdAssigned {
          who: caller,
          random_id: randomness,
          }
          .into(),
          );
          }
          on_filled_randomness_no_pending {
          #[benchmark]
          fn on_filled_randomness_no_pending() {
          let caller: T::AccountId = whitelisted_caller();
          let randomness = H256(T::AccountIdToSalt::convert(caller.clone()));
          let request_id = pallet_provide_randomness::Pallet::<T>::force_request(pallet_provide_randomness::RandomnessType::RandomnessFromTwoEpochsAgo, randomness);
          let request_id = pallet_provide_randomness::Pallet::<T>::force_request(
          pallet_provide_randomness::RandomnessType::RandomnessFromTwoEpochsAgo,
          randomness,
          );
          assert!(!PendingRandomIdAssignments::<T>::contains_key(request_id));
          }: { Pallet::<T>::on_filled_randomness(request_id, randomness); }
          #[block]
          {
          Pallet::<T>::on_filled_randomness(request_id, randomness);
          }
          }
          }
          pallets/identity/src/benchmarking.rs
          + 342
          − 198
          View file @ 1143537b
          This diff is collapsed.
          pallets/membership/src/benchmarking.rs
          + 34
          − 26
          View file @ 1143537b
          ......@@ -18,58 +18,66 @@
          use super::*;
          use frame_benchmarking::benchmarks;
          use frame_benchmarking::v2::*;
          use frame_system::pallet_prelude::BlockNumberFor;
          #[cfg(test)]
          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_clause {
          #[benchmarks(
          where
          T::IdtyId: From<u32>,
          BlockNumberFor<T>: From<u32>,
          }
          )]
          mod benchmarks {
          use super::*;
          // TODO membership add and renewal should be included to distance on_new_session as worst case scenario
          // Base weight of an empty initialize
          on_initialize {
          }: {Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());}
          #[benchmark]
          fn on_initialize() {
          // Base weight of an empty initialize
          #[block]
          {
          Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());
          }
          }
          expire_memberships {
          let i in 0..3; // Limited by the number of validators
          #[benchmark]
          fn expire_memberships(i: Linear<0, 3>) {
          // Limited by the number of validators
          // Arbitrarily high, to be in the worst case of wot instance,
          // this will overcount the weight in hooks see https://git.duniter.org/nodes/rust/duniter-v2s/-/issues/167
          let block_number: BlockNumberFor::<T> = 10_000_000.into();
          let block_number: BlockNumberFor<T> = 10_000_000.into();
          frame_system::pallet::Pallet::<T>::set_block_number(block_number);
          let mut idties: Vec<T::IdtyId> = Vec::new();
          for j in 1..i+1 {
          for j in 1..i + 1 {
          let j: T::IdtyId = j.into();
          Membership::<T>::insert(j, MembershipData::<BlockNumberFor<T>>::default());
          idties.push(j);
          }
          MembershipsExpireOn::<T>::insert(block_number, idties);
          assert_eq!(MembershipsExpireOn::<T>::get(block_number).len(), i as usize);
          }: {Pallet::<T>::expire_memberships(block_number);}
          verify {
          assert_eq!(
          MembershipsExpireOn::<T>::get(block_number).len(),
          i as usize
          );
          #[block]
          {
          Pallet::<T>::expire_memberships(block_number);
          }
          assert_eq!(MembershipsExpireOn::<T>::get(block_number).len(), 0_usize);
          }
          impl_benchmark_test_suite!(
          Pallet,
          crate::mock::new_test_ext(crate::mock::MembershipConfig {
          memberships: btreemap![
          3 => MembershipData {
          expire_on: 3,
          },
          ],}),
          memberships: maplit::btreemap![
          3 => crate::MembershipData {
          expire_on: 3,
          },
          ],
          }),
          crate::mock::Test
          );
          }
          0% or .
          You are about to add 0 people to the discussion. Proceed with caution.
          Finish editing this message first!
          Please register or to comment