Benchmarking for Offchain Phragmén.

frame/staking/Cargo.toml

@@ -45,13 +45,17 @@ env_logger = "0.7.1"
 hex = "0.4"
 
 [features]
+<<<<<<< HEAD
+default = ["std", "runtime-benchmarks"]
+=======
 testing-utils = [
 	"std",
 	"pallet-indices/std",
 	"sp-core/std",
 	"rand/std",
 ]
 default = ["std"]
+>>>>>>> f7bd10a548201cb68491f72be73115279d97f160
 std = [
 	"serde",
 	"codec/std",
@@ -68,6 +72,13 @@ std = [
 	"sp-core/std",
 ]
 runtime-benchmarks = [
+	"testing-utils",
 	"rand_chacha",
 	"frame-benchmarking",
 ]
+testing-utils = [
+	"std",
+	"pallet-indices/std",
+	"sp-core/std",
+	"rand/std",
+]

frame/staking/src/benchmarking.rs

@@ -28,8 +28,100 @@ use frame_benchmarking::{benchmarks, account};
 
 use crate::Module as Staking;
 use frame_system::Module as System;
+use frame_support::assert_ok;
 
 const SEED: u32 = 0;
+const USER: u32 = 10;
+
+#[repr(u32)]
+#[allow(dead_code)]
+#[derive(Debug, Clone, Copy)]
+pub enum OffchainBenchmarkingMode {
+	/// Initial submission. This will be rather cheap
+	InitialSubmission,
+	/// A better submission that will replace the previous ones. This is the most expensive.
+	StrongerSubmission,
+	/// A weak submission that will be rejected. This will be rather cheap.
+	WeakerSubmission,
+}
+
+fn setup_submit_election_solution<T: Trait>(
+	mode: OffchainBenchmarkingMode,
+	num_nominators: u32,
+	num_validators: u32,
+	edge_per_voter: u32,
+	to_elect: u32,
+	do_reduce: bool,
+) -> Result<(Call<T>, RawOrigin<T::AccountId>), &'static str> {
+	sp_std::if_std! {
+		println!("++ instance with params {} / {} / {} / {:?} / {}",
+			num_nominators,
+			num_validators,
+			edge_per_voter,
+			mode,
+			to_elect,
+		);
+	}
+
+	if num_validators < to_elect {
+		return Err("invalid setup. too few candidates");
+	}
+
+	// stake and nominate everyone
+	create_validators_with_nominators_for_era::<T>(num_validators, num_nominators)?;
+
+	// create snapshot
+	<Module<T>>::create_stakers_snapshot();
+
+	let era = <Module<T>>::active_era().unwrap().index;
+	let origin = RawOrigin::Signed(create_funded_user::<T>("Alan Turing", 999));
+
+	// call data
+	let (winners, compact, score) = match mode {
+		OffchainBenchmarkingMode::InitialSubmission => {
+			// No need to setup anything
+			testing_utils::get_seq_phragmen_solution::<T>(do_reduce)
+		},
+		OffchainBenchmarkingMode::StrongerSubmission => {
+			let (winners, compact, score) = testing_utils::get_weak_solution::<T>(false);
+			assert_ok!(
+				<Module<T>>::submit_election_solution(
+					origin.clone().into(),
+					winners,
+					compact,
+					score,
+					era,
+				)
+			);
+			testing_utils::get_seq_phragmen_solution::<T>(do_reduce)
+		},
+		OffchainBenchmarkingMode::WeakerSubmission => {
+			let (winners, compact, score) = testing_utils::get_seq_phragmen_solution::<T>(do_reduce);
+			assert_ok!(
+				<Module<T>>::submit_election_solution(
+					origin.clone().into(),
+					winners,
+					compact,
+					score,
+					era,
+				)
+			);
+			testing_utils::get_weak_solution::<T>(false)
+		}
+	};
+
+	// must have chosen correct number of winners.
+	assert_eq!(winners.len() as u32, <Module<T>>::validator_count());
+
+	let call = crate::Call::<T>::submit_election_solution(
+		winners,
+		compact,
+		score,
+		era,
+	);
+
+	Ok((call, origin))
+}
 
 fn create_funded_user<T: Trait>(string: &'static str, n: u32) -> T::AccountId {
 	let user = account(string, n, SEED);

frame/staking/src/lib.rs

@@ -254,6 +254,10 @@
 mod mock;
 #[cfg(test)]
 mod tests;
+<<<<<<< HEAD
+
+=======
+>>>>>>> f7bd10a548201cb68491f72be73115279d97f160
 #[cfg(feature = "testing-utils")]
 pub mod testing_utils;
 #[cfg(any(feature = "runtime-benchmarks", test))]

frame/staking/src/testing_utils.rs

@@ -141,8 +141,6 @@ where
 			targets,
 		);
 	});
-
-	<Module<T>>::create_stakers_snapshot();
 }
 
 /// Build a _really bad_ but acceptable solution for election. This should always yield a solution
@@ -153,13 +151,13 @@ pub fn get_weak_solution<T: Trait>(
 	let mut backing_stake_of: BTreeMap<T::AccountId, BalanceOf<T>> = BTreeMap::new();
 
 	// self stake
-	<Validators<T>>::enumerate().for_each(|(who, _p)| {
+	<Validators<T>>::iter().for_each(|(who, _p)| {
 		*backing_stake_of.entry(who.clone()).or_insert(Zero::zero()) +=
 			<Module<T>>::slashable_balance_of(&who)
 	});
 
 	// add nominator stuff
-	<Nominators<T>>::enumerate().for_each(|(who, nomination)| {
+	<Nominators<T>>::iter().for_each(|(who, nomination)| {
 		nomination.targets.into_iter().for_each(|v| {
 			*backing_stake_of.entry(v).or_insert(Zero::zero()) +=
 				<Module<T>>::slashable_balance_of(&who)
@@ -176,7 +174,7 @@ pub fn get_weak_solution<T: Trait>(
 		.collect();
 
 	let mut staked_assignments: Vec<StakedAssignment<T::AccountId>> = Vec::new();
-	<Nominators<T>>::enumerate().for_each(|(who, nomination)| {
+	<Nominators<T>>::iter().for_each(|(who, nomination)| {
 		let mut dist: Vec<(T::AccountId, ExtendedBalance)> = Vec::new();
 		nomination.targets.into_iter().for_each(|v| {
 			if winners.iter().find(|&w| *w == v).is_some() {
@@ -320,19 +318,20 @@ pub fn get_seq_phragmen_solution<T: Trait>(
 }
 
 /// Remove all validator, nominators, votes and exposures.
+/// TODO: this can be better probably.
 pub fn clean<T: Trait>(era: EraIndex)
 	where
 		<T as frame_system::Trait>::AccountId: codec::EncodeLike<u32>,
 		u32: codec::EncodeLike<T::AccountId>,
 {
-	<Validators<T>>::enumerate().for_each(|(k, _)| {
+	<Validators<T>>::iter().for_each(|(k, _)| {
 		let ctrl = <Module<T>>::bonded(&k).unwrap();
 		<Bonded<T>>::remove(&k);
 		<Validators<T>>::remove(&k);
 		<Ledger<T>>::remove(&ctrl);
 		<ErasStakers<T>>::remove(k, era);
 	});
-	<Nominators<T>>::enumerate().for_each(|(k, _)| <Nominators<T>>::remove(k));
+	<Nominators<T>>::iter().for_each(|(k, _)| <Nominators<T>>::remove(k));
 	<Ledger<T>>::remove_all();
 	<Bonded<T>>::remove_all();
 	<QueuedElected<T>>::kill();

primitives/phragmen/src/tests.rs

@@ -522,6 +522,19 @@ fn self_votes_should_be_kept() {
 }
 
 #[test]
+<<<<<<< HEAD
+fn elect_should_never_output_zero() {
+	// phragmen internally uses Rational128 to keep ratios, which is _as accurate as it gets_. When
+	// down-casting this number to a PerThing, this might lead to `Zero::zero()`. This should simply
+	// be dropped as an edge.
+	// We also guard against this when we convert assignments into staked and visa versa, but still
+	// the elect must also check this.
+	unimplemented!();
+}
+
+#[test]
+=======
+>>>>>>> f7bd10a548201cb68491f72be73115279d97f160
 fn assignment_convert_works() {
 	let staked = StakedAssignment {
 		who: 1 as AccountId,
@@ -940,7 +953,11 @@ mod compact {
 		);
 	}
 
+<<<<<<< HEAD
+	#[test]
+=======
 		#[test]
+>>>>>>> f7bd10a548201cb68491f72be73115279d97f160
 	fn zero_target_count_is_ignored() {
 		let voters = vec![1 as AccountId, 2];
 		let targets = vec![10 as AccountId, 11];