From e89d937aab515f7f0d12d64596ea973b67a17a44 Mon Sep 17 00:00:00 2001 From: weichweich <14820950+weichweich@users.noreply.github.com> Date: Tue, 7 Sep 2021 11:12:34 +0200 Subject: [PATCH 1/8] wip: initialize v5 migrations --- pallets/parachain-staking/src/migrations.rs | 12 +++- .../parachain-staking/src/migrations/v5.rs | 71 +++++++++++++++++++ 2 files changed, 80 insertions(+), 3 deletions(-) create mode 100644 pallets/parachain-staking/src/migrations/v5.rs diff --git a/pallets/parachain-staking/src/migrations.rs b/pallets/parachain-staking/src/migrations.rs index 11a114a2d..81267ee49 100644 --- a/pallets/parachain-staking/src/migrations.rs +++ b/pallets/parachain-staking/src/migrations.rs @@ -29,6 +29,7 @@ use crate::*; mod v2; mod v3; mod v4; +mod v5; /// A trait that allows version migrators to access the underlying pallet's /// context, e.g., its Config trait. @@ -53,6 +54,7 @@ pub enum StakingStorageVersion { V2_0_0, // New Reward calculation, MaxCollatorCandidateStake V3_0_0, // Update InflationConfig V4, // Sort TopCandidates and parachain-stakings by amount + V5, // Remove SelectedCandidates, Count Candidates } #[cfg(feature = "try-runtime")] @@ -84,7 +86,8 @@ impl VersionMigratorTrait for StakingStorageVersion { Self::V1_0_0 => v2::pre_migrate::(), Self::V2_0_0 => v3::pre_migrate::(), Self::V3_0_0 => v4::pre_migrate::(), - Self::V4 => Err("Already on latest version v4."), + Self::V4 => v5::pre_migrate::(), + Self::V5 => Err("Already on latest version v5."), } } @@ -94,7 +97,8 @@ impl VersionMigratorTrait for StakingStorageVersion { Self::V1_0_0 => v2::migrate::(), Self::V2_0_0 => v3::migrate::(), Self::V3_0_0 => v4::migrate::(), - Self::V4 => Weight::zero(), + Self::V4 => v5::migrate::(), + Self::V5 => Weight::zero(), } } @@ -106,7 +110,8 @@ impl VersionMigratorTrait for StakingStorageVersion { Self::V1_0_0 => v2::post_migrate::(), Self::V2_0_0 => v3::post_migrate::(), Self::V3_0_0 => v4::post_migrate::(), - Self::V4 => Err("Migration from v4 should have never happened in the first place."), + Self::V4 => v5::post_migrate::(), + Self::V5 => Err("Migration from v4 should have never happened in the first place."), } } } @@ -128,6 +133,7 @@ impl StakingStorageMigrator { // Migration happens naturally, no need to point to the latest version StakingStorageVersion::V3_0_0 => None, StakingStorageVersion::V4 => None, + StakingStorageVersion::V5 => None, } } diff --git a/pallets/parachain-staking/src/migrations/v5.rs b/pallets/parachain-staking/src/migrations/v5.rs new file mode 100644 index 000000000..c27facce3 --- /dev/null +++ b/pallets/parachain-staking/src/migrations/v5.rs @@ -0,0 +1,71 @@ +// KILT Blockchain – https://botlabs.org +// Copyright (C) 2019-2021 BOTLabs GmbH + +// The KILT Blockchain 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. + +// The KILT Blockchain 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 this program. If not, see . + +// If you feel like getting in touch with us, you can do so at info@botlabs.org + +use crate::{migrations::StakingStorageVersion, CandidateCount, CandidatePool, Config, StorageVersion, TopCandidates}; +use frame_support::{dispatch::Weight, storage::unhashed::kill_prefix, traits::Get}; +pub use sp_runtime::traits::Zero; + +#[cfg(feature = "try-runtime")] +pub(crate) fn pre_migrate() -> Result<(), &'static str> { + assert_eq!(StorageVersion::::get(), StakingStorageVersion::V4); + Ok(()) +} + +pub(crate) fn migrate() -> Weight { + log::info!("Migrating staking to StakingStorageVersion::V5"); + + let candidate_count = CandidatePool::::iter().fold(0u32, |acc, _| acc.saturating_add(1)); + CandidateCount::::put(candidate_count); + + StorageVersion::::put(StakingStorageVersion::V5); + log::info!("Completed staking migration to StakingStorageVersion::V5"); + + T::DbWeight::get().reads_writes(candidate_count.saturating_add(2).into(), 3) +} + +#[cfg(feature = "try-runtime")] +pub(crate) fn post_migrate() -> Result<(), &'static str> { + let mut candidates = TopCandidates::::get(); + candidates.sort_greatest_to_lowest(); + assert_eq!( + TopCandidates::::get().into_bounded_vec().into_inner(), + candidates.into_bounded_vec().into_inner() + ); + assert_eq!(StorageVersion::::get(), StakingStorageVersion::V5); + Ok(()) +} + +pub(crate) mod storage { + use frame_support::{decl_module, decl_storage}; + use sp_std::prelude::*; + + use super::*; + + decl_module! { + pub struct OldPallet for enum Call where origin: T::Origin {} + } + + decl_storage! { + trait Store for OldPallet as ParachainStaking { + pub(crate) CollatorState: map hasher(twox_64_concat) T::AccountId => Option, T::MaxDelegatorsPerCollator>>; + pub(crate) SelectedCandidates: Vec; + pub(crate) Total: crate::types::TotalStake>; + pub(crate) CandidatePool: Vec>>; + } + } +} From 9c97a70c38c4054ac15f19228ed455b07e5022d9 Mon Sep 17 00:00:00 2001 From: weichweich <14820950+weichweich@users.noreply.github.com> Date: Tue, 7 Sep 2021 17:51:37 +0200 Subject: [PATCH 2/8] fix: try-runtime run even if everything is up to date --- pallets/delegation/src/migrations.rs | 9 ++------- pallets/did/src/migrations.rs | 9 ++------- 2 files changed, 4 insertions(+), 14 deletions(-) diff --git a/pallets/delegation/src/migrations.rs b/pallets/delegation/src/migrations.rs index 7367ac704..ba45f117d 100644 --- a/pallets/delegation/src/migrations.rs +++ b/pallets/delegation/src/migrations.rs @@ -58,7 +58,7 @@ impl VersionMigratorTrait for DelegationStorageVersion { fn pre_migrate(&self) -> Result<(), &str> { match *self { Self::V1 => v1::pre_migrate::(), - Self::V2 => Err("Already latest v2 version."), + Self::V2 => Ok(()), } } @@ -76,7 +76,7 @@ impl VersionMigratorTrait for DelegationStorageVersion { fn post_migrate(&self) -> Result<(), &str> { match *self { Self::V1 => v1::post_migrate::(), - Self::V2 => Err("Migration from v2 should have never happened in the first place."), + Self::V2 => Ok(()), } } } @@ -104,11 +104,6 @@ impl DelegationStorageMigrator { /// latest possible. #[cfg(feature = "try-runtime")] pub(crate) fn pre_migrate() -> Result<(), &'static str> { - ensure!( - StorageVersion::::get() < DelegationStorageVersion::latest(), - "Already the latest storage version." - ); - // Don't need to check for any other pre_migrate, as in try-runtime it is also // called in the migrate() function. Same applies for post_migrate checks for // each version migrator. diff --git a/pallets/did/src/migrations.rs b/pallets/did/src/migrations.rs index 073146b5a..5bf086070 100644 --- a/pallets/did/src/migrations.rs +++ b/pallets/did/src/migrations.rs @@ -58,7 +58,7 @@ impl VersionMigratorTrait for DidStorageVersion { fn pre_migrate(&self) -> Result<(), &str> { match *self { Self::V1 => v1::pre_migrate::(), - Self::V2 => Err("Already latest v2 version."), + Self::V2 => Ok(()), } } @@ -76,7 +76,7 @@ impl VersionMigratorTrait for DidStorageVersion { fn post_migrate(&self) -> Result<(), &str> { match *self { Self::V1 => v1::post_migrate::(), - Self::V2 => Err("Migration from v2 should have never happened in the first place."), + Self::V2 => Ok(()), } } } @@ -104,11 +104,6 @@ impl DidStorageMigrator { /// latest possible. #[cfg(feature = "try-runtime")] pub(crate) fn pre_migrate() -> Result<(), &'static str> { - ensure!( - StorageVersion::::get() < DidStorageVersion::latest(), - "Already the latest storage version." - ); - // Don't need to check for any other pre_migrate, as in try-runtime it is also // called in the migrate() function. Same applies for post_migrate checks for // each version migrator. From deee4c01948073e6701e8d14e5f21a4208c238a1 Mon Sep 17 00:00:00 2001 From: weichweich <14820950+weichweich@users.noreply.github.com> Date: Tue, 7 Sep 2021 17:51:50 +0200 Subject: [PATCH 3/8] wip: staking migrations --- pallets/parachain-staking/src/lib.rs | 3 ++ pallets/parachain-staking/src/migrations.rs | 15 +++------ .../parachain-staking/src/migrations/v5.rs | 32 ++++++++----------- runtimes/peregrine/src/lib.rs | 9 ++++-- runtimes/spiritnet/src/lib.rs | 2 +- runtimes/standalone/src/lib.rs | 2 +- 6 files changed, 29 insertions(+), 34 deletions(-) diff --git a/pallets/parachain-staking/src/lib.rs b/pallets/parachain-staking/src/lib.rs index f5723bbed..cd44ae01d 100644 --- a/pallets/parachain-staking/src/lib.rs +++ b/pallets/parachain-staking/src/lib.rs @@ -580,6 +580,7 @@ pub mod pallet { /// It maps from an account to its information. #[pallet::storage] #[pallet::getter(fn candidate_pool)] + #[pallet::storage_prefix = "CollatorState"] pub(crate) type CandidatePool = StorageMap< _, Twox64Concat, @@ -600,6 +601,7 @@ pub mod pallet { /// non collating candidates is not included in [TotalCollatorStake]. #[pallet::storage] #[pallet::getter(fn total_collator_stake)] + #[pallet::storage_prefix = "Total"] pub(crate) type TotalCollatorStake = StorageValue<_, TotalStake>, ValueQuery>; /// The collator candidates with the highest amount of stake. @@ -613,6 +615,7 @@ pub mod pallet { /// that a collator can drop out of the collator set by reducing his stake. #[pallet::storage] #[pallet::getter(fn top_candidates)] + #[pallet::storage_prefix = "CollatorPool"] pub(crate) type TopCandidates = StorageValue<_, OrderedSet>, T::MaxTopCandidates>, ValueQuery>; diff --git a/pallets/parachain-staking/src/migrations.rs b/pallets/parachain-staking/src/migrations.rs index 81267ee49..816e14cb7 100644 --- a/pallets/parachain-staking/src/migrations.rs +++ b/pallets/parachain-staking/src/migrations.rs @@ -61,7 +61,7 @@ pub enum StakingStorageVersion { impl StakingStorageVersion { /// The latest storage version. fn latest() -> Self { - Self::V4 + Self::V5 } } @@ -87,7 +87,7 @@ impl VersionMigratorTrait for StakingStorageVersion { Self::V2_0_0 => v3::pre_migrate::(), Self::V3_0_0 => v4::pre_migrate::(), Self::V4 => v5::pre_migrate::(), - Self::V5 => Err("Already on latest version v5."), + Self::V5 => Ok(()), } } @@ -111,7 +111,7 @@ impl VersionMigratorTrait for StakingStorageVersion { Self::V2_0_0 => v3::post_migrate::(), Self::V3_0_0 => v4::post_migrate::(), Self::V4 => v5::post_migrate::(), - Self::V5 => Err("Migration from v4 should have never happened in the first place."), + Self::V5 => Ok(()), } } } @@ -131,8 +131,8 @@ impl StakingStorageMigrator { StakingStorageVersion::V1_0_0 => Some(StakingStorageVersion::V2_0_0), StakingStorageVersion::V2_0_0 => Some(StakingStorageVersion::V3_0_0), // Migration happens naturally, no need to point to the latest version - StakingStorageVersion::V3_0_0 => None, - StakingStorageVersion::V4 => None, + StakingStorageVersion::V3_0_0 => Some(StakingStorageVersion::V4), + StakingStorageVersion::V4 => Some(StakingStorageVersion::V5), StakingStorageVersion::V5 => None, } } @@ -141,11 +141,6 @@ impl StakingStorageMigrator { /// latest possible. #[cfg(feature = "try-runtime")] pub(crate) fn pre_migrate() -> Result<(), &'static str> { - ensure!( - StorageVersion::::get() < StakingStorageVersion::latest(), - "Already the latest storage version." - ); - // Don't need to check for any other pre_migrate, as in try-runtime it is also // called in the migrate() function. Same applies for post_migrate checks for // each version migrator. diff --git a/pallets/parachain-staking/src/migrations/v5.rs b/pallets/parachain-staking/src/migrations/v5.rs index c27facce3..c9c90d388 100644 --- a/pallets/parachain-staking/src/migrations/v5.rs +++ b/pallets/parachain-staking/src/migrations/v5.rs @@ -16,9 +16,8 @@ // If you feel like getting in touch with us, you can do so at info@botlabs.org -use crate::{migrations::StakingStorageVersion, CandidateCount, CandidatePool, Config, StorageVersion, TopCandidates}; -use frame_support::{dispatch::Weight, storage::unhashed::kill_prefix, traits::Get}; -pub use sp_runtime::traits::Zero; +use crate::{migrations::StakingStorageVersion, CandidateCount, CandidatePool, Config, StorageVersion}; +use frame_support::{dispatch::Weight, storage::StorageValue, traits::Get}; #[cfg(feature = "try-runtime")] pub(crate) fn pre_migrate() -> Result<(), &'static str> { @@ -29,43 +28,38 @@ pub(crate) fn pre_migrate() -> Result<(), &'static str> { pub(crate) fn migrate() -> Weight { log::info!("Migrating staking to StakingStorageVersion::V5"); - let candidate_count = CandidatePool::::iter().fold(0u32, |acc, _| acc.saturating_add(1)); - CandidateCount::::put(candidate_count); + // Kill selected candidates list + old::SelectedCandidates::::kill(); + // count candidates + let counter: u32 = CandidatePool::::iter().fold(0, |acc, _| acc.saturating_add(1)); + CandidateCount::::put(counter); + + // update storage version StorageVersion::::put(StakingStorageVersion::V5); log::info!("Completed staking migration to StakingStorageVersion::V5"); - T::DbWeight::get().reads_writes(candidate_count.saturating_add(2).into(), 3) + T::DbWeight::get().reads_writes(counter.saturating_add(2).into(), counter.saturating_add(3).into()) } #[cfg(feature = "try-runtime")] pub(crate) fn post_migrate() -> Result<(), &'static str> { - let mut candidates = TopCandidates::::get(); - candidates.sort_greatest_to_lowest(); - assert_eq!( - TopCandidates::::get().into_bounded_vec().into_inner(), - candidates.into_bounded_vec().into_inner() - ); - assert_eq!(StorageVersion::::get(), StakingStorageVersion::V5); + // assert_eq!(StorageVersion::::get(), StakingStorageVersion::V5); Ok(()) } -pub(crate) mod storage { +pub(crate) mod old { + use super::*; use frame_support::{decl_module, decl_storage}; use sp_std::prelude::*; - use super::*; - decl_module! { pub struct OldPallet for enum Call where origin: T::Origin {} } decl_storage! { trait Store for OldPallet as ParachainStaking { - pub(crate) CollatorState: map hasher(twox_64_concat) T::AccountId => Option, T::MaxDelegatorsPerCollator>>; pub(crate) SelectedCandidates: Vec; - pub(crate) Total: crate::types::TotalStake>; - pub(crate) CandidatePool: Vec>>; } } } diff --git a/runtimes/peregrine/src/lib.rs b/runtimes/peregrine/src/lib.rs index 102ca94c3..5e7a6abf2 100644 --- a/runtimes/peregrine/src/lib.rs +++ b/runtimes/peregrine/src/lib.rs @@ -104,7 +104,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("mashnet-node"), impl_name: create_runtime_str!("mashnet-node"), authoring_version: 4, - spec_version: 22, + spec_version: 23, impl_version: 0, apis: RUNTIME_API_VERSIONS, transaction_version: 2, @@ -1131,12 +1131,15 @@ impl_runtime_apis! { } } - // From the Polkadot repo: https://github.com/paritytech/polkadot/blob/master/runtime/polkadot/src/lib.rs#L1371 + // From the Polkadot repo: https://github.com/paritytech/polkadot/blob/1876963f254f31f8cd2d7b8d5fb26cd38b7836ab/runtime/polkadot/src/lib.rs#L1413 #[cfg(feature = "try-runtime")] impl frame_try_runtime::TryRuntime for Runtime { fn on_runtime_upgrade() -> Result<(Weight, Weight), sp_runtime::RuntimeString> { log::info!("try-runtime::on_runtime_upgrade for peregrine runtime."); - let weight = Executive::try_runtime_upgrade()?; + let weight = Executive::try_runtime_upgrade().map_err(|err|{ + log::info!("try-runtime::on_runtime_upgrade failed with: {:?}", err); + err + })?; Ok((weight, RuntimeBlockWeights::get().max_block)) } } diff --git a/runtimes/spiritnet/src/lib.rs b/runtimes/spiritnet/src/lib.rs index 1239444b1..eac0309f5 100644 --- a/runtimes/spiritnet/src/lib.rs +++ b/runtimes/spiritnet/src/lib.rs @@ -87,7 +87,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("kilt-spiritnet"), impl_name: create_runtime_str!("kilt-spiritnet"), authoring_version: 1, - spec_version: 22, + spec_version: 23, impl_version: 0, apis: RUNTIME_API_VERSIONS, transaction_version: 1, diff --git a/runtimes/standalone/src/lib.rs b/runtimes/standalone/src/lib.rs index 1777802fb..88d101091 100644 --- a/runtimes/standalone/src/lib.rs +++ b/runtimes/standalone/src/lib.rs @@ -110,7 +110,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("mashnet-node"), impl_name: create_runtime_str!("mashnet-node"), authoring_version: 4, - spec_version: 22, + spec_version: 23, impl_version: 0, apis: RUNTIME_API_VERSIONS, transaction_version: 2, From 484866480287ee5528af3a7936ed97e937c60023 Mon Sep 17 00:00:00 2001 From: weichweich <14820950+weichweich@users.noreply.github.com> Date: Wed, 8 Sep 2021 10:17:40 +0200 Subject: [PATCH 4/8] tests: add tests --- pallets/parachain-staking/src/migrations/v5.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/pallets/parachain-staking/src/migrations/v5.rs b/pallets/parachain-staking/src/migrations/v5.rs index c9c90d388..e919d5582 100644 --- a/pallets/parachain-staking/src/migrations/v5.rs +++ b/pallets/parachain-staking/src/migrations/v5.rs @@ -39,12 +39,13 @@ pub(crate) fn migrate() -> Weight { StorageVersion::::put(StakingStorageVersion::V5); log::info!("Completed staking migration to StakingStorageVersion::V5"); - T::DbWeight::get().reads_writes(counter.saturating_add(2).into(), counter.saturating_add(3).into()) + T::DbWeight::get().reads_writes(counter.saturating_add(2).into(), 3) } #[cfg(feature = "try-runtime")] pub(crate) fn post_migrate() -> Result<(), &'static str> { - // assert_eq!(StorageVersion::::get(), StakingStorageVersion::V5); + assert_eq!(StorageVersion::::get(), StakingStorageVersion::V5); + assert!(CandidateCount::::get() > T::MinCollators::get()); Ok(()) } From d77927bfcddc21e252c3acbf1ca40e20fa3a14a2 Mon Sep 17 00:00:00 2001 From: weichweich <14820950+weichweich@users.noreply.github.com> Date: Mon, 13 Sep 2021 15:40:09 +0200 Subject: [PATCH 5/8] fix tests --- pallets/parachain-staking/src/migrations.rs | 28 ++------------------- 1 file changed, 2 insertions(+), 26 deletions(-) diff --git a/pallets/parachain-staking/src/migrations.rs b/pallets/parachain-staking/src/migrations.rs index 816e14cb7..e75aee5e6 100644 --- a/pallets/parachain-staking/src/migrations.rs +++ b/pallets/parachain-staking/src/migrations.rs @@ -199,35 +199,11 @@ mod tests { use crate::mock::Test as TestRuntime; - #[test] - fn ok_from_v1_migration() { - let mut ext = mock::ExtBuilder::default() - .with_balances(vec![(1, 100), (2, 100)]) - .with_collators(vec![(1, 100), (2, 100)]) - .with_storage_version(StakingStorageVersion::V1_0_0) - .build(); - ext.execute_with(|| { - #[cfg(feature = "try-runtime")] - assert!( - StakingStorageMigrator::::pre_migrate().is_ok(), - "Storage pre-migrate from v1 should not fail." - ); - - StakingStorageMigrator::::migrate(); - - #[cfg(feature = "try-runtime")] - assert!( - StakingStorageMigrator::::post_migrate().is_ok(), - "Storage post-migrate from v1 should not fail." - ); - }); - } - #[test] fn ok_from_default_migration() { let mut ext = mock::ExtBuilder::default() - .with_balances(vec![(1, 100), (2, 100)]) - .with_collators(vec![(1, 100), (2, 100)]) + .with_balances((0..15).into_iter().map(|n| (n, 120)).collect()) + .with_collators((0..15).into_iter().map(|n| (n, 100)).collect()) .build(); ext.execute_with(|| { #[cfg(feature = "try-runtime")] From e75f792b75f6ddc41c028ee7b6888cdf486b8af3 Mon Sep 17 00:00:00 2001 From: weichweich <14820950+weichweich@users.noreply.github.com> Date: Mon, 13 Sep 2021 16:55:12 +0200 Subject: [PATCH 6/8] =?UTF-8?q?chore:=20=F0=9F=A7=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pallets/parachain-staking/src/mock.rs | 5 ----- 1 file changed, 5 deletions(-) diff --git a/pallets/parachain-staking/src/mock.rs b/pallets/parachain-staking/src/mock.rs index 6b39c9ef6..a0a3cca95 100644 --- a/pallets/parachain-staking/src/mock.rs +++ b/pallets/parachain-staking/src/mock.rs @@ -273,11 +273,6 @@ impl ExtBuilder { self } - pub(crate) fn with_storage_version(mut self, storage_version: StakingStorageVersion) -> Self { - self.storage_version = storage_version; - self - } - pub(crate) fn build(self) -> sp_io::TestExternalities { let mut t = frame_system::GenesisConfig::default() .build_storage::() From f0d7131f3a6bcd357b68408ae9365d59f606c60d Mon Sep 17 00:00:00 2001 From: Albrecht Date: Tue, 14 Sep 2021 12:50:26 +0200 Subject: [PATCH 7/8] add benchmarks --- .../parachain-staking/src/default_weights.rs | 388 ++++++++-------- .../src/weights/parachain_staking.rs | 419 +++++++++++++----- 2 files changed, 498 insertions(+), 309 deletions(-) diff --git a/pallets/parachain-staking/src/default_weights.rs b/pallets/parachain-staking/src/default_weights.rs index 550173776..6543c8ca0 100644 --- a/pallets/parachain-staking/src/default_weights.rs +++ b/pallets/parachain-staking/src/default_weights.rs @@ -18,14 +18,14 @@ //! Autogenerated weights for parachain_staking //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 3.0.0 -//! DATE: 2021-08-11, STEPS: {{cmd.steps}}\, REPEAT: {{cmd.repeat}}\, LOW RANGE: {{cmd.lowest_range_values}}\, HIGH RANGE: {{cmd.highest_range_values}}\ -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 128 +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2021-09-13, STEPS: {{cmd.steps}}\, REPEAT: {{cmd.repeat}}\, LOW RANGE: {{cmd.lowest_range_values}}\, HIGH RANGE: {{cmd.highest_range_values}}\ +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("spiritnet-dev"), DB CACHE: 128 // Executed Command: -// /home/willi/mashnet-node/target/release/kilt-parachain +// target/release/kilt-parachain // benchmark -// --chain=dev +// --chain=spiritnet-dev // --steps=50 // --repeat=20 // --pallet=parachain-staking @@ -33,8 +33,8 @@ // --execution=wasm // --wasm-execution=compiled // --heap-pages=4096 -// --output=../../pallets/parachain-staking/src/default_weights.rs -// --template=../../.maintain/weight-template.hbs +// --output=./pallets/parachain-staking/src/default_weights.rs +// --template=.maintain/weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] @@ -73,170 +73,169 @@ pub trait WeightInfo { pub struct SubstrateWeight(PhantomData); impl WeightInfo for SubstrateWeight { fn on_initialize_no_action() -> Weight { - (6_853_000_u64) + (4_028_000_u64) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn on_initialize_round_update() -> Weight { - (30_216_000_u64) + (18_570_000_u64) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } fn on_initialize_new_year() -> Weight { - (56_085_000_u64) + (36_187_000_u64) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } fn force_new_round() -> Weight { - (3_847_000_u64) + (2_536_000_u64) .saturating_add(T::DbWeight::get().writes(1_u64)) } fn set_inflation() -> Weight { - (28_523_000_u64) + (17_041_000_u64) .saturating_add(T::DbWeight::get().writes(1_u64)) } fn set_max_selected_candidates(n: u32, m: u32, ) -> Weight { (0_u64) - // Standard Error: 61_000 - .saturating_add((25_089_000_u64).saturating_mul(n as Weight)) - // Standard Error: 172_000 - .saturating_add((16_276_000_u64).saturating_mul(m as Weight)) + // Standard Error: 16_000 + .saturating_add((17_808_000_u64).saturating_mul(n as Weight)) + // Standard Error: 45_000 + .saturating_add((15_031_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n as Weight))) - .saturating_add(T::DbWeight::get().writes(4_u64)) + .saturating_add(T::DbWeight::get().writes(2_u64)) } fn set_blocks_per_round() -> Weight { - (30_918_000_u64) + (19_263_000_u64) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } fn force_remove_candidate(n: u32, m: u32, ) -> Weight { - (206_999_000_u64) - // Standard Error: 74_000 - .saturating_add((3_498_000_u64).saturating_mul(n as Weight)) - // Standard Error: 205_000 - .saturating_add((40_964_000_u64).saturating_mul(m as Weight)) - .saturating_add(T::DbWeight::get().reads(24_u64)) + (112_307_000_u64) + // Standard Error: 18_000 + .saturating_add((3_134_000_u64).saturating_mul(n as Weight)) + // Standard Error: 51_000 + .saturating_add((28_144_000_u64).saturating_mul(m as Weight)) + .saturating_add(T::DbWeight::get().reads(25_u64)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(m as Weight))) .saturating_add(T::DbWeight::get().writes(7_u64)) .saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(m as Weight))) } fn join_candidates(n: u32, m: u32, ) -> Weight { - (192_349_000_u64) - // Standard Error: 93_000 - .saturating_add((4_159_000_u64).saturating_mul(n as Weight)) - // Standard Error: 340_000 - .saturating_add((9_366_000_u64).saturating_mul(m as Weight)) - .saturating_add(T::DbWeight::get().reads(17_u64)) + (69_130_000_u64) + // Standard Error: 60_000 + .saturating_add((4_137_000_u64).saturating_mul(n as Weight)) + // Standard Error: 219_000 + .saturating_add((9_836_000_u64).saturating_mul(m as Weight)) + .saturating_add(T::DbWeight::get().reads(18_u64)) .saturating_add(T::DbWeight::get().writes(7_u64)) } fn init_leave_candidates(n: u32, m: u32, ) -> Weight { - (336_470_000_u64) - // Standard Error: 27_000 - .saturating_add((1_636_000_u64).saturating_mul(n as Weight)) - // Standard Error: 74_000 - .saturating_add((6_236_000_u64).saturating_mul(m as Weight)) + (149_433_000_u64) + // Standard Error: 18_000 + .saturating_add((2_552_000_u64).saturating_mul(n as Weight)) + // Standard Error: 48_000 + .saturating_add((8_307_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(21_u64)) - .saturating_add(T::DbWeight::get().writes(4_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) } fn cancel_leave_candidates(n: u32, m: u32, ) -> Weight { - (338_223_000_u64) - // Standard Error: 29_000 - .saturating_add((1_468_000_u64).saturating_mul(n as Weight)) - // Standard Error: 78_000 - .saturating_add((6_225_000_u64).saturating_mul(m as Weight)) + (147_226_000_u64) + // Standard Error: 15_000 + .saturating_add((2_519_000_u64).saturating_mul(n as Weight)) + // Standard Error: 41_000 + .saturating_add((8_477_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(19_u64)) - .saturating_add(T::DbWeight::get().writes(4_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) } fn execute_leave_candidates(n: u32, m: u32, u: u32, ) -> Weight { (0_u64) - // Standard Error: 35_000 - .saturating_add((2_270_000_u64).saturating_mul(n as Weight)) - // Standard Error: 96_000 - .saturating_add((36_246_000_u64).saturating_mul(m as Weight)) - // Standard Error: 422_000 - .saturating_add((1_090_000_u64).saturating_mul(u as Weight)) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Standard Error: 16_000 + .saturating_add((3_248_000_u64).saturating_mul(n as Weight)) + // Standard Error: 43_000 + .saturating_add((28_209_000_u64).saturating_mul(m as Weight)) + // Standard Error: 190_000 + .saturating_add((808_000_u64).saturating_mul(u as Weight)) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(m as Weight))) - .saturating_add(T::DbWeight::get().writes(4_u64)) + .saturating_add(T::DbWeight::get().writes(5_u64)) .saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(m as Weight))) } fn candidate_stake_more(n: u32, m: u32, u: u32, ) -> Weight { - (115_540_000_u64) - // Standard Error: 90_000 - .saturating_add((4_227_000_u64).saturating_mul(n as Weight)) - // Standard Error: 335_000 - .saturating_add((9_456_000_u64).saturating_mul(m as Weight)) - // Standard Error: 1_113_000 - .saturating_add((6_654_000_u64).saturating_mul(u as Weight)) + (0_u64) + // Standard Error: 65_000 + .saturating_add((4_760_000_u64).saturating_mul(n as Weight)) + // Standard Error: 240_000 + .saturating_add((12_067_000_u64).saturating_mul(m as Weight)) + // Standard Error: 797_000 + .saturating_add((6_453_000_u64).saturating_mul(u as Weight)) .saturating_add(T::DbWeight::get().reads(13_u64)) - .saturating_add(T::DbWeight::get().writes(7_u64)) + .saturating_add(T::DbWeight::get().writes(6_u64)) } fn candidate_stake_less(n: u32, m: u32, ) -> Weight { - (140_434_000_u64) - // Standard Error: 93_000 - .saturating_add((4_100_000_u64).saturating_mul(n as Weight)) - // Standard Error: 341_000 - .saturating_add((8_914_000_u64).saturating_mul(m as Weight)) + (0_u64) + // Standard Error: 68_000 + .saturating_add((4_592_000_u64).saturating_mul(n as Weight)) + // Standard Error: 249_000 + .saturating_add((11_635_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(12_u64)) - .saturating_add(T::DbWeight::get().writes(5_u64)) + .saturating_add(T::DbWeight::get().writes(4_u64)) } fn join_delegators(n: u32, m: u32, ) -> Weight { - (193_909_000_u64) - // Standard Error: 101_000 - .saturating_add((4_337_000_u64).saturating_mul(n as Weight)) - // Standard Error: 417_000 - .saturating_add((10_629_000_u64).saturating_mul(m as Weight)) + (14_302_000_u64) + // Standard Error: 70_000 + .saturating_add((4_857_000_u64).saturating_mul(n as Weight)) + // Standard Error: 288_000 + .saturating_add((13_395_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(18_u64)) - .saturating_add(T::DbWeight::get().writes(9_u64)) + .saturating_add(T::DbWeight::get().writes(8_u64)) } fn delegator_stake_more(n: u32, m: u32, u: u32, ) -> Weight { - (116_048_000_u64) - // Standard Error: 91_000 - .saturating_add((4_135_000_u64).saturating_mul(n as Weight)) - // Standard Error: 382_000 - .saturating_add((9_973_000_u64).saturating_mul(m as Weight)) - // Standard Error: 1_308_000 - .saturating_add((7_593_000_u64).saturating_mul(u as Weight)) + (0_u64) + // Standard Error: 67_000 + .saturating_add((4_734_000_u64).saturating_mul(n as Weight)) + // Standard Error: 280_000 + .saturating_add((12_743_000_u64).saturating_mul(m as Weight)) + // Standard Error: 959_000 + .saturating_add((7_291_000_u64).saturating_mul(u as Weight)) .saturating_add(T::DbWeight::get().reads(13_u64)) - .saturating_add(T::DbWeight::get().writes(8_u64)) + .saturating_add(T::DbWeight::get().writes(7_u64)) } fn delegator_stake_less(n: u32, m: u32, ) -> Weight { - (144_889_000_u64) - // Standard Error: 99_000 - .saturating_add((4_048_000_u64).saturating_mul(n as Weight)) - // Standard Error: 408_000 - .saturating_add((9_997_000_u64).saturating_mul(m as Weight)) + (13_040_000_u64) + // Standard Error: 71_000 + .saturating_add((4_393_000_u64).saturating_mul(n as Weight)) + // Standard Error: 294_000 + .saturating_add((11_853_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(13_u64)) - .saturating_add(T::DbWeight::get().writes(6_u64)) + .saturating_add(T::DbWeight::get().writes(5_u64)) } fn revoke_delegation(n: u32, m: u32, ) -> Weight { - (152_499_000_u64) - // Standard Error: 92_000 - .saturating_add((4_120_000_u64).saturating_mul(n as Weight)) - // Standard Error: 381_000 - .saturating_add((9_819_000_u64).saturating_mul(m as Weight)) + (18_647_000_u64) + // Standard Error: 69_000 + .saturating_add((4_412_000_u64).saturating_mul(n as Weight)) + // Standard Error: 286_000 + .saturating_add((11_593_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(13_u64)) - .saturating_add(T::DbWeight::get().writes(6_u64)) + .saturating_add(T::DbWeight::get().writes(5_u64)) } fn leave_delegators(n: u32, m: u32, ) -> Weight { - (153_615_000_u64) - // Standard Error: 93_000 - .saturating_add((4_178_000_u64).saturating_mul(n as Weight)) - // Standard Error: 385_000 - .saturating_add((9_744_000_u64).saturating_mul(m as Weight)) + (27_394_000_u64) + // Standard Error: 68_000 + .saturating_add((4_286_000_u64).saturating_mul(n as Weight)) + // Standard Error: 280_000 + .saturating_add((11_435_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(13_u64)) - .saturating_add(T::DbWeight::get().writes(6_u64)) + .saturating_add(T::DbWeight::get().writes(5_u64)) } fn unlock_unstaked(u: u32, ) -> Weight { - (60_311_000_u64) - // Standard Error: 50_000 - .saturating_add((413_000_u64).saturating_mul(u as Weight)) + (44_409_000_u64) + // Standard Error: 15_000 + .saturating_add((364_000_u64).saturating_mul(u as Weight)) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } fn set_max_candidate_stake() -> Weight { - (29_014_000_u64) - .saturating_add(T::DbWeight::get().reads(1_u64)) + (15_269_000_u64) .saturating_add(T::DbWeight::get().writes(1_u64)) } } @@ -244,170 +243,169 @@ impl WeightInfo for SubstrateWeight { // For backwards compatibility and tests impl WeightInfo for () { fn on_initialize_no_action() -> Weight { - (6_853_000_u64) + (4_028_000_u64) .saturating_add(RocksDbWeight::get().reads(1_u64)) } fn on_initialize_round_update() -> Weight { - (30_216_000_u64) + (18_570_000_u64) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } fn on_initialize_new_year() -> Weight { - (56_085_000_u64) + (36_187_000_u64) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } fn force_new_round() -> Weight { - (3_847_000_u64) + (2_536_000_u64) .saturating_add(RocksDbWeight::get().writes(1_u64)) } fn set_inflation() -> Weight { - (28_523_000_u64) + (17_041_000_u64) .saturating_add(RocksDbWeight::get().writes(1_u64)) } fn set_max_selected_candidates(n: u32, m: u32, ) -> Weight { (0_u64) - // Standard Error: 61_000 - .saturating_add((25_089_000_u64).saturating_mul(n as Weight)) - // Standard Error: 172_000 - .saturating_add((16_276_000_u64).saturating_mul(m as Weight)) + // Standard Error: 16_000 + .saturating_add((17_808_000_u64).saturating_mul(n as Weight)) + // Standard Error: 45_000 + .saturating_add((15_031_000_u64).saturating_mul(m as Weight)) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n as Weight))) - .saturating_add(RocksDbWeight::get().writes(4_u64)) + .saturating_add(RocksDbWeight::get().writes(2_u64)) } fn set_blocks_per_round() -> Weight { - (30_918_000_u64) + (19_263_000_u64) .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } fn force_remove_candidate(n: u32, m: u32, ) -> Weight { - (206_999_000_u64) - // Standard Error: 74_000 - .saturating_add((3_498_000_u64).saturating_mul(n as Weight)) - // Standard Error: 205_000 - .saturating_add((40_964_000_u64).saturating_mul(m as Weight)) - .saturating_add(RocksDbWeight::get().reads(24_u64)) + (112_307_000_u64) + // Standard Error: 18_000 + .saturating_add((3_134_000_u64).saturating_mul(n as Weight)) + // Standard Error: 51_000 + .saturating_add((28_144_000_u64).saturating_mul(m as Weight)) + .saturating_add(RocksDbWeight::get().reads(25_u64)) .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(m as Weight))) .saturating_add(RocksDbWeight::get().writes(7_u64)) .saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(m as Weight))) } fn join_candidates(n: u32, m: u32, ) -> Weight { - (192_349_000_u64) - // Standard Error: 93_000 - .saturating_add((4_159_000_u64).saturating_mul(n as Weight)) - // Standard Error: 340_000 - .saturating_add((9_366_000_u64).saturating_mul(m as Weight)) - .saturating_add(RocksDbWeight::get().reads(17_u64)) + (69_130_000_u64) + // Standard Error: 60_000 + .saturating_add((4_137_000_u64).saturating_mul(n as Weight)) + // Standard Error: 219_000 + .saturating_add((9_836_000_u64).saturating_mul(m as Weight)) + .saturating_add(RocksDbWeight::get().reads(18_u64)) .saturating_add(RocksDbWeight::get().writes(7_u64)) } fn init_leave_candidates(n: u32, m: u32, ) -> Weight { - (336_470_000_u64) - // Standard Error: 27_000 - .saturating_add((1_636_000_u64).saturating_mul(n as Weight)) - // Standard Error: 74_000 - .saturating_add((6_236_000_u64).saturating_mul(m as Weight)) + (149_433_000_u64) + // Standard Error: 18_000 + .saturating_add((2_552_000_u64).saturating_mul(n as Weight)) + // Standard Error: 48_000 + .saturating_add((8_307_000_u64).saturating_mul(m as Weight)) .saturating_add(RocksDbWeight::get().reads(21_u64)) - .saturating_add(RocksDbWeight::get().writes(4_u64)) + .saturating_add(RocksDbWeight::get().writes(3_u64)) } fn cancel_leave_candidates(n: u32, m: u32, ) -> Weight { - (338_223_000_u64) - // Standard Error: 29_000 - .saturating_add((1_468_000_u64).saturating_mul(n as Weight)) - // Standard Error: 78_000 - .saturating_add((6_225_000_u64).saturating_mul(m as Weight)) + (147_226_000_u64) + // Standard Error: 15_000 + .saturating_add((2_519_000_u64).saturating_mul(n as Weight)) + // Standard Error: 41_000 + .saturating_add((8_477_000_u64).saturating_mul(m as Weight)) .saturating_add(RocksDbWeight::get().reads(19_u64)) - .saturating_add(RocksDbWeight::get().writes(4_u64)) + .saturating_add(RocksDbWeight::get().writes(3_u64)) } fn execute_leave_candidates(n: u32, m: u32, u: u32, ) -> Weight { (0_u64) - // Standard Error: 35_000 - .saturating_add((2_270_000_u64).saturating_mul(n as Weight)) - // Standard Error: 96_000 - .saturating_add((36_246_000_u64).saturating_mul(m as Weight)) - // Standard Error: 422_000 - .saturating_add((1_090_000_u64).saturating_mul(u as Weight)) - .saturating_add(RocksDbWeight::get().reads(6_u64)) + // Standard Error: 16_000 + .saturating_add((3_248_000_u64).saturating_mul(n as Weight)) + // Standard Error: 43_000 + .saturating_add((28_209_000_u64).saturating_mul(m as Weight)) + // Standard Error: 190_000 + .saturating_add((808_000_u64).saturating_mul(u as Weight)) + .saturating_add(RocksDbWeight::get().reads(7_u64)) .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(m as Weight))) - .saturating_add(RocksDbWeight::get().writes(4_u64)) + .saturating_add(RocksDbWeight::get().writes(5_u64)) .saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(m as Weight))) } fn candidate_stake_more(n: u32, m: u32, u: u32, ) -> Weight { - (115_540_000_u64) - // Standard Error: 90_000 - .saturating_add((4_227_000_u64).saturating_mul(n as Weight)) - // Standard Error: 335_000 - .saturating_add((9_456_000_u64).saturating_mul(m as Weight)) - // Standard Error: 1_113_000 - .saturating_add((6_654_000_u64).saturating_mul(u as Weight)) + (0_u64) + // Standard Error: 65_000 + .saturating_add((4_760_000_u64).saturating_mul(n as Weight)) + // Standard Error: 240_000 + .saturating_add((12_067_000_u64).saturating_mul(m as Weight)) + // Standard Error: 797_000 + .saturating_add((6_453_000_u64).saturating_mul(u as Weight)) .saturating_add(RocksDbWeight::get().reads(13_u64)) - .saturating_add(RocksDbWeight::get().writes(7_u64)) + .saturating_add(RocksDbWeight::get().writes(6_u64)) } fn candidate_stake_less(n: u32, m: u32, ) -> Weight { - (140_434_000_u64) - // Standard Error: 93_000 - .saturating_add((4_100_000_u64).saturating_mul(n as Weight)) - // Standard Error: 341_000 - .saturating_add((8_914_000_u64).saturating_mul(m as Weight)) + (0_u64) + // Standard Error: 68_000 + .saturating_add((4_592_000_u64).saturating_mul(n as Weight)) + // Standard Error: 249_000 + .saturating_add((11_635_000_u64).saturating_mul(m as Weight)) .saturating_add(RocksDbWeight::get().reads(12_u64)) - .saturating_add(RocksDbWeight::get().writes(5_u64)) + .saturating_add(RocksDbWeight::get().writes(4_u64)) } fn join_delegators(n: u32, m: u32, ) -> Weight { - (193_909_000_u64) - // Standard Error: 101_000 - .saturating_add((4_337_000_u64).saturating_mul(n as Weight)) - // Standard Error: 417_000 - .saturating_add((10_629_000_u64).saturating_mul(m as Weight)) + (14_302_000_u64) + // Standard Error: 70_000 + .saturating_add((4_857_000_u64).saturating_mul(n as Weight)) + // Standard Error: 288_000 + .saturating_add((13_395_000_u64).saturating_mul(m as Weight)) .saturating_add(RocksDbWeight::get().reads(18_u64)) - .saturating_add(RocksDbWeight::get().writes(9_u64)) + .saturating_add(RocksDbWeight::get().writes(8_u64)) } fn delegator_stake_more(n: u32, m: u32, u: u32, ) -> Weight { - (116_048_000_u64) - // Standard Error: 91_000 - .saturating_add((4_135_000_u64).saturating_mul(n as Weight)) - // Standard Error: 382_000 - .saturating_add((9_973_000_u64).saturating_mul(m as Weight)) - // Standard Error: 1_308_000 - .saturating_add((7_593_000_u64).saturating_mul(u as Weight)) + (0_u64) + // Standard Error: 67_000 + .saturating_add((4_734_000_u64).saturating_mul(n as Weight)) + // Standard Error: 280_000 + .saturating_add((12_743_000_u64).saturating_mul(m as Weight)) + // Standard Error: 959_000 + .saturating_add((7_291_000_u64).saturating_mul(u as Weight)) .saturating_add(RocksDbWeight::get().reads(13_u64)) - .saturating_add(RocksDbWeight::get().writes(8_u64)) + .saturating_add(RocksDbWeight::get().writes(7_u64)) } fn delegator_stake_less(n: u32, m: u32, ) -> Weight { - (144_889_000_u64) - // Standard Error: 99_000 - .saturating_add((4_048_000_u64).saturating_mul(n as Weight)) - // Standard Error: 408_000 - .saturating_add((9_997_000_u64).saturating_mul(m as Weight)) + (13_040_000_u64) + // Standard Error: 71_000 + .saturating_add((4_393_000_u64).saturating_mul(n as Weight)) + // Standard Error: 294_000 + .saturating_add((11_853_000_u64).saturating_mul(m as Weight)) .saturating_add(RocksDbWeight::get().reads(13_u64)) - .saturating_add(RocksDbWeight::get().writes(6_u64)) + .saturating_add(RocksDbWeight::get().writes(5_u64)) } fn revoke_delegation(n: u32, m: u32, ) -> Weight { - (152_499_000_u64) - // Standard Error: 92_000 - .saturating_add((4_120_000_u64).saturating_mul(n as Weight)) - // Standard Error: 381_000 - .saturating_add((9_819_000_u64).saturating_mul(m as Weight)) + (18_647_000_u64) + // Standard Error: 69_000 + .saturating_add((4_412_000_u64).saturating_mul(n as Weight)) + // Standard Error: 286_000 + .saturating_add((11_593_000_u64).saturating_mul(m as Weight)) .saturating_add(RocksDbWeight::get().reads(13_u64)) - .saturating_add(RocksDbWeight::get().writes(6_u64)) + .saturating_add(RocksDbWeight::get().writes(5_u64)) } fn leave_delegators(n: u32, m: u32, ) -> Weight { - (153_615_000_u64) - // Standard Error: 93_000 - .saturating_add((4_178_000_u64).saturating_mul(n as Weight)) - // Standard Error: 385_000 - .saturating_add((9_744_000_u64).saturating_mul(m as Weight)) + (27_394_000_u64) + // Standard Error: 68_000 + .saturating_add((4_286_000_u64).saturating_mul(n as Weight)) + // Standard Error: 280_000 + .saturating_add((11_435_000_u64).saturating_mul(m as Weight)) .saturating_add(RocksDbWeight::get().reads(13_u64)) - .saturating_add(RocksDbWeight::get().writes(6_u64)) + .saturating_add(RocksDbWeight::get().writes(5_u64)) } fn unlock_unstaked(u: u32, ) -> Weight { - (60_311_000_u64) - // Standard Error: 50_000 - .saturating_add((413_000_u64).saturating_mul(u as Weight)) + (44_409_000_u64) + // Standard Error: 15_000 + .saturating_add((364_000_u64).saturating_mul(u as Weight)) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } fn set_max_candidate_stake() -> Weight { - (29_014_000_u64) - .saturating_add(RocksDbWeight::get().reads(1_u64)) + (15_269_000_u64) .saturating_add(RocksDbWeight::get().writes(1_u64)) } } diff --git a/runtimes/peregrine/src/weights/parachain_staking.rs b/runtimes/peregrine/src/weights/parachain_staking.rs index 8e77248f8..e35aa34a5 100644 --- a/runtimes/peregrine/src/weights/parachain_staking.rs +++ b/runtimes/peregrine/src/weights/parachain_staking.rs @@ -18,203 +18,394 @@ //! Autogenerated weights for parachain_staking //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 3.0.0 -//! DATE: 2021-08-11, STEPS: {{cmd.steps}}\, REPEAT: {{cmd.repeat}}\, LOW RANGE: {{cmd.lowest_range_values}}\, HIGH RANGE: {{cmd.highest_range_values}}\ -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("spiritnet-dev"), DB CACHE: 128 +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2021-09-14, STEPS: {{cmd.steps}}\, REPEAT: {{cmd.repeat}}\, LOW RANGE: {{cmd.lowest_range_values}}\, HIGH RANGE: {{cmd.highest_range_values}}\ +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 128 // Executed Command: -// /home/willi/mashnet-node/target/release/kilt-parachain +// target/release/kilt-parachain // benchmark -// --chain=spiritnet-dev -// --execution=wasm -// --wasm-execution=Compiled -// --heap-pages=4096 -// --extrinsic=* -// --pallet=parachain_staking +// --chain=dev // --steps=50 // --repeat=20 -// --output -// ../../runtimes/peregrine/src/weights/parachain_staking.rs -// --template -// ../../.maintain/runtime-weight-template.hbs +// --pallet=parachain-staking +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --heap-pages=4096 +// --output=./runtimes/peregrine/src/weights/parachain_staking.rs +// --template=.maintain/weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] #![allow(unused_imports)] -use frame_support::{traits::Get, weights::Weight}; +use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; use sp_std::marker::PhantomData; -/// Weights for parachain_staking using the recommended hardware. -pub struct WeightInfo(PhantomData); -impl parachain_staking::WeightInfo for WeightInfo { +/// Weight functions needed for parachain_staking. +pub trait WeightInfo { + fn on_initialize_no_action() -> Weight; + fn on_initialize_round_update() -> Weight; + fn on_initialize_new_year() -> Weight; + fn force_new_round() -> Weight; + fn set_inflation() -> Weight; + fn set_max_selected_candidates(n: u32, m: u32, ) -> Weight; + fn set_blocks_per_round() -> Weight; + fn force_remove_candidate(n: u32, m: u32, ) -> Weight; + fn join_candidates(n: u32, m: u32, ) -> Weight; + fn init_leave_candidates(n: u32, m: u32, ) -> Weight; + fn cancel_leave_candidates(n: u32, m: u32, ) -> Weight; + fn execute_leave_candidates(n: u32, m: u32, u: u32, ) -> Weight; + fn candidate_stake_more(n: u32, m: u32, u: u32, ) -> Weight; + fn candidate_stake_less(n: u32, m: u32, ) -> Weight; + fn join_delegators(n: u32, m: u32, ) -> Weight; + fn delegator_stake_more(n: u32, m: u32, u: u32, ) -> Weight; + fn delegator_stake_less(n: u32, m: u32, ) -> Weight; + fn revoke_delegation(n: u32, m: u32, ) -> Weight; + fn leave_delegators(n: u32, m: u32, ) -> Weight; + fn unlock_unstaked(u: u32, ) -> Weight; + fn set_max_candidate_stake() -> Weight; +} + +/// Weights for parachain_staking using the Substrate node and recommended hardware. +pub struct SubstrateWeight(PhantomData); +impl WeightInfo for SubstrateWeight { fn on_initialize_no_action() -> Weight { - (6_623_000_u64) + (4_449_000_u64) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn on_initialize_round_update() -> Weight { - (25_949_000_u64) + (20_754_000_u64) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } fn on_initialize_new_year() -> Weight { - (50_535_000_u64) + (38_871_000_u64) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } fn force_new_round() -> Weight { - (11_933_000_u64) - .saturating_add(T::DbWeight::get().reads(1_u64)) - .saturating_add(T::DbWeight::get().writes(2_u64)) + (2_691_000_u64) + .saturating_add(T::DbWeight::get().writes(1_u64)) } fn set_inflation() -> Weight { - (23_353_000_u64) + (19_018_000_u64) .saturating_add(T::DbWeight::get().writes(1_u64)) } fn set_max_selected_candidates(n: u32, m: u32, ) -> Weight { (0_u64) - // Standard Error: 70_000 - .saturating_add((24_079_000_u64).saturating_mul(n as Weight)) - // Standard Error: 197_000 - .saturating_add((14_997_000_u64).saturating_mul(m as Weight)) + // Standard Error: 13_000 + .saturating_add((19_072_000_u64).saturating_mul(n as Weight)) + // Standard Error: 39_000 + .saturating_add((16_335_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n as Weight))) - .saturating_add(T::DbWeight::get().writes(4_u64)) + .saturating_add(T::DbWeight::get().writes(2_u64)) } fn set_blocks_per_round() -> Weight { - (30_818_000_u64) + (21_868_000_u64) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } fn force_remove_candidate(n: u32, m: u32, ) -> Weight { - (256_842_000_u64) - // Standard Error: 61_000 - .saturating_add((2_473_000_u64).saturating_mul(n as Weight)) - // Standard Error: 168_000 - .saturating_add((37_184_000_u64).saturating_mul(m as Weight)) - .saturating_add(T::DbWeight::get().reads(24_u64)) + (122_939_000_u64) + // Standard Error: 15_000 + .saturating_add((3_230_000_u64).saturating_mul(n as Weight)) + // Standard Error: 42_000 + .saturating_add((29_927_000_u64).saturating_mul(m as Weight)) + .saturating_add(T::DbWeight::get().reads(25_u64)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(m as Weight))) .saturating_add(T::DbWeight::get().writes(7_u64)) .saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(m as Weight))) } fn join_candidates(n: u32, m: u32, ) -> Weight { - (179_642_000_u64) - // Standard Error: 88_000 - .saturating_add((3_917_000_u64).saturating_mul(n as Weight)) - // Standard Error: 320_000 - .saturating_add((8_823_000_u64).saturating_mul(m as Weight)) - .saturating_add(T::DbWeight::get().reads(17_u64)) + (74_327_000_u64) + // Standard Error: 64_000 + .saturating_add((4_340_000_u64).saturating_mul(n as Weight)) + // Standard Error: 234_000 + .saturating_add((10_455_000_u64).saturating_mul(m as Weight)) + .saturating_add(T::DbWeight::get().reads(18_u64)) .saturating_add(T::DbWeight::get().writes(7_u64)) } fn init_leave_candidates(n: u32, m: u32, ) -> Weight { - (314_776_000_u64) - // Standard Error: 24_000 - .saturating_add((1_456_000_u64).saturating_mul(n as Weight)) - // Standard Error: 65_000 - .saturating_add((5_965_000_u64).saturating_mul(m as Weight)) + (168_105_000_u64) + // Standard Error: 16_000 + .saturating_add((2_537_000_u64).saturating_mul(n as Weight)) + // Standard Error: 45_000 + .saturating_add((8_768_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(21_u64)) - .saturating_add(T::DbWeight::get().writes(4_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) } fn cancel_leave_candidates(n: u32, m: u32, ) -> Weight { - (316_316_000_u64) - // Standard Error: 26_000 - .saturating_add((1_351_000_u64).saturating_mul(n as Weight)) - // Standard Error: 71_000 - .saturating_add((5_840_000_u64).saturating_mul(m as Weight)) + (154_553_000_u64) + // Standard Error: 14_000 + .saturating_add((2_659_000_u64).saturating_mul(n as Weight)) + // Standard Error: 37_000 + .saturating_add((9_020_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(19_u64)) - .saturating_add(T::DbWeight::get().writes(4_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) } fn execute_leave_candidates(n: u32, m: u32, u: u32, ) -> Weight { (0_u64) - // Standard Error: 49_000 - .saturating_add((2_355_000_u64).saturating_mul(n as Weight)) - // Standard Error: 134_000 - .saturating_add((34_131_000_u64).saturating_mul(m as Weight)) - // Standard Error: 589_000 - .saturating_add((467_000_u64).saturating_mul(u as Weight)) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Standard Error: 15_000 + .saturating_add((3_312_000_u64).saturating_mul(n as Weight)) + // Standard Error: 41_000 + .saturating_add((29_436_000_u64).saturating_mul(m as Weight)) + // Standard Error: 181_000 + .saturating_add((1_127_000_u64).saturating_mul(u as Weight)) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(m as Weight))) - .saturating_add(T::DbWeight::get().writes(4_u64)) + .saturating_add(T::DbWeight::get().writes(5_u64)) .saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(m as Weight))) } fn candidate_stake_more(n: u32, m: u32, u: u32, ) -> Weight { - (108_582_000_u64) - // Standard Error: 87_000 - .saturating_add((3_870_000_u64).saturating_mul(n as Weight)) - // Standard Error: 323_000 - .saturating_add((8_787_000_u64).saturating_mul(m as Weight)) - // Standard Error: 1_070_000 - .saturating_add((6_961_000_u64).saturating_mul(u as Weight)) + (0_u64) + // Standard Error: 68_000 + .saturating_add((5_083_000_u64).saturating_mul(n as Weight)) + // Standard Error: 253_000 + .saturating_add((12_844_000_u64).saturating_mul(m as Weight)) + // Standard Error: 841_000 + .saturating_add((6_084_000_u64).saturating_mul(u as Weight)) .saturating_add(T::DbWeight::get().reads(13_u64)) - .saturating_add(T::DbWeight::get().writes(7_u64)) + .saturating_add(T::DbWeight::get().writes(6_u64)) } fn candidate_stake_less(n: u32, m: u32, ) -> Weight { - (125_060_000_u64) - // Standard Error: 91_000 - .saturating_add((3_814_000_u64).saturating_mul(n as Weight)) - // Standard Error: 332_000 - .saturating_add((8_699_000_u64).saturating_mul(m as Weight)) + (0_u64) + // Standard Error: 74_000 + .saturating_add((4_914_000_u64).saturating_mul(n as Weight)) + // Standard Error: 270_000 + .saturating_add((12_551_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(12_u64)) - .saturating_add(T::DbWeight::get().writes(5_u64)) + .saturating_add(T::DbWeight::get().writes(4_u64)) } fn join_delegators(n: u32, m: u32, ) -> Weight { - (181_776_000_u64) - // Standard Error: 91_000 - .saturating_add((4_046_000_u64).saturating_mul(n as Weight)) - // Standard Error: 376_000 - .saturating_add((9_952_000_u64).saturating_mul(m as Weight)) + (24_014_000_u64) + // Standard Error: 74_000 + .saturating_add((5_152_000_u64).saturating_mul(n as Weight)) + // Standard Error: 306_000 + .saturating_add((13_969_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(18_u64)) - .saturating_add(T::DbWeight::get().writes(9_u64)) + .saturating_add(T::DbWeight::get().writes(8_u64)) } fn delegator_stake_more(n: u32, m: u32, u: u32, ) -> Weight { - (90_904_000_u64) - // Standard Error: 82_000 - .saturating_add((3_945_000_u64).saturating_mul(n as Weight)) - // Standard Error: 345_000 - .saturating_add((9_549_000_u64).saturating_mul(m as Weight)) - // Standard Error: 1_182_000 - .saturating_add((7_724_000_u64).saturating_mul(u as Weight)) + (0_u64) + // Standard Error: 70_000 + .saturating_add((5_032_000_u64).saturating_mul(n as Weight)) + // Standard Error: 295_000 + .saturating_add((13_558_000_u64).saturating_mul(m as Weight)) + // Standard Error: 1_011_000 + .saturating_add((7_824_000_u64).saturating_mul(u as Weight)) .saturating_add(T::DbWeight::get().reads(13_u64)) - .saturating_add(T::DbWeight::get().writes(8_u64)) + .saturating_add(T::DbWeight::get().writes(7_u64)) } fn delegator_stake_less(n: u32, m: u32, ) -> Weight { - (132_451_000_u64) - // Standard Error: 87_000 - .saturating_add((3_822_000_u64).saturating_mul(n as Weight)) - // Standard Error: 360_000 - .saturating_add((9_176_000_u64).saturating_mul(m as Weight)) + (16_399_000_u64) + // Standard Error: 75_000 + .saturating_add((4_643_000_u64).saturating_mul(n as Weight)) + // Standard Error: 308_000 + .saturating_add((12_539_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(13_u64)) - .saturating_add(T::DbWeight::get().writes(6_u64)) + .saturating_add(T::DbWeight::get().writes(5_u64)) } fn revoke_delegation(n: u32, m: u32, ) -> Weight { - (140_353_000_u64) - // Standard Error: 87_000 - .saturating_add((3_803_000_u64).saturating_mul(n as Weight)) - // Standard Error: 358_000 - .saturating_add((9_240_000_u64).saturating_mul(m as Weight)) + (29_707_000_u64) + // Standard Error: 74_000 + .saturating_add((4_559_000_u64).saturating_mul(n as Weight)) + // Standard Error: 306_000 + .saturating_add((12_261_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(13_u64)) - .saturating_add(T::DbWeight::get().writes(6_u64)) + .saturating_add(T::DbWeight::get().writes(5_u64)) } fn leave_delegators(n: u32, m: u32, ) -> Weight { - (142_811_000_u64) - // Standard Error: 86_000 - .saturating_add((3_801_000_u64).saturating_mul(n as Weight)) - // Standard Error: 356_000 - .saturating_add((9_142_000_u64).saturating_mul(m as Weight)) + (15_526_000_u64) + // Standard Error: 74_000 + .saturating_add((4_641_000_u64).saturating_mul(n as Weight)) + // Standard Error: 306_000 + .saturating_add((12_525_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(13_u64)) - .saturating_add(T::DbWeight::get().writes(6_u64)) + .saturating_add(T::DbWeight::get().writes(5_u64)) } fn unlock_unstaked(u: u32, ) -> Weight { - (56_092_000_u64) - // Standard Error: 15_000 - .saturating_add((193_000_u64).saturating_mul(u as Weight)) + (46_512_000_u64) + // Standard Error: 14_000 + .saturating_add((378_000_u64).saturating_mul(u as Weight)) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } fn set_max_candidate_stake() -> Weight { - (25_518_000_u64) - .saturating_add(T::DbWeight::get().reads(1_u64)) + (17_074_000_u64) .saturating_add(T::DbWeight::get().writes(1_u64)) } } + +// For backwards compatibility and tests +impl WeightInfo for () { + fn on_initialize_no_action() -> Weight { + (4_449_000_u64) + .saturating_add(RocksDbWeight::get().reads(1_u64)) + } + fn on_initialize_round_update() -> Weight { + (20_754_000_u64) + .saturating_add(RocksDbWeight::get().reads(1_u64)) + .saturating_add(RocksDbWeight::get().writes(1_u64)) + } + fn on_initialize_new_year() -> Weight { + (38_871_000_u64) + .saturating_add(RocksDbWeight::get().reads(3_u64)) + .saturating_add(RocksDbWeight::get().writes(3_u64)) + } + fn force_new_round() -> Weight { + (2_691_000_u64) + .saturating_add(RocksDbWeight::get().writes(1_u64)) + } + fn set_inflation() -> Weight { + (19_018_000_u64) + .saturating_add(RocksDbWeight::get().writes(1_u64)) + } + fn set_max_selected_candidates(n: u32, m: u32, ) -> Weight { + (0_u64) + // Standard Error: 13_000 + .saturating_add((19_072_000_u64).saturating_mul(n as Weight)) + // Standard Error: 39_000 + .saturating_add((16_335_000_u64).saturating_mul(m as Weight)) + .saturating_add(RocksDbWeight::get().reads(3_u64)) + .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n as Weight))) + .saturating_add(RocksDbWeight::get().writes(2_u64)) + } + fn set_blocks_per_round() -> Weight { + (21_868_000_u64) + .saturating_add(RocksDbWeight::get().reads(1_u64)) + .saturating_add(RocksDbWeight::get().writes(1_u64)) + } + fn force_remove_candidate(n: u32, m: u32, ) -> Weight { + (122_939_000_u64) + // Standard Error: 15_000 + .saturating_add((3_230_000_u64).saturating_mul(n as Weight)) + // Standard Error: 42_000 + .saturating_add((29_927_000_u64).saturating_mul(m as Weight)) + .saturating_add(RocksDbWeight::get().reads(25_u64)) + .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(m as Weight))) + .saturating_add(RocksDbWeight::get().writes(7_u64)) + .saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(m as Weight))) + } + fn join_candidates(n: u32, m: u32, ) -> Weight { + (74_327_000_u64) + // Standard Error: 64_000 + .saturating_add((4_340_000_u64).saturating_mul(n as Weight)) + // Standard Error: 234_000 + .saturating_add((10_455_000_u64).saturating_mul(m as Weight)) + .saturating_add(RocksDbWeight::get().reads(18_u64)) + .saturating_add(RocksDbWeight::get().writes(7_u64)) + } + fn init_leave_candidates(n: u32, m: u32, ) -> Weight { + (168_105_000_u64) + // Standard Error: 16_000 + .saturating_add((2_537_000_u64).saturating_mul(n as Weight)) + // Standard Error: 45_000 + .saturating_add((8_768_000_u64).saturating_mul(m as Weight)) + .saturating_add(RocksDbWeight::get().reads(21_u64)) + .saturating_add(RocksDbWeight::get().writes(3_u64)) + } + fn cancel_leave_candidates(n: u32, m: u32, ) -> Weight { + (154_553_000_u64) + // Standard Error: 14_000 + .saturating_add((2_659_000_u64).saturating_mul(n as Weight)) + // Standard Error: 37_000 + .saturating_add((9_020_000_u64).saturating_mul(m as Weight)) + .saturating_add(RocksDbWeight::get().reads(19_u64)) + .saturating_add(RocksDbWeight::get().writes(3_u64)) + } + fn execute_leave_candidates(n: u32, m: u32, u: u32, ) -> Weight { + (0_u64) + // Standard Error: 15_000 + .saturating_add((3_312_000_u64).saturating_mul(n as Weight)) + // Standard Error: 41_000 + .saturating_add((29_436_000_u64).saturating_mul(m as Weight)) + // Standard Error: 181_000 + .saturating_add((1_127_000_u64).saturating_mul(u as Weight)) + .saturating_add(RocksDbWeight::get().reads(7_u64)) + .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(m as Weight))) + .saturating_add(RocksDbWeight::get().writes(5_u64)) + .saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(m as Weight))) + } + fn candidate_stake_more(n: u32, m: u32, u: u32, ) -> Weight { + (0_u64) + // Standard Error: 68_000 + .saturating_add((5_083_000_u64).saturating_mul(n as Weight)) + // Standard Error: 253_000 + .saturating_add((12_844_000_u64).saturating_mul(m as Weight)) + // Standard Error: 841_000 + .saturating_add((6_084_000_u64).saturating_mul(u as Weight)) + .saturating_add(RocksDbWeight::get().reads(13_u64)) + .saturating_add(RocksDbWeight::get().writes(6_u64)) + } + fn candidate_stake_less(n: u32, m: u32, ) -> Weight { + (0_u64) + // Standard Error: 74_000 + .saturating_add((4_914_000_u64).saturating_mul(n as Weight)) + // Standard Error: 270_000 + .saturating_add((12_551_000_u64).saturating_mul(m as Weight)) + .saturating_add(RocksDbWeight::get().reads(12_u64)) + .saturating_add(RocksDbWeight::get().writes(4_u64)) + } + fn join_delegators(n: u32, m: u32, ) -> Weight { + (24_014_000_u64) + // Standard Error: 74_000 + .saturating_add((5_152_000_u64).saturating_mul(n as Weight)) + // Standard Error: 306_000 + .saturating_add((13_969_000_u64).saturating_mul(m as Weight)) + .saturating_add(RocksDbWeight::get().reads(18_u64)) + .saturating_add(RocksDbWeight::get().writes(8_u64)) + } + fn delegator_stake_more(n: u32, m: u32, u: u32, ) -> Weight { + (0_u64) + // Standard Error: 70_000 + .saturating_add((5_032_000_u64).saturating_mul(n as Weight)) + // Standard Error: 295_000 + .saturating_add((13_558_000_u64).saturating_mul(m as Weight)) + // Standard Error: 1_011_000 + .saturating_add((7_824_000_u64).saturating_mul(u as Weight)) + .saturating_add(RocksDbWeight::get().reads(13_u64)) + .saturating_add(RocksDbWeight::get().writes(7_u64)) + } + fn delegator_stake_less(n: u32, m: u32, ) -> Weight { + (16_399_000_u64) + // Standard Error: 75_000 + .saturating_add((4_643_000_u64).saturating_mul(n as Weight)) + // Standard Error: 308_000 + .saturating_add((12_539_000_u64).saturating_mul(m as Weight)) + .saturating_add(RocksDbWeight::get().reads(13_u64)) + .saturating_add(RocksDbWeight::get().writes(5_u64)) + } + fn revoke_delegation(n: u32, m: u32, ) -> Weight { + (29_707_000_u64) + // Standard Error: 74_000 + .saturating_add((4_559_000_u64).saturating_mul(n as Weight)) + // Standard Error: 306_000 + .saturating_add((12_261_000_u64).saturating_mul(m as Weight)) + .saturating_add(RocksDbWeight::get().reads(13_u64)) + .saturating_add(RocksDbWeight::get().writes(5_u64)) + } + fn leave_delegators(n: u32, m: u32, ) -> Weight { + (15_526_000_u64) + // Standard Error: 74_000 + .saturating_add((4_641_000_u64).saturating_mul(n as Weight)) + // Standard Error: 306_000 + .saturating_add((12_525_000_u64).saturating_mul(m as Weight)) + .saturating_add(RocksDbWeight::get().reads(13_u64)) + .saturating_add(RocksDbWeight::get().writes(5_u64)) + } + fn unlock_unstaked(u: u32, ) -> Weight { + (46_512_000_u64) + // Standard Error: 14_000 + .saturating_add((378_000_u64).saturating_mul(u as Weight)) + .saturating_add(RocksDbWeight::get().reads(3_u64)) + .saturating_add(RocksDbWeight::get().writes(3_u64)) + } + fn set_max_candidate_stake() -> Weight { + (17_074_000_u64) + .saturating_add(RocksDbWeight::get().writes(1_u64)) + } +} From 8e27436a08c3df9ce153991267580dec3cb87a1f Mon Sep 17 00:00:00 2001 From: weichweich <14820950+weichweich@users.noreply.github.com> Date: Tue, 14 Sep 2021 13:39:51 +0200 Subject: [PATCH 8/8] fix weights --- .../src/weights/parachain_staking.rs | 199 +---------------- .../src/weights/parachain_staking.rs | 210 +++++++++--------- 2 files changed, 105 insertions(+), 304 deletions(-) diff --git a/runtimes/peregrine/src/weights/parachain_staking.rs b/runtimes/peregrine/src/weights/parachain_staking.rs index e35aa34a5..376602553 100644 --- a/runtimes/peregrine/src/weights/parachain_staking.rs +++ b/runtimes/peregrine/src/weights/parachain_staking.rs @@ -44,34 +44,9 @@ use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; use sp_std::marker::PhantomData; -/// Weight functions needed for parachain_staking. -pub trait WeightInfo { - fn on_initialize_no_action() -> Weight; - fn on_initialize_round_update() -> Weight; - fn on_initialize_new_year() -> Weight; - fn force_new_round() -> Weight; - fn set_inflation() -> Weight; - fn set_max_selected_candidates(n: u32, m: u32, ) -> Weight; - fn set_blocks_per_round() -> Weight; - fn force_remove_candidate(n: u32, m: u32, ) -> Weight; - fn join_candidates(n: u32, m: u32, ) -> Weight; - fn init_leave_candidates(n: u32, m: u32, ) -> Weight; - fn cancel_leave_candidates(n: u32, m: u32, ) -> Weight; - fn execute_leave_candidates(n: u32, m: u32, u: u32, ) -> Weight; - fn candidate_stake_more(n: u32, m: u32, u: u32, ) -> Weight; - fn candidate_stake_less(n: u32, m: u32, ) -> Weight; - fn join_delegators(n: u32, m: u32, ) -> Weight; - fn delegator_stake_more(n: u32, m: u32, u: u32, ) -> Weight; - fn delegator_stake_less(n: u32, m: u32, ) -> Weight; - fn revoke_delegation(n: u32, m: u32, ) -> Weight; - fn leave_delegators(n: u32, m: u32, ) -> Weight; - fn unlock_unstaked(u: u32, ) -> Weight; - fn set_max_candidate_stake() -> Weight; -} - /// Weights for parachain_staking using the Substrate node and recommended hardware. -pub struct SubstrateWeight(PhantomData); -impl WeightInfo for SubstrateWeight { +pub struct WeightInfo(PhantomData); +impl parachain_staking::WeightInfo for WeightInfo { fn on_initialize_no_action() -> Weight { (4_449_000_u64) .saturating_add(T::DbWeight::get().reads(1_u64)) @@ -239,173 +214,3 @@ impl WeightInfo for SubstrateWeight { .saturating_add(T::DbWeight::get().writes(1_u64)) } } - -// For backwards compatibility and tests -impl WeightInfo for () { - fn on_initialize_no_action() -> Weight { - (4_449_000_u64) - .saturating_add(RocksDbWeight::get().reads(1_u64)) - } - fn on_initialize_round_update() -> Weight { - (20_754_000_u64) - .saturating_add(RocksDbWeight::get().reads(1_u64)) - .saturating_add(RocksDbWeight::get().writes(1_u64)) - } - fn on_initialize_new_year() -> Weight { - (38_871_000_u64) - .saturating_add(RocksDbWeight::get().reads(3_u64)) - .saturating_add(RocksDbWeight::get().writes(3_u64)) - } - fn force_new_round() -> Weight { - (2_691_000_u64) - .saturating_add(RocksDbWeight::get().writes(1_u64)) - } - fn set_inflation() -> Weight { - (19_018_000_u64) - .saturating_add(RocksDbWeight::get().writes(1_u64)) - } - fn set_max_selected_candidates(n: u32, m: u32, ) -> Weight { - (0_u64) - // Standard Error: 13_000 - .saturating_add((19_072_000_u64).saturating_mul(n as Weight)) - // Standard Error: 39_000 - .saturating_add((16_335_000_u64).saturating_mul(m as Weight)) - .saturating_add(RocksDbWeight::get().reads(3_u64)) - .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n as Weight))) - .saturating_add(RocksDbWeight::get().writes(2_u64)) - } - fn set_blocks_per_round() -> Weight { - (21_868_000_u64) - .saturating_add(RocksDbWeight::get().reads(1_u64)) - .saturating_add(RocksDbWeight::get().writes(1_u64)) - } - fn force_remove_candidate(n: u32, m: u32, ) -> Weight { - (122_939_000_u64) - // Standard Error: 15_000 - .saturating_add((3_230_000_u64).saturating_mul(n as Weight)) - // Standard Error: 42_000 - .saturating_add((29_927_000_u64).saturating_mul(m as Weight)) - .saturating_add(RocksDbWeight::get().reads(25_u64)) - .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(m as Weight))) - .saturating_add(RocksDbWeight::get().writes(7_u64)) - .saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(m as Weight))) - } - fn join_candidates(n: u32, m: u32, ) -> Weight { - (74_327_000_u64) - // Standard Error: 64_000 - .saturating_add((4_340_000_u64).saturating_mul(n as Weight)) - // Standard Error: 234_000 - .saturating_add((10_455_000_u64).saturating_mul(m as Weight)) - .saturating_add(RocksDbWeight::get().reads(18_u64)) - .saturating_add(RocksDbWeight::get().writes(7_u64)) - } - fn init_leave_candidates(n: u32, m: u32, ) -> Weight { - (168_105_000_u64) - // Standard Error: 16_000 - .saturating_add((2_537_000_u64).saturating_mul(n as Weight)) - // Standard Error: 45_000 - .saturating_add((8_768_000_u64).saturating_mul(m as Weight)) - .saturating_add(RocksDbWeight::get().reads(21_u64)) - .saturating_add(RocksDbWeight::get().writes(3_u64)) - } - fn cancel_leave_candidates(n: u32, m: u32, ) -> Weight { - (154_553_000_u64) - // Standard Error: 14_000 - .saturating_add((2_659_000_u64).saturating_mul(n as Weight)) - // Standard Error: 37_000 - .saturating_add((9_020_000_u64).saturating_mul(m as Weight)) - .saturating_add(RocksDbWeight::get().reads(19_u64)) - .saturating_add(RocksDbWeight::get().writes(3_u64)) - } - fn execute_leave_candidates(n: u32, m: u32, u: u32, ) -> Weight { - (0_u64) - // Standard Error: 15_000 - .saturating_add((3_312_000_u64).saturating_mul(n as Weight)) - // Standard Error: 41_000 - .saturating_add((29_436_000_u64).saturating_mul(m as Weight)) - // Standard Error: 181_000 - .saturating_add((1_127_000_u64).saturating_mul(u as Weight)) - .saturating_add(RocksDbWeight::get().reads(7_u64)) - .saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(m as Weight))) - .saturating_add(RocksDbWeight::get().writes(5_u64)) - .saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(m as Weight))) - } - fn candidate_stake_more(n: u32, m: u32, u: u32, ) -> Weight { - (0_u64) - // Standard Error: 68_000 - .saturating_add((5_083_000_u64).saturating_mul(n as Weight)) - // Standard Error: 253_000 - .saturating_add((12_844_000_u64).saturating_mul(m as Weight)) - // Standard Error: 841_000 - .saturating_add((6_084_000_u64).saturating_mul(u as Weight)) - .saturating_add(RocksDbWeight::get().reads(13_u64)) - .saturating_add(RocksDbWeight::get().writes(6_u64)) - } - fn candidate_stake_less(n: u32, m: u32, ) -> Weight { - (0_u64) - // Standard Error: 74_000 - .saturating_add((4_914_000_u64).saturating_mul(n as Weight)) - // Standard Error: 270_000 - .saturating_add((12_551_000_u64).saturating_mul(m as Weight)) - .saturating_add(RocksDbWeight::get().reads(12_u64)) - .saturating_add(RocksDbWeight::get().writes(4_u64)) - } - fn join_delegators(n: u32, m: u32, ) -> Weight { - (24_014_000_u64) - // Standard Error: 74_000 - .saturating_add((5_152_000_u64).saturating_mul(n as Weight)) - // Standard Error: 306_000 - .saturating_add((13_969_000_u64).saturating_mul(m as Weight)) - .saturating_add(RocksDbWeight::get().reads(18_u64)) - .saturating_add(RocksDbWeight::get().writes(8_u64)) - } - fn delegator_stake_more(n: u32, m: u32, u: u32, ) -> Weight { - (0_u64) - // Standard Error: 70_000 - .saturating_add((5_032_000_u64).saturating_mul(n as Weight)) - // Standard Error: 295_000 - .saturating_add((13_558_000_u64).saturating_mul(m as Weight)) - // Standard Error: 1_011_000 - .saturating_add((7_824_000_u64).saturating_mul(u as Weight)) - .saturating_add(RocksDbWeight::get().reads(13_u64)) - .saturating_add(RocksDbWeight::get().writes(7_u64)) - } - fn delegator_stake_less(n: u32, m: u32, ) -> Weight { - (16_399_000_u64) - // Standard Error: 75_000 - .saturating_add((4_643_000_u64).saturating_mul(n as Weight)) - // Standard Error: 308_000 - .saturating_add((12_539_000_u64).saturating_mul(m as Weight)) - .saturating_add(RocksDbWeight::get().reads(13_u64)) - .saturating_add(RocksDbWeight::get().writes(5_u64)) - } - fn revoke_delegation(n: u32, m: u32, ) -> Weight { - (29_707_000_u64) - // Standard Error: 74_000 - .saturating_add((4_559_000_u64).saturating_mul(n as Weight)) - // Standard Error: 306_000 - .saturating_add((12_261_000_u64).saturating_mul(m as Weight)) - .saturating_add(RocksDbWeight::get().reads(13_u64)) - .saturating_add(RocksDbWeight::get().writes(5_u64)) - } - fn leave_delegators(n: u32, m: u32, ) -> Weight { - (15_526_000_u64) - // Standard Error: 74_000 - .saturating_add((4_641_000_u64).saturating_mul(n as Weight)) - // Standard Error: 306_000 - .saturating_add((12_525_000_u64).saturating_mul(m as Weight)) - .saturating_add(RocksDbWeight::get().reads(13_u64)) - .saturating_add(RocksDbWeight::get().writes(5_u64)) - } - fn unlock_unstaked(u: u32, ) -> Weight { - (46_512_000_u64) - // Standard Error: 14_000 - .saturating_add((378_000_u64).saturating_mul(u as Weight)) - .saturating_add(RocksDbWeight::get().reads(3_u64)) - .saturating_add(RocksDbWeight::get().writes(3_u64)) - } - fn set_max_candidate_stake() -> Weight { - (17_074_000_u64) - .saturating_add(RocksDbWeight::get().writes(1_u64)) - } -} diff --git a/runtimes/spiritnet/src/weights/parachain_staking.rs b/runtimes/spiritnet/src/weights/parachain_staking.rs index a14616471..11de15668 100644 --- a/runtimes/spiritnet/src/weights/parachain_staking.rs +++ b/runtimes/spiritnet/src/weights/parachain_staking.rs @@ -18,25 +18,23 @@ //! Autogenerated weights for parachain_staking //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 3.0.0 -//! DATE: 2021-08-11, STEPS: {{cmd.steps}}\, REPEAT: {{cmd.repeat}}\, LOW RANGE: {{cmd.lowest_range_values}}\, HIGH RANGE: {{cmd.highest_range_values}}\ +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2021-09-13, STEPS: {{cmd.steps}}\, REPEAT: {{cmd.repeat}}\, LOW RANGE: {{cmd.lowest_range_values}}\, HIGH RANGE: {{cmd.highest_range_values}}\ //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("spiritnet-dev"), DB CACHE: 128 // Executed Command: -// /home/willi/mashnet-node/target/release/kilt-parachain +// target/release/kilt-parachain // benchmark // --chain=spiritnet-dev -// --execution=wasm -// --wasm-execution=Compiled -// --heap-pages=4096 -// --extrinsic=* -// --pallet=parachain_staking // --steps=50 // --repeat=20 -// --output -// ../../runtimes/spiritnet/src/weights/parachain_staking.rs -// --template -// ../../.maintain/runtime-weight-template.hbs +// --pallet=parachain-staking +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --heap-pages=4096 +// --output=./pallets/parachain-staking/src/default_weights.rs +// --template=.maintain/weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] @@ -50,171 +48,169 @@ use sp_std::marker::PhantomData; pub struct WeightInfo(PhantomData); impl parachain_staking::WeightInfo for WeightInfo { fn on_initialize_no_action() -> Weight { - (6_623_000_u64) + (4_028_000_u64) .saturating_add(T::DbWeight::get().reads(1_u64)) } fn on_initialize_round_update() -> Weight { - (25_949_000_u64) + (18_570_000_u64) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } fn on_initialize_new_year() -> Weight { - (50_535_000_u64) + (36_187_000_u64) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } fn force_new_round() -> Weight { - (11_933_000_u64) - .saturating_add(T::DbWeight::get().reads(1_u64)) - .saturating_add(T::DbWeight::get().writes(2_u64)) + (2_536_000_u64) + .saturating_add(T::DbWeight::get().writes(1_u64)) } fn set_inflation() -> Weight { - (23_353_000_u64) + (17_041_000_u64) .saturating_add(T::DbWeight::get().writes(1_u64)) } fn set_max_selected_candidates(n: u32, m: u32, ) -> Weight { (0_u64) - // Standard Error: 70_000 - .saturating_add((24_079_000_u64).saturating_mul(n as Weight)) - // Standard Error: 197_000 - .saturating_add((14_997_000_u64).saturating_mul(m as Weight)) + // Standard Error: 16_000 + .saturating_add((17_808_000_u64).saturating_mul(n as Weight)) + // Standard Error: 45_000 + .saturating_add((15_031_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n as Weight))) - .saturating_add(T::DbWeight::get().writes(4_u64)) + .saturating_add(T::DbWeight::get().writes(2_u64)) } fn set_blocks_per_round() -> Weight { - (30_818_000_u64) + (19_263_000_u64) .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } fn force_remove_candidate(n: u32, m: u32, ) -> Weight { - (256_842_000_u64) - // Standard Error: 61_000 - .saturating_add((2_473_000_u64).saturating_mul(n as Weight)) - // Standard Error: 168_000 - .saturating_add((37_184_000_u64).saturating_mul(m as Weight)) - .saturating_add(T::DbWeight::get().reads(24_u64)) + (112_307_000_u64) + // Standard Error: 18_000 + .saturating_add((3_134_000_u64).saturating_mul(n as Weight)) + // Standard Error: 51_000 + .saturating_add((28_144_000_u64).saturating_mul(m as Weight)) + .saturating_add(T::DbWeight::get().reads(25_u64)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(m as Weight))) .saturating_add(T::DbWeight::get().writes(7_u64)) .saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(m as Weight))) } fn join_candidates(n: u32, m: u32, ) -> Weight { - (179_642_000_u64) - // Standard Error: 88_000 - .saturating_add((3_917_000_u64).saturating_mul(n as Weight)) - // Standard Error: 320_000 - .saturating_add((8_823_000_u64).saturating_mul(m as Weight)) - .saturating_add(T::DbWeight::get().reads(17_u64)) + (69_130_000_u64) + // Standard Error: 60_000 + .saturating_add((4_137_000_u64).saturating_mul(n as Weight)) + // Standard Error: 219_000 + .saturating_add((9_836_000_u64).saturating_mul(m as Weight)) + .saturating_add(T::DbWeight::get().reads(18_u64)) .saturating_add(T::DbWeight::get().writes(7_u64)) } fn init_leave_candidates(n: u32, m: u32, ) -> Weight { - (314_776_000_u64) - // Standard Error: 24_000 - .saturating_add((1_456_000_u64).saturating_mul(n as Weight)) - // Standard Error: 65_000 - .saturating_add((5_965_000_u64).saturating_mul(m as Weight)) + (149_433_000_u64) + // Standard Error: 18_000 + .saturating_add((2_552_000_u64).saturating_mul(n as Weight)) + // Standard Error: 48_000 + .saturating_add((8_307_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(21_u64)) - .saturating_add(T::DbWeight::get().writes(4_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) } fn cancel_leave_candidates(n: u32, m: u32, ) -> Weight { - (316_316_000_u64) - // Standard Error: 26_000 - .saturating_add((1_351_000_u64).saturating_mul(n as Weight)) - // Standard Error: 71_000 - .saturating_add((5_840_000_u64).saturating_mul(m as Weight)) + (147_226_000_u64) + // Standard Error: 15_000 + .saturating_add((2_519_000_u64).saturating_mul(n as Weight)) + // Standard Error: 41_000 + .saturating_add((8_477_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(19_u64)) - .saturating_add(T::DbWeight::get().writes(4_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) } fn execute_leave_candidates(n: u32, m: u32, u: u32, ) -> Weight { (0_u64) - // Standard Error: 49_000 - .saturating_add((2_355_000_u64).saturating_mul(n as Weight)) - // Standard Error: 134_000 - .saturating_add((34_131_000_u64).saturating_mul(m as Weight)) - // Standard Error: 589_000 - .saturating_add((467_000_u64).saturating_mul(u as Weight)) - .saturating_add(T::DbWeight::get().reads(6_u64)) + // Standard Error: 16_000 + .saturating_add((3_248_000_u64).saturating_mul(n as Weight)) + // Standard Error: 43_000 + .saturating_add((28_209_000_u64).saturating_mul(m as Weight)) + // Standard Error: 190_000 + .saturating_add((808_000_u64).saturating_mul(u as Weight)) + .saturating_add(T::DbWeight::get().reads(7_u64)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(m as Weight))) - .saturating_add(T::DbWeight::get().writes(4_u64)) + .saturating_add(T::DbWeight::get().writes(5_u64)) .saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(m as Weight))) } fn candidate_stake_more(n: u32, m: u32, u: u32, ) -> Weight { - (108_582_000_u64) - // Standard Error: 87_000 - .saturating_add((3_870_000_u64).saturating_mul(n as Weight)) - // Standard Error: 323_000 - .saturating_add((8_787_000_u64).saturating_mul(m as Weight)) - // Standard Error: 1_070_000 - .saturating_add((6_961_000_u64).saturating_mul(u as Weight)) + (0_u64) + // Standard Error: 65_000 + .saturating_add((4_760_000_u64).saturating_mul(n as Weight)) + // Standard Error: 240_000 + .saturating_add((12_067_000_u64).saturating_mul(m as Weight)) + // Standard Error: 797_000 + .saturating_add((6_453_000_u64).saturating_mul(u as Weight)) .saturating_add(T::DbWeight::get().reads(13_u64)) - .saturating_add(T::DbWeight::get().writes(7_u64)) + .saturating_add(T::DbWeight::get().writes(6_u64)) } fn candidate_stake_less(n: u32, m: u32, ) -> Weight { - (125_060_000_u64) - // Standard Error: 91_000 - .saturating_add((3_814_000_u64).saturating_mul(n as Weight)) - // Standard Error: 332_000 - .saturating_add((8_699_000_u64).saturating_mul(m as Weight)) + (0_u64) + // Standard Error: 68_000 + .saturating_add((4_592_000_u64).saturating_mul(n as Weight)) + // Standard Error: 249_000 + .saturating_add((11_635_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(12_u64)) - .saturating_add(T::DbWeight::get().writes(5_u64)) + .saturating_add(T::DbWeight::get().writes(4_u64)) } fn join_delegators(n: u32, m: u32, ) -> Weight { - (181_776_000_u64) - // Standard Error: 91_000 - .saturating_add((4_046_000_u64).saturating_mul(n as Weight)) - // Standard Error: 376_000 - .saturating_add((9_952_000_u64).saturating_mul(m as Weight)) + (14_302_000_u64) + // Standard Error: 70_000 + .saturating_add((4_857_000_u64).saturating_mul(n as Weight)) + // Standard Error: 288_000 + .saturating_add((13_395_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(18_u64)) - .saturating_add(T::DbWeight::get().writes(9_u64)) + .saturating_add(T::DbWeight::get().writes(8_u64)) } fn delegator_stake_more(n: u32, m: u32, u: u32, ) -> Weight { - (90_904_000_u64) - // Standard Error: 82_000 - .saturating_add((3_945_000_u64).saturating_mul(n as Weight)) - // Standard Error: 345_000 - .saturating_add((9_549_000_u64).saturating_mul(m as Weight)) - // Standard Error: 1_182_000 - .saturating_add((7_724_000_u64).saturating_mul(u as Weight)) + (0_u64) + // Standard Error: 67_000 + .saturating_add((4_734_000_u64).saturating_mul(n as Weight)) + // Standard Error: 280_000 + .saturating_add((12_743_000_u64).saturating_mul(m as Weight)) + // Standard Error: 959_000 + .saturating_add((7_291_000_u64).saturating_mul(u as Weight)) .saturating_add(T::DbWeight::get().reads(13_u64)) - .saturating_add(T::DbWeight::get().writes(8_u64)) + .saturating_add(T::DbWeight::get().writes(7_u64)) } fn delegator_stake_less(n: u32, m: u32, ) -> Weight { - (132_451_000_u64) - // Standard Error: 87_000 - .saturating_add((3_822_000_u64).saturating_mul(n as Weight)) - // Standard Error: 360_000 - .saturating_add((9_176_000_u64).saturating_mul(m as Weight)) + (13_040_000_u64) + // Standard Error: 71_000 + .saturating_add((4_393_000_u64).saturating_mul(n as Weight)) + // Standard Error: 294_000 + .saturating_add((11_853_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(13_u64)) - .saturating_add(T::DbWeight::get().writes(6_u64)) + .saturating_add(T::DbWeight::get().writes(5_u64)) } fn revoke_delegation(n: u32, m: u32, ) -> Weight { - (140_353_000_u64) - // Standard Error: 87_000 - .saturating_add((3_803_000_u64).saturating_mul(n as Weight)) - // Standard Error: 358_000 - .saturating_add((9_240_000_u64).saturating_mul(m as Weight)) + (18_647_000_u64) + // Standard Error: 69_000 + .saturating_add((4_412_000_u64).saturating_mul(n as Weight)) + // Standard Error: 286_000 + .saturating_add((11_593_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(13_u64)) - .saturating_add(T::DbWeight::get().writes(6_u64)) + .saturating_add(T::DbWeight::get().writes(5_u64)) } fn leave_delegators(n: u32, m: u32, ) -> Weight { - (142_811_000_u64) - // Standard Error: 86_000 - .saturating_add((3_801_000_u64).saturating_mul(n as Weight)) - // Standard Error: 356_000 - .saturating_add((9_142_000_u64).saturating_mul(m as Weight)) + (27_394_000_u64) + // Standard Error: 68_000 + .saturating_add((4_286_000_u64).saturating_mul(n as Weight)) + // Standard Error: 280_000 + .saturating_add((11_435_000_u64).saturating_mul(m as Weight)) .saturating_add(T::DbWeight::get().reads(13_u64)) - .saturating_add(T::DbWeight::get().writes(6_u64)) + .saturating_add(T::DbWeight::get().writes(5_u64)) } fn unlock_unstaked(u: u32, ) -> Weight { - (56_092_000_u64) + (44_409_000_u64) // Standard Error: 15_000 - .saturating_add((193_000_u64).saturating_mul(u as Weight)) + .saturating_add((364_000_u64).saturating_mul(u as Weight)) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } fn set_max_candidate_stake() -> Weight { - (25_518_000_u64) - .saturating_add(T::DbWeight::get().reads(1_u64)) + (15_269_000_u64) .saturating_add(T::DbWeight::get().writes(1_u64)) } }