lots of changes again...

bin/node/runtime/src/lib.rs

@@ -595,7 +595,10 @@ impl pallet_fast_unstake::Config for Runtime {
 	type Deposit = ConstU128<{ DOLLARS }>;
 	type Currency = Balances;
 	type Staking = Staking;
+	type MaxErasToCheckPerBlock = ConstU32<4>;
 	type WeightInfo = ();
+	#[cfg(feature = "runtime-benchmarks")]
+	type MaxBackersPerValidator = MaxNominatorRewardedPerValidator;
 }
 
 parameter_types! {

frame/fast-unstake/src/benchmarking.rs

@@ -31,9 +31,6 @@ use sp_staking::{EraIndex, StakingInterface};
 use sp_std::prelude::*;
 
 const USER_SEED: u32 = 0;
-const DEFAULT_BACKER_PER_VALIDATOR: u32 = 32;
-const MAX_VALIDATORS: u32 = 16;
-const MAX_BONDING_DURATION: u32 = 16;
 
 type CurrencyOf<T> = <T as Config>::Currency;
 
@@ -77,7 +74,7 @@ fn setup_staking<T: Config>(v: u32, until: EraIndex) {
 		.collect::<Vec<_>>();
 
 	for era in 0..=until {
-		let others = (0..DEFAULT_BACKER_PER_VALIDATOR)
+		let others = (0..T::MaxBackersPerValidator::get())
 			.map(|s| {
 				let who = frame_benchmarking::account::<T::AccountId>("nominator", era, s);
 				let value = ed;
@@ -132,15 +129,14 @@ benchmarks! {
 
 	// on_idle, when we check some number of eras and when we need to build the queue.
 	on_idle_check {
-		let x in (MAX_BONDING_DURATION * 1) .. (MAX_BONDING_DURATION * MAX_VALIDATORS);
+		let v in 1 .. 1000;
 		let b in 1 .. T::BatchSize::get();
 
 		// both of these can be fetched from `T::Staking`, but the values might be unnecessarily
-		// large and make the benchmarks too slow. We know the complexity is linear, a small range
-		// should be enough. Also, we use the multiplied version because this helps the benchmarking
-		// tool establish the fact that we have a total of `uv` reads in total.
-		let u = (x / MAX_BONDING_DURATION).min(T::Staking::bonding_duration());
-		let v = x / u;
+		// large and make the benchmarks too slow. Also, we use the multiplied version because this
+		// helps the benchmarking tool establish the fact that we have a total of `uv` reads in
+		// total. Although, this means that for a lot of the other aspects, we are assuming
+		let u = T::MaxErasToCheckPerBlock::get().min(T::Staking::bonding_duration());
 
 		ErasToCheckPerBlock::<T>::put(u);
 		T::Staking::set_current_era(u);
@@ -205,7 +201,7 @@ benchmarks! {
 	control {
 		let origin = <T as Config>::ControlOrigin::successful_origin();
 	}
-	: _<T::RuntimeOrigin>(origin, 128)
+	: _<T::RuntimeOrigin>(origin, T::MaxErasToCheckPerBlock::get())
 	verify {}
 
 	impl_benchmark_test_suite!(Pallet, crate::mock::ExtBuilder::default().build(), crate::mock::Runtime)

frame/fast-unstake/src/lib.rs

@@ -86,10 +86,7 @@ pub mod pallet {
 		traits::{Defensive, ReservableCurrency, StorageVersion},
 	};
 	use frame_system::pallet_prelude::*;
-	use sp_runtime::{
-		traits::{Saturating, Zero},
-		DispatchResult,
-	};
+	use sp_runtime::{traits::Zero, DispatchResult};
 	use sp_staking::{EraIndex, StakingInterface};
 	use sp_std::{collections::btree_set::BTreeSet, prelude::*, vec::Vec};
 	pub use weights::WeightInfo;
@@ -138,6 +135,14 @@ pub mod pallet {
 
 		/// The weight information of this pallet.
 		type WeightInfo: WeightInfo;
+
+		/// Maximum value for `ErasToCheckPerBlock`. This should be as close as possible, but more
+		/// than the actual value, in order to have accurate benchmarks.
+		type MaxErasToCheckPerBlock: Get<u32>;
+
+		/// Use only for benchmarking.
+		#[cfg(feature = "runtime-benchmarks")]
+		type MaxBackersPerValidator: Get<u32>;
 	}
 
 	/// The current "head of the queue" being unstaked.
@@ -288,9 +293,10 @@ pub mod pallet {
 		/// Dispatch origin must be signed by the [`Config::ControlOrigin`].
 		#[pallet::call_index(2)]
 		#[pallet::weight(<T as Config>::WeightInfo::control())]
-		pub fn control(origin: OriginFor<T>, unchecked_eras_to_check: EraIndex) -> DispatchResult {
+		pub fn control(origin: OriginFor<T>, eras_to_check: EraIndex) -> DispatchResult {
 			let _ = T::ControlOrigin::ensure_origin(origin)?;
-			ErasToCheckPerBlock::<T>::put(unchecked_eras_to_check);
+			ensure!(eras_to_check <= T::MaxErasToCheckPerBlock::get(), Error::<T>::CallNotAllowed);
+			ErasToCheckPerBlock::<T>::put(eras_to_check);
 			Ok(())
 		}
 	}
@@ -327,35 +333,35 @@ pub mod pallet {
 			// any weight that is unaccounted for
 			let mut unaccounted_weight = Weight::from_ref_time(0);
 
-			let mut eras_to_check_per_block = ErasToCheckPerBlock::<T>::get();
+			let eras_to_check_per_block = ErasToCheckPerBlock::<T>::get();
 			if eras_to_check_per_block.is_zero() {
 				return T::DbWeight::get().reads(1).saturating_add(unaccounted_weight)
 			}
 
 			// NOTE: here we're assuming that the number of validators has only ever increased,
 			// meaning that the number of exposures to check is either this per era, or less.
 			let validator_count = T::Staking::desired_validator_count();
-			let next_batch_size = Head::<T>::get()
-				.map_or(Queue::<T>::count().min(T::BatchSize::get()), |head| {
-					head.stashes.len() as u32
+			let (next_batch_size, reads_from_queue) = Head::<T>::get()
+				.map_or((Queue::<T>::count().min(T::BatchSize::get()), true), |head| {
+					(head.stashes.len() as u32, false)
 				});
 
 			// determine the number of eras to check. This is based on both `ErasToCheckPerBlock`
 			// and `remaining_weight` passed on to us from the runtime executive.
-			let max_weight = |v, u: u32, b| {
+			let max_weight = |v, b| {
 				// NOTE: this potentially under-counts by up to `BatchSize` reads from the queue.
-				<T as Config>::WeightInfo::on_idle_check(u.saturating_mul(v), b)
+				<T as Config>::WeightInfo::on_idle_check(v, b)
 					.max(<T as Config>::WeightInfo::on_idle_unstake(b))
-					.saturating_add(T::DbWeight::get().reads(T::BatchSize::get() as u64))
+					.saturating_add(if reads_from_queue {
+						T::DbWeight::get().reads(next_batch_size.into())
+					} else {
+						Zero::zero()
+					})
 			};
-			while max_weight(validator_count, eras_to_check_per_block, next_batch_size)
-				.any_gt(remaining_weight)
-			{
-				eras_to_check_per_block.saturating_dec();
-				if eras_to_check_per_block.is_zero() {
-					log!(debug, "early exit because eras_to_check_per_block is zero");
-					return T::DbWeight::get().reads(3).saturating_add(unaccounted_weight)
-				}
+
+			if max_weight(validator_count, next_batch_size).any_gt(remaining_weight) {
+				log!(debug, "early exit because eras_to_check_per_block is zero");
+				return T::DbWeight::get().reads(3).saturating_add(unaccounted_weight)
 			}
 
 			if T::Staking::election_ongoing() {
@@ -507,11 +513,8 @@ pub mod pallet {
 					},
 				}
 
-				<T as Config>::WeightInfo::on_idle_check(
-					(eras_checked.len() as u32).saturating_mul(validator_count),
-					pre_length as u32,
-				)
-				.saturating_add(unaccounted_weight)
+				<T as Config>::WeightInfo::on_idle_check(validator_count, pre_length as u32)
+					.saturating_add(unaccounted_weight)
 			}
 		}
 	}

frame/fast-unstake/src/mock.rs

@@ -185,6 +185,9 @@ impl fast_unstake::Config for Runtime {
 	type ControlOrigin = frame_system::EnsureRoot<Self::AccountId>;
 	type BatchSize = BatchSize;
 	type WeightInfo = ();
+	type MaxErasToCheckPerBlock = ConstU32<16>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type MaxBackersPerValidator = ConstU32<128>;
 }
 
 type Block = frame_system::mocking::MockBlock<Runtime>;

frame/fast-unstake/src/tests.rs

@@ -18,7 +18,7 @@
 //! Tests for pallet-fast-unstake.
 
 use super::*;
-use crate::{mock::*, types::*, Event};
+use crate::{mock::*, types::*,  Event};
 use frame_support::{assert_noop, assert_ok, bounded_vec, pallet_prelude::*, traits::Currency};
 use pallet_staking::{CurrentEra, RewardDestination};
 
@@ -1216,23 +1216,16 @@ mod batched {
 #[test]
 fn kusama_estimate() {
 	use crate::WeightInfo;
-	let block_time = frame_support::weights::Weight::from_ref_time(
-		frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND * 2,
-	)
-	.ref_time() as f32;
-	let on_idle =
-		crate::weights::SubstrateWeight::<T>::on_idle_check(1 * 1000, 64).ref_time() as f32;
+	let block_time = frame_support::weights::Weight::from_ref_time(frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND * 2).ref_time() as f32;
+	let on_idle = crate::weights::SubstrateWeight::<T>::on_idle_check(1000, 64).ref_time() as f32;
 	dbg!(block_time, on_idle, on_idle / block_time);
 }
 
+
 #[test]
 fn polkadot_estimate() {
 	use crate::WeightInfo;
-	let block_time = frame_support::weights::Weight::from_ref_time(
-		frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND * 2,
-	)
-	.ref_time() as f32;
-	let on_idle =
-		crate::weights::SubstrateWeight::<T>::on_idle_check(1 * 300, 64).ref_time() as f32;
+	let block_time = frame_support::weights::Weight::from_ref_time(frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND * 2).ref_time() as f32;
+	let on_idle = crate::weights::SubstrateWeight::<T>::on_idle_check(300, 64).ref_time() as f32;
 	dbg!(block_time, on_idle, on_idle / block_time);
 }

frame/fast-unstake/src/weights.rs

@@ -18,21 +18,20 @@
 //! Autogenerated weights for pallet_fast_unstake
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-01-13, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]`
-//! HOSTNAME: `bm3`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz`
+//! DATE: 2023-01-14, STEPS: `10`, REPEAT: 5, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! HOSTNAME: `Kians-MacBook-Pro-2.local`, CPU: `<UNKNOWN>`
 //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
 
 // Executed Command:
-// /home/benchbot/cargo_target_dir/production/substrate
+// target/debug/substrate
 // benchmark
 // pallet
-// --steps=50
-// --repeat=20
+// --steps=10
+// --repeat=5
 // --extrinsic=*
 // --execution=wasm
 // --wasm-execution=compiled
 // --heap-pages=4096
-// --json-file=/var/lib/gitlab-runner/builds/zyw4fam_/0/parity/mirrors/substrate/.git/.artifacts/bench.json
 // --pallet=pallet_fast_unstake
 // --chain=dev
 // --header=./HEADER-APACHE2
@@ -49,7 +48,7 @@ use sp_std::marker::PhantomData;
 /// Weight functions needed for pallet_fast_unstake.
 pub trait WeightInfo {
 	fn on_idle_unstake(b: u32, ) -> Weight;
-	fn on_idle_check(x: u32, b: u32, ) -> Weight;
+	fn on_idle_check(v: u32, b: u32, ) -> Weight;
 	fn register_fast_unstake() -> Weight;
 	fn deregister() -> Weight;
 	fn control() -> Weight;
@@ -74,10 +73,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Staking Payee (r:0 w:1)
 	/// The range of component `b` is `[1, 32]`.
 	fn on_idle_unstake(b: u32, ) -> Weight {
-		// Minimum execution time: 104_891 nanoseconds.
-		Weight::from_ref_time(81_179_276)
-			// Standard Error: 69_111
-			.saturating_add(Weight::from_ref_time(37_598_449).saturating_mul(b.into()))
+		// Minimum execution time: 1_337_000 nanoseconds.
+		Weight::from_ref_time(746_206_289)
+			// Standard Error: 2_119_343
+			.saturating_add(Weight::from_ref_time(713_517_207).saturating_mul(b.into()))
 			.saturating_add(T::DbWeight::get().reads(6))
 			.saturating_add(T::DbWeight::get().reads((6_u64).saturating_mul(b.into())))
 			.saturating_add(T::DbWeight::get().writes(1))
@@ -90,16 +89,16 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:0)
 	// Storage: Staking CurrentEra (r:1 w:0)
 	// Storage: Staking ErasStakers (r:17 w:0)
-	/// The range of component `x` is `[16, 256]`.
+	/// The range of component `x` is `[16, 1024]`.
 	/// The range of component `b` is `[1, 32]`.
 	fn on_idle_check(x: u32, b: u32, ) -> Weight {
-		// Minimum execution time: 2_366_234 nanoseconds.
-		Weight::from_ref_time(2_389_275_000)
-			// Standard Error: 2_667_329
-			.saturating_add(Weight::from_ref_time(77_884_068).saturating_mul(x.into()))
-			// Standard Error: 21_532_980
-			.saturating_add(Weight::from_ref_time(638_582_459).saturating_mul(b.into()))
-			.saturating_add(T::DbWeight::get().reads(8))
+		// Minimum execution time: 48_524_000 nanoseconds.
+		Weight::from_ref_time(48_619_000_000)
+			// Standard Error: 167_085_763
+			.saturating_add(Weight::from_ref_time(1_211_164_800).saturating_mul(x.into()))
+			// Standard Error: 5_360_315_553
+			.saturating_add(Weight::from_ref_time(37_490_662_723).saturating_mul(b.into()))
+			.saturating_add(T::DbWeight::get().reads(6))
 			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(x.into())))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
@@ -118,8 +117,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: Balances Locks (r:1 w:1)
 	// Storage: FastUnstake CounterForQueue (r:1 w:1)
 	fn register_fast_unstake() -> Weight {
-		// Minimum execution time: 146_745 nanoseconds.
-		Weight::from_ref_time(148_464_000)
+		// Minimum execution time: 2_035_000 nanoseconds.
+		Weight::from_ref_time(2_144_000_000)
 			.saturating_add(T::DbWeight::get().reads(15))
 			.saturating_add(T::DbWeight::get().writes(10))
 	}
@@ -129,15 +128,15 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 	// Storage: FastUnstake Head (r:1 w:0)
 	// Storage: FastUnstake CounterForQueue (r:1 w:1)
 	fn deregister() -> Weight {
-		// Minimum execution time: 67_591 nanoseconds.
-		Weight::from_ref_time(68_455_000)
+		// Minimum execution time: 707_000 nanoseconds.
+		Weight::from_ref_time(714_000_000)
 			.saturating_add(T::DbWeight::get().reads(5))
 			.saturating_add(T::DbWeight::get().writes(2))
 	}
 	// Storage: FastUnstake ErasToCheckPerBlock (r:0 w:1)
 	fn control() -> Weight {
-		// Minimum execution time: 4_553 nanoseconds.
-		Weight::from_ref_time(4_813_000)
+		// Minimum execution time: 63_000 nanoseconds.
+		Weight::from_ref_time(64_000_000)
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
 }
@@ -160,10 +159,10 @@ impl WeightInfo for () {
 	// Storage: Staking Payee (r:0 w:1)
 	/// The range of component `b` is `[1, 32]`.
 	fn on_idle_unstake(b: u32, ) -> Weight {
-		// Minimum execution time: 104_891 nanoseconds.
-		Weight::from_ref_time(81_179_276)
-			// Standard Error: 69_111
-			.saturating_add(Weight::from_ref_time(37_598_449).saturating_mul(b.into()))
+		// Minimum execution time: 1_337_000 nanoseconds.
+		Weight::from_ref_time(746_206_289)
+			// Standard Error: 2_119_343
+			.saturating_add(Weight::from_ref_time(713_517_207).saturating_mul(b.into()))
 			.saturating_add(RocksDbWeight::get().reads(6))
 			.saturating_add(RocksDbWeight::get().reads((6_u64).saturating_mul(b.into())))
 			.saturating_add(RocksDbWeight::get().writes(1))
@@ -176,16 +175,16 @@ impl WeightInfo for () {
 	// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:0)
 	// Storage: Staking CurrentEra (r:1 w:0)
 	// Storage: Staking ErasStakers (r:17 w:0)
-	/// The range of component `x` is `[16, 256]`.
+	/// The range of component `x` is `[16, 1024]`.
 	/// The range of component `b` is `[1, 32]`.
 	fn on_idle_check(x: u32, b: u32, ) -> Weight {
-		// Minimum execution time: 2_366_234 nanoseconds.
-		Weight::from_ref_time(2_389_275_000)
-			// Standard Error: 2_667_329
-			.saturating_add(Weight::from_ref_time(77_884_068).saturating_mul(x.into()))
-			// Standard Error: 21_532_980
-			.saturating_add(Weight::from_ref_time(638_582_459).saturating_mul(b.into()))
-			.saturating_add(RocksDbWeight::get().reads(8))
+		// Minimum execution time: 48_524_000 nanoseconds.
+		Weight::from_ref_time(48_619_000_000)
+			// Standard Error: 167_085_763
+			.saturating_add(Weight::from_ref_time(1_211_164_800).saturating_mul(x.into()))
+			// Standard Error: 5_360_315_553
+			.saturating_add(Weight::from_ref_time(37_490_662_723).saturating_mul(b.into()))
+			.saturating_add(RocksDbWeight::get().reads(6))
 			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(x.into())))
 			.saturating_add(RocksDbWeight::get().writes(1))
 	}
@@ -204,8 +203,8 @@ impl WeightInfo for () {
 	// Storage: Balances Locks (r:1 w:1)
 	// Storage: FastUnstake CounterForQueue (r:1 w:1)
 	fn register_fast_unstake() -> Weight {
-		// Minimum execution time: 146_745 nanoseconds.
-		Weight::from_ref_time(148_464_000)
+		// Minimum execution time: 2_035_000 nanoseconds.
+		Weight::from_ref_time(2_144_000_000)
 			.saturating_add(RocksDbWeight::get().reads(15))
 			.saturating_add(RocksDbWeight::get().writes(10))
 	}
@@ -215,15 +214,15 @@ impl WeightInfo for () {
 	// Storage: FastUnstake Head (r:1 w:0)
 	// Storage: FastUnstake CounterForQueue (r:1 w:1)
 	fn deregister() -> Weight {
-		// Minimum execution time: 67_591 nanoseconds.
-		Weight::from_ref_time(68_455_000)
+		// Minimum execution time: 707_000 nanoseconds.
+		Weight::from_ref_time(714_000_000)
 			.saturating_add(RocksDbWeight::get().reads(5))
 			.saturating_add(RocksDbWeight::get().writes(2))
 	}
 	// Storage: FastUnstake ErasToCheckPerBlock (r:0 w:1)
 	fn control() -> Weight {
-		// Minimum execution time: 4_553 nanoseconds.
-		Weight::from_ref_time(4_813_000)
+		// Minimum execution time: 63_000 nanoseconds.
+		Weight::from_ref_time(64_000_000)
 			.saturating_add(RocksDbWeight::get().writes(1))
 	}
 }