Skip to content
This repository has been archived by the owner on Nov 15, 2023. It is now read-only.

Add Benchmarking Instance to Pallets #12026

Merged
merged 4 commits into from
Aug 13, 2022
Merged

Add Benchmarking Instance to Pallets #12026

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
a503727
benchmark instance
shawntabrizi Aug 13, 2022
0d3b6cf
add benchmark instance to conviction voting
shawntabrizi Aug 13, 2022
ef5f0d9
instance on bags list
shawntabrizi Aug 13, 2022
829b943
fmt
shawntabrizi Aug 13, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 3 additions & 3 deletions frame/bags-list/src/benchmarks.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -25,7 +25,7 @@ use frame_support::{assert_ok, traits::Get};
use frame_system::RawOrigin as SystemOrigin;
use sp_runtime::traits::One;

frame_benchmarking::benchmarks! {
frame_benchmarking::benchmarks_instance_pallet! {
rebag_non_terminal {
// An expensive case for rebag-ing (rebag a non-terminal node):
//
Expand Down Expand Up @@ -97,7 +97,7 @@ frame_benchmarking::benchmarks! {

// clear any pre-existing storage.
// NOTE: safe to call outside block production
List::<T>::unsafe_clear();
List::<T, I>::unsafe_clear();

// define our origin and destination thresholds.
let origin_bag_thresh = T::BagThresholds::get()[0];
Expand Down Expand Up @@ -146,7 +146,7 @@ frame_benchmarking::benchmarks! {

// clear any pre-existing storage.
// NOTE: safe to call outside block production
List::<T>::unsafe_clear();
List::<T, I>::unsafe_clear();

let bag_thresh = T::BagThresholds::get()[0];

Expand Down
117 changes: 59 additions & 58 deletions frame/conviction-voting/src/benchmarking.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,7 +20,7 @@
use super::*;

use assert_matches::assert_matches;
use frame_benchmarking::{account, benchmarks, whitelist_account};
use frame_benchmarking::{account, benchmarks_instance_pallet, whitelist_account};
use frame_support::{
dispatch::RawOrigin,
traits::{fungible, Currency, Get},
Expand All @@ -34,8 +34,9 @@ const SEED: u32 = 0;

/// Fill all classes as much as possible up to `MaxVotes` and return the Class with the most votes
/// ongoing.
fn fill_voting<T: Config>() -> (ClassOf<T>, BTreeMap<ClassOf<T>, Vec<IndexOf<T>>>) {
let mut r = BTreeMap::<ClassOf<T>, Vec<IndexOf<T>>>::new();
fn fill_voting<T: Config<I>, I: 'static>(
) -> (ClassOf<T, I>, BTreeMap<ClassOf<T, I>, Vec<IndexOf<T, I>>>) {
let mut r = BTreeMap::<ClassOf<T, I>, Vec<IndexOf<T, I>>>::new();
for class in T::Polls::classes().into_iter() {
for _ in 0..T::MaxVotes::get() {
match T::Polls::create_ongoing(class.clone()) {
Expand All @@ -48,34 +49,34 @@ fn fill_voting<T: Config>() -> (ClassOf<T>, BTreeMap<ClassOf<T>, Vec<IndexOf<T>>
(c, r)
}

fn funded_account<T: Config>(name: &'static str, index: u32) -> T::AccountId {
fn funded_account<T: Config<I>, I: 'static>(name: &'static str, index: u32) -> T::AccountId {
let caller: T::AccountId = account(name, index, SEED);
T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
caller
}

fn account_vote<T: Config>(b: BalanceOf<T>) -> AccountVote<BalanceOf<T>> {
fn account_vote<T: Config<I>, I: 'static>(b: BalanceOf<T, I>) -> AccountVote<BalanceOf<T, I>> {
let v = Vote { aye: true, conviction: Conviction::Locked1x };

AccountVote::Standard { vote: v, balance: b }
}

benchmarks! {
benchmarks_instance_pallet! {
where_clause { where T::MaxVotes: core::fmt::Debug }

vote_new {
let caller = funded_account::<T>("caller", 0);
let caller = funded_account::<T, I>("caller", 0);
whitelist_account!(caller);
let account_vote = account_vote::<T>(100u32.into());
let account_vote = account_vote::<T, I>(100u32.into());

let (class, all_polls) = fill_voting::<T>();
let (class, all_polls) = fill_voting::<T, I>();
let polls = &all_polls[&class];
let r = polls.len() - 1;
// We need to create existing votes
for i in polls.iter().skip(1) {
ConvictionVoting::<T>::vote(RawOrigin::Signed(caller.clone()).into(), *i, account_vote)?;
ConvictionVoting::<T, I>::vote(RawOrigin::Signed(caller.clone()).into(), *i, account_vote)?;
}
let votes = match VotingFor::<T>::get(&caller, &class) {
let votes = match VotingFor::<T, I>::get(&caller, &class) {
Voting::Casting(Casting { votes, .. }) => votes,
_ => return Err("Votes are not direct".into()),
};
Expand All @@ -85,52 +86,52 @@ benchmarks! {
}: vote(RawOrigin::Signed(caller.clone()), index, account_vote)
verify {
assert_matches!(
VotingFor::<T>::get(&caller, &class),
VotingFor::<T, I>::get(&caller, &class),
Voting::Casting(Casting { votes, .. }) if votes.len() == (r + 1) as usize
);
}

vote_existing {
let caller = funded_account::<T>("caller", 0);
let caller = funded_account::<T, I>("caller", 0);
whitelist_account!(caller);
let old_account_vote = account_vote::<T>(100u32.into());
let old_account_vote = account_vote::<T, I>(100u32.into());

let (class, all_polls) = fill_voting::<T>();
let (class, all_polls) = fill_voting::<T, I>();
let polls = &all_polls[&class];
let r = polls.len();
// We need to create existing votes
for i in polls.iter() {
ConvictionVoting::<T>::vote(RawOrigin::Signed(caller.clone()).into(), *i, old_account_vote)?;
ConvictionVoting::<T, I>::vote(RawOrigin::Signed(caller.clone()).into(), *i, old_account_vote)?;
}
let votes = match VotingFor::<T>::get(&caller, &class) {
let votes = match VotingFor::<T, I>::get(&caller, &class) {
Voting::Casting(Casting { votes, .. }) => votes,
_ => return Err("Votes are not direct".into()),
};
assert_eq!(votes.len(), r, "Votes were not recorded.");

let new_account_vote = account_vote::<T>(200u32.into());
let new_account_vote = account_vote::<T, I>(200u32.into());
let index = polls[0];
}: vote(RawOrigin::Signed(caller.clone()), index, new_account_vote)
verify {
assert_matches!(
VotingFor::<T>::get(&caller, &class),
VotingFor::<T, I>::get(&caller, &class),
Voting::Casting(Casting { votes, .. }) if votes.len() == r as usize
);
}

remove_vote {
let caller = funded_account::<T>("caller", 0);
let caller = funded_account::<T, I>("caller", 0);
whitelist_account!(caller);
let old_account_vote = account_vote::<T>(100u32.into());
let old_account_vote = account_vote::<T, I>(100u32.into());

let (class, all_polls) = fill_voting::<T>();
let (class, all_polls) = fill_voting::<T, I>();
let polls = &all_polls[&class];
let r = polls.len();
// We need to create existing votes
for i in polls.iter() {
ConvictionVoting::<T>::vote(RawOrigin::Signed(caller.clone()).into(), *i, old_account_vote)?;
ConvictionVoting::<T, I>::vote(RawOrigin::Signed(caller.clone()).into(), *i, old_account_vote)?;
}
let votes = match VotingFor::<T>::get(&caller, &class) {
let votes = match VotingFor::<T, I>::get(&caller, &class) {
Voting::Casting(Casting { votes, .. }) => votes,
_ => return Err("Votes are not direct".into()),
};
Expand All @@ -140,25 +141,25 @@ benchmarks! {
}: _(RawOrigin::Signed(caller.clone()), Some(class.clone()), index)
verify {
assert_matches!(
VotingFor::<T>::get(&caller, &class),
VotingFor::<T, I>::get(&caller, &class),
Voting::Casting(Casting { votes, .. }) if votes.len() == (r - 1) as usize
);
}

remove_other_vote {
let caller = funded_account::<T>("caller", 0);
let voter = funded_account::<T>("caller", 0);
let caller = funded_account::<T, I>("caller", 0);
let voter = funded_account::<T, I>("caller", 0);
whitelist_account!(caller);
let old_account_vote = account_vote::<T>(100u32.into());
let old_account_vote = account_vote::<T, I>(100u32.into());

let (class, all_polls) = fill_voting::<T>();
let (class, all_polls) = fill_voting::<T, I>();
let polls = &all_polls[&class];
let r = polls.len();
// We need to create existing votes
for i in polls.iter() {
ConvictionVoting::<T>::vote(RawOrigin::Signed(voter.clone()).into(), *i, old_account_vote)?;
ConvictionVoting::<T, I>::vote(RawOrigin::Signed(voter.clone()).into(), *i, old_account_vote)?;
}
let votes = match VotingFor::<T>::get(&caller, &class) {
let votes = match VotingFor::<T, I>::get(&caller, &class) {
Voting::Casting(Casting { votes, .. }) => votes,
_ => return Err("Votes are not direct".into()),
};
Expand All @@ -169,52 +170,52 @@ benchmarks! {
}: _(RawOrigin::Signed(caller.clone()), voter.clone(), class.clone(), index)
verify {
assert_matches!(
VotingFor::<T>::get(&voter, &class),
VotingFor::<T, I>::get(&voter, &class),
Voting::Casting(Casting { votes, .. }) if votes.len() == (r - 1) as usize
);
}

delegate {
let r in 0 .. T::MaxVotes::get().min(T::Polls::max_ongoing().1);

let all_polls = fill_voting::<T>().1;
let all_polls = fill_voting::<T, I>().1;
let class = T::Polls::max_ongoing().0;
let polls = &all_polls[&class];
let voter = funded_account::<T>("voter", 0);
let caller = funded_account::<T>("caller", 0);
let voter = funded_account::<T, I>("voter", 0);
let caller = funded_account::<T, I>("caller", 0);
whitelist_account!(caller);

let delegated_balance: BalanceOf<T> = 1000u32.into();
let delegate_vote = account_vote::<T>(delegated_balance);
let delegated_balance: BalanceOf<T, I> = 1000u32.into();
let delegate_vote = account_vote::<T, I>(delegated_balance);

// We need to create existing delegations
for i in polls.iter().take(r as usize) {
ConvictionVoting::<T>::vote(RawOrigin::Signed(voter.clone()).into(), *i, delegate_vote)?;
ConvictionVoting::<T, I>::vote(RawOrigin::Signed(voter.clone()).into(), *i, delegate_vote)?;
}
assert_matches!(
VotingFor::<T>::get(&voter, &class),
VotingFor::<T, I>::get(&voter, &class),
Voting::Casting(Casting { votes, .. }) if votes.len() == r as usize
);

}: _(RawOrigin::Signed(caller.clone()), class.clone(), voter, Conviction::Locked1x, delegated_balance)
verify {
assert_matches!(VotingFor::<T>::get(&caller, &class), Voting::Delegating(_));
assert_matches!(VotingFor::<T, I>::get(&caller, &class), Voting::Delegating(_));
}

undelegate {
let r in 0 .. T::MaxVotes::get().min(T::Polls::max_ongoing().1);

let all_polls = fill_voting::<T>().1;
let all_polls = fill_voting::<T, I>().1;
let class = T::Polls::max_ongoing().0;
let polls = &all_polls[&class];
let voter = funded_account::<T>("voter", 0);
let caller = funded_account::<T>("caller", 0);
let voter = funded_account::<T, I>("voter", 0);
let caller = funded_account::<T, I>("caller", 0);
whitelist_account!(caller);

let delegated_balance: BalanceOf<T> = 1000u32.into();
let delegate_vote = account_vote::<T>(delegated_balance);
let delegated_balance: BalanceOf<T, I> = 1000u32.into();
let delegate_vote = account_vote::<T, I>(delegated_balance);

ConvictionVoting::<T>::delegate(
ConvictionVoting::<T, I>::delegate(
RawOrigin::Signed(caller.clone()).into(),
class.clone(),
voter.clone(),
Expand All @@ -224,31 +225,31 @@ benchmarks! {

// We need to create delegations
for i in polls.iter().take(r as usize) {
ConvictionVoting::<T>::vote(RawOrigin::Signed(voter.clone()).into(), *i, delegate_vote)?;
ConvictionVoting::<T, I>::vote(RawOrigin::Signed(voter.clone()).into(), *i, delegate_vote)?;
}
assert_matches!(
VotingFor::<T>::get(&voter, &class),
VotingFor::<T, I>::get(&voter, &class),
Voting::Casting(Casting { votes, .. }) if votes.len() == r as usize
);
assert_matches!(VotingFor::<T>::get(&caller, &class), Voting::Delegating(_));
assert_matches!(VotingFor::<T, I>::get(&caller, &class), Voting::Delegating(_));
}: _(RawOrigin::Signed(caller.clone()), class.clone())
verify {
assert_matches!(VotingFor::<T>::get(&caller, &class), Voting::Casting(_));
assert_matches!(VotingFor::<T, I>::get(&caller, &class), Voting::Casting(_));
}

unlock {
let caller = funded_account::<T>("caller", 0);
let caller = funded_account::<T, I>("caller", 0);
whitelist_account!(caller);
let normal_account_vote = account_vote::<T>(T::Currency::free_balance(&caller) - 100u32.into());
let big_account_vote = account_vote::<T>(T::Currency::free_balance(&caller));
let normal_account_vote = account_vote::<T, I>(T::Currency::free_balance(&caller) - 100u32.into());
let big_account_vote = account_vote::<T, I>(T::Currency::free_balance(&caller));

// Fill everything up to the max by filling all classes with votes and voting on them all.
let (class, all_polls) = fill_voting::<T>();
let (class, all_polls) = fill_voting::<T, I>();
assert!(all_polls.len() > 0);
for (class, polls) in all_polls.iter() {
assert!(polls.len() > 0);
for i in polls.iter() {
ConvictionVoting::<T>::vote(RawOrigin::Signed(caller.clone()).into(), *i, normal_account_vote)?;
ConvictionVoting::<T, I>::vote(RawOrigin::Signed(caller.clone()).into(), *i, normal_account_vote)?;
}
}

Expand All @@ -257,12 +258,12 @@ benchmarks! {

// Vote big on the class with the most ongoing votes of them to bump the lock and make it
// hard to recompute when removed.
ConvictionVoting::<T>::vote(RawOrigin::Signed(caller.clone()).into(), polls[0], big_account_vote)?;
ConvictionVoting::<T, I>::vote(RawOrigin::Signed(caller.clone()).into(), polls[0], big_account_vote)?;
let now_usable = <T::Currency as fungible::Inspect<T::AccountId>>::reducible_balance(&caller, false);
assert_eq!(orig_usable - now_usable, 100u32.into());

// Remove the vote
ConvictionVoting::<T>::remove_vote(RawOrigin::Signed(caller.clone()).into(), Some(class.clone()), polls[0])?;
ConvictionVoting::<T, I>::remove_vote(RawOrigin::Signed(caller.clone()).into(), Some(class.clone()), polls[0])?;

// We can now unlock on `class` from 200 to 100...
}: _(RawOrigin::Signed(caller.clone()), class, caller.clone())
Expand Down
Loading