Struct frame_system::limits::BlockWeights
source · pub struct BlockWeights {
pub base_block: Weight,
pub max_block: Weight,
pub per_class: PerDispatchClass<WeightsPerClass>,
}
Expand description
Block weight limits & base values configuration.
This object is responsible for defining weight limits and base weight values tracked during extrinsic execution.
Each block starts with base_block
weight being consumed right away. Next up the
on_initialize
pallet callbacks are invoked and their cost is added before any extrinsic
is executed. This cost is tracked as Mandatory
dispatch class.
| | `max_block` | |
| | | |
| | | |
| | | |
| | | #| `on_initialize`
| #| `base_block` | #|
|NOM| |NOM|
||\_ Mandatory
|\__ Operational
\___ Normal
The remaining capacity can be used to dispatch extrinsics. Note that each dispatch class
is being tracked separately, but the sum can’t exceed max_block
(except for reserved
).
Below you can see a picture representing full block with 3 extrinsics (two Operational
and
one Normal
). Each class has it’s own limit max_total
, but also the sum cannot exceed
max_block
value.
-- `Mandatory` limit (unlimited)
| # | | |
| # | `Ext3` | - - `Operational` limit
|# | `Ext2` |- - `Normal` limit
| # | `Ext1` | # |
| #| `on_initialize` | ##|
| #| `base_block` |###|
|NOM| |NOM|
It should be obvious now that it’s possible for one class to reach it’s limit (say Normal
),
while the block has still capacity to process more transactions (max_block
not reached,
Operational
transactions can still go in). Setting max_total
to None
disables the
per-class limit. This is generally highly recommended for Mandatory
dispatch class, while it
can be dangerous for Normal
class and should only be done with extra care and consideration.
Often it’s desirable for some class of transactions to be added to the block despite it being
full. For instance one might want to prevent high-priority Normal
transactions from pushing
out lower-priority Operational
transactions. In such cases you might add a reserved
capacity
for given class.
_
| # | `Ext7 | - - `Operational` limit
|# | `Ext6` | |
|# | `Ext5` |-# - `Normal` limit
|# | `Ext4` |## |
| #| `on_initialize` |###|
| #| `base_block` |###|
|NOM| |NOM|
In the above example, Ext4-6
fill up the block almost up to max_block
. Ext7
would not fit
if there wasn’t the extra reserved
space for Operational
transactions. Note that max_total
limit applies to reserved
space as well (i.e. the sum of weights of Ext7
& Ext8
mustn’t
exceed it). Setting reserved
to None
allows the extrinsics to always get into the block up
to their max_total
limit. If max_total
is set to None
as well, all extrinsics witch
dispatchables of given class will always end up in the block (recommended for Mandatory
dispatch class).
As a consequence of reserved
space, total consumed block weight might exceed max_block
value, so this parameter should rather be thought of as “target block weight” than a hard limit.
Fields
base_block: Weight
Base weight of block execution.
max_block: Weight
Maximal total weight consumed by all kinds of extrinsics (without reserved
space).
per_class: PerDispatchClass<WeightsPerClass>
Weight limits for extrinsics of given dispatch class.
Implementations
sourceimpl BlockWeights
impl BlockWeights
sourcepub fn get(&self, class: DispatchClass) -> &WeightsPerClass
pub fn get(&self, class: DispatchClass) -> &WeightsPerClass
Get per-class weight settings.
sourcepub fn validate(self) -> ValidationResult
pub fn validate(self) -> ValidationResult
Verifies correctness of this BlockWeights
object.
sourcepub fn simple_max(block_weight: Weight) -> Self
pub fn simple_max(block_weight: Weight) -> Self
Create new weights definition, with both Normal
and Operational
classes limited to given weight.
Note there is no reservation for Operational
class, so this constructor
is not suitable for production deployments.
sourcepub fn with_sensible_defaults(
expected_block_weight: Weight,
normal_ratio: Perbill
) -> Self
pub fn with_sensible_defaults(
expected_block_weight: Weight,
normal_ratio: Perbill
) -> Self
Create a sensible default weights system given only expected maximal block weight and the
ratio that Normal
extrinsics should occupy.
Assumptions:
- Average block initialization is assumed to be
10%
. Operational
transactions have reserved allowance (1.0 - normal_ratio
)
sourcepub fn builder() -> BlockWeightsBuilder
pub fn builder() -> BlockWeightsBuilder
Start constructing new BlockWeights
object.
By default all kinds except of Mandatory
extrinsics are disallowed.
Trait Implementations
sourceimpl Clone for BlockWeights
impl Clone for BlockWeights
sourcefn clone(&self) -> BlockWeights
fn clone(&self) -> BlockWeights
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresourceimpl Debug for BlockWeights
impl Debug for BlockWeights
sourceimpl Decode for BlockWeights
impl Decode for BlockWeights
sourcefn decode<__CodecInputEdqy: Input>(
__codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Self, Error>
fn decode<__CodecInputEdqy: Input>(
__codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Self, Error>
fn skip<I>(input: &mut I) -> Result<(), Error>where
I: Input,
fn skip<I>(input: &mut I) -> Result<(), Error>where
I: Input,
fn encoded_fixed_size() -> Option<usize>
fn encoded_fixed_size() -> Option<usize>
sourceimpl Default for BlockWeights
impl Default for BlockWeights
sourceimpl Encode for BlockWeights
impl Encode for BlockWeights
sourcefn encode_to<__CodecOutputEdqy: Output + ?Sized>(
&self,
__codec_dest_edqy: &mut __CodecOutputEdqy
)
fn encode_to<__CodecOutputEdqy: Output + ?Sized>(
&self,
__codec_dest_edqy: &mut __CodecOutputEdqy
)
fn using_encoded<R, F>(&self, f: F) -> Rwhere
F: FnOnce(&[u8]) -> R,
fn using_encoded<R, F>(&self, f: F) -> Rwhere
F: FnOnce(&[u8]) -> R,
fn encoded_size(&self) -> usize
fn encoded_size(&self) -> usize
sourceimpl TypeInfo for BlockWeights
impl TypeInfo for BlockWeights
type Identity = BlockWeights
type Identity = BlockWeights
impl EncodeLike<BlockWeights> for BlockWeights
Auto Trait Implementations
impl RefUnwindSafe for BlockWeights
impl Send for BlockWeights
impl Sync for BlockWeights
impl Unpin for BlockWeights
impl UnwindSafe for BlockWeights
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
sourceimpl<T> CheckedConversion for T
impl<T> CheckedConversion for T
sourcefn checked_from<T>(t: T) -> Option<Self>where
Self: TryFrom<T>,
fn checked_from<T>(t: T) -> Option<Self>where
Self: TryFrom<T>,
sourcefn checked_into<T>(self) -> Option<T>where
Self: TryInto<T>,
fn checked_into<T>(self) -> Option<T>where
Self: TryInto<T>,
impl<T> DecodeAll for Twhere
T: Decode,
impl<T> DecodeAll for Twhere
T: Decode,
fn decode_all(input: &mut &[u8]) -> Result<T, Error>
fn decode_all(input: &mut &[u8]) -> Result<T, Error>
Self
and consume all of the given input data. Read moreimpl<T> DecodeLimit for Twhere
T: Decode,
impl<T> DecodeLimit for Twhere
T: Decode,
fn decode_all_with_depth_limit(limit: u32, input: &mut &[u8]) -> Result<T, Error>
fn decode_all_with_depth_limit(limit: u32, input: &mut &[u8]) -> Result<T, Error>
Self
and consume all of the given input data. Read morefn decode_with_depth_limit<I>(limit: u32, input: &mut I) -> Result<T, Error>where
I: Input,
fn decode_with_depth_limit<I>(limit: u32, input: &mut I) -> Result<T, Error>where
I: Input,
Self
with the given maximum recursion depth and advance input
by the number of
bytes consumed. Read moreimpl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
. Read morefn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read morefn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read morefn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read moresourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
sourceimpl<T, Outer> IsWrappedBy<Outer> for Twhere
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,
impl<T, Outer> IsWrappedBy<Outer> for Twhere
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,
impl<T> Pointable for T
impl<T> Pointable for T
sourceimpl<T> SaturatedConversion for T
impl<T> SaturatedConversion for T
sourcefn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,
fn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,
sourcefn saturated_into<T>(self) -> Twhere
Self: UniqueSaturatedInto<T>,
fn saturated_into<T>(self) -> Twhere
Self: UniqueSaturatedInto<T>,
T
. Read moresourceimpl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,
impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,
sourcefn unchecked_into(self) -> T
fn unchecked_into(self) -> T
unchecked_from
.sourceimpl<T, S> UniqueSaturatedInto<T> for Swhere
T: Bounded,
S: TryInto<T>,
impl<T, S> UniqueSaturatedInto<T> for Swhere
T: Bounded,
S: TryInto<T>,
sourcefn unique_saturated_into(self) -> T
fn unique_saturated_into(self) -> T
T
.