Struct HeapSpec

pub struct HeapSpec {
    pub reserved_size: u64,
    pub guard_size: u64,
    pub initial_size: u64,
    pub max_size: Option<u64>,
}

Specifications about the heap of a Lucet module.

Fields

reserved_size: u64

Total bytes of memory for the heap to possibly expand into, as configured for Cranelift codegen.

All of this memory is addressable. Only some part of it is accessible - from 0 to the initial size, guaranteed, and up to the max_size. This size allows Cranelift to elide checks of the base pointer. At the moment that just means checking if it is greater than 4gb, in which case it can elide the base pointer check completely. In the future, Cranelift could use a solver to elide more base pointer checks if it can prove the calculation will always be less than this bound.

Specified in bytes, and must be evenly divisible by the host page size (4K).

guard_size: u64

Total bytes of memory after the reserved area, as configured for Cranelift codegen.

All of this memory is addressable, but it is never accessible - it is guaranteed to trap if an access happens in this region. This size allows Cranelift to use common subexpression elimination to reduce checks of the sum of base pointer and offset (where the offset is always rounded up to a multiple of the guard size, to be friendly to CSE).

Specified in bytes, and must be evenly divisible by the host page size (4K).

initial_size: u64

Total bytes of memory for the WebAssembly program’s linear memory upon initialization.

Specified in bytes, must be evenly divisible by the WebAssembly page size (64K), and must be less than or equal to reserved_size.

max_size: Option<u64>

Maximum bytes of memory for the WebAssembly program’s linear memory at any time.

This is not necessarily the same as reserved_size - we want to be able to tune the check bound there separately than the declaration of a max size in the client program.

The program may optionally define this value. If it does, it must be less than the reserved_size. If it does not, the max size is left up to the runtime, and is allowed to be less than reserved_size.

Implementations

impl HeapSpec

pub fn new( reserved_size: u64, guard_size: u64, initial_size: u64, max_size: Option<u64>, ) -> Self

pub fn empty() -> Self

Some very small test programs dont specify a memory import or definition.

Trait Implementations

impl Clone for HeapSpec

fn clone(&self) -> HeapSpec

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for HeapSpec

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

Formats the value using the given formatter.

impl Default for HeapSpec

fn default() -> HeapSpec

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for HeapSpec

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for HeapSpec

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for HeapSpec

impl StructuralPartialEq for HeapSpec