Struct Memory

pub struct Memory {
    pub minimum: u64,
    pub maximum: Option<u64>,
    pub shared: bool,
    pub memory64: bool,
    pub page_size_log2: u8,
}

WebAssembly linear memory.

Fields

minimum: u64

The minimum number of pages in the memory.

maximum: Option<u64>

The maximum number of pages in the memory.

shared: bool

Whether the memory may be shared between multiple threads.

memory64: bool

Whether or not this is a 64-bit memory

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.

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