pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-27 17:28:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Weight annotation. (#3157)

Browse Source 
* Make extrinsics extensible.

Also Remove old extrinsic types.

* Rest of mockup. Add tips.

* Fix some build issues

* Runtiem builds :)

* Substrate builds.

* Fix a doc test

* Compact encoding

* Extract out the era logic into an extension

* Weight Check signed extension. (#3115)

* Weight signed extension.

* Revert a bit + test for check era.

* Update Cargo.toml

* Update node/cli/src/factory_impl.rs

* Update node/executor/src/lib.rs

* Update node/executor/src/lib.rs

* Don't use len for weight - use data.

* Operational Transaction; second attempt (#3138)

* working poc added.

* some fixes.

* Update doc.

* Fix all tests + final logic.

* more refactoring.

* nits.

* System block limit in bytes.

* Silent the storage macro warnings.

* More logic more tests.

* Fix import.

* Refactor names.

* Fix build.

* Update srml/balances/src/lib.rs

* Final refactor.

* Bump transaction version

* Fix weight mult test.

* Fix more tests and improve doc.

* Bump.

* Make some tests work again.

* Fix subkey.

* Remove todos + bump.

* First draft of annotating weights.

* Refactor weight to u64.

* More refactoring and tests.

* New convert for weight to fee

* more tests.

* remove merge redundancy.

* Fix system test.

* Bring back subkey stuff.

* a few stress tests.

* fix some of the grumbles.

* Final nits.

* Update srml/system/src/lib.rs

Co-Authored-By: DemiMarie-parity <48690212+DemiMarie-parity@users.noreply.github.com>

* Scale weights by 1000.

* Bump.

* Fix decl_storage test.
This commit is contained in:
Kian Peymani
2019-07-25 11:58:47 +02:00
committed by Bastian Köcher
parent 80472956f8
commit 002acb9373
44 changed files with 844 additions and 259 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/node/runtime/src/impls.rs
+118 -44
View File
@@ -20,8 +20,16 @@ use node_primitives::Balance;
use runtime_primitives::weights::{Weight, WeightMultiplier};
use runtime_primitives::traits::{Convert, Saturating};
use runtime_primitives::Fixed64;
use support::traits::Get;
use crate::{Balances, MaximumBlockWeight};
use support::traits::{OnUnbalanced, Currency};
use crate::{Balances, Authorship, MaximumBlockWeight, NegativeImbalance};
use crate::constants::fee::TARGET_BLOCK_FULLNESS;
pub struct Author;
impl OnUnbalanced<NegativeImbalance> for Author {
fn on_unbalanced(amount: NegativeImbalance) {
Balances::resolve_creating(&Authorship::author(), amount);
}
}
/// Struct that handles the conversion of Balance -> `u64`. This is used for staking's election
/// calculation.
@@ -39,32 +47,53 @@ impl Convert<u128, Balance> for CurrencyToVoteHandler {
fn convert(x: u128) -> Balance { x * Self::factor() }
}
/// Handles converting a weight scalar to a fee value, based on the scale and granularity of the
/// node's balance type.
///
/// This should typically create a mapping between the following ranges:
/// - [0, system::MaximumBlockWeight]
/// - [Balance::min, Balance::max]
///
/// Yet, it can be used for any other sort of change to weight-fee. Some examples being:
/// - Setting it to `0` will essentially disable the weight fee.
/// - Setting it to `1` will cause the literal `#[weight = x]` values to be charged.
///
/// By default, substrate node will have a weight range of [0, 1_000_000_000].
pub struct WeightToFee;
impl Convert<Weight, Balance> for WeightToFee {
fn convert(x: Weight) -> Balance {
// substrate-node a weight of 10_000 (smallest non-zero weight) to be mapped to 10^7 units of
// fees, hence:
Balance::from(x).saturating_mul(1_000)
}
}
/// A struct that updates the weight multiplier based on the saturation level of the previous block.
/// This should typically be called once per-block.
///
/// This assumes that weight is a numeric value in the u32 range.
///
/// Given `TARGET_BLOCK_FULLNESS = 1/2`, a block saturation greater than 1/2 will cause the system
/// fees to slightly grow and the opposite for block saturations less than 1/2.
///
/// Formula:
/// diff = (ideal_weight - current_block_weight)
/// diff = (target_weight - current_block_weight)
/// v = 0.00004
/// next_weight = weight * (1 + (v . diff) + (v . diff)^2 / 2)
///
/// https://research.web3.foundation/en/latest/polkadot/Token%20Economics/#relay-chain-transaction-fees
pub struct WeightMultiplierUpdateHandler;
impl Convert<(Weight, WeightMultiplier), WeightMultiplier> for WeightMultiplierUpdateHandler {
fn convert(previous_state: (Weight, WeightMultiplier)) -> WeightMultiplier {
let (block_weight, multiplier) = previous_state;
// CRITICAL NOTE: what the system module interprets as maximum block weight, and a portion
// of it (1/4 usually) as ideal weight demonstrate the gap in block weights for operational
// transactions. What this weight multiplier interprets as the maximum, is actually the
// maximum that is available to normal transactions. Hence,
let max_weight = <MaximumBlockWeight as Get<u32>>::get() / 4;
let ideal_weight = (max_weight / 4) as u128;
let max_weight = MaximumBlockWeight::get();
let target_weight = (TARGET_BLOCK_FULLNESS * max_weight) as u128;
let block_weight = block_weight as u128;
// determines if the first_term is positive
let positive = block_weight >= ideal_weight;
let diff_abs = block_weight.max(ideal_weight) - block_weight.min(ideal_weight);
let positive = block_weight >= target_weight;
let diff_abs = block_weight.max(target_weight) - block_weight.min(target_weight);
// diff is within u32, safe.
let diff = Fixed64::from_rational(diff_abs as i64, max_weight as u64);
let diff_squared = diff.saturating_mul(diff);
@@ -81,6 +110,8 @@ impl Convert<(Weight, WeightMultiplier), WeightMultiplier> for WeightMultiplierU
let second_term = v_squared_2.saturating_mul(diff_squared);
if positive {
// Note: this is merely bounded by how big the multiplier and the inner value can go,
// not by any economical reasoning.
let excess = first_term.saturating_add(second_term);
multiplier.saturating_add(WeightMultiplier::from_fixed(excess))
} else {
@@ -90,7 +121,7 @@ impl Convert<(Weight, WeightMultiplier), WeightMultiplier> for WeightMultiplierU
// despite the fact that apply_to saturates weight (final fee cannot go below 0)
// it is crucially important to stop here and don't further reduce the weight fee
// multiplier. While at -1, it means that the network is so un-congested that all
// transactions are practically free. We stop here and only increase if the network
// transactions have no weight fee. We stop here and only increase if the network
// became more busy.
.max(WeightMultiplier::from_rational(-1, 1))
}
@@ -102,13 +133,15 @@ mod tests {
use super::*;
use runtime_primitives::weights::Weight;
use runtime_primitives::Perbill;
use crate::{MaximumBlockWeight, AvailableBlockRatio, Runtime};
use crate::constants::currency::*;
fn max() -> Weight {
<MaximumBlockWeight as Get<Weight>>::get()
MaximumBlockWeight::get()
}
fn ideal() -> Weight {
max() / 4 / 4
fn target() -> Weight {
TARGET_BLOCK_FULLNESS * max()
}
// poc reference implementation.
@@ -120,7 +153,7 @@ mod tests {
// maximum tx weight
let m = max() as f32;
// Ideal saturation in terms of weight
let ss = ideal() as f32;
let ss = target() as f32;
// Current saturation in terms of weight
let s = block_weight;
@@ -130,52 +163,93 @@ mod tests {
Perbill::from_parts((fm * 1_000_000_000_f32) as u32)
}
fn fm(parts: i64) -> WeightMultiplier {
fn wm(parts: i64) -> WeightMultiplier {
WeightMultiplier::from_parts(parts)
}
#[test]
fn empty_chain_simulation() {
// just a few txs per_block.
let block_weight = 1000;
let mut wm = WeightMultiplier::default();
let mut iterations: u64 = 0;
loop {
let next = WeightMultiplierUpdateHandler::convert((block_weight, wm));
wm = next;
if wm == WeightMultiplier::from_rational(-1, 1) { break; }
iterations += 1;
}
println!("iteration {}, new wm = {:?}. Weight fee is now zero", iterations, wm);
}
#[test]
#[ignore]
fn congested_chain_simulation() {
// `cargo test congested_chain_simulation -- --nocapture` to get some insight.
// almost full. The entire quota of normal transactions is taken.
let block_weight = AvailableBlockRatio::get() * max();
let tx_weight = 1000;
let mut wm = WeightMultiplier::default();
let mut iterations: u64 = 0;
loop {
let next = WeightMultiplierUpdateHandler::convert((block_weight, wm));
if wm == next { break; }
wm = next;
iterations += 1;
let fee = <Runtime as balances::Trait>::WeightToFee::convert(wm.apply_to(tx_weight));
println!(
"iteration {}, new wm = {:?}. Fee at this point is: {} millicents, {} cents, {} dollars",
iterations,
wm,
fee / MILLICENTS,
fee / CENTS,
fee / DOLLARS
);
}
}
#[test]
fn stateless_weight_mul() {
// Light block. Fee is reduced a little.
assert_eq!(
WeightMultiplierUpdateHandler::convert((ideal() / 4, WeightMultiplier::default())),
fm(-7500)
WeightMultiplierUpdateHandler::convert((target() / 4, WeightMultiplier::default())),
wm(-7500)
);
// a bit more. Fee is decreased less, meaning that the fee increases as the block grows.
assert_eq!(
WeightMultiplierUpdateHandler::convert((ideal() / 2, WeightMultiplier::default())),
fm(-5000)
WeightMultiplierUpdateHandler::convert((target() / 2, WeightMultiplier::default())),
wm(-5000)
);
// ideal. Original fee. No changes.
assert_eq!(
WeightMultiplierUpdateHandler::convert((ideal() as u32, WeightMultiplier::default())),
fm(0)
WeightMultiplierUpdateHandler::convert((target(), WeightMultiplier::default())),
wm(0)
);
// // More than ideal. Fee is increased.
assert_eq!(
WeightMultiplierUpdateHandler::convert(((ideal() * 2) as u32, WeightMultiplier::default())),
fm(10000)
WeightMultiplierUpdateHandler::convert(((target() * 2), WeightMultiplier::default())),
wm(10000)
);
}
#[test]
fn stateful_weight_mul_grow_to_infinity() {
assert_eq!(
WeightMultiplierUpdateHandler::convert((ideal() * 2, WeightMultiplier::default())),
fm(10000)
WeightMultiplierUpdateHandler::convert((target() * 2, WeightMultiplier::default())),
wm(10000)
);
assert_eq!(
WeightMultiplierUpdateHandler::convert((ideal() * 2, fm(10000))),
fm(20000)
WeightMultiplierUpdateHandler::convert((target() * 2, wm(10000))),
wm(20000)
);
assert_eq!(
WeightMultiplierUpdateHandler::convert((ideal() * 2, fm(20000))),
fm(30000)
WeightMultiplierUpdateHandler::convert((target() * 2, wm(20000))),
wm(30000)
);
// ...
assert_eq!(
WeightMultiplierUpdateHandler::convert((ideal() * 2, fm(1_000_000_000))),
fm(1_000_000_000 + 10000)
WeightMultiplierUpdateHandler::convert((target() * 2, wm(1_000_000_000))),
wm(1_000_000_000 + 10000)
);
}
@@ -183,28 +257,26 @@ mod tests {
fn stateful_weight_mil_collapse_to_minus_one() {
assert_eq!(
WeightMultiplierUpdateHandler::convert((0, WeightMultiplier::default())),
fm(-10000)
wm(-10000)
);
assert_eq!(
WeightMultiplierUpdateHandler::convert((0, fm(-10000))),
fm(-20000)
WeightMultiplierUpdateHandler::convert((0, wm(-10000))),
wm(-20000)
);
assert_eq!(
WeightMultiplierUpdateHandler::convert((0, fm(-20000))),
fm(-30000)
WeightMultiplierUpdateHandler::convert((0, wm(-20000))),
wm(-30000)
);
// ...
assert_eq!(
WeightMultiplierUpdateHandler::convert((0, fm(1_000_000_000 * -1))),
fm(-1_000_000_000)
WeightMultiplierUpdateHandler::convert((0, wm(1_000_000_000 * -1))),
wm(-1_000_000_000)
);
}
#[test]
fn weight_to_fee_should_not_overflow_on_large_weights() {
// defensive-only test. at the moment we are not allowing any weight more than
// 4 * 1024 * 1024 in a block.
let kb = 1024_u32;
let kb = 1024 as Weight;
let mb = kb * kb;
let max_fm = WeightMultiplier::from_fixed(Fixed64::from_natural(i64::max_value()));
@@ -214,7 +286,9 @@ mod tests {
WeightMultiplierUpdateHandler::convert((i, WeightMultiplier::default()));
});
vec![10 * mb, Weight::max_value() / 2, Weight::max_value()]
// Some values that are all above the target and will cause an increase.
let t = target();
vec![t + 100, t * 2, t * 4]
.into_iter()
.for_each(|i| {
let fm = WeightMultiplierUpdateHandler::convert((