mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-06-12 08:51:09 +00:00
Move phragmen benchmarks out of Staking (#3588)
* Move phragmen benches to.. phragmen. * Move some basic phragmen tests to.. phragmen. * Line-width * Add phragmen equ implementation as flot * Add phragmen equ implementation as flot * Add mock and test file.
This commit is contained in:
Kian Paimani
@@ -9,7 +9,9 @@ sr-primitives = { path = "../sr-primitives", default-features = false }
|
||||
rstd = { package = "sr-std", path = "../sr-std", default-features = false }
|
||||
|
||||
[dev-dependencies]
|
||||
runtime-io ={ package = "sr-io", path = "../sr-io" }
|
||||
support = { package = "srml-support", path = "../../srml/support" }
|
||||
rand = "0.7.0"
|
||||
|
||||
[features]
|
||||
default = ["std"]
|
||||
|
||||
@@ -0,0 +1,198 @@
|
||||
// Copyright 2019 Parity Technologies
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Benchmarks of the phragmen election algorithm.
|
||||
//! Note that execution times will not be accurate in an absolute scale, since
|
||||
//! - Everything is executed in the context of `TestExternalities`
|
||||
//! - Everything is executed in native environment.
|
||||
|
||||
#![feature(test)]
|
||||
|
||||
extern crate test;
|
||||
use test::Bencher;
|
||||
|
||||
use rand::{self, Rng};
|
||||
extern crate substrate_phragmen as phragmen;
|
||||
use phragmen::{Support, SupportMap, ACCURACY};
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
use sr_primitives::traits::{Convert, SaturatedConversion};
|
||||
|
||||
const VALIDATORS: u64 = 1000;
|
||||
const NOMINATORS: u64 = 10_000;
|
||||
const EDGES: u64 = 2;
|
||||
const TO_ELECT: usize = 100;
|
||||
const STAKE: Balance = 1000;
|
||||
|
||||
type Balance = u128;
|
||||
type AccountId = u64;
|
||||
|
||||
pub struct TestCurrencyToVote;
|
||||
impl Convert<Balance, u64> for TestCurrencyToVote {
|
||||
fn convert(x: Balance) -> u64 { x.saturated_into() }
|
||||
}
|
||||
impl Convert<u128, Balance> for TestCurrencyToVote {
|
||||
fn convert(x: u128) -> Balance { x.saturated_into() }
|
||||
}
|
||||
|
||||
fn do_phragmen(
|
||||
b: &mut Bencher,
|
||||
num_vals: u64,
|
||||
num_noms: u64,
|
||||
count: usize,
|
||||
votes_per: u64,
|
||||
eq_iters: usize,
|
||||
_eq_tolerance: u128,
|
||||
) {
|
||||
assert!(num_vals > votes_per);
|
||||
let rr = |a, b| rand::thread_rng().gen_range(a as usize, b as usize) as Balance;
|
||||
|
||||
// prefix to distinguish the validator and nominator account ranges.
|
||||
let np = 10_000;
|
||||
|
||||
let mut candidates = vec![];
|
||||
let mut voters = vec![];
|
||||
let mut slashable_balance_of: BTreeMap<AccountId, Balance> = BTreeMap::new();
|
||||
|
||||
(1 ..= num_vals)
|
||||
.for_each(|acc| {
|
||||
candidates.push(acc);
|
||||
slashable_balance_of.insert(acc, STAKE + rr(10, 50));
|
||||
});
|
||||
|
||||
(np ..= (np + num_noms))
|
||||
.for_each(|acc| {
|
||||
let mut stashes_to_vote = candidates.clone();
|
||||
let votes = (0 .. votes_per)
|
||||
.map(|_| {
|
||||
stashes_to_vote.remove(rr(0, stashes_to_vote.len()) as usize)
|
||||
})
|
||||
.collect::<Vec<AccountId>>();
|
||||
voters.push((acc, votes));
|
||||
slashable_balance_of.insert(acc, STAKE + rr(10, 50));
|
||||
});
|
||||
|
||||
let slashable_balance = |who: &AccountId| -> Balance {
|
||||
*slashable_balance_of.get(who).unwrap()
|
||||
};
|
||||
|
||||
b.iter(|| {
|
||||
let r = phragmen::elect::<AccountId, Balance, _, TestCurrencyToVote>(
|
||||
count,
|
||||
1_usize,
|
||||
candidates.clone(),
|
||||
voters.clone(),
|
||||
slashable_balance,
|
||||
true,
|
||||
).unwrap();
|
||||
|
||||
// Do the benchmarking with equalize.
|
||||
if eq_iters > 0 {
|
||||
let elected_stashes = r.winners;
|
||||
let mut assignments = r.assignments;
|
||||
|
||||
let to_votes = |b: Balance|
|
||||
<TestCurrencyToVote as Convert<Balance, u128>>::convert(b) as u128;
|
||||
let ratio_of = |b, r: u128| r.saturating_mul(to_votes(b)) / ACCURACY;
|
||||
|
||||
// Initialize the support of each candidate.
|
||||
let mut supports = <SupportMap<u64>>::new();
|
||||
elected_stashes
|
||||
.iter()
|
||||
.map(|e| (e, to_votes(slashable_balance(e))))
|
||||
.for_each(|(e, s)| {
|
||||
let item = Support { own: s, total: s, ..Default::default() };
|
||||
supports.insert(e.clone(), item);
|
||||
});
|
||||
|
||||
for (n, assignment) in assignments.iter_mut() {
|
||||
for (c, r) in assignment.iter_mut() {
|
||||
let nominator_stake = slashable_balance(n);
|
||||
let other_stake = ratio_of(nominator_stake, *r);
|
||||
if let Some(support) = supports.get_mut(c) {
|
||||
support.total = support.total.saturating_add(other_stake);
|
||||
support.others.push((n.clone(), other_stake));
|
||||
}
|
||||
*r = other_stake;
|
||||
}
|
||||
}
|
||||
|
||||
let tolerance = 0_u128;
|
||||
let iterations = 2_usize;
|
||||
phragmen::equalize::<_, _, _, TestCurrencyToVote>(
|
||||
assignments,
|
||||
&mut supports,
|
||||
tolerance,
|
||||
iterations,
|
||||
slashable_balance,
|
||||
);
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
macro_rules! phragmen_benches {
|
||||
($($name:ident: $tup:expr,)*) => {
|
||||
$(
|
||||
#[bench]
|
||||
fn $name(b: &mut Bencher) {
|
||||
let (v, n, t, e, eq_iter, eq_tol) = $tup;
|
||||
println!("----------------------");
|
||||
println!(
|
||||
"++ Benchmark: {} Validators // {} Nominators // {} Edges-per-nominator // {} \
|
||||
total edges // electing {} // Equalize: {} iterations -- {} tolerance",
|
||||
v, n, e, e * n, t, eq_iter, eq_tol,
|
||||
);
|
||||
do_phragmen(b, v, n, t, e, eq_iter, eq_tol);
|
||||
}
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
phragmen_benches! {
|
||||
bench_1_1: (VALIDATORS, NOMINATORS, TO_ELECT, EDGES, 0, 0),
|
||||
bench_1_2: (VALIDATORS*2, NOMINATORS, TO_ELECT, EDGES, 0, 0),
|
||||
bench_1_3: (VALIDATORS*4, NOMINATORS, TO_ELECT, EDGES, 0, 0),
|
||||
bench_1_4: (VALIDATORS*8, NOMINATORS, TO_ELECT, EDGES, 0, 0),
|
||||
bench_1_1_eq: (VALIDATORS, NOMINATORS, TO_ELECT, EDGES, 2, 0),
|
||||
bench_1_2_eq: (VALIDATORS*2, NOMINATORS, TO_ELECT, EDGES, 2, 0),
|
||||
bench_1_3_eq: (VALIDATORS*4, NOMINATORS, TO_ELECT, EDGES, 2, 0),
|
||||
bench_1_4_eq: (VALIDATORS*8, NOMINATORS, TO_ELECT, EDGES, 2, 0),
|
||||
|
||||
bench_0_1: (VALIDATORS, NOMINATORS, TO_ELECT, EDGES, 0, 0),
|
||||
bench_0_2: (VALIDATORS, NOMINATORS, TO_ELECT * 4, EDGES, 0, 0),
|
||||
bench_0_3: (VALIDATORS, NOMINATORS, TO_ELECT * 8, EDGES, 0, 0),
|
||||
bench_0_4: (VALIDATORS, NOMINATORS, TO_ELECT * 16, EDGES , 0, 0),
|
||||
bench_0_1_eq: (VALIDATORS, NOMINATORS, TO_ELECT, EDGES, 2, 0),
|
||||
bench_0_2_eq: (VALIDATORS, NOMINATORS, TO_ELECT * 4, EDGES, 2, 0),
|
||||
bench_0_3_eq: (VALIDATORS, NOMINATORS, TO_ELECT * 8, EDGES, 2, 0),
|
||||
bench_0_4_eq: (VALIDATORS, NOMINATORS, TO_ELECT * 16, EDGES , 2, 0),
|
||||
|
||||
bench_2_1: (VALIDATORS, NOMINATORS, TO_ELECT, EDGES, 0, 0),
|
||||
bench_2_2: (VALIDATORS, NOMINATORS*2, TO_ELECT, EDGES, 0, 0),
|
||||
bench_2_3: (VALIDATORS, NOMINATORS*4, TO_ELECT, EDGES, 0, 0),
|
||||
bench_2_4: (VALIDATORS, NOMINATORS*8, TO_ELECT, EDGES, 0, 0),
|
||||
bench_2_1_eq: (VALIDATORS, NOMINATORS, TO_ELECT, EDGES, 2, 0),
|
||||
bench_2_2_eq: (VALIDATORS, NOMINATORS*2, TO_ELECT, EDGES, 2, 0),
|
||||
bench_2_3_eq: (VALIDATORS, NOMINATORS*4, TO_ELECT, EDGES, 2, 0),
|
||||
bench_2_4_eq: (VALIDATORS, NOMINATORS*8, TO_ELECT, EDGES, 2, 0),
|
||||
|
||||
bench_3_1: (VALIDATORS, NOMINATORS, TO_ELECT, EDGES, 0, 0 ),
|
||||
bench_3_2: (VALIDATORS, NOMINATORS, TO_ELECT, EDGES*2, 0, 0),
|
||||
bench_3_3: (VALIDATORS, NOMINATORS, TO_ELECT, EDGES*4, 0, 0),
|
||||
bench_3_4: (VALIDATORS, NOMINATORS, TO_ELECT, EDGES*8, 0, 0),
|
||||
bench_3_1_eq: (VALIDATORS, NOMINATORS, TO_ELECT, EDGES, 2, 0),
|
||||
bench_3_2_eq: (VALIDATORS, NOMINATORS, TO_ELECT, EDGES*2, 2, 0),
|
||||
bench_3_3_eq: (VALIDATORS, NOMINATORS, TO_ELECT, EDGES*4, 2, 0),
|
||||
bench_3_4_eq: (VALIDATORS, NOMINATORS, TO_ELECT, EDGES*8, 2, 0),
|
||||
}
|
||||
@@ -37,6 +37,9 @@ use rstd::{prelude::*, collections::btree_map::BTreeMap};
|
||||
use sr_primitives::PerU128;
|
||||
use sr_primitives::traits::{Zero, Convert, Member, SimpleArithmetic};
|
||||
|
||||
mod mock;
|
||||
mod tests;
|
||||
|
||||
/// Type used as the fraction.
|
||||
type Fraction = PerU128;
|
||||
|
||||
@@ -355,7 +358,7 @@ pub fn elect<AccountId, Balance, FS, C>(
|
||||
/// * `tolerance`: maximum difference that can occur before an early quite happens.
|
||||
/// * `iterations`: maximum number of iterations that will be processed.
|
||||
/// * `stake_of`: something that can return the stake stake of a particular candidate or voter.
|
||||
pub fn equalize<Balance, AccountId, C, FS>(
|
||||
pub fn equalize<Balance, AccountId, FS, C>(
|
||||
mut assignments: Vec<(AccountId, Vec<PhragmenAssignment<AccountId>>)>,
|
||||
supports: &mut SupportMap<AccountId>,
|
||||
tolerance: ExtendedBalance,
|
||||
@@ -489,226 +492,3 @@ fn do_equalize<Balance, AccountId, C>(
|
||||
|
||||
difference
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{elect, ACCURACY, PhragmenResult};
|
||||
use sr_primitives::traits::{Convert, Member, SaturatedConversion};
|
||||
use rstd::collections::btree_map::BTreeMap;
|
||||
use support::assert_eq_uvec;
|
||||
|
||||
pub struct C;
|
||||
impl Convert<u64, u64> for C {
|
||||
fn convert(x: u64) -> u64 { x }
|
||||
}
|
||||
impl Convert<u128, u64> for C {
|
||||
fn convert(x: u128) -> u64 { x.saturated_into() }
|
||||
}
|
||||
|
||||
#[derive(Default, Debug)]
|
||||
struct _Candidate<AccountId> {
|
||||
who: AccountId,
|
||||
score: f64,
|
||||
approval_stake: f64,
|
||||
elected: bool,
|
||||
}
|
||||
|
||||
#[derive(Default, Debug)]
|
||||
struct _Voter<AccountId> {
|
||||
who: AccountId,
|
||||
edges: Vec<_Edge<AccountId>>,
|
||||
budget: f64,
|
||||
load: f64,
|
||||
}
|
||||
|
||||
#[derive(Default, Debug)]
|
||||
struct _Edge<AccountId> {
|
||||
who: AccountId,
|
||||
load: f64,
|
||||
candidate_index: usize,
|
||||
}
|
||||
|
||||
type _PhragmenAssignment<AccountId> = (AccountId, f64);
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct _PhragmenResult<AccountId> {
|
||||
pub winners: Vec<AccountId>,
|
||||
pub assignments: Vec<(AccountId, Vec<_PhragmenAssignment<AccountId>>)>
|
||||
}
|
||||
|
||||
pub fn elect_poc<AccountId, FS>(
|
||||
candidate_count: usize,
|
||||
minimum_candidate_count: usize,
|
||||
initial_candidates: Vec<AccountId>,
|
||||
initial_voters: Vec<(AccountId, Vec<AccountId>)>,
|
||||
stake_of: FS,
|
||||
self_vote: bool,
|
||||
) -> Option<_PhragmenResult<AccountId>> where
|
||||
AccountId: Default + Ord + Member + Copy,
|
||||
for<'r> FS: Fn(&'r AccountId) -> u64,
|
||||
{
|
||||
let mut elected_candidates: Vec<AccountId>;
|
||||
let mut assigned: Vec<(AccountId, Vec<_PhragmenAssignment<AccountId>>)>;
|
||||
let mut c_idx_cache = BTreeMap::<AccountId, usize>::new();
|
||||
let num_voters = initial_candidates.len() + initial_voters.len();
|
||||
let mut voters: Vec<_Voter<AccountId>> = Vec::with_capacity(num_voters);
|
||||
|
||||
let mut candidates = if self_vote {
|
||||
initial_candidates.into_iter().map(|who| {
|
||||
let stake = stake_of(&who) as f64;
|
||||
_Candidate { who, approval_stake: stake, ..Default::default() }
|
||||
})
|
||||
.filter(|c| c.approval_stake != 0f64)
|
||||
.enumerate()
|
||||
.map(|(i, c)| {
|
||||
let who = c.who;
|
||||
voters.push(_Voter {
|
||||
who: who.clone(),
|
||||
edges: vec![
|
||||
_Edge { who: who.clone(), candidate_index: i, ..Default::default() }
|
||||
],
|
||||
budget: c.approval_stake,
|
||||
load: 0f64,
|
||||
});
|
||||
c_idx_cache.insert(c.who.clone(), i);
|
||||
c
|
||||
})
|
||||
.collect::<Vec<_Candidate<AccountId>>>()
|
||||
} else {
|
||||
initial_candidates.into_iter()
|
||||
.enumerate()
|
||||
.map(|(idx, who)| {
|
||||
c_idx_cache.insert(who.clone(), idx);
|
||||
_Candidate { who, ..Default::default() }
|
||||
})
|
||||
.collect::<Vec<_Candidate<AccountId>>>()
|
||||
};
|
||||
|
||||
if candidates.len() < minimum_candidate_count {
|
||||
return None;
|
||||
}
|
||||
|
||||
voters.extend(initial_voters.into_iter().map(|(who, votes)| {
|
||||
let voter_stake = stake_of(&who) as f64;
|
||||
let mut edges: Vec<_Edge<AccountId>> = Vec::with_capacity(votes.len());
|
||||
for v in votes {
|
||||
if let Some(idx) = c_idx_cache.get(&v) {
|
||||
candidates[*idx].approval_stake = candidates[*idx].approval_stake + voter_stake;
|
||||
edges.push(
|
||||
_Edge { who: v.clone(), candidate_index: *idx, ..Default::default() }
|
||||
);
|
||||
}
|
||||
}
|
||||
_Voter {
|
||||
who,
|
||||
edges: edges,
|
||||
budget: voter_stake,
|
||||
load: 0f64,
|
||||
}
|
||||
}));
|
||||
|
||||
let to_elect = candidate_count.min(candidates.len());
|
||||
elected_candidates = Vec::with_capacity(candidate_count);
|
||||
assigned = Vec::with_capacity(candidate_count);
|
||||
|
||||
for _round in 0..to_elect {
|
||||
for c in &mut candidates {
|
||||
if !c.elected {
|
||||
c.score = 1.0 / c.approval_stake;
|
||||
}
|
||||
}
|
||||
for n in &voters {
|
||||
for e in &n.edges {
|
||||
let c = &mut candidates[e.candidate_index];
|
||||
if !c.elected && !(c.approval_stake == 0f64) {
|
||||
c.score += n.budget * n.load / c.approval_stake;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(winner) = candidates
|
||||
.iter_mut()
|
||||
.filter(|c| !c.elected)
|
||||
.min_by(|x, y| x.score.partial_cmp(&y.score).unwrap_or(rstd::cmp::Ordering::Equal))
|
||||
{
|
||||
winner.elected = true;
|
||||
for n in &mut voters {
|
||||
for e in &mut n.edges {
|
||||
if e.who == winner.who {
|
||||
e.load = winner.score - n.load;
|
||||
n.load = winner.score;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
elected_candidates.push(winner.who.clone());
|
||||
} else {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
for n in &mut voters {
|
||||
let mut assignment = (n.who.clone(), vec![]);
|
||||
for e in &mut n.edges {
|
||||
if let Some(c) = elected_candidates.iter().cloned().find(|c| *c == e.who) {
|
||||
if c != n.who {
|
||||
let ratio = e.load / n.load;
|
||||
assignment.1.push((e.who.clone(), ratio));
|
||||
}
|
||||
}
|
||||
}
|
||||
assigned.push(assignment);
|
||||
}
|
||||
|
||||
Some(_PhragmenResult {
|
||||
winners: elected_candidates,
|
||||
assignments: assigned,
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn float_poc_works() {
|
||||
let candidates = vec![1, 2, 3];
|
||||
let voters = vec![
|
||||
(10, vec![1, 2]),
|
||||
(20, vec![1, 3]),
|
||||
(30, vec![2, 3]),
|
||||
];
|
||||
let stake_of = |x: &u64| { if *x >= 10 { *x } else { 0 }};
|
||||
let _PhragmenResult { winners, assignments } =
|
||||
elect_poc(2, 2, candidates, voters, stake_of, false).unwrap();
|
||||
|
||||
assert_eq_uvec!(winners, vec![2, 3]);
|
||||
assert_eq_uvec!(
|
||||
assignments,
|
||||
vec![
|
||||
(10, vec![(2, 1.0)]),
|
||||
(20, vec![(3, 1.0)]),
|
||||
(30, vec![(2, 0.5), (3, 0.5)])
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn phragmen_works() {
|
||||
let candidates = vec![1, 2, 3];
|
||||
let voters = vec![
|
||||
(10, vec![1, 2]),
|
||||
(20, vec![1, 3]),
|
||||
(30, vec![2, 3]),
|
||||
];
|
||||
let stake_of = |x: &u64| { if *x >= 10 { *x } else { 0 }};
|
||||
let PhragmenResult { winners, assignments } =
|
||||
elect::<_, _, _, C>(2, 2, candidates, voters, stake_of, false).unwrap();
|
||||
|
||||
assert_eq_uvec!(winners, vec![2, 3]);
|
||||
assert_eq_uvec!(
|
||||
assignments,
|
||||
vec![
|
||||
(10, vec![(2, ACCURACY)]),
|
||||
(20, vec![(3, ACCURACY)]),
|
||||
(30, vec![(2, ACCURACY/2), (3, ACCURACY/2)])
|
||||
]
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,419 @@
|
||||
// Copyright 2019 Parity Technologies (UK) Ltd.
|
||||
// This file is part of Substrate.
|
||||
|
||||
// Substrate is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// Substrate is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Substrate. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
//! Mock file for phragmen.
|
||||
|
||||
#![cfg(test)]
|
||||
|
||||
use crate::{elect, ACCURACY, PhragmenResult};
|
||||
use sr_primitives::traits::{Convert, Member, SaturatedConversion};
|
||||
use rstd::collections::btree_map::BTreeMap;
|
||||
use support::assert_eq_error_rate;
|
||||
|
||||
pub(crate) struct TestCurrencyToVote;
|
||||
impl Convert<Balance, u64> for TestCurrencyToVote {
|
||||
fn convert(x: Balance) -> u64 { x.saturated_into() }
|
||||
}
|
||||
impl Convert<u128, Balance> for TestCurrencyToVote {
|
||||
fn convert(x: u128) -> Balance { x }
|
||||
}
|
||||
|
||||
#[derive(Default, Debug)]
|
||||
pub(crate) struct _Candidate<A> {
|
||||
who: A,
|
||||
score: f64,
|
||||
approval_stake: f64,
|
||||
elected: bool,
|
||||
}
|
||||
|
||||
#[derive(Default, Debug)]
|
||||
pub(crate) struct _Voter<A> {
|
||||
who: A,
|
||||
edges: Vec<_Edge<A>>,
|
||||
budget: f64,
|
||||
load: f64,
|
||||
}
|
||||
|
||||
#[derive(Default, Debug)]
|
||||
pub(crate) struct _Edge<A> {
|
||||
who: A,
|
||||
load: f64,
|
||||
candidate_index: usize,
|
||||
}
|
||||
|
||||
#[derive(Default, Debug, PartialEq)]
|
||||
pub(crate) struct _Support<A> {
|
||||
pub own: f64,
|
||||
pub total: f64,
|
||||
pub others: Vec<_PhragmenAssignment<A>>,
|
||||
}
|
||||
|
||||
pub(crate) type _PhragmenAssignment<A> = (A, f64);
|
||||
pub(crate) type _SupportMap<A> = BTreeMap<A, _Support<A>>;
|
||||
|
||||
pub(crate) type Balance = u128;
|
||||
pub(crate) type AccountId = u64;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub(crate) struct _PhragmenResult<A: Clone> {
|
||||
pub winners: Vec<A>,
|
||||
pub assignments: Vec<(A, Vec<_PhragmenAssignment<A>>)>
|
||||
}
|
||||
|
||||
pub(crate) fn elect_float<A, FS>(
|
||||
candidate_count: usize,
|
||||
minimum_candidate_count: usize,
|
||||
initial_candidates: Vec<A>,
|
||||
initial_voters: Vec<(A, Vec<A>)>,
|
||||
stake_of: FS,
|
||||
self_vote: bool,
|
||||
) -> Option<_PhragmenResult<A>> where
|
||||
A: Default + Ord + Member + Copy,
|
||||
for<'r> FS: Fn(&'r A) -> Balance,
|
||||
{
|
||||
let mut elected_candidates: Vec<A>;
|
||||
let mut assigned: Vec<(A, Vec<_PhragmenAssignment<A>>)>;
|
||||
let mut c_idx_cache = BTreeMap::<A, usize>::new();
|
||||
let num_voters = initial_candidates.len() + initial_voters.len();
|
||||
let mut voters: Vec<_Voter<A>> = Vec::with_capacity(num_voters);
|
||||
|
||||
let mut candidates = if self_vote {
|
||||
initial_candidates.into_iter().map(|who| {
|
||||
let stake = stake_of(&who) as f64;
|
||||
_Candidate { who, approval_stake: stake, ..Default::default() }
|
||||
})
|
||||
.filter(|c| c.approval_stake != 0f64)
|
||||
.enumerate()
|
||||
.map(|(i, c)| {
|
||||
let who = c.who;
|
||||
voters.push(_Voter {
|
||||
who: who.clone(),
|
||||
edges: vec![
|
||||
_Edge { who: who.clone(), candidate_index: i, ..Default::default() }
|
||||
],
|
||||
budget: c.approval_stake,
|
||||
load: 0f64,
|
||||
});
|
||||
c_idx_cache.insert(c.who.clone(), i);
|
||||
c
|
||||
})
|
||||
.collect::<Vec<_Candidate<A>>>()
|
||||
} else {
|
||||
initial_candidates.into_iter()
|
||||
.enumerate()
|
||||
.map(|(idx, who)| {
|
||||
c_idx_cache.insert(who.clone(), idx);
|
||||
_Candidate { who, ..Default::default() }
|
||||
})
|
||||
.collect::<Vec<_Candidate<A>>>()
|
||||
};
|
||||
|
||||
if candidates.len() < minimum_candidate_count {
|
||||
return None;
|
||||
}
|
||||
|
||||
voters.extend(initial_voters.into_iter().map(|(who, votes)| {
|
||||
let voter_stake = stake_of(&who) as f64;
|
||||
let mut edges: Vec<_Edge<A>> = Vec::with_capacity(votes.len());
|
||||
for v in votes {
|
||||
if let Some(idx) = c_idx_cache.get(&v) {
|
||||
candidates[*idx].approval_stake = candidates[*idx].approval_stake + voter_stake;
|
||||
edges.push(
|
||||
_Edge { who: v.clone(), candidate_index: *idx, ..Default::default() }
|
||||
);
|
||||
}
|
||||
}
|
||||
_Voter {
|
||||
who,
|
||||
edges: edges,
|
||||
budget: voter_stake,
|
||||
load: 0f64,
|
||||
}
|
||||
}));
|
||||
|
||||
let to_elect = candidate_count.min(candidates.len());
|
||||
elected_candidates = Vec::with_capacity(candidate_count);
|
||||
assigned = Vec::with_capacity(candidate_count);
|
||||
|
||||
for _round in 0..to_elect {
|
||||
for c in &mut candidates {
|
||||
if !c.elected {
|
||||
c.score = 1.0 / c.approval_stake;
|
||||
}
|
||||
}
|
||||
for n in &voters {
|
||||
for e in &n.edges {
|
||||
let c = &mut candidates[e.candidate_index];
|
||||
if !c.elected && !(c.approval_stake == 0f64) {
|
||||
c.score += n.budget * n.load / c.approval_stake;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(winner) = candidates
|
||||
.iter_mut()
|
||||
.filter(|c| !c.elected)
|
||||
.min_by(|x, y| x.score.partial_cmp(&y.score).unwrap_or(rstd::cmp::Ordering::Equal))
|
||||
{
|
||||
winner.elected = true;
|
||||
for n in &mut voters {
|
||||
for e in &mut n.edges {
|
||||
if e.who == winner.who {
|
||||
e.load = winner.score - n.load;
|
||||
n.load = winner.score;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
elected_candidates.push(winner.who.clone());
|
||||
} else {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
for n in &mut voters {
|
||||
let mut assignment = (n.who.clone(), vec![]);
|
||||
for e in &mut n.edges {
|
||||
if let Some(c) = elected_candidates.iter().cloned().find(|c| *c == e.who) {
|
||||
if c != n.who {
|
||||
let ratio = e.load / n.load;
|
||||
assignment.1.push((e.who.clone(), ratio));
|
||||
}
|
||||
}
|
||||
}
|
||||
if assignment.1.len() > 0 {
|
||||
assigned.push(assignment);
|
||||
}
|
||||
}
|
||||
|
||||
Some(_PhragmenResult {
|
||||
winners: elected_candidates,
|
||||
assignments: assigned,
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn equalize_float<A, FS>(
|
||||
mut assignments: Vec<(A, Vec<_PhragmenAssignment<A>>)>,
|
||||
supports: &mut _SupportMap<A>,
|
||||
tolerance: f64,
|
||||
iterations: usize,
|
||||
stake_of: FS,
|
||||
) where
|
||||
for<'r> FS: Fn(&'r A) -> Balance,
|
||||
A: Ord + Clone + std::fmt::Debug,
|
||||
{
|
||||
for _i in 0..iterations {
|
||||
let mut max_diff = 0.0;
|
||||
for (voter, assignment) in assignments.iter_mut() {
|
||||
let voter_budget = stake_of(&voter);
|
||||
let diff = do_equalize_float(
|
||||
voter,
|
||||
voter_budget,
|
||||
assignment,
|
||||
supports,
|
||||
tolerance,
|
||||
);
|
||||
if diff > max_diff { max_diff = diff; }
|
||||
}
|
||||
|
||||
if max_diff < tolerance {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn do_equalize_float<A>(
|
||||
voter: &A,
|
||||
budget_balance: Balance,
|
||||
elected_edges: &mut Vec<_PhragmenAssignment<A>>,
|
||||
support_map: &mut _SupportMap<A>,
|
||||
tolerance: f64
|
||||
) -> f64 where
|
||||
A: Ord + Clone,
|
||||
{
|
||||
let budget = budget_balance as f64;
|
||||
if elected_edges.is_empty() { return 0.0; }
|
||||
|
||||
let stake_used = elected_edges
|
||||
.iter()
|
||||
.fold(0.0, |s, e| s + e.1);
|
||||
|
||||
let backed_stakes_iter = elected_edges
|
||||
.iter()
|
||||
.filter_map(|e| support_map.get(&e.0))
|
||||
.map(|e| e.total);
|
||||
|
||||
let backing_backed_stake = elected_edges
|
||||
.iter()
|
||||
.filter(|e| e.1 > 0.0)
|
||||
.filter_map(|e| support_map.get(&e.0))
|
||||
.map(|e| e.total)
|
||||
.collect::<Vec<f64>>();
|
||||
|
||||
let mut difference;
|
||||
if backing_backed_stake.len() > 0 {
|
||||
let max_stake = backing_backed_stake
|
||||
.iter()
|
||||
.max_by(|x, y| x.partial_cmp(&y).unwrap_or(rstd::cmp::Ordering::Equal))
|
||||
.expect("vector with positive length will have a max; qed");
|
||||
let min_stake = backed_stakes_iter
|
||||
.min_by(|x, y| x.partial_cmp(&y).unwrap_or(rstd::cmp::Ordering::Equal))
|
||||
.expect("iterator with positive length will have a min; qed");
|
||||
|
||||
difference = max_stake - min_stake;
|
||||
difference = difference + budget - stake_used;
|
||||
if difference < tolerance {
|
||||
return difference;
|
||||
}
|
||||
} else {
|
||||
difference = budget;
|
||||
}
|
||||
|
||||
// Undo updates to support
|
||||
elected_edges.iter_mut().for_each(|e| {
|
||||
if let Some(support) = support_map.get_mut(&e.0) {
|
||||
support.total = support.total - e.1;
|
||||
support.others.retain(|i_support| i_support.0 != *voter);
|
||||
}
|
||||
e.1 = 0.0;
|
||||
});
|
||||
|
||||
// todo: rewrite.
|
||||
elected_edges.sort_unstable_by(|x, y|
|
||||
if let Some(x) = support_map.get(&x.0) {
|
||||
if let Some(y) = support_map.get(&y.0) {
|
||||
x.total.partial_cmp(&y.total).unwrap_or(rstd::cmp::Ordering::Equal)
|
||||
} else {
|
||||
rstd::cmp::Ordering::Equal
|
||||
}
|
||||
} else {
|
||||
rstd::cmp::Ordering::Equal
|
||||
}
|
||||
);
|
||||
|
||||
let mut cumulative_stake = 0.0;
|
||||
let mut last_index = elected_edges.len() - 1;
|
||||
elected_edges.iter_mut().enumerate().for_each(|(idx, e)| {
|
||||
if let Some(support) = support_map.get_mut(&e.0) {
|
||||
let stake = support.total;
|
||||
let stake_mul = stake * (idx as f64);
|
||||
let stake_sub = stake_mul - cumulative_stake;
|
||||
if stake_sub > budget {
|
||||
last_index = idx.checked_sub(1).unwrap_or(0);
|
||||
return
|
||||
}
|
||||
cumulative_stake = cumulative_stake + stake;
|
||||
}
|
||||
});
|
||||
|
||||
let last_stake = elected_edges[last_index].1;
|
||||
let split_ways = last_index + 1;
|
||||
let excess = budget + cumulative_stake - last_stake * (split_ways as f64);
|
||||
elected_edges.iter_mut().take(split_ways).for_each(|e| {
|
||||
if let Some(support) = support_map.get_mut(&e.0) {
|
||||
e.1 = excess / (split_ways as f64) + last_stake - support.total;
|
||||
support.total = support.total + e.1;
|
||||
support.others.push((voter.clone(), e.1));
|
||||
}
|
||||
});
|
||||
|
||||
difference
|
||||
}
|
||||
|
||||
|
||||
pub(crate) fn create_stake_of(stakes: &[(AccountId, Balance)])
|
||||
-> Box<dyn Fn(&AccountId) -> Balance>
|
||||
{
|
||||
let mut storage = BTreeMap::<AccountId, Balance>::new();
|
||||
stakes.iter().for_each(|s| { storage.insert(s.0, s.1); });
|
||||
let stake_of = move |who: &AccountId| -> Balance { storage.get(who).unwrap().to_owned() };
|
||||
Box::new(stake_of)
|
||||
}
|
||||
|
||||
pub(crate) fn run_and_compare(
|
||||
candidates: Vec<AccountId>,
|
||||
voters: Vec<(AccountId, Vec<AccountId>)>,
|
||||
stake_of: Box<dyn Fn(&AccountId) -> Balance>,
|
||||
to_elect: usize,
|
||||
min_to_elect: usize,
|
||||
self_vote: bool,
|
||||
) {
|
||||
// run fixed point code.
|
||||
let PhragmenResult { winners, assignments } = elect::<_, _, _, TestCurrencyToVote>(
|
||||
to_elect,
|
||||
min_to_elect,
|
||||
candidates.clone(),
|
||||
voters.clone(),
|
||||
&stake_of,
|
||||
self_vote,
|
||||
).unwrap();
|
||||
|
||||
// run float poc code.
|
||||
let truth_value = elect_float(
|
||||
to_elect,
|
||||
min_to_elect,
|
||||
candidates,
|
||||
voters,
|
||||
&stake_of,
|
||||
self_vote,
|
||||
).unwrap();
|
||||
|
||||
assert_eq!(winners, truth_value.winners);
|
||||
|
||||
for (nominator, assigned) in assignments.clone() {
|
||||
if let Some(float_assignments) = truth_value.assignments.iter().find(|x| x.0 == nominator) {
|
||||
for (candidate, ratio) in assigned {
|
||||
if let Some(float_assignment) = float_assignments.1.iter().find(|x| x.0 == candidate ) {
|
||||
assert_eq_error_rate!((float_assignment.1 * ACCURACY as f64).round() as u128, ratio, 1);
|
||||
} else {
|
||||
panic!("candidate mismatch. This should never happen.")
|
||||
}
|
||||
}
|
||||
} else {
|
||||
panic!("nominator mismatch. This should never happen.")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn build_support_map<FS>(
|
||||
result: &mut _PhragmenResult<AccountId>,
|
||||
stake_of: FS,
|
||||
) -> _SupportMap<AccountId>
|
||||
where for<'r> FS: Fn(&'r AccountId) -> Balance
|
||||
{
|
||||
let mut supports = <_SupportMap<AccountId>>::new();
|
||||
result.winners
|
||||
.iter()
|
||||
.map(|e| (e, stake_of(e) as f64))
|
||||
.for_each(|(e, s)| {
|
||||
let item = _Support { own: s, total: s, ..Default::default() };
|
||||
supports.insert(e.clone(), item);
|
||||
});
|
||||
|
||||
for (n, assignment) in result.assignments.iter_mut() {
|
||||
for (c, r) in assignment.iter_mut() {
|
||||
let nominator_stake = stake_of(n) as f64;
|
||||
let other_stake = nominator_stake * *r;
|
||||
if let Some(support) = supports.get_mut(c) {
|
||||
support.total = support.total + other_stake;
|
||||
support.others.push((n.clone(), other_stake));
|
||||
}
|
||||
*r = other_stake;
|
||||
}
|
||||
}
|
||||
|
||||
supports
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
// Copyright 2019 Parity Technologies (UK) Ltd.
|
||||
// This file is part of Substrate.
|
||||
|
||||
// Substrate is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
|
||||
// Substrate is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Substrate. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
//! Tests for phragmen.
|
||||
|
||||
#![cfg(test)]
|
||||
|
||||
use crate::mock::*;
|
||||
use crate::{elect, ACCURACY, PhragmenResult};
|
||||
use support::assert_eq_uvec;
|
||||
|
||||
#[test]
|
||||
fn float_phragmen_poc_works() {
|
||||
let candidates = vec![1, 2, 3];
|
||||
let voters = vec![
|
||||
(10, vec![1, 2]),
|
||||
(20, vec![1, 3]),
|
||||
(30, vec![2, 3]),
|
||||
];
|
||||
let stake_of = create_stake_of(&[(10, 10), (20, 20), (30, 30), (1, 0), (2, 0), (3, 0)]);
|
||||
let mut phragmen_result = elect_float(2, 2, candidates, voters, &stake_of, false).unwrap();
|
||||
let winners = phragmen_result.clone().winners;
|
||||
let assignments = phragmen_result.clone().assignments;
|
||||
|
||||
assert_eq_uvec!(winners, vec![2, 3]);
|
||||
assert_eq_uvec!(
|
||||
assignments,
|
||||
vec![
|
||||
(10, vec![(2, 1.0)]),
|
||||
(20, vec![(3, 1.0)]),
|
||||
(30, vec![(2, 0.5), (3, 0.5)]),
|
||||
]
|
||||
);
|
||||
|
||||
let mut support_map = build_support_map(&mut phragmen_result, &stake_of);
|
||||
|
||||
assert_eq!(
|
||||
support_map.get(&2).unwrap(),
|
||||
&_Support { own: 0.0, total: 25.0, others: vec![(10u64, 10.0), (30u64, 15.0)]}
|
||||
);
|
||||
assert_eq!(
|
||||
support_map.get(&3).unwrap(),
|
||||
&_Support { own: 0.0, total: 35.0, others: vec![(20u64, 20.0), (30u64, 15.0)]}
|
||||
);
|
||||
|
||||
equalize_float(phragmen_result.assignments, &mut support_map, 0.0, 2, stake_of);
|
||||
|
||||
assert_eq!(
|
||||
support_map.get(&2).unwrap(),
|
||||
&_Support { own: 0.0, total: 30.0, others: vec![(10u64, 10.0), (30u64, 20.0)]}
|
||||
);
|
||||
assert_eq!(
|
||||
support_map.get(&3).unwrap(),
|
||||
&_Support { own: 0.0, total: 30.0, others: vec![(20u64, 20.0), (30u64, 10.0)]}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn phragmen_poc_works() {
|
||||
let candidates = vec![1, 2, 3];
|
||||
let voters = vec![
|
||||
(10, vec![1, 2]),
|
||||
(20, vec![1, 3]),
|
||||
(30, vec![2, 3]),
|
||||
];
|
||||
|
||||
let PhragmenResult { winners, assignments } = elect::<_, _, _, TestCurrencyToVote>(
|
||||
2,
|
||||
2,
|
||||
candidates,
|
||||
voters,
|
||||
create_stake_of(&[(10, 10), (20, 20), (30, 30)]),
|
||||
false,
|
||||
).unwrap();
|
||||
|
||||
assert_eq_uvec!(winners, vec![2, 3]);
|
||||
assert_eq_uvec!(
|
||||
assignments,
|
||||
vec![
|
||||
(10, vec![(2, ACCURACY)]),
|
||||
(20, vec![(3, ACCURACY)]),
|
||||
(30, vec![(2, ACCURACY/2), (3, ACCURACY/2)]),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn phragmen_poc_2_works() {
|
||||
let candidates = vec![10, 20, 30];
|
||||
let voters = vec![
|
||||
(2, vec![10, 20, 30]),
|
||||
(4, vec![10, 20, 40]),
|
||||
];
|
||||
let stake_of = create_stake_of(&[
|
||||
(10, 1000),
|
||||
(20, 1000),
|
||||
(30, 1000),
|
||||
(40, 1000),
|
||||
(2, 500),
|
||||
(4, 500),
|
||||
]);
|
||||
|
||||
run_and_compare(candidates, voters, stake_of, 2, 2, true);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn phragmen_poc_3_works() {
|
||||
let candidates = vec![10, 20, 30];
|
||||
let voters = vec![
|
||||
(2, vec![10, 20, 30]),
|
||||
(4, vec![10, 20, 40]),
|
||||
];
|
||||
let stake_of = create_stake_of(&[
|
||||
(10, 1000),
|
||||
(20, 1000),
|
||||
(30, 1000),
|
||||
(2, 50),
|
||||
(4, 1000),
|
||||
]);
|
||||
|
||||
run_and_compare(candidates, voters, stake_of, 2, 2, true);
|
||||
}
|
||||
Reference in New Issue
Block a user