Struct core_processor::configs::PageCosts

pub struct PageCosts {
    pub lazy_pages_signal_read: CostPerPage<GearPage>,
    pub lazy_pages_signal_write: CostPerPage<GearPage>,
    pub lazy_pages_signal_write_after_read: CostPerPage<GearPage>,
    pub lazy_pages_host_func_read: CostPerPage<GearPage>,
    pub lazy_pages_host_func_write: CostPerPage<GearPage>,
    pub lazy_pages_host_func_write_after_read: CostPerPage<GearPage>,
    pub load_page_data: CostPerPage<GearPage>,
    pub upload_page_data: CostPerPage<GearPage>,
    pub static_page: CostPerPage<WasmPage>,
    pub mem_grow: CostPerPage<WasmPage>,
    pub parachain_load_heuristic: CostPerPage<GearPage>,
}

Memory operations costs.

Each weight with lazy_pages_ prefix contains weight for storage read, because for each first page access we need at least check if 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: CostPerPage<GearPage>

Cost per one GearPage signal read processing in lazy-pages.

lazy_pages_signal_write: CostPerPage<GearPage>

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

lazy_pages_signal_write_after_read: CostPerPage<GearPage>

Cost per one GearPage signal write after read processing in lazy-pages.

lazy_pages_host_func_read: CostPerPage<GearPage>

Cost per one GearPage host func read access processing in lazy-pages.

lazy_pages_host_func_write: CostPerPage<GearPage>

Cost per one GearPage host func write access processing in lazy-pages.

lazy_pages_host_func_write_after_read: CostPerPage<GearPage>

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

load_page_data: CostPerPage<GearPage>

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: CostPerPage<GearPage>

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.

static_page: CostPerPage<WasmPage>

Cost per one WasmPage static page. Static pages can have static data, and executor must to move this data to static pages before execution.

mem_grow: CostPerPage<WasmPage>

Cost per one WasmPage for memory growing.

parachain_load_heuristic: CostPerPage<GearPage>

Cost per one GearPage storage read, when para-chain execution.

Implementations

impl PageCosts

pub fn lazy_pages_weights(&self) -> LazyPagesWeights

Calculates and returns weights for lazy-pages.

pub fn new_for_tests() -> Self

New one for tests usage.

Trait Implementations

impl Clone for PageCosts

fn clone(&self) -> PageCosts

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PageCosts

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

Formats the value using the given formatter.

impl Decode for PageCosts

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 Default for PageCosts

fn default() -> PageCosts

Returns the “default value” for a type.

impl Encode for PageCosts

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

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

fn size_hint(&self) -> usize

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

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

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere 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 EncodeLike<PageCosts> for PageCosts