Struct InstanceAllocator 

pub struct InstanceAllocator { /* private fields */ }

This is an intermediate type that manages the raw allocation and metadata when creating a VMInstance.

This type will free the allocated memory if it’s dropped before being used.

It is important to remind that VMInstance is dynamically-sized based on VMOffsets: The Instance.vmctx field represents a dynamically-sized array that extends beyond the nominal end of the type. So in order to create an instance of it, we must:

1. Define the correct layout for Instance (size and alignment),
2. Allocate it properly.

The InstanceAllocator::instance_layout helper computes the correct layout to represent the wanted VMInstance.

Then we use this layout to allocate an empty Instance properly.

Implementations

impl InstanceAllocator

pub fn new( module: &ModuleInfo, ) -> (Self, Vec<NonNull<VMMemoryDefinition>>, Vec<NonNull<VMTableDefinition>>, Vec<NonNull<VMGlobalDefinition>>)

Allocates instance data for use with VMInstance::new.

Returns a wrapper type around the allocation and 2 vectors of pointers into the allocated buffer. These lists of pointers correspond to the location in memory for the local memories and tables respectively. These pointers should be written to before calling VMInstance::new.

pub fn new_with_offsets( offsets: VMOffsets, module: &ModuleInfo, ) -> (Self, Vec<NonNull<VMMemoryDefinition>>, Vec<NonNull<VMTableDefinition>>, Vec<NonNull<VMGlobalDefinition>>)

Same as InstanceAllocator::new, but accepts pre-computed VMOffsets instead of computing them from the module.

VMOffsets::new(pointer_size, module) is deterministic given (pointer_size, module), and the pointer_size is fixed to size_of::<usize>() on the host. Callers that instantiate the same module repeatedly (per-request wasm hosts: cloud workers, CosmWasm, op-vm, …) can compute the offsets once at compile/cache time and pass them here to skip the recomputation on every Instance::new.

Caller contract

offsets MUST equal VMOffsets::new(size_of::<usize>() as u8, module) for the same module. Passing offsets computed for a different module, or with a different pointer size, will produce an incorrectly sized allocation and undefined behavior. Callers that cache the offsets should key the cache by the same ModuleInfo they pass here.

Trait Implementations

impl Drop for InstanceAllocator

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.