Struct frame_support::weights::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 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_consume(&self, w: Weight) -> bool

Check if the given weight can be consumed.

pub fn reclaim_proof_size(&mut self, s: u64)

Reclaim the given weight.

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.