Skip to content
Snippets Groups Projects
Unverified Commit 43c79748 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 #35781 failed
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
          Showing
          with 1005 additions and 594 deletions
          pallets/authority-members/src/benchmarking.rs
          + 52
          − 39
          View file @ 43c79748
          ......@@ -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 @ 43c79748
          ......@@ -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 @ 43c79748
          ......@@ -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 @ 43c79748
          ......@@ -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 @ 43c79748
          This diff is collapsed.
          pallets/membership/src/benchmarking.rs
          + 34
          − 26
          View file @ 43c79748
          ......@@ -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
          );
          }
          pallets/oneshot-account/src/benchmarking.rs
          + 52
          − 46
          View file @ 43c79748
          ......@@ -18,7 +18,8 @@
          use super::*;
          use frame_benchmarking::{account, benchmarks, whitelisted_caller};
          use frame_benchmarking::v2::*;
          use frame_benchmarking::{account, whitelisted_caller};
          use frame_support::pallet_prelude::IsType;
          use frame_support::traits::Get;
          use frame_system::RawOrigin;
          ......@@ -26,90 +27,99 @@ use pallet_balances::Pallet as Balances;
          use crate::Pallet;
          const SEED: u32 = 0;
          benchmarks! {
          where_clause {
          #[benchmarks(
          where
          T: pallet_balances::Config,
          T::Balance: From<u64>,
          <T::Currency as Currency<T::AccountId>>::Balance: IsType<T::Balance>+From<T::Balance>
          }
          create_oneshot_account {
          )]
          mod benchmarks {
          use super::*;
          #[benchmark]
          fn create_oneshot_account() {
          let existential_deposit = T::ExistentialDeposit::get();
          let caller = whitelisted_caller();
          // Give some multiple of the existential deposit
          let balance = existential_deposit.saturating_mul((2).into());
          let _ = T::Currency::make_free_balance_be(&caller, balance.into());
          let recipient: T::AccountId = account("recipient", 0, SEED);
          let recipient: T::AccountId = account("recipient", 0, 1);
          let recipient_lookup: <T::Lookup as StaticLookup>::Source =
          T::Lookup::unlookup(recipient.clone());
          let transfer_amount = existential_deposit;
          }: _(RawOrigin::Signed(caller.clone()), recipient_lookup, transfer_amount.into())
          verify {
          #[extrinsic_call]
          _(
          RawOrigin::Signed(caller.clone()),
          recipient_lookup,
          transfer_amount.into(),
          );
          assert_eq!(Balances::<T>::free_balance(&caller), transfer_amount);
          assert_eq!(OneshotAccounts::<T>::get(&recipient), Some(transfer_amount.into()));
          assert_eq!(
          OneshotAccounts::<T>::get(&recipient),
          Some(transfer_amount.into())
          );
          }
          consume_oneshot_account {
          #[benchmark]
          fn consume_oneshot_account() {
          let existential_deposit = T::ExistentialDeposit::get();
          let caller: T::AccountId = whitelisted_caller();
          // Give some multiple of the existential deposit
          let balance = existential_deposit.saturating_mul((2).into());
          OneshotAccounts::<T>::insert(
          caller.clone(),
          Into::<<T::Currency as Currency<T::AccountId>>::Balance>::into(balance)
          Into::<<T::Currency as Currency<T::AccountId>>::Balance>::into(balance),
          );
          // Deposit into a normal account is more expensive than into a oneshot account
          // so we create the recipient account with an existential deposit.
          let recipient: T::AccountId = account("recipient", 0, SEED);
          let recipient: T::AccountId = account("recipient", 0, 1);
          let recipient_lookup: <T::Lookup as StaticLookup>::Source =
          T::Lookup::unlookup(recipient.clone());
          let _ = T::Currency::make_free_balance_be(&recipient, existential_deposit.into());
          }: _(
          RawOrigin::Signed(caller.clone()),
          BlockNumberFor::<T>::zero(),
          Account::<<T::Lookup as StaticLookup>::Source>::Normal(recipient_lookup)
          )
          verify {
          #[extrinsic_call]
          _(
          RawOrigin::Signed(caller.clone()),
          BlockNumberFor::<T>::zero(),
          Account::<<T::Lookup as StaticLookup>::Source>::Normal(recipient_lookup),
          );
          assert_eq!(OneshotAccounts::<T>::get(&caller), None);
          assert_eq!(
          Balances::<T>::free_balance(&recipient),
          existential_deposit.saturating_mul((3).into())
          );
          }
          consume_oneshot_account_with_remaining {
          #[benchmark]
          fn consume_oneshot_account_with_remaining() {
          let existential_deposit = T::ExistentialDeposit::get();
          let caller: T::AccountId = whitelisted_caller();
          // Give some multiple of the existential deposit
          let balance = existential_deposit.saturating_mul((2).into());
          OneshotAccounts::<T>::insert(
          caller.clone(),
          Into::<<T::Currency as Currency<T::AccountId>>::Balance>::into(balance)
          Into::<<T::Currency as Currency<T::AccountId>>::Balance>::into(balance),
          );
          // Deposit into a normal account is more expensive than into a oneshot account
          // so we create the recipient accounts with an existential deposits.
          let recipient1: T::AccountId = account("recipient1", 0, SEED);
          let recipient1: T::AccountId = account("recipient1", 0, 1);
          let recipient1_lookup: <T::Lookup as StaticLookup>::Source =
          T::Lookup::unlookup(recipient1.clone());
          let _ = T::Currency::make_free_balance_be(&recipient1, existential_deposit.into());
          let recipient2: T::AccountId = account("recipient2", 1, SEED);
          let recipient2: T::AccountId = account("recipient2", 1, 1);
          let recipient2_lookup: <T::Lookup as StaticLookup>::Source =
          T::Lookup::unlookup(recipient2.clone());
          let _ = T::Currency::make_free_balance_be(&recipient2, existential_deposit.into());
          }: _(
          RawOrigin::Signed(caller.clone()),
          BlockNumberFor::<T>::zero(),
          Account::<<T::Lookup as StaticLookup>::Source>::Normal(recipient1_lookup),
          Account::<<T::Lookup as StaticLookup>::Source>::Normal(recipient2_lookup),
          existential_deposit.into()
          )
          verify {
          #[extrinsic_call]
          _(
          RawOrigin::Signed(caller.clone()),
          BlockNumberFor::<T>::zero(),
          Account::<<T::Lookup as StaticLookup>::Source>::Normal(recipient1_lookup),
          Account::<<T::Lookup as StaticLookup>::Source>::Normal(recipient2_lookup),
          existential_deposit.into(),
          );
          assert_eq!(OneshotAccounts::<T>::get(&caller), None);
          assert_eq!(
          Balances::<T>::free_balance(&recipient1),
          ......@@ -121,9 +131,5 @@ benchmarks! {
          );
          }
          impl_benchmark_test_suite!(
          Pallet,
          crate::mock::new_test_ext(),
          crate::mock::Test
          );
          impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test);
          }
          pallets/provide-randomness/src/benchmarking.rs
          + 94
          − 56
          View file @ 43c79748
          ......@@ -18,7 +18,8 @@
          use super::*;
          use frame_benchmarking::{benchmarks, whitelisted_caller};
          use frame_benchmarking::v2::*;
          use frame_benchmarking::whitelisted_caller;
          use frame_support::ensure;
          use frame_support::pallet_prelude::IsType;
          use frame_support::sp_runtime::{traits::One, Saturating};
          ......@@ -29,49 +30,51 @@ use sp_core::H256;
          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: pallet_balances::Config,
          T::Balance: From<u64>,
          <T::Currency as Currency<T::AccountId>>::Balance: IsType<T::Balance>,
          BlockNumberFor<T>: From<u32>,
          )]
          mod benchmarks {
          use super::*;
          fn add_requests_next_block<T: Config>(i: u32) -> Result<(), &'static str> {
          for _ in 0..i {
          let salt: H256 = H256([0; 32]);
          let request_id = RequestIdProvider::<T>::mutate(|next_request_id| {
          core::mem::replace(next_request_id, next_request_id.saturating_add(1))
          });
          RequestsIds::<T>::insert(request_id, ());
          RequestsReadyAtNextBlock::<T>::append(Request { request_id, salt });
          fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
          frame_system::Pallet::<T>::assert_has_event(generic_event.into());
          }
          Ok(())
          }
          fn add_requests_next_epoch<T: Config>(i: u32) -> Result<(), &'static str> {
          for _ in 0..i {
          let salt: H256 = H256([0; 32]);
          let request_id = RequestIdProvider::<T>::mutate(|next_request_id| {
          core::mem::replace(next_request_id, next_request_id.saturating_add(1))
          });
          RequestsIds::<T>::insert(request_id, ());
          RequestsReadyAtEpoch::<T>::append(
          T::GetCurrentEpochIndex::get(),
          Request { request_id, salt },
          );
          fn add_requests_next_block<T: Config>(i: u32) -> Result<(), &'static str> {
          for _ in 0..i {
          let salt: H256 = H256([0; 32]);
          let request_id = RequestIdProvider::<T>::mutate(|next_request_id| {
          core::mem::replace(next_request_id, next_request_id.saturating_add(1))
          });
          RequestsIds::<T>::insert(request_id, ());
          RequestsReadyAtNextBlock::<T>::append(Request { request_id, salt });
          }
          Ok(())
          }
          Ok(())
          }
          benchmarks! {
          where_clause { where
          T: pallet_balances::Config,
          T::Balance: From<u64>,
          <T::Currency as Currency<T::AccountId>>::Balance: IsType<T::Balance>,
          BlockNumberFor<T>: From<u32>,
          fn add_requests_next_epoch<T: Config>(i: u32) -> Result<(), &'static str> {
          for _ in 0..i {
          let salt: H256 = H256([0; 32]);
          let request_id = RequestIdProvider::<T>::mutate(|next_request_id| {
          core::mem::replace(next_request_id, next_request_id.saturating_add(1))
          });
          RequestsIds::<T>::insert(request_id, ());
          RequestsReadyAtEpoch::<T>::append(
          T::GetCurrentEpochIndex::get(),
          Request { request_id, salt },
          );
          }
          Ok(())
          }
          request {
          #[benchmark]
          fn request() {
          // Get account
          let caller: T::AccountId = whitelisted_caller();
          let caller_origin: <T as frame_system::Config>::RuntimeOrigin =
          RawOrigin::Signed(caller.clone()).into();
          // Provide deposit
          let existential_deposit = T::ExistentialDeposit::get();
          ......@@ -81,36 +84,71 @@ benchmarks! {
          // Set randomness parameters
          let random = RandomnessType::RandomnessFromOneEpochAgo;
          let salt: H256 = H256([1; 32]);
          }: _<T::RuntimeOrigin>(caller_origin.clone(), random, salt)
          verify {
          #[extrinsic_call]
          _(RawOrigin::Signed(caller), random, salt);
          let request_id = RequestIdProvider::<T>::get() - 1;
          assert_has_event::<T>(Event::RequestedRandomness {
          request_id, salt, r#type: random }.into() );
          assert_has_event::<T>(
          Event::RequestedRandomness {
          request_id,
          salt,
          r#type: random,
          }
          .into(),
          );
          }
          on_initialize {
          let i in 1 .. T::MaxRequests::get() => add_requests_next_block::<T>(i)?;
          #[benchmark]
          fn on_initialize(i: Linear<1, { T::MaxRequests::get() }>) -> Result<(), BenchmarkError> {
          add_requests_next_block::<T>(i)?;
          ensure!(RequestsIds::<T>::count() == i, "List not filled properly.");
          ensure!(RequestsReadyAtNextBlock::<T>::get().len() == i as usize, "List not filled properly.");
          ensure!(
          RequestsReadyAtNextBlock::<T>::get().len() == i as usize,
          "List not filled properly."
          );
          let next_epoch_hook_in = NexEpochHookIn::<T>::mutate(|next_in| {
          core::mem::replace(next_in, next_in.saturating_sub(1))
          });
          ensure!(next_epoch_hook_in != 1, "Will be next epoch.");
          }: { Pallet::<T>::on_initialize(BlockNumberFor::<T>::one()); }
          verify {
          #[block]
          {
          Pallet::<T>::on_initialize(BlockNumberFor::<T>::one());
          }
          ensure!(RequestsIds::<T>::count() == 0, "List not processed.");
          ensure!(RequestsReadyAtNextBlock::<T>::get().is_empty(), "List not processed.");
          ensure!(
          RequestsReadyAtNextBlock::<T>::get().is_empty(),
          "List not processed."
          );
          Ok(())
          }
          on_initialize_epoch {
          let i in 1 .. T::MaxRequests::get() => add_requests_next_epoch::<T>(i)?;
          ensure!(RequestsReadyAtNextBlock::<T>::get().is_empty(), "List not filled properly.");
          #[benchmark]
          fn on_initialize_epoch(i: Linear<1, { T::MaxRequests::get() }>) -> Result<(), BenchmarkError> {
          add_requests_next_epoch::<T>(i)?;
          ensure!(
          RequestsReadyAtNextBlock::<T>::get().is_empty(),
          "List not filled properly."
          );
          ensure!(RequestsIds::<T>::count() == i, "List not filled properly.");
          ensure!(RequestsReadyAtEpoch::<T>::get(T::GetCurrentEpochIndex::get()).len() == i as usize, "List not filled properly.");
          let next_epoch_hook_in = NexEpochHookIn::<T>::mutate(|next_in| {
          core::mem::replace(next_in, 1)
          });
          }: { Pallet::<T>::on_initialize(1.into()); }
          verify {
          ensure!(
          RequestsReadyAtEpoch::<T>::get(T::GetCurrentEpochIndex::get()).len() == i as usize,
          "List not filled properly."
          );
          NexEpochHookIn::<T>::mutate(|next_in| core::mem::replace(next_in, 1));
          #[block]
          {
          Pallet::<T>::on_initialize(1.into());
          }
          ensure!(RequestsIds::<T>::count() == 0, "List not processed.");
          ensure!(RequestsReadyAtEpoch::<T>::get(T::GetCurrentEpochIndex::get()).is_empty(), "List not processed properly.");
          ensure!(
          RequestsReadyAtEpoch::<T>::get(T::GetCurrentEpochIndex::get()).is_empty(),
          "List not processed properly."
          );
          Ok(())
          }
          }
          pallets/quota/src/benchmarking.rs
          + 85
          − 45
          View file @ 43c79748
          ......@@ -17,21 +17,25 @@
          #![cfg(feature = "runtime-benchmarks")]
          use super::*;
          use frame_benchmarking::{account, benchmarks};
          use frame_benchmarking::account;
          use frame_benchmarking::v2::*;
          use sp_runtime::traits::One;
          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
          IdtyId<T>: From<u32>,
          BalanceOf<T>: From<u64>,
          T::AccountId: From<[u8; 32]>,
          }
          queue_refund {
          )]
          mod benchmarks {
          use super::*;
          #[benchmark]
          fn queue_refund() {
          let account: T::AccountId = account("Alice", 1, 1);
          let dummy_refund = Refund {
          account: account.clone(),
          ......@@ -44,15 +48,21 @@ benchmarks! {
          amount: 10u64.into(),
          };
          // Complexity is bound to MAX_QUEUD_REFUNDS where an insertion is O(n-1)
          for i in 0..MAX_QUEUED_REFUNDS-1 {
          for _ in 0..MAX_QUEUED_REFUNDS - 1 {
          Pallet::<T>::queue_refund(dummy_refund.clone())
          }
          }: { Pallet::<T>::queue_refund(refund.clone()) }
          verify {
          #[block]
          {
          Pallet::<T>::queue_refund(refund.clone());
          }
          assert_eq!(RefundQueue::<T>::get().last(), Some(refund).as_ref());
          assert_eq!(RefundQueue::<T>::get().len() as u32, MAX_QUEUED_REFUNDS);
          }
          spend_quota {
          #[benchmark]
          fn spend_quota() {
          let idty_id: IdtyId<T> = 1u32.into();
          let amount = 2u64;
          let quota_amount = 10u64;
          ......@@ -63,15 +73,23 @@ benchmarks! {
          amount: quota_amount.into(),
          },
          );
          }: { Pallet::<T>::spend_quota(idty_id, amount.into()) }
          verify {
          let quota_growth = sp_runtime::Perbill::from_rational(
          BlockNumberFor::<T>::one(),
          T::ReloadRate::get(),
          ).mul_floor(T::MaxQuota::get());
          assert_eq!(IdtyQuota::<T>::get(idty_id).unwrap().amount, quota_growth +quota_amount.into() - amount.into());
          #[block]
          {
          Pallet::<T>::spend_quota(idty_id, amount.into());
          }
          let quota_growth =
          sp_runtime::Perbill::from_rational(BlockNumberFor::<T>::one(), T::ReloadRate::get())
          .mul_floor(T::MaxQuota::get());
          assert_eq!(
          IdtyQuota::<T>::get(idty_id).unwrap().amount,
          quota_growth + quota_amount.into() - amount.into()
          );
          }
          try_refund {
          #[benchmark]
          fn try_refund() {
          let account: T::AccountId = account("Alice", 1, 1);
          let idty_id: IdtyId<T> = 1u32.into();
          IdtyQuota::<T>::insert(
          ......@@ -81,9 +99,7 @@ benchmarks! {
          amount: 10u64.into(),
          },
          );
          let _ = CurrencyOf::<T>:: make_free_balance_be(
          &T::RefundAccount::get(),u32::MAX.into(),
          );
          let _ = CurrencyOf::<T>::make_free_balance_be(&T::RefundAccount::get(), u32::MAX.into());
          // The worst-case scenario is when the refund fails
          // and can only be triggered if the account is dead,
          // in this case by having no balance in the account.
          ......@@ -92,15 +108,19 @@ benchmarks! {
          identity: 1u32.into(),
          amount: 10u64.into(),
          };
          }: { Pallet::<T>::try_refund(refund) }
          verify {
          assert_has_event::<T>(Event::<T>::RefundFailed ( account ).into());
          #[block]
          {
          Pallet::<T>::try_refund(refund);
          }
          assert_has_event::<T>(Event::<T>::RefundFailed(account).into());
          }
          do_refund {
          #[benchmark]
          fn do_refund() {
          let account: T::AccountId = account("Alice", 1, 1);
          let _ = CurrencyOf::<T>:: make_free_balance_be(
          &T::RefundAccount::get(),u32::MAX.into(),
          );
          let _ = CurrencyOf::<T>::make_free_balance_be(&T::RefundAccount::get(), u32::MAX.into());
          // The worst-case scenario is when the refund fails
          // and can only be triggered if the account is dead,
          // in this case by having no balance in the account.
          ......@@ -109,19 +129,30 @@ benchmarks! {
          identity: 1u32.into(),
          amount: 10u64.into(),
          };
          }: { Pallet::<T>::try_refund(refund) }
          verify {
          assert_has_event::<T>(Event::<T>::RefundFailed ( account ).into());
          #[block]
          {
          Pallet::<T>::try_refund(refund);
          }
          assert_has_event::<T>(Event::<T>::RefundFailed(account).into());
          }
          // The base weight consumed on processing refund queue when empty.
          on_process_refund_queue {
          #[benchmark]
          fn on_process_refund_queue() {
          // The base weight consumed on processing refund queue when empty.
          assert_eq!(RefundQueue::<T>::get().len() as u32, 0);
          }: { Pallet::<T>::process_refund_queue(Weight::MAX) }
          // The weight consumed on processing refund queue with one element.
          // Can deduce the process_refund_queue overhead by subtracting try_refund weight.
          #[pov_mode = Measured]
          on_process_refund_queue_elements {
          let i in 1..MAX_QUEUED_REFUNDS;
          #[block]
          {
          Pallet::<T>::process_refund_queue(Weight::MAX);
          }
          }
          #[benchmark]
          fn on_process_refund_queue_elements(i: Linear<1, MAX_QUEUED_REFUNDS>) {
          // The weight consumed on processing refund queue with one element.
          // Can deduce the process_refund_queue overhead by subtracting try_refund weight.
          let account: T::AccountId = account("Alice", 1, 1);
          let idty_id: IdtyId<T> = 1u32.into();
          IdtyQuota::<T>::insert(
          ......@@ -131,9 +162,7 @@ benchmarks! {
          amount: 10u64.into(),
          },
          );
          let _ = CurrencyOf::<T>:: make_free_balance_be(
          &T::RefundAccount::get(),u32::MAX.into(),
          );
          let _ = CurrencyOf::<T>::make_free_balance_be(&T::RefundAccount::get(), u32::MAX.into());
          // The worst-case scenario is when the refund fails
          // and can only be triggered if the account is dead,
          // in this case by having no balance in the account.
          ......@@ -146,10 +175,21 @@ benchmarks! {
          Pallet::<T>::queue_refund(refund.clone());
          }
          assert_eq!(RefundQueue::<T>::get().len() as u32, i);
          }: { Pallet::<T>::process_refund_queue(Weight::MAX) }
          verify {
          #[block]
          {
          Pallet::<T>::process_refund_queue(Weight::MAX);
          }
          assert_eq!(RefundQueue::<T>::get().len() as u32, 0);
          assert_has_event::<T>(Event::<T>::RefundFailed ( account ).into());
          assert_has_event::<T>(Event::<T>::RefundFailed(account).into());
          }
          impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(crate::mock::QuotaConfig{identities: vec![1, 2]}), crate::mock::Test);
          impl_benchmark_test_suite!(
          Pallet,
          crate::mock::new_test_ext(crate::mock::QuotaConfig {
          identities: vec![1, 2]
          }),
          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