Enum wasmtime_environ::MemoryInitialization

pub enum MemoryInitialization {
    Segmented(Vec<MemoryInitializer>),
    Paged {
        map: PrimaryMap<DefinedMemoryIndex, Vec<(u64, Range<u32>)>>,
        out_of_bounds: bool,
    },
}

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

Variants

Segmented(Vec<MemoryInitializer>)

Tuple Fields

0: 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

Fields

map: PrimaryMap<DefinedMemoryIndex, Vec<(u64, Range<u32>)>>

The map of defined memory index to a list of initialization pages.

The list of page data is sparse, with each element starting with the offset in memory where it will be placed (specified here, as a page index, with a u64). Each page of initialization data is WebAssembly page-sized (64 KiB). Pages whose offset are not specified in this array start with 0s in memory. The Range indices, like those in MemoryInitializer, point within a data segment that will come as an auxiliary descriptor with other data such as the compiled code for the wasm module.

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.

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.

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.