Benchmark Collective Pallet (#5343)

* Init

* Fix execute.

* Duplicate macro for instances temporarilly

* Add propose.

* Add vote, close.

* Propose from own module

* Add old members to set_members.

* Add previous proposals to propose.

* Compress a bit the macro.

Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com>
This commit is contained in:
Marcio Diaz
2020-03-24 18:06:29 +01:00
committed by GitHub
parent 27fe4206ed
commit 22e23b0103
8 changed files with 429 additions and 28 deletions
@@ -0,0 +1,185 @@
// Copyright 2020 Parity Technologies (UK) Ltd.
// This file is part of Substrate.
// Substrate is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Substrate is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Substrate. If not, see <http://www.gnu.org/licenses/>.
//! Staking pallet benchmarking.
use super::*;
use frame_system::RawOrigin as SystemOrigin;
use frame_benchmarking::{benchmarks_instance, account};
use frame_system::Module as System;
use crate::Module as Collective;
const SEED: u32 = 0;
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);
}
// Set old members.
// We compute the difference of old and new members, so it should influence timing.
let mut old_members = vec![];
for i in 0 .. n {
let old_member = account("old member", i, SEED);
old_members.push(old_member);
}
let prime = Some(account("prime", 0, SEED));
Collective::<T, _>::set_members(SystemOrigin::Root.into(), old_members, prime.clone())?;
}: _(SystemOrigin::Root, new_members, prime)
execute {
let u in ...;
let caller: T::AccountId = account("caller", u, SEED);
let proposal: T::Proposal = Call::<T, I>::close(Default::default(), Default::default()).into();
Collective::<T, _>::set_members(SystemOrigin::Root.into(), vec![caller.clone()], None)?;
}: _(SystemOrigin::Signed(caller), Box::new(proposal))
propose {
let u in ...;
let caller: T::AccountId = account("caller", u, SEED);
let proposal: T::Proposal = Call::<T, I>::close(Default::default(), Default::default()).into();
Collective::<T, _>::set_members(SystemOrigin::Root.into(), vec![caller.clone()], None)?;
let member_count = 0;
}: _(SystemOrigin::Signed(caller), member_count, Box::new(proposal.into()))
propose_else_branch {
let u in ...;
let p in ...;
let caller: T::AccountId = account("caller", u, SEED);
let proposal: T::Proposal = Call::<T, I>::close(Default::default(), Default::default()).into();
Collective::<T, _>::set_members(SystemOrigin::Root.into(), vec![caller.clone()], None)?;
let member_count = 3;
// 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()))?;
}
}: propose(SystemOrigin::Signed(caller), member_count, Box::new(proposal.into()))
vote {
let u in ...;
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());
let proposal_hash = T::Hashing::hash_of(&proposal);
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;
let approve = true;
}: _(SystemOrigin::Signed(caller2), proposal_hash, index, approve)
vote_not_approve {
let u in ...;
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());
let proposal_hash = T::Hashing::hash_of(&proposal);
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;
let approve = false;
}: vote(SystemOrigin::Signed(caller2), proposal_hash, index, approve)
vote_approved {
let u in ...;
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());
let proposal_hash = T::Hashing::hash_of(&proposal);
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)?;
let index = 0;
let approve = true;
}: vote(SystemOrigin::Signed(caller2), proposal_hash, index, approve)
close {
let u in ...;
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());
let proposal_hash = T::Hashing::hash_of(&proposal);
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)?;
let index = 0;
let approve = true;
let vote_end = T::MotionDuration::get() + 1u32.into();
System::<T>::set_block_number(vote_end);
}: _(SystemOrigin::Signed(caller2), proposal_hash, index)
}
+5 -2
View File
@@ -48,6 +48,9 @@ use frame_support::{
};
use frame_system::{self as system, ensure_signed, ensure_root};
#[cfg(feature = "runtime-benchmarks")]
mod benchmarking;
/// Simple index type for proposal counting.
pub type ProposalIndex = u32;
@@ -57,12 +60,12 @@ pub type ProposalIndex = u32;
/// vote exactly once, therefore also the number of votes for any given motion.
pub type MemberCount = u32;
pub trait Trait<I=DefaultInstance>: frame_system::Trait {
pub trait Trait<I: Instance=DefaultInstance>: frame_system::Trait {
/// The outer origin type.
type Origin: From<RawOrigin<Self::AccountId, I>>;
/// The outer call dispatch type.
type Proposal: Parameter + Dispatchable<Origin=<Self as Trait<I>>::Origin>;
type Proposal: Parameter + Dispatchable<Origin=<Self as Trait<I>>::Origin> + From<Call<Self, I>>;
/// The outer event type.
type Event: From<Event<Self, I>> + Into<<Self as frame_system::Trait>::Event>;