Struct wasmer::Memory

pub struct Memory(/* private fields */);

A WebAssembly memory instance.

A memory instance is the runtime representation of a linear memory. It consists of a vector of bytes and an optional maximum size.

The length of the vector always is a multiple of the WebAssembly page size, which is defined to be the constant 65536 – abbreviated 64Ki. Like in a memory type, the maximum size in a memory instance is given in units of this page size.

A memory created by the host or in WebAssembly code will be accessible and mutable from both host and WebAssembly.

Spec: https://webassembly.github.io/spec/core/exec/runtime.html#memory-instances

Implementations

impl Memory

pub fn new( store: &mut impl AsStoreMut, ty: MemoryType, ) -> Result<Self, MemoryError>

Creates a new host Memory from the provided MemoryType.

This function will construct the Memory using the store BaseTunables.

Example

let m = Memory::new(&mut store, MemoryType::new(1, None, false)).unwrap();

pub fn new_from_existing( new_store: &mut impl AsStoreMut, memory: VMMemory, ) -> Self

Create a memory object from an existing memory and attaches it to the store

pub fn ty(&self, store: &impl AsStoreRef) -> MemoryType

Returns the MemoryType of the Memory.

Example

let mt = MemoryType::new(1, None, false);
let m = Memory::new(&mut store, mt).unwrap();

assert_eq!(m.ty(&mut store), mt);

pub fn view<'a>(&self, store: &'a (impl AsStoreRef + ?Sized)) -> MemoryView<'a>

Creates a view into the memory that then allows for read and write

pub fn grow<IntoPages>( &self, store: &mut impl AsStoreMut, delta: IntoPages, ) -> Result<Pages, MemoryError>

where IntoPages: Into<Pages>,

Grow memory by the specified amount of WebAssembly Pages and return the previous memory size.

Example

let m = Memory::new(&mut store, MemoryType::new(1, Some(3), false)).unwrap();
let p = m.grow(&mut store, 2).unwrap();

assert_eq!(p, Pages(1));
assert_eq!(m.view(&mut store).size(), Pages(3));

Errors

Returns an error if memory can’t be grown by the specified amount of pages.

let m = Memory::new(&mut store, MemoryType::new(1, Some(1), false)).unwrap();

// This results in an error: `MemoryError::CouldNotGrow`.
let s = m.grow(&mut store, 1).unwrap();

pub fn grow_at_least( &self, store: &mut impl AsStoreMut, min_size: u64, ) -> Result<(), MemoryError>

Grows the memory to at least a minimum size. If the memory is already big enough for the min size then this function does nothing

pub fn reset(&self, store: &mut impl AsStoreMut) -> Result<(), MemoryError>

Resets the memory back to zero length

pub fn copy_to_store( &self, store: &impl AsStoreRef, new_store: &mut impl AsStoreMut, ) -> Result<Self, MemoryError>

Attempts to duplicate this memory (if its clonable) in a new store (copied memory)

pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool

Checks whether this Memory can be used with the given context.

pub fn try_clone( &self, store: &impl AsStoreRef, ) -> Result<VMMemory, MemoryError>

Attempts to clone this memory (if its clonable)

pub fn share_in_store( &self, store: &impl AsStoreRef, new_store: &mut impl AsStoreMut, ) -> Result<Self, MemoryError>

Attempts to clone this memory (if its clonable) in a new store (cloned memory will be shared between those that clone it)

pub fn as_shared(&self, store: &impl AsStoreRef) -> Option<SharedMemory>

Get a SharedMemory.

Only returns Some(_) if the memory is shared, and if the target backend supports shared memory operations.

See SharedMemory and its methods for more information.

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<'a> Exportable<'a> for Memory

fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError>

Implementation of how to get the export corresponding to the implementing type from an Instance by name.

impl From<Memory> for Extern

fn from(r: Memory) -> Self

Converts to this type from the input type.

impl PartialEq for Memory

fn eq(&self, other: &Memory) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Memory

impl StructuralPartialEq for Memory