Skip to content

Commit

Permalink
Add Benchmarking Instance to Pallets (paritytech#12026)
Browse files Browse the repository at this point in the history 
* benchmark instance

* add benchmark instance to conviction voting

* instance on bags list

* fmt
  • Loading branch information
@shawntabrizi @ark0f
shawntabrizi authored and ark0f committed Feb 27, 2023
1 parent 4e7d5c4 commit 4f63978
Show file tree
Hide file tree
Showing 3 changed files with 266 additions and 265 deletions.
6 changes: 3 additions & 3 deletions frame/bags-list/src/benchmarks.rs
View file
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
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

0 comments on commit 4f63978

Please sign in to comment.