pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-12 21:41:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Repair and extend some benchmarks (#5648)

Browse Source
This commit is contained in:
Shawn Tabrizi
2020-04-24 11:40:28 +02:00
committed by GitHub
parent 000c924b62
commit 2fb22de02e
10 changed files with 1187 additions and 333 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/frame/collective/src/benchmarking.rs
+327 -101
View File
@@ -19,173 +19,398 @@
use super::*;
use frame_system::RawOrigin as SystemOrigin;
use frame_system::EventRecord;
use frame_benchmarking::{benchmarks_instance, account};
use sp_runtime::traits::Bounded;
use frame_system::Module as System;
use crate::Module as Collective;
const SEED: u32 = 0;
const MAX_MEMBERS: u32 = 1000;
const MAX_PROPOSALS: u32 = 100;
const MAX_BYTES: u32 = 1_024;
fn assert_last_event<T: Trait<I>, I: Instance>(generic_event: <T as Trait<I>>::Event) {
let events = System::<T>::events();
let system_event: <T as frame_system::Trait>::Event = generic_event.into();
// compare to the last event record
let EventRecord { event, .. } = &events[events.len() - 1];
assert_eq!(event, &system_event);
}
benchmarks_instance! {
_{
// User account seed.
let u in 1 .. 1000 => ();
// Old members.
let n in 1 .. 1000 => ();
// New members.
let m in 1 .. 1000 => ();
// Existing proposals.
let p in 1 .. 100 => ();
}
_{ }
set_members {
let m in ...;
let n in ...;
// Construct `new_members`.
// It should influence timing since it will sort this vector.
let mut new_members = vec![];
for i in 0 .. m {
let member = account("member", i, SEED);
new_members.push(member);
}
let m in 1 .. MAX_MEMBERS;
let n in 1 .. MAX_MEMBERS;
// Set old members.
// We compute the difference of old and new members, so it should influence timing.
let mut old_members = vec![];
let mut last_old_member = T::AccountId::default();
for i in 0 .. n {
let old_member = account("old member", i, SEED);
old_members.push(old_member);
last_old_member = account("old member", i, SEED);
old_members.push(last_old_member.clone());
}
let prime = Some(account("prime", 0, SEED));
Collective::<T, _>::set_members(SystemOrigin::Root.into(), old_members, Some(last_old_member))?;
Collective::<T, _>::set_members(SystemOrigin::Root.into(), old_members, prime.clone())?;
// Construct `new_members`.
// It should influence timing since it will sort this vector.
let mut new_members = vec![];
let mut last_member = T::AccountId::default();
for i in 0 .. m {
last_member = account("member", i, SEED);
new_members.push(last_member.clone());
}
}: _(SystemOrigin::Root, new_members.clone(), prime)
}: _(SystemOrigin::Root, new_members.clone(), Some(last_member))
verify {
new_members.sort();
assert_eq!(Collective::<T, _>::members(), new_members);
}
execute {
let u in ...;
let m in 1 .. MAX_MEMBERS;
let b in 1 .. MAX_BYTES;
let caller: T::AccountId = account("caller", u, SEED);
let proposal: T::Proposal = Call::<T, I>::close(Default::default(), Default::default()).into();
// Construct `members`.
let mut members = vec![];
for i in 0 .. m {
let member = account("member", i, SEED);
members.push(member);
}
Collective::<T, _>::set_members(SystemOrigin::Root.into(), vec![caller.clone()], None)?;
let caller: T::AccountId = account("caller", 0, SEED);
members.push(caller.clone());
}: _(SystemOrigin::Signed(caller), Box::new(proposal))
Collective::<T, _>::set_members(SystemOrigin::Root.into(), members, None)?;
propose {
let u in ...;
let proposal: T::Proposal = frame_system::Call::<T>::remark(vec![1; b as usize]).into();
let caller: T::AccountId = account("caller", u, SEED);
let proposal: T::Proposal = Call::<T, I>::close(Default::default(), Default::default()).into();
}: _(SystemOrigin::Signed(caller), Box::new(proposal.clone()))
verify {
let proposal_hash = T::Hashing::hash_of(&proposal);
// Note that execution fails due to mis-matched origin
assert_last_event::<T, I>(RawEvent::MemberExecuted(proposal_hash, false).into());
}
Collective::<T, _>::set_members(SystemOrigin::Root.into(), vec![caller.clone()], None)?;
// This tests when execution would happen immediately after proposal
propose_execute {
let m in 1 .. MAX_MEMBERS;
let b in 1 .. MAX_BYTES;
let member_count = 0;
// Construct `members`.
let mut members = vec![];
for i in 0 .. m {
let member = account("member", i, SEED);
members.push(member);
}
}: _(SystemOrigin::Signed(caller), member_count, Box::new(proposal.into()))
let caller: T::AccountId = account("caller", 0, SEED);
members.push(caller.clone());
propose_else_branch {
let u in ...;
let p in ...;
Collective::<T, _>::set_members(SystemOrigin::Root.into(), members, None)?;
let caller: T::AccountId = account("caller", u, SEED);
let proposal: T::Proposal = Call::<T, I>::close(Default::default(), Default::default()).into();
let proposal: T::Proposal = frame_system::Call::<T>::remark(vec![1; b as usize]).into();
let threshold = 1;
Collective::<T, _>::set_members(SystemOrigin::Root.into(), vec![caller.clone()], None)?;
}: propose(SystemOrigin::Signed(caller), threshold, Box::new(proposal.clone()))
verify {
let proposal_hash = T::Hashing::hash_of(&proposal);
// Note that execution fails due to mis-matched origin
assert_last_event::<T, I>(RawEvent::Executed(proposal_hash, false).into());
}
let member_count = 3;
// This tests when proposal is created and queued as "proposed"
propose_proposed {
let m in 1 .. MAX_MEMBERS;
let p in 0 .. MAX_PROPOSALS;
let b in 1 .. MAX_BYTES;
// Construct `members`.
let mut members = vec![];
for i in 0 .. m {
let member = account("member", i, SEED);
members.push(member);
}
let caller: T::AccountId = account("caller", 0, SEED);
members.push(caller.clone());
Collective::<T, _>::set_members(SystemOrigin::Root.into(), members, None)?;
let threshold = m.max(2);
// Add previous proposals.
for i in 0 .. p {
let proposal: T::Proposal = Call::<T, I>::close(Default::default(), (i + 1).into()).into();
Collective::<T, _>::propose(SystemOrigin::Signed(caller.clone()).into(), member_count.clone(), Box::new(proposal.into()))?;
// Proposals should be different so that different proposal hashes are generated
let proposal: T::Proposal = frame_system::Call::<T>::remark(vec![i as u8; b as usize]).into();
Collective::<T, _>::propose(SystemOrigin::Signed(caller.clone()).into(), threshold, Box::new(proposal))?;
}
}: propose(SystemOrigin::Signed(caller), member_count, Box::new(proposal.into()))
assert_eq!(Collective::<T, _>::proposals().len(), p as usize);
vote {
let u in ...;
let proposal: T::Proposal = frame_system::Call::<T>::remark(vec![p as u8; b as usize]).into();
let caller1: T::AccountId = account("caller1", u, SEED);
let caller2: T::AccountId = account("caller2", u, SEED);
let proposal: Box<T::Proposal> = Box::new(Call::<T, I>::close(Default::default(), Default::default()).into());
}: propose(SystemOrigin::Signed(caller.clone()), threshold, Box::new(proposal.clone()))
verify {
// New proposal is recorded
assert_eq!(Collective::<T, _>::proposals().len(), (p + 1) as usize);
let proposal_hash = T::Hashing::hash_of(&proposal);
assert_last_event::<T, I>(RawEvent::Proposed(caller, p, proposal_hash, threshold).into());
}
Collective::<T, _>::set_members(SystemOrigin::Root.into(), vec![caller1.clone(), caller2.clone()], None)?;
vote_insert {
let m in 2 .. MAX_MEMBERS;
let p in 1 .. MAX_PROPOSALS;
let b in 1 .. MAX_BYTES;
let member_count = 3;
Collective::<T, _>::propose(SystemOrigin::Signed(caller1.clone()).into(), member_count, proposal)?;
// Construct `members`.
let mut members = vec![];
for i in 0 .. m {
let member = account("member", i, SEED);
members.push(member);
}
let index = 0;
let approve = true;
let caller: T::AccountId = account("caller", 0, SEED);
members.push(caller.clone());
Collective::<T, _>::set_members(SystemOrigin::Root.into(), members.clone(), None)?;
}: _(SystemOrigin::Signed(caller2), proposal_hash, index, approve)
// Threshold is 1 less than the number of members so that one person can vote nay
let threshold = m;
vote_not_approve {
let u in ...;
// Add previous proposals
let mut last_hash = T::Hash::default();
for i in 0 .. p {
// Proposals should be different so that different proposal hashes are generated
let proposal: T::Proposal = frame_system::Call::<T>::remark(vec![i as u8; b as usize]).into();
Collective::<T, _>::propose(SystemOrigin::Signed(caller.clone()).into(), threshold, Box::new(proposal.clone()))?;
last_hash = T::Hashing::hash_of(&proposal);
}
let caller1: T::AccountId = account("caller1", u, SEED);
let caller2: T::AccountId = account("caller2", u, SEED);
// Have everyone vote aye on last proposal, while keeping it from passing
for j in 2 .. m {
let voter = &members[j as usize];
let approve = true;
Collective::<T, _>::vote(SystemOrigin::Signed(voter.clone()).into(), last_hash.clone(), p - 1, approve)?;
}
let proposal: Box<T::Proposal> = Box::new(Call::<T, I>::close(Default::default(), Default::default()).into());
let proposal_hash = T::Hashing::hash_of(&proposal);
assert_eq!(Collective::<T, _>::proposals().len(), p as usize);
Collective::<T, _>::set_members(SystemOrigin::Root.into(), vec![caller1.clone(), caller2.clone()], None)?;
let member_count = 3;
Collective::<T, _>::propose(SystemOrigin::Signed(caller1.clone()).into(), member_count, proposal)?;
let index = 0;
// Caller switches vote to nay, but does not kill the vote, just updates + inserts
let index = p - 1;
let approve = false;
}: vote(SystemOrigin::Signed(caller2), proposal_hash, index, approve)
}: vote(SystemOrigin::Signed(caller), last_hash.clone(), index, approve)
verify {
// All proposals exist and the last proposal has just been updated.
assert_eq!(Collective::<T, _>::proposals().len(), p as usize);
let voting = Collective::<T, _>::voting(&last_hash).ok_or(Error::<T, I>::ProposalMissing)?;
assert_eq!(voting.ayes.len(), (m - 2) as usize);
assert_eq!(voting.nays.len(), 1);
}
vote_disapproved {
let m in 2 .. MAX_MEMBERS;
let p in 1 .. MAX_PROPOSALS;
let b in 1 .. MAX_BYTES;
// Construct `members`.
let mut members = vec![];
for i in 0 .. m {
let member = account("member", i, SEED);
members.push(member);
}
let caller: T::AccountId = account("caller", 0, SEED);
members.push(caller.clone());
Collective::<T, _>::set_members(SystemOrigin::Root.into(), members.clone(), None)?;
// Threshold is total members so that one nay will disapprove the vote
let threshold = m + 1;
// Add previous proposals
let mut last_hash = T::Hash::default();
for i in 0 .. p {
// Proposals should be different so that different proposal hashes are generated
let proposal: T::Proposal = frame_system::Call::<T>::remark(vec![i as u8; b as usize]).into();
Collective::<T, _>::propose(SystemOrigin::Signed(caller.clone()).into(), threshold, Box::new(proposal.clone()))?;
last_hash = T::Hashing::hash_of(&proposal);
}
// Have everyone vote aye on last proposal, while keeping it from passing
for j in 1 .. m {
let voter = &members[j as usize];
let approve = true;
Collective::<T, _>::vote(SystemOrigin::Signed(voter.clone()).into(), last_hash.clone(), p - 1, approve)?;
}
assert_eq!(Collective::<T, _>::proposals().len(), p as usize);
// Caller switches vote to nay, which kills the vote
let index = p - 1;
let approve = false;
}: vote(SystemOrigin::Signed(caller), last_hash.clone(), index, approve)
verify {
// The last proposal is removed.
assert_eq!(Collective::<T, _>::proposals().len(), (p - 1) as usize);
assert_last_event::<T, I>(RawEvent::Disapproved(last_hash).into());
}
vote_approved {
let u in ...;
let m in 2 .. MAX_MEMBERS;
let p in 1 .. MAX_PROPOSALS;
let b in 1 .. MAX_BYTES;
let caller1: T::AccountId = account("caller1", u, SEED);
let caller2: T::AccountId = account("caller2", u, SEED);
// Construct `members`.
let mut members = vec![];
for i in 0 .. m {
let member = account("member", i, SEED);
members.push(member);
}
let proposal: Box<T::Proposal> = Box::new(Call::<T, I>::close(Default::default(), Default::default()).into());
let proposal_hash = T::Hashing::hash_of(&proposal);
let caller: T::AccountId = account("caller", 0, SEED);
members.push(caller.clone());
Collective::<T, _>::set_members(SystemOrigin::Root.into(), members.clone(), None)?;
Collective::<T, _>::set_members(SystemOrigin::Root.into(), vec![caller1.clone(), caller2.clone()], None)?;
// Threshold is 2 so any two ayes will approve the vote
let threshold = 2;
let member_count = 2;
Collective::<T, _>::propose(SystemOrigin::Signed(caller1.clone()).into(), member_count, proposal)?;
// Add previous proposals
let mut last_hash = T::Hash::default();
for i in 0 .. p {
// Proposals should be different so that different proposal hashes are generated
let proposal: T::Proposal = frame_system::Call::<T>::remark(vec![i as u8; b as usize]).into();
Collective::<T, _>::propose(SystemOrigin::Signed(caller.clone()).into(), threshold, Box::new(proposal.clone()))?;
last_hash = T::Hashing::hash_of(&proposal);
}
let index = 0;
// Caller switches vote to nay on their own proposal, allowing them to be the deciding approval vote
Collective::<T, _>::vote(SystemOrigin::Signed(caller.clone()).into(), last_hash.clone(), p - 1, false)?;
// Have everyone vote nay on last proposal, while keeping it from failing
for j in 2 .. m {
let voter = &members[j as usize];
let approve = false;
Collective::<T, _>::vote(SystemOrigin::Signed(voter.clone()).into(), last_hash.clone(), p - 1, approve)?;
}
// Member zero is the first aye
Collective::<T, _>::vote(SystemOrigin::Signed(members[0].clone()).into(), last_hash.clone(), p - 1, true)?;
assert_eq!(Collective::<T, _>::proposals().len(), p as usize);
// Caller switches vote to aye, which passes the vote
let index = p - 1;
let approve = true;
}: vote(SystemOrigin::Signed(caller2), proposal_hash, index, approve)
}: vote(SystemOrigin::Signed(caller), last_hash.clone(), index, approve)
verify {
// The last proposal is removed.
assert_eq!(Collective::<T, _>::proposals().len(), (p - 1) as usize);
assert_last_event::<T, I>(RawEvent::Executed(last_hash, false).into());
}
close {
let u in ...;
close_disapproved {
let m in 2 .. MAX_MEMBERS;
let p in 1 .. MAX_PROPOSALS;
let b in 1 .. MAX_BYTES;
let caller1: T::AccountId = account("caller1", u, SEED);
let caller2: T::AccountId = account("caller2", u, SEED);
// Construct `members`.
let mut members = vec![];
for i in 0 .. m {
let member = account("member", i, SEED);
members.push(member);
}
let caller: T::AccountId = account("caller", 0, SEED);
members.push(caller.clone());
let proposal: Box<T::Proposal> = Box::new(Call::<T, I>::close(Default::default(), Default::default()).into());
let proposal_hash = T::Hashing::hash_of(&proposal);
Collective::<T, _>::set_members(SystemOrigin::Root.into(), members.clone(), Some(caller.clone()))?;
Collective::<T, _>::set_members(SystemOrigin::Root.into(), vec![caller1.clone(), caller2.clone()], None)?;
let member_count = 2;
Collective::<T, _>::propose(SystemOrigin::Signed(caller1.clone()).into(), member_count, proposal)?;
// Threshold is one less than total members so that two nays will disapprove the vote
let threshold = m;
let index = 0;
let approve = true;
// Add proposals
let mut last_hash = T::Hash::default();
for i in 0 .. p {
// Proposals should be different so that different proposal hashes are generated
let proposal: T::Proposal = frame_system::Call::<T>::remark(vec![i as u8; b as usize]).into();
Collective::<T, _>::propose(SystemOrigin::Signed(caller.clone()).into(), threshold, Box::new(proposal.clone()))?;
last_hash = T::Hashing::hash_of(&proposal);
}
let vote_end = T::MotionDuration::get() + 1u32.into();
System::<T>::set_block_number(vote_end);
// Have everyone vote aye on last proposal, while keeping it from passing
// A few abstainers will be the nay votes needed to fail the vote
for j in 2 .. m {
let voter = &members[j as usize];
let approve = true;
Collective::<T, _>::vote(SystemOrigin::Signed(voter.clone()).into(), last_hash.clone(), p - 1, approve)?;
}
}: _(SystemOrigin::Signed(caller2), proposal_hash, index)
// caller is prime, prime votes nay
Collective::<T, _>::vote(SystemOrigin::Signed(caller.clone()).into(), last_hash.clone(), p - 1, false)?;
System::<T>::set_block_number(T::BlockNumber::max_value());
assert_eq!(Collective::<T, _>::proposals().len(), p as usize);
// Prime nay will close it as disapproved
}: close(SystemOrigin::Signed(caller), last_hash, p - 1)
verify {
assert_eq!(Collective::<T, _>::proposals().len(), (p - 1) as usize);
assert_last_event::<T, I>(RawEvent::Disapproved(last_hash).into());
}
close_approved {
let m in 2 .. MAX_MEMBERS;
let p in 1 .. MAX_PROPOSALS;
let b in 1 .. MAX_BYTES;
// Construct `members`.
let mut members = vec![];
for i in 0 .. m {
let member = account("member", i, SEED);
members.push(member);
}
let caller: T::AccountId = account("caller", 0, SEED);
members.push(caller.clone());
Collective::<T, _>::set_members(SystemOrigin::Root.into(), members.clone(), Some(caller.clone()))?;
// Threshold is two, so any two ayes will pass the vote
let threshold = 2;
// Add proposals
let mut last_hash = T::Hash::default();
for i in 0 .. p {
// Proposals should be different so that different proposal hashes are generated
let proposal: T::Proposal = frame_system::Call::<T>::remark(vec![i as u8; b as usize]).into();
Collective::<T, _>::propose(SystemOrigin::Signed(caller.clone()).into(), threshold, Box::new(proposal.clone()))?;
last_hash = T::Hashing::hash_of(&proposal);
}
// Have everyone vote nay on last proposal, while keeping it from failing
// A few abstainers will be the aye votes needed to pass the vote
for j in 2 .. m {
let voter = &members[j as usize];
let approve = false;
Collective::<T, _>::vote(SystemOrigin::Signed(voter.clone()).into(), last_hash.clone(), p - 1, approve)?;
}
// caller is prime, prime already votes aye by creating the proposal
System::<T>::set_block_number(T::BlockNumber::max_value());
assert_eq!(Collective::<T, _>::proposals().len(), p as usize);
// Prime aye will close it as approved
}: close(SystemOrigin::Signed(caller), last_hash, p - 1)
verify {
assert_eq!(Collective::<T, _>::proposals().len(), (p - 1) as usize);
assert_last_event::<T, I>(RawEvent::Executed(last_hash, false).into());
}
}
#[cfg(test)]
@@ -199,12 +424,13 @@ mod tests {
new_test_ext().execute_with(|| {
assert_ok!(test_benchmark_set_members::<Test>());
assert_ok!(test_benchmark_execute::<Test>());
assert_ok!(test_benchmark_propose::<Test>());
assert_ok!(test_benchmark_propose_else_branch::<Test>());
assert_ok!(test_benchmark_vote::<Test>());
assert_ok!(test_benchmark_vote_not_approve::<Test>());
assert_ok!(test_benchmark_propose_execute::<Test>());
assert_ok!(test_benchmark_propose_proposed::<Test>());
assert_ok!(test_benchmark_vote_insert::<Test>());
assert_ok!(test_benchmark_vote_disapproved::<Test>());
assert_ok!(test_benchmark_vote_approved::<Test>());
assert_ok!(test_benchmark_close::<Test>());
assert_ok!(test_benchmark_close_disapproved::<Test>());
assert_ok!(test_benchmark_close_approved::<Test>());
});
}
}
substrate/frame/collective/src/lib.rs
+1 -1
View File
@@ -65,7 +65,7 @@ pub trait Trait<I: Instance=DefaultInstance>: frame_system::Trait {
type Origin: From<RawOrigin<Self::AccountId, I>>;
/// The outer call dispatch type.
type Proposal: Parameter + Dispatchable<Origin=<Self as Trait<I>>::Origin> + From<Call<Self, I>>;
type Proposal: Parameter + Dispatchable<Origin=<Self as Trait<I>>::Origin> + From<frame_system::Call<Self>>;
/// The outer event type.
type Event: From<Event<Self, I>> + Into<<Self as frame_system::Trait>::Event>;