From 43c797484ad5424ae2636ca1514bc655ff896c89 Mon Sep 17 00:00:00 2001
From: bgallois <benjamin@gallois.cc>
Date: Wed, 31 Jan 2024 12:08:36 +0100
Subject: [PATCH] update to benchmarking v2
---
pallets/authority-members/src/benchmarking.rs | 91 +--
pallets/certification/src/benchmarking.rs | 168 +++---
pallets/distance/src/benchmarking.rs | 192 ++++---
pallets/duniter-account/src/benchmarking.rs | 170 ++++--
pallets/identity/src/benchmarking.rs | 540 +++++++++++-------
pallets/membership/src/benchmarking.rs | 60 +-
pallets/oneshot-account/src/benchmarking.rs | 98 ++--
.../provide-randomness/src/benchmarking.rs | 150 +++--
pallets/quota/src/benchmarking.rs | 130 +++--
9 files changed, 1005 insertions(+), 594 deletions(-)
diff --git a/pallets/authority-members/src/benchmarking.rs b/pallets/authority-members/src/benchmarking.rs
index 893d89ba8..808ea5865 100644
--- a/pallets/authority-members/src/benchmarking.rs
+++ b/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);
}
diff --git a/pallets/certification/src/benchmarking.rs b/pallets/certification/src/benchmarking.rs
index 5aa67fdf4..1f273af05 100644
--- a/pallets/certification/src/benchmarking.rs
+++ b/pallets/certification/src/benchmarking.rs
@@ -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
);
diff --git a/pallets/distance/src/benchmarking.rs b/pallets/distance/src/benchmarking.rs
index 4b5fb9557..0e888c826 100644
--- a/pallets/distance/src/benchmarking.rs
+++ b/pallets/distance/src/benchmarking.rs
@@ -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());
}
diff --git a/pallets/duniter-account/src/benchmarking.rs b/pallets/duniter-account/src/benchmarking.rs
index 27a839e1a..74835636c 100644
--- a/pallets/duniter-account/src/benchmarking.rs
+++ b/pallets/duniter-account/src/benchmarking.rs
@@ -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);
+ }
+ }
}
diff --git a/pallets/identity/src/benchmarking.rs b/pallets/identity/src/benchmarking.rs
index 0d4fe93e4..89db5ffe4 100644
--- a/pallets/identity/src/benchmarking.rs
+++ b/pallets/identity/src/benchmarking.rs
@@ -20,7 +20,8 @@ use super::*;
//use codec::Encode;
use codec::Encode;
-use frame_benchmarking::{account, benchmarks};
+use frame_benchmarking::account;
+use frame_benchmarking::v2::*;
use frame_support::traits::OnInitialize;
use frame_system::pallet_prelude::BlockNumberFor;
use frame_system::RawOrigin;
@@ -30,128 +31,146 @@ use sp_runtime::{AccountId32, MultiSigner};
use crate::Pallet;
-const SEED: u32 = 1;
-
-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::Signature: From<sp_core::sr25519::Signature>,
+ T::Signature: From<sp_core::sr25519::Signature>,
+ T::AccountId: From<AccountId32>,
+ T::IdtyIndex: From<u32>,
+)]
+mod benchmarks {
+ use super::*;
-struct Account<T: Config> {
- key: T::AccountId,
- index: T::IdtyIndex,
- origin: <T as frame_system::Config>::RuntimeOrigin,
- // name: IdtyName,
-}
+ fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+ frame_system::Pallet::<T>::assert_has_event(generic_event.into());
+ }
-// Create and confirm one account using Alice authorized account.
-// key, origin, name and index are returned.
-// Alice next_creatable_identity_on is reinitialized at the end so several account can be
-// created in a row.
-fn create_one_identity<T: Config>(owner_key: T::AccountId) -> Result<Account<T>, &'static str> {
- // get Alice account to create identity
- let caller: T::AccountId = Identities::<T>::get(T::IdtyIndex::from(1u32))
- .unwrap()
- .owner_key;
- let caller_origin: <T as frame_system::Config>::RuntimeOrigin =
- RawOrigin::Signed(caller.clone()).into();
- let owner_key_origin: <T as frame_system::Config>::RuntimeOrigin =
- RawOrigin::Signed(owner_key.clone()).into();
- Pallet::<T>::create_identity(caller_origin.clone(), owner_key.clone())?;
- let name = IdtyName("new_identity".into());
- Pallet::<T>::confirm_identity(owner_key_origin.clone(), name.clone())?;
- let idty_index = IdentityIndexOf::<T>::get(&owner_key).unwrap();
- // make identity member
- <Identities<T>>::mutate_exists(idty_index, |idty_val_opt| {
- if let Some(ref mut idty_val) = idty_val_opt {
- idty_val.status = IdtyStatus::Member;
- }
- });
- // Reset next_creatable_identity_on to add more identities with Alice
- <Identities<T>>::mutate_exists(T::IdtyIndex::from(1u32), |idty_val_opt| {
- if let Some(ref mut idty_val) = idty_val_opt {
- idty_val.next_creatable_identity_on = BlockNumberFor::<T>::zero();
- }
- });
- Ok(Account {
- key: owner_key,
- index: idty_index,
- origin: owner_key_origin,
- // name: name,
- })
-}
+ struct Account<T: Config> {
+ key: T::AccountId,
+ index: T::IdtyIndex,
+ origin: <T as frame_system::Config>::RuntimeOrigin,
+ }
-// Create a dummy identity bypassing all the checks.
-fn create_dummy_identity<T: Config>(i: u32) -> Result<(), &'static str> {
- let idty_index: T::IdtyIndex = i.into();
- let owner_key: T::AccountId = account("Bob", i, SEED);
- let next_scheduled = BlockNumberFor::<T>::zero();
- let value = IdtyValue {
- data: Default::default(),
- next_creatable_identity_on: BlockNumberFor::<T>::zero(),
- old_owner_key: None,
- owner_key: owner_key.clone(),
- next_scheduled,
- status: IdtyStatus::Unvalidated,
- };
- let name = i.to_le_bytes();
- let idty_name = IdtyName(name.into());
- <Identities<T>>::insert(idty_index, value);
- IdentityChangeSchedule::<T>::append(next_scheduled, idty_index);
- IdentityIndexOf::<T>::insert(owner_key.clone(), idty_index);
- <IdentitiesNames<T>>::insert(idty_name.clone(), idty_index);
- Ok(())
-}
+ // Create and confirm one account using Alice authorized account.
+ // key, origin, name and index are returned.
+ // Alice next_creatable_identity_on is reinitialized at the end so several account can be
+ // created in a row.
+ fn create_one_identity<T: Config>(owner_key: T::AccountId) -> Result<Account<T>, &'static str> {
+ // get Alice account to create identity
+ let caller: T::AccountId = Identities::<T>::get(T::IdtyIndex::from(1u32))
+ .unwrap()
+ .owner_key;
+ let caller_origin: <T as frame_system::Config>::RuntimeOrigin =
+ RawOrigin::Signed(caller.clone()).into();
+ let owner_key_origin: <T as frame_system::Config>::RuntimeOrigin =
+ RawOrigin::Signed(owner_key.clone()).into();
+ Pallet::<T>::create_identity(caller_origin.clone(), owner_key.clone())?;
+ let name = IdtyName("new_identity".into());
+ Pallet::<T>::confirm_identity(owner_key_origin.clone(), name.clone())?;
+ let idty_index = IdentityIndexOf::<T>::get(&owner_key).unwrap();
+ // make identity member
+ <Identities<T>>::mutate_exists(idty_index, |idty_val_opt| {
+ if let Some(ref mut idty_val) = idty_val_opt {
+ idty_val.status = IdtyStatus::Member;
+ }
+ });
+ // Reset next_creatable_identity_on to add more identities with Alice
+ <Identities<T>>::mutate_exists(T::IdtyIndex::from(1u32), |idty_val_opt| {
+ if let Some(ref mut idty_val) = idty_val_opt {
+ idty_val.next_creatable_identity_on = BlockNumberFor::<T>::zero();
+ }
+ });
+ Ok(Account {
+ key: owner_key,
+ index: idty_index,
+ origin: owner_key_origin,
+ // name: name,
+ })
+ }
-// Add `i` dummy identities.
-fn create_identities<T: Config>(i: u32) -> Result<(), &'static str> {
- let identities_count = Pallet::<T>::identities_count();
- for j in 0..i {
- create_dummy_identity::<T>(j + identities_count + 1)?;
+ // Create a dummy identity bypassing all the checks.
+ fn create_dummy_identity<T: Config>(i: u32) -> Result<(), &'static str> {
+ let idty_index: T::IdtyIndex = i.into();
+ let owner_key: T::AccountId = account("Bob", i, 1);
+ let next_scheduled = BlockNumberFor::<T>::zero();
+ let value = IdtyValue {
+ data: Default::default(),
+ next_creatable_identity_on: BlockNumberFor::<T>::zero(),
+ old_owner_key: None,
+ owner_key: owner_key.clone(),
+ next_scheduled,
+ status: IdtyStatus::Unvalidated,
+ };
+ let name = i.to_le_bytes();
+ let idty_name = IdtyName(name.into());
+ <Identities<T>>::insert(idty_index, value);
+ IdentityChangeSchedule::<T>::append(next_scheduled, idty_index);
+ IdentityIndexOf::<T>::insert(owner_key.clone(), idty_index);
+ <IdentitiesNames<T>>::insert(idty_name.clone(), idty_index);
+ Ok(())
}
- assert!(
- identities_count + i == Pallet::<T>::identities_count(),
- "Identities not created"
- );
- Ok(())
-}
-benchmarks! {
- where_clause {
- where
- T::Signature: From<sp_core::sr25519::Signature>,
- T::Signature: From<sp_core::sr25519::Signature>,
- T::AccountId: From<AccountId32>,
- T::IdtyIndex: From<u32>,
+ // Add `i` dummy identities.
+ fn create_identities<T: Config>(i: u32) -> Result<(), &'static str> {
+ let identities_count = Pallet::<T>::identities_count();
+ for j in 0..i {
+ create_dummy_identity::<T>(j + identities_count + 1)?;
+ }
+ assert!(
+ identities_count + i == Pallet::<T>::identities_count(),
+ "Identities not created"
+ );
+ Ok(())
}
- // create identity
- create_identity {
- let caller: T::AccountId = Identities::<T>::get(T::IdtyIndex::one()).unwrap().owner_key; // Alice
- let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
- let owner_key: T::AccountId = account("new_identity", 2, SEED);
- }: _<T::RuntimeOrigin>(caller_origin.clone(), owner_key.clone())
- verify {
+ #[benchmark]
+ fn create_identity() {
+ let caller: T::AccountId = Identities::<T>::get(T::IdtyIndex::one()).unwrap().owner_key; // Alice
+ let owner_key: T::AccountId = account("new_identity", 2, 1);
+
+ #[extrinsic_call]
+ _(RawOrigin::Signed(caller), owner_key.clone());
+
let idty_index = IdentityIndexOf::<T>::get(&owner_key);
assert!(idty_index.is_some(), "Identity not added");
- assert_has_event::<T>(Event::<T>::IdtyCreated { idty_index: idty_index.unwrap(), owner_key }.into());
+ assert_has_event::<T>(
+ Event::<T>::IdtyCreated {
+ idty_index: idty_index.unwrap(),
+ owner_key,
+ }
+ .into(),
+ );
}
- // confirm identity
- confirm_identity {
- let caller: T::AccountId = Identities::<T>::get(T::IdtyIndex::one()).unwrap().owner_key;
- let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
- let owner_key: T::AccountId = account("new_identity", 2, SEED);
- let owner_key_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(owner_key.clone()).into();
+ #[benchmark]
+ fn confirm_identity() -> Result<(), BenchmarkError> {
+ let caller: T::AccountId = Identities::<T>::get(T::IdtyIndex::one()).unwrap().owner_key;
+ let caller_origin: <T as frame_system::Config>::RuntimeOrigin =
+ RawOrigin::Signed(caller.clone()).into();
+ let owner_key: T::AccountId = account("new_identity", 2, 1);
Pallet::<T>::create_identity(caller_origin.clone(), owner_key.clone())?;
- }: _<T::RuntimeOrigin>(owner_key_origin.clone(), IdtyName("new_identity".into()))
- verify {
+
+ #[extrinsic_call]
+ _(
+ RawOrigin::Signed(owner_key.clone()),
+ IdtyName("new_identity".into()),
+ );
+
let idty_index = IdentityIndexOf::<T>::get(&owner_key);
- assert_has_event::<T>(Event::<T>::IdtyConfirmed { idty_index: idty_index.unwrap(), owner_key, name: IdtyName("new_identity".into()) }.into());
+ assert_has_event::<T>(
+ Event::<T>::IdtyConfirmed {
+ idty_index: idty_index.unwrap(),
+ owner_key,
+ name: IdtyName("new_identity".into()),
+ }
+ .into(),
+ );
+ Ok(())
}
- // change owner key
- change_owner_key {
- let old_key: T::AccountId = account("new_identity", 2, SEED);
+ #[benchmark]
+ fn change_owner_key() -> Result<(), BenchmarkError> {
+ let old_key: T::AccountId = account("new_identity", 2, 1);
let account: Account<T> = create_one_identity(old_key.clone())?;
// Change key a first time to add an old-old key
@@ -164,12 +183,14 @@ benchmarks! {
let message = (NEW_OWNER_KEY_PAYLOAD_PREFIX, new_key_payload).encode();
let caller_public = sr25519_generate(0.into(), None);
let caller: T::AccountId = MultiSigner::Sr25519(caller_public).into_account().into();
- let signature = sr25519_sign(0.into(), &caller_public, &message).unwrap().into();
+ let signature = sr25519_sign(0.into(), &caller_public, &message)
+ .unwrap()
+ .into();
Pallet::<T>::change_owner_key(account.origin.clone(), caller.clone(), signature)?;
// Change key a second time to benchmark
// The sufficients for the old_old key will drop to 0 during benchmark
- let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
+ let caller_origin = RawOrigin::Signed(caller.clone());
let genesis_hash = frame_system::Pallet::<T>::block_hash(BlockNumberFor::<T>::zero());
let new_key_payload = IdtyIndexAccountIdPayload {
genesis_hash: &genesis_hash,
@@ -179,17 +200,33 @@ benchmarks! {
let message = (NEW_OWNER_KEY_PAYLOAD_PREFIX, new_key_payload).encode();
let caller_public = sr25519_generate(0.into(), None);
let caller: T::AccountId = MultiSigner::Sr25519(caller_public).into_account().into();
- let signature = sr25519_sign(0.into(), &caller_public, &message).unwrap().into();
- <frame_system::Pallet<T>>::set_block_number(<frame_system::Pallet<T>>::block_number() + T::ChangeOwnerKeyPeriod::get());
- }: _<T::RuntimeOrigin>(caller_origin.clone(), caller.clone(), signature)
- verify {
- assert_has_event::<T>(Event::<T>::IdtyChangedOwnerKey { idty_index: account.index, new_owner_key: caller.clone() }.into());
- assert!(IdentityIndexOf::<T>::get(&caller).unwrap() == account.index, "Owner key not changed");
+ let signature = sr25519_sign(0.into(), &caller_public, &message)
+ .unwrap()
+ .into();
+ <frame_system::Pallet<T>>::set_block_number(
+ <frame_system::Pallet<T>>::block_number() + T::ChangeOwnerKeyPeriod::get(),
+ );
+
+ #[extrinsic_call]
+ _(caller_origin, caller.clone(), signature);
+
+ assert_has_event::<T>(
+ Event::<T>::IdtyChangedOwnerKey {
+ idty_index: account.index,
+ new_owner_key: caller.clone(),
+ }
+ .into(),
+ );
+ assert!(
+ IdentityIndexOf::<T>::get(&caller).unwrap() == account.index,
+ "Owner key not changed"
+ );
+ Ok(())
}
- // revoke identity
- revoke_identity {
- let old_key: T::AccountId = account("new_identity", 2, SEED);
+ #[benchmark]
+ fn revoke_identity() -> Result<(), BenchmarkError> {
+ let old_key: T::AccountId = account("new_identity", 2, 1);
let account: Account<T> = create_one_identity(old_key.clone())?;
// Change key
@@ -203,7 +240,9 @@ benchmarks! {
let message = (NEW_OWNER_KEY_PAYLOAD_PREFIX, new_key_payload).encode();
let caller_public = sr25519_generate(0.into(), None);
let caller: T::AccountId = MultiSigner::Sr25519(caller_public).into_account().into();
- let signature = sr25519_sign(0.into(), &caller_public, &message).unwrap().into();
+ let signature = sr25519_sign(0.into(), &caller_public, &message)
+ .unwrap()
+ .into();
Pallet::<T>::change_owner_key(account.origin.clone(), caller.clone(), signature)?;
let genesis_hash = frame_system::Pallet::<T>::block_hash(BlockNumberFor::<T>::zero());
@@ -212,147 +251,252 @@ benchmarks! {
idty_index: account.index,
};
let message = (REVOCATION_PAYLOAD_PREFIX, revocation_payload).encode();
- let signature = sr25519_sign(0.into(), &caller_public, &message).unwrap().into();
- }: _<T::RuntimeOrigin>(account.origin, account.index, caller.clone(), signature)
- verify {
- assert_has_event::<T>(Event::<T>::IdtyRevoked { idty_index: account.index, reason: RevocationReason::User }.into());
- // revocation does not mean deletion anymore
- // assert!(IdentityIndexOf::<T>::get(&account.key).is_none(), "Identity not revoked");
+ let signature = sr25519_sign(0.into(), &caller_public, &message)
+ .unwrap()
+ .into();
+
+ #[extrinsic_call]
+ _(
+ RawOrigin::Signed(account.key),
+ account.index,
+ caller.clone(),
+ signature,
+ );
+
+ assert_has_event::<T>(
+ Event::<T>::IdtyRevoked {
+ idty_index: account.index,
+ reason: RevocationReason::User,
+ }
+ .into(),
+ );
+ Ok(())
}
- // The complexity depends on the number of identities to prune
- prune_item_identities_names {
+ #[benchmark]
+ fn prune_item_identities_names(i: Linear<2, 1_000>) -> Result<(), BenchmarkError> {
+ // The complexity depends on the number of identities to prune
// Populate identities
let identities_count = Pallet::<T>::identities_count();
- let i in 1 .. 1000 => create_identities::<T>(i)?;
+ create_identities::<T>(i)?;
let mut names = Vec::<IdtyName>::new();
for k in 1..i {
let name: IdtyName = IdtyName((k + identities_count).to_le_bytes().into());
- assert!(IdentitiesNames::<T>::contains_key(&name), "Name not existing");
+ assert!(
+ IdentitiesNames::<T>::contains_key(&name),
+ "Name not existing"
+ );
names.push(name);
}
- }: _<T::RuntimeOrigin>(RawOrigin::Root.into(), names.clone())
- verify {
+
+ #[extrinsic_call]
+ _(RawOrigin::Root, names.clone());
+
for name in names {
assert!(!IdentitiesNames::<T>::contains_key(&name), "Name existing");
}
+ Ok(())
}
- // fix sufficients identity
- fix_sufficients {
- let new_identity: T::AccountId = account("Bob", 2, SEED);
+ #[benchmark]
+ fn fix_sufficients() -> Result<(), BenchmarkError> {
+ let new_identity: T::AccountId = account("Bob", 2, 1);
let account: Account<T> = create_one_identity(new_identity)?;
let sufficient = frame_system::Pallet::<T>::sufficients(&account.key);
- }: _<T::RuntimeOrigin>(RawOrigin::Root.into(), account.key.clone(), true)
- verify {
- assert!(sufficient < frame_system::Pallet::<T>::sufficients(&account.key), "Sufficient not incremented");
+
+ #[extrinsic_call]
+ _(RawOrigin::Root, account.key.clone(), true);
+
+ assert!(
+ sufficient < frame_system::Pallet::<T>::sufficients(&account.key),
+ "Sufficient not incremented"
+ );
+ Ok(())
}
- // link account
- link_account {
- let alice_origin = RawOrigin::Signed(Identities::<T>::get(T::IdtyIndex::one()).unwrap().owner_key);
+ #[benchmark]
+ fn link_account() -> Result<(), BenchmarkError> {
+ let alice_origin =
+ RawOrigin::Signed(Identities::<T>::get(T::IdtyIndex::one()).unwrap().owner_key);
let bob_public = sr25519_generate(0.into(), None);
let bob: T::AccountId = MultiSigner::Sr25519(bob_public).into_account().into();
frame_system::Pallet::<T>::inc_providers(&bob);
let genesis_hash = frame_system::Pallet::<T>::block_hash(BlockNumberFor::<T>::zero());
let payload = (
- LINK_IDTY_PAYLOAD_PREFIX, genesis_hash, T::IdtyIndex::one(), bob.clone(),
- ).encode();
- let signature = sr25519_sign(0.into(), &bob_public, &payload).unwrap().into();
- }: _<T::RuntimeOrigin>(alice_origin.into(), bob, signature)
+ LINK_IDTY_PAYLOAD_PREFIX,
+ genesis_hash,
+ T::IdtyIndex::one(),
+ bob.clone(),
+ )
+ .encode();
+ let signature = sr25519_sign(0.into(), &bob_public, &payload)
+ .unwrap()
+ .into();
- // Base weight of an empty initialize
- on_initialize {
- }: {Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());}
+ #[extrinsic_call]
+ _(alice_origin, bob, signature);
- // --- do revoke identity
- do_revoke_identity_noop {
+ Ok(())
+ }
+
+ #[benchmark]
+ fn on_initialize() {
+ // Base weight of an empty initialize
+ #[block]
+ {
+ Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());
+ }
+ }
+
+ #[benchmark]
+ fn do_revoke_identity_noop() {
let idty_index: T::IdtyIndex = 0u32.into();
assert!(Identities::<T>::get(idty_index).is_none());
- }: {Pallet::<T>::do_revoke_identity(idty_index, RevocationReason::Root);}
- do_revoke_identity {
+
+ #[block]
+ {
+ Pallet::<T>::do_revoke_identity(idty_index, RevocationReason::Root);
+ }
+ }
+
+ #[benchmark]
+ fn do_revoke_identity() {
let idty_index: T::IdtyIndex = 1u32.into();
- let new_identity: T::AccountId = account("Bob", 2, SEED);
+ let new_identity: T::AccountId = account("Bob", 2, 1);
assert!(Identities::<T>::get(idty_index).is_some());
- Identities::<T>::mutate( idty_index, |id| {
+ Identities::<T>::mutate(idty_index, |id| {
if let Some(id) = id {
id.old_owner_key = Some((new_identity, BlockNumberFor::<T>::zero()));
}
});
- assert!(Identities::<T>::get(idty_index).unwrap().old_owner_key.is_some());
- }: {Pallet::<T>::do_revoke_identity(idty_index, RevocationReason::Root);}
- verify {
- assert_has_event::<T>(Event::<T>::IdtyRevoked { idty_index, reason: RevocationReason::Root }.into());
+ assert!(Identities::<T>::get(idty_index)
+ .unwrap()
+ .old_owner_key
+ .is_some());
+
+ #[block]
+ {
+ Pallet::<T>::do_revoke_identity(idty_index, RevocationReason::Root);
+ }
+
+ assert_has_event::<T>(
+ Event::<T>::IdtyRevoked {
+ idty_index,
+ reason: RevocationReason::Root,
+ }
+ .into(),
+ );
}
- // --- do remove identity
- do_remove_identity_noop {
+ #[benchmark]
+ fn do_remove_identity_noop() {
let idty_index: T::IdtyIndex = 0u32.into();
assert!(Identities::<T>::get(idty_index).is_none());
- }: {Pallet::<T>::do_remove_identity(idty_index, RemovalReason::Revoked);}
- do_remove_identity {
+
+ #[block]
+ {
+ Pallet::<T>::do_remove_identity(idty_index, RemovalReason::Revoked);
+ }
+ }
+
+ #[benchmark]
+ fn do_remove_identity() {
let idty_index: T::IdtyIndex = 1u32.into();
- let new_identity: T::AccountId = account("Bob", 2, SEED);
+ let new_identity: T::AccountId = account("Bob", 2, 1);
assert!(Identities::<T>::get(idty_index).is_some());
- Identities::<T>::mutate( idty_index, |id| {
+ Identities::<T>::mutate(idty_index, |id| {
if let Some(id) = id {
id.old_owner_key = Some((new_identity, BlockNumberFor::<T>::zero()));
}
});
- assert!(Identities::<T>::get(idty_index).unwrap().old_owner_key.is_some());
- }: {Pallet::<T>::do_remove_identity(idty_index, RemovalReason::Revoked);}
- verify {
- assert_has_event::<T>(Event::<T>::IdtyRemoved { idty_index, reason: RemovalReason::Revoked }.into());
+ assert!(Identities::<T>::get(idty_index)
+ .unwrap()
+ .old_owner_key
+ .is_some());
+
+ #[block]
+ {
+ Pallet::<T>::do_remove_identity(idty_index, RemovalReason::Revoked);
+ }
+
+ assert_has_event::<T>(
+ Event::<T>::IdtyRemoved {
+ idty_index,
+ reason: RemovalReason::Revoked,
+ }
+ .into(),
+ );
}
- // --- prune identities
- prune_identities_noop {
+ #[benchmark]
+ fn prune_identities_noop() {
assert!(IdentityChangeSchedule::<T>::try_get(BlockNumberFor::<T>::zero()).is_err());
- }: {Pallet::<T>::prune_identities(BlockNumberFor::<T>::zero());}
- prune_identities_none {
+ #[block]
+ {
+ Pallet::<T>::prune_identities(BlockNumberFor::<T>::zero());
+ }
+ }
+
+ #[benchmark]
+ fn prune_identities_none() {
let idty_index: T::IdtyIndex = 100u32.into();
IdentityChangeSchedule::<T>::append(BlockNumberFor::<T>::zero(), idty_index);
assert!(IdentityChangeSchedule::<T>::try_get(BlockNumberFor::<T>::zero()).is_ok());
assert!(<Identities<T>>::try_get(idty_index).is_err());
- }: {Pallet::<T>::prune_identities(BlockNumberFor::<T>::zero());}
- prune_identities_err {
+ #[block]
+ {
+ Pallet::<T>::prune_identities(BlockNumberFor::<T>::zero());
+ }
+ }
+
+ #[benchmark]
+ fn prune_identities_err() -> Result<(), BenchmarkError> {
let idty_index: T::IdtyIndex = 100u32.into();
create_dummy_identity::<T>(100u32)?;
IdentityChangeSchedule::<T>::append(BlockNumberFor::<T>::zero(), idty_index);
- }: {Pallet::<T>::prune_identities(BlockNumberFor::<T>::zero());}
+
+ #[block]
+ {
+ Pallet::<T>::prune_identities(BlockNumberFor::<T>::zero());
+ }
+
+ Ok(())
+ }
impl_benchmark_test_suite!(
Pallet,
// Create genesis identity Alice to test benchmark in mock
- crate::mock::new_test_ext(crate::mock::IdentityConfig{ identities: vec![
- GenesisIdty {
- index: 1,
- name: IdtyName::from("Alice"),
- value: IdtyValue {
- data: (),
- next_creatable_identity_on: 0,
- old_owner_key: None,
- owner_key: account("Alice", 1, SEED),
- next_scheduled: 0,
- status: crate::IdtyStatus::Member,
+ crate::mock::new_test_ext(crate::mock::IdentityConfig {
+ identities: vec![
+ crate::GenesisIdty {
+ index: 1,
+ name: crate::IdtyName::from("Alice"),
+ value: crate::IdtyValue {
+ data: (),
+ next_creatable_identity_on: 0,
+ old_owner_key: None,
+ owner_key: frame_benchmarking::account("Alice", 1, 1),
+ next_scheduled: 0,
+ status: crate::IdtyStatus::Member,
+ },
},
- },
- GenesisIdty {
- index: 2,
- name: IdtyName::from("Bob"),
- value: IdtyValue {
- data: (),
- next_creatable_identity_on: 0,
- old_owner_key: None,
- owner_key: account("Bob", 1, SEED),
- next_scheduled: 0,
- status: crate::IdtyStatus::Unconfirmed,
+ crate::GenesisIdty {
+ index: 2,
+ name: crate::IdtyName::from("Bob"),
+ value: crate::IdtyValue {
+ data: (),
+ next_creatable_identity_on: 0,
+ old_owner_key: None,
+ owner_key: frame_benchmarking::account("Bob", 1, 1),
+ next_scheduled: 0,
+ status: crate::IdtyStatus::Unconfirmed,
+ },
},
- },
- ]}),
+ ]
+ }),
crate::mock::Test,
);
}
diff --git a/pallets/membership/src/benchmarking.rs b/pallets/membership/src/benchmarking.rs
index a3475c7d0..0f2be6c80 100644
--- a/pallets/membership/src/benchmarking.rs
+++ b/pallets/membership/src/benchmarking.rs
@@ -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
);
}
diff --git a/pallets/oneshot-account/src/benchmarking.rs b/pallets/oneshot-account/src/benchmarking.rs
index dcc72ff2e..cf79d0494 100644
--- a/pallets/oneshot-account/src/benchmarking.rs
+++ b/pallets/oneshot-account/src/benchmarking.rs
@@ -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);
}
diff --git a/pallets/provide-randomness/src/benchmarking.rs b/pallets/provide-randomness/src/benchmarking.rs
index 56dfe1590..5f0ed8eed 100644
--- a/pallets/provide-randomness/src/benchmarking.rs
+++ b/pallets/provide-randomness/src/benchmarking.rs
@@ -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(())
}
}
diff --git a/pallets/quota/src/benchmarking.rs b/pallets/quota/src/benchmarking.rs
index bae829e73..834268d9c 100644
--- a/pallets/quota/src/benchmarking.rs
+++ b/pallets/quota/src/benchmarking.rs
@@ -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
+ );
}
--
GitLab