Struct Memory

pub struct Memory {
    pub idx_type: IndexType,
    pub limits: Limits,
    pub shared: bool,
    pub page_size_log2: u8,
}

WebAssembly linear memory.

Fields

idx_type: IndexType

The type of the index used to access the memory.

limits: Limits

The limits constrain the minimum and optionally the maximum size of a memory. The limits are given in units of page size.

shared: bool

Whether the memory may be shared between multiple threads.

page_size_log2: u8

The log2 of this memory’s page size, in bytes.

By default the page size is 64KiB (0x10000; 2**16; 1<<16; 65536) but the custom-page-sizes proposal allows opting into a page size of 1.

Implementations

impl Memory

pub const DEFAULT_PAGE_SIZE: u32 = 65_536u32

WebAssembly page sizes are 64KiB by default.

pub const DEFAULT_PAGE_SIZE_LOG2: u8 = 16u8

WebAssembly page sizes are 64KiB (or 2**16) by default.

pub fn minimum_byte_size(&self) -> Result<u64, SizeOverflow>

Returns the minimum size, in bytes, that this memory must be.

Errors

Returns an error if the calculation of the minimum size overflows the u64 return type. This means that the memory can’t be allocated but it’s deferred to the caller to how to deal with that.

pub fn maximum_byte_size(&self) -> Result<u64, SizeOverflow>

Returns the maximum size, in bytes, that this memory is allowed to be.

Note that the return value here is not an Option despite the maximum size of a linear memory being optional in wasm. If a maximum size is not present in the memory’s type then a maximum size is selected for it. For example the maximum size of a 32-bit memory is 1<<32. The maximum size of a 64-bit linear memory is chosen to be a value that won’t ever be allowed at runtime.

Errors

Returns an error if the calculation of the maximum size overflows the u64 return type. This means that the memory can’t be allocated but it’s deferred to the caller to how to deal with that.

pub fn page_size(&self) -> u64

Get the size of this memory’s pages, in bytes.

pub fn max_size_based_on_index_type(&self) -> u64

Returns the maximum size memory is allowed to be only based on the index type used by this memory.

For example 32-bit linear memories return 1<<32 from this method.

pub fn can_use_virtual_memory( &self, tunables: &Tunables, host_page_size_log2: u8, ) -> bool

Returns whether this memory can be implemented with virtual memory on a host with host_page_size_log2.

When this function returns true then it means that signals such as SIGSEGV on the host are compatible with wasm and can be used to represent out-of-bounds memory accesses.

When this function returns false then it means that this memory must, for example, have explicit bounds checks. This additionally means that virtual memory traps (e.g. SIGSEGV) cannot be relied on to implement linear memory semantics.

pub fn can_elide_bounds_check( &self, tunables: &Tunables, host_page_size_log2: u8, ) -> bool

Returns whether this memory is a candidate for bounds check elision given the configuration and host page size.

This function determines whether the given compilation configuration and hos enables possible bounds check elision for this memory. Bounds checks can only be elided if Memory::can_use_virtual_memory returns true for example but there are additionally requirements on the index size of this memory and the memory reservation in tunables.

Currently the only case that supports bounds check elision is when all of these apply:

• When Memory::can_use_virtual_memory returns true.
• This is a 32-bit linear memory (e.g. not 64-bit)
• tunables.memory_reservation is in excess of 4GiB

In this situation all computable addresses fall within the reserved space (modulo static offsets factoring in guard pages) so bounds checks may be elidable.

pub fn static_heap_size(&self) -> Option<u64>

Returns the static size of this heap in bytes at runtime, if available.

This is only computable when the minimum size equals the maximum size.

pub fn memory_may_move(&self, tunables: &Tunables) -> bool

Returs whether or not the base pointer of this memory is allowed to be relocated at runtime.

When this function returns false then it means that after the initial allocation the base pointer is constant for the entire lifetime of a memory. This can enable compiler optimizations, for example.

Trait Implementations

impl Clone for Memory

fn clone(&self) -> Memory

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Memory

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Memory

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<MemoryType> for Memory

fn from(ty: MemoryType) -> Memory

Converts to this type from the input type.

impl Hash for Memory

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Memory

fn eq(&self, other: &Memory) -> 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 Serialize for Memory

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Memory

impl Eq for Memory

impl StructuralPartialEq for Memory