Struct pallet_gear::MemoryWeights

pub struct MemoryWeights<T: Config> {
    pub lazy_pages_signal_read: Weight,
    pub lazy_pages_signal_write: Weight,
    pub lazy_pages_signal_write_after_read: Weight,
    pub lazy_pages_host_func_read: Weight,
    pub lazy_pages_host_func_write: Weight,
    pub lazy_pages_host_func_write_after_read: Weight,
    pub load_page_data: Weight,
    pub upload_page_data: Weight,
    pub mem_grow: Weight,
    pub mem_grow_per_page: Weight,
    pub parachain_read_heuristic: Weight,
    pub _phantom: PhantomData<T>,
}

Describes the weight for memory interaction.

Each weight with lazy_pages_ prefix includes weight for storage read, because for each first page access we need to at least check whether page exists in storage. But they do not include cost for loading page data from storage into program memory. This weight is taken in account separately, when loading occurs.

Lazy-pages write accesses does not include cost for uploading page data to storage, because uploading happens after execution, so benchmarks do not include this cost. But they include cost for processing changed page data in runtime.

Fields

lazy_pages_signal_read: Weight

Cost per one [GearPage] signal read processing in lazy-pages,

lazy_pages_signal_write: Weight

Cost per one [GearPage] signal write processing in lazy-pages,

lazy_pages_signal_write_after_read: Weight

Cost per one [GearPage] signal write after read processing in lazy-pages,

lazy_pages_host_func_read: Weight

Cost per one [GearPage] host func read access processing in lazy-pages,

lazy_pages_host_func_write: Weight

Cost per one [GearPage] host func write access processing in lazy-pages,

lazy_pages_host_func_write_after_read: Weight

Cost per one [GearPage] host func write after read access processing in lazy-pages,

load_page_data: Weight

Cost per one [GearPage] data loading from storage and moving it in program memory. Does not include cost for storage read, because it is taken in account separately.

upload_page_data: Weight

Cost per one [GearPage] uploading data to storage. Does not include cost for processing changed page data in runtime, cause it is taken in account separately.

mem_grow: Weight

Cost per one [WasmPage] for memory growing.

mem_grow_per_page: Weight

Cost per one [WasmPage] for memory growing.

parachain_read_heuristic: Weight

Cost per one [GearPage]. When we read page data from storage in para-chain, then it should be sent to relay-chain, in order to use it for process queue execution. So, reading from storage cause additional resources consumption after block(s) production on para-chain.

_phantom: PhantomData<T>

The type parameter is used in the default implementation.

Trait Implementations

impl<T: Clone + Config> Clone for MemoryWeights<T>

fn clone(&self) -> MemoryWeights<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Config> Debug for MemoryWeights<T>

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

Formats the value using the given formatter.

impl<T: Config> Decode for MemoryWeights<T>

where PhantomData<T>: Default,

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<T: Config> Default for MemoryWeights<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T: Config> Deserialize<'de> for MemoryWeights<T>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Config> Encode for MemoryWeights<T>

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<T: Config> From<MemoryWeights<T>> for LazyPagesCosts

fn from(val: MemoryWeights<T>) -> Self

Converts to this type from the input type.

impl<T: PartialEq + Config> PartialEq for MemoryWeights<T>

fn eq(&self, other: &MemoryWeights<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Config> Serialize for MemoryWeights<T>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> TypeInfo for MemoryWeights<T>

where PhantomData<T>: TypeInfo + 'static, T: Config + 'static,

type Identity = MemoryWeights<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<T: Config> EncodeLike for MemoryWeights<T>

impl<T: Eq + Config> Eq for MemoryWeights<T>

impl<T: Config> StructuralPartialEq for MemoryWeights<T>