Method new

crates/wasmtime/src/runtime/vm/memory/malloc.rs:26–66

(
        _ty: &wasmtime_environ::Memory,
        memory_tunables: &MemoryTunables<'_>,
        minimum: usize,
    )

impl MallocMemory {
    pub fn new(
        _ty: &wasmtime_environ::Memory,
        memory_tunables: &MemoryTunables<'_>,
        minimum: usize,
    ) -> Result<Self> {
        if memory_tunables.guard_size() > 0 {
            bail!("malloc memory is only compatible if guard pages aren't used");
        }
        if memory_tunables.reservation() > 0 {
            bail!("malloc memory is only compatible with no ahead-of-time memory reservation");
        }
        if memory_tunables.tunables().memory_init_cow {
            bail!("malloc memory cannot be used with CoW images");
        }

        let initial_allocation_byte_size = minimum
            .checked_add(memory_tunables.reservation_for_growth().try_into()?)
            .context("memory allocation size too large")?;

        let initial_allocation_len = byte_size_to_element_len(initial_allocation_byte_size);
        let mut storage = Vec::new();
        storage
            .try_reserve(initial_allocation_len)
            .with_context(|| {
                format!(
                    "failed to allocate {initial_allocation_byte_size:#x} \
                     bytes ({minimum:#x} minimum + {:#x} memory_reservation_for_growth)",
                    memory_tunables.reservation_for_growth(),
                )
            })?;

        let initial_len = byte_size_to_element_len(minimum);
        if initial_len > 0 {
            grow_storage_to(&mut storage, initial_len);
        }
        Ok(MallocMemory {
            base_ptr: SendSyncPtr::new(NonNull::new(storage.as_mut_ptr()).unwrap()).cast(),
            storage,
            byte_len: minimum,
        })
    }
}

impl RuntimeLinearMemory for MallocMemory {