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
Show 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 crate::Pallet;
use frame_benchmarking::benchmarks;
use frame_benchmarking::v2::*;
use frame_system::RawOrigin;
use crate::Pallet;
#[benchmarks(
where
<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());
}
benchmarks! {
where_clause {
where
T::MemberId: From<u32>,
}
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 {
#[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 {
#[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 {
#[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 {
#[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 {
#[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,15 +18,19 @@
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;
#[benchmarks(
where
<T as Config>::IdtyIndex: 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());
}
......@@ -43,93 +47,127 @@ fn add_certs<T: Config>(i: u32, receiver: T::IdtyIndex) -> Result<(), &'static s
Ok(())
}
benchmarks! {
where_clause {
where
T::IdtyIndex: From<u32>,
}
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 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 {
#[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 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 {
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 {
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![
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),
],
......
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,6 +29,15 @@ use sp_runtime::Perbill;
use crate::Pallet;
#[benchmarks(
where
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());
}
......@@ -45,76 +54,125 @@ fn populate_pool<T: Config>(i: u32) -> Result<(), &'static str> {
})
}
benchmarks! {
where_clause {
where
T: pallet_balances::Config, T::Balance: From<u64>,
BlockNumberFor<T>: From<u32>,
}
// request distance evaluation
request_distance_evaluation {
#[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);
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]})
<frame_system::Pallet<T>>::deposit_log(digest);
populate_pool::<T>(i)?;
#[extrinsic_call]
_(
RawOrigin::None,
ComputationResult {
distances: vec![Perbill::one(); i as usize],
},
);
// force update evaluation
force_update_evaluation {
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::Root.into(), caller.clone(), ComputationResult{distances: vec![Perbill::one(); i as usize]})
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(())
}
// force valid distance status
force_valid_distance_status {
#[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,13 +18,18 @@
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;
#[benchmarks]
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());
}
......@@ -39,7 +44,8 @@ fn create_pending_accounts<T: Config>(
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(
let _ =
<pallet_balances::Pallet<T> as Currency<T::AccountId>>::make_free_balance_be(
&caller, balance,
);
} else {
......@@ -58,33 +64,93 @@ fn create_pending_accounts<T: Config>(
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);
}
on_filled_randomness_no_pending {
assert_has_event::<T>(
Event::<T>::RandomIdAssigned {
who: caller,
random_id: randomness,
}
.into(),
);
}
#[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
......@@ -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,7 +31,15 @@ use sp_runtime::{AccountId32, MultiSigner};
use crate::Pallet;
const SEED: u32 = 1;
#[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::*;
fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
frame_system::Pallet::<T>::assert_has_event(generic_event.into());
......@@ -40,7 +49,6 @@ struct Account<T: Config> {
key: T::AccountId,
index: T::IdtyIndex,
origin: <T as frame_system::Config>::RuntimeOrigin,
// name: IdtyName,
}
// Create and confirm one account using Alice authorized account.
......@@ -83,7 +91,7 @@ fn create_one_identity<T: Config>(owner_key: T::AccountId) -> Result<Account<T>,
// 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 owner_key: T::AccountId = account("Bob", i, 1);
let next_scheduled = BlockNumberFor::<T>::zero();
let value = IdtyValue {
data: Default::default(),
......@@ -115,43 +123,54 @@ fn create_identities<T: Config>(i: u32) -> Result<(), &'static str> {
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>,
}
// create identity
create_identity {
#[benchmark]
fn 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 {
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 {
#[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, SEED);
let owner_key_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(owner_key.clone()).into();
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(())
}
#[benchmark]
fn prune_item_identities_names(i: Linear<2, 1_000>) -> Result<(), BenchmarkError> {
// The complexity depends on the number of identities to prune
prune_item_identities_names {
// 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();
#[extrinsic_call]
_(alice_origin, bob, signature);
Ok(())
}
#[benchmark]
fn on_initialize() {
// Base weight of an empty initialize
on_initialize {
}: {Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());}
#[block]
{
Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());
}
}
// --- do revoke identity
do_revoke_identity_noop {
#[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| {
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| {
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 {
crate::mock::new_test_ext(crate::mock::IdentityConfig {
identities: vec![
crate::GenesisIdty {
index: 1,
name: IdtyName::from("Alice"),
value: IdtyValue {
name: crate::IdtyName::from("Alice"),
value: crate::IdtyValue {
data: (),
next_creatable_identity_on: 0,
old_owner_key: None,
owner_key: account("Alice", 1, SEED),
owner_key: frame_benchmarking::account("Alice", 1, 1),
next_scheduled: 0,
status: crate::IdtyStatus::Member,
},
},
GenesisIdty {
crate::GenesisIdty {
index: 2,
name: IdtyName::from("Bob"),
value: IdtyValue {
name: crate::IdtyName::from("Bob"),
value: crate::IdtyValue {
data: (),
next_creatable_identity_on: 0,
old_owner_key: None,
owner_key: account("Bob", 1, SEED),
owner_key: frame_benchmarking::account("Bob", 1, 1),
next_scheduled: 0,
status: crate::IdtyStatus::Unconfirmed,
},
},
]}),
]
}),
crate::mock::Test,
);
}
pallets/membership/src/benchmarking.rs
+ 34
− 26
View file @ 43c79748
......@@ -18,36 +18,36 @@
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
#[benchmark]
fn on_initialize() {
// Base weight of an empty initialize
on_initialize {
}: {Pallet::<T>::on_initialize(BlockNumberFor::<T>::zero());}
#[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 {
......@@ -56,20 +56,28 @@ benchmarks! {
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 {
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());
}: _(
#[extrinsic_call]
_(
RawOrigin::Signed(caller.clone()),
BlockNumberFor::<T>::zero(),
Account::<<T::Lookup as StaticLookup>::Source>::Normal(recipient_lookup)
)
verify {
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());
}: _(
#[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()
)
verify {
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,6 +30,16 @@ use sp_core::H256;
use crate::Pallet;
#[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 assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
frame_system::Pallet::<T>::assert_has_event(generic_event.into());
}
......@@ -60,18 +71,10 @@ fn add_requests_next_epoch<T: Config>(i: u32) -> Result<(), &'static str> {
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>,
}
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());
}
try_refund {
#[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()
);
}
#[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 {
#[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 {
#[block]
{
Pallet::<T>::try_refund(refund);
}
assert_has_event::<T>(Event::<T>::RefundFailed(account).into());
}
#[benchmark]
fn on_process_refund_queue() {
// The base weight consumed on processing refund queue when empty.
on_process_refund_queue {
assert_eq!(RefundQueue::<T>::get().len() as u32, 0);
}: { Pallet::<T>::process_refund_queue(Weight::MAX) }
#[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.
#[pov_mode = Measured]
on_process_refund_queue_elements {
let i in 1..MAX_QUEUED_REFUNDS;
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());
}
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.
Please register or to comment