Enum wasmtime_environ::MemoryInitialization

pub enum MemoryInitialization {
    Segmented(Vec<MemoryInitializer>),
    Paged {
        map: PrimaryMap<DefinedMemoryIndex, Vec<Option<Box<[u8]>>>>,
        out_of_bounds: bool,
    },
}

The type of WebAssembly linear memory initialization to use for a module.

Variants

Segmented(Vec<MemoryInitializer>)

Memory initialization is segmented.

Segmented initialization can be used for any module, but it is required if:

• A data segment referenced an imported memory.
• A data segment uses a global base.

Segmented initialization is performed by processing the complete set of data segments when the module is instantiated.

This is the default memory initialization type.

Paged

Memory initialization is paged.

To be paged, the following requirements must be met:

• All data segments must reference defined memories.
• All data segments must not use a global base.

Paged initialization is performed by copying (or mapping) entire WebAssembly pages to each linear memory.

The uffd feature makes use of this type of memory initialization because it can instruct the kernel to back an entire WebAssembly page from an existing set of in-memory pages.

By processing the data segments at module compilation time, the uffd fault handler doesn’t have to do any work to point the kernel at the right linear memory page to use.

Fields of Paged

map: PrimaryMap<DefinedMemoryIndex, Vec<Option<Box<[u8]>>>>

The map of defined memory index to a list of initialization pages. The list of page data is sparse, with None representing a zero page. Each page of initialization data is WebAssembly page-sized (64 KiB). The size of the list will be the maximum page written to by a data segment.

out_of_bounds: bool

Whether or not an out-of-bounds data segment was observed. This is used to fail module instantiation after the pages are initialized.

Implementations

impl MemoryInitialization

pub fn to_paged(&self, module: &Module) -> Option<Self>

Attempts to convert segmented memory initialization into paged initialization for the given module.

Returns None if the initialization cannot be paged or if it is already paged.

Trait Implementations

impl Clone for MemoryInitialization

fn clone(&self) -> MemoryInitialization

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MemoryInitialization

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

Formats the value using the given formatter.

impl Default for MemoryInitialization

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MemoryInitialization

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for MemoryInitialization

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

Serialize this value into the given Serde serializer.