Struct xcm_simulator::WeightMeter

pub struct WeightMeter { /* private fields */ }

Meters consumed weight and a hard limit for the maximal consumable weight.

Can be used to check if enough weight for an operation is available before committing to it.

Example

use sp_weights::{Weight, WeightMeter};

// The weight is limited to (10, 0).
let mut meter = WeightMeter::with_limit(Weight::from_parts(10, 0));
// There is enough weight remaining for an operation with (6, 0) weight.
assert!(meter.try_consume(Weight::from_parts(6, 0)).is_ok());
assert_eq!(meter.remaining(), Weight::from_parts(4, 0));
// There is not enough weight remaining for an operation with (5, 0) weight.
assert!(!meter.try_consume(Weight::from_parts(5, 0)).is_ok());
// The total limit is obviously unchanged:
assert_eq!(meter.limit(), Weight::from_parts(10, 0));

Implementations

impl WeightMeter

pub fn with_limit(limit: Weight) -> WeightMeter

Creates Self from a limit for the maximal consumable weight.

pub fn new() -> WeightMeter

Creates Self with the maximal possible limit for the consumable weight.

pub fn consumed(&self) -> Weight

The already consumed weight.

pub fn limit(&self) -> Weight

The limit can ever be accrued.

pub fn remaining(&self) -> Weight

The remaining weight that can still be consumed.

pub fn consumed_ratio(&self) -> Perbill

The ratio of consumed weight to the limit.

Calculates one ratio per component and returns the largest.

Example

use sp_weights::{Weight, WeightMeter};
use sp_arithmetic::Perbill;

let mut meter = WeightMeter::with_limit(Weight::from_parts(10, 20));
// Nothing consumed so far:
assert_eq!(meter.consumed_ratio(), Perbill::from_percent(0));
meter.consume(Weight::from_parts(5, 5));
// The ref-time is the larger ratio:
assert_eq!(meter.consumed_ratio(), Perbill::from_percent(50));
meter.consume(Weight::from_parts(1, 10));
// Now the larger ratio is proof-size:
assert_eq!(meter.consumed_ratio(), Perbill::from_percent(75));
// Eventually it reaches 100%:
meter.consume(Weight::from_parts(4, 0));
assert_eq!(meter.consumed_ratio(), Perbill::from_percent(100));
// Saturating the second component won't change anything anymore:
meter.consume(Weight::from_parts(0, 5));
assert_eq!(meter.consumed_ratio(), Perbill::from_percent(100));

pub fn defensive_saturating_accrue(&mut self, w: Weight)

👎Deprecated: Use consume instead. Will be removed after December 2023.

Consume some weight and defensively fail if it is over the limit. Saturate in any case.

pub fn consume(&mut self, w: Weight)

Consume some weight and defensively fail if it is over the limit. Saturate in any case.

pub fn check_accrue(&mut self, w: Weight) -> bool

👎Deprecated: Use try_consume instead. Will be removed after December 2023.

Consume the given weight after checking that it can be consumed and return true. Otherwise do nothing and return false.

pub fn try_consume(&mut self, w: Weight) -> Result<(), ()>

Consume the given weight after checking that it can be consumed.

Returns Ok if the weight can be consumed or otherwise an Err.

pub fn can_accrue(&self, w: Weight) -> bool

👎Deprecated: Use can_consume instead. Will be removed after December 2023.

Check if the given weight can be consumed.

pub fn can_consume(&self, w: Weight) -> bool

Check if the given weight can be consumed.

Trait Implementations

impl Clone for WeightMeter

fn clone(&self) -> WeightMeter

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WeightMeter

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.