Struct wasmer::Engine

pub struct Engine { /* private fields */ }

A WebAssembly Universal Engine.

Implementations

impl Engine

pub fn new(
    compiler_config: Box<dyn CompilerConfig + 'static, Global>,
    target: Target,
    features: Features
) -> Engine

Create a new Engine with the given config

pub fn headless() -> Engine

Create a headless Engine

A headless engine is an engine without any compiler attached. This is useful for assuring a minimal runtime for running WebAssembly modules.

For example, for running in IoT devices where compilers are very expensive, or also to optimize startup speed.

Important

Headless engines can’t compile or validate any modules, they just take already processed Modules (via Module::serialize).

pub fn inner(&self) -> MutexGuard<'_, EngineInner>

Get reference to EngineInner.

pub fn inner_mut(&self) -> MutexGuard<'_, EngineInner>

Get mutable reference to EngineInner.

pub fn target(&self) -> &Target

Gets the target

pub fn register_signature(
    &self,
    func_type: &FunctionType
) -> VMSharedSignatureIndex

Register a signature

pub fn lookup_signature(
    &self,
    sig: VMSharedSignatureIndex
) -> Option<FunctionType>

Lookup a signature

pub fn validate(&self, binary: &[u8]) -> Result<(), CompileError>

Validates a WebAssembly module

pub fn compile(
    &self,
    binary: &[u8],
    tunables: &dyn Tunables
) -> Result<Arc<Artifact>, CompileError>

Compile a WebAssembly binary

pub unsafe fn deserialize(
    &self,
    bytes: &[u8]
) -> Result<Arc<Artifact>, DeserializeError>

Deserializes a WebAssembly module

Safety

The serialized content must represent a serialized WebAssembly module.

pub unsafe fn deserialize_from_file(
    &self,
    file_ref: &Path
) -> Result<Arc<Artifact>, DeserializeError>

Deserializes a WebAssembly module from a path

Safety

The file’s content must represent a serialized WebAssembly module.

pub fn id(&self) -> &EngineId

A unique identifier for this object.

This exists to allow us to compare two Engines for equality. Otherwise, comparing two trait objects unsafely relies on implementation details of trait representation.

pub fn cloned(&self) -> Engine

Clone the engine

Trait Implementations

impl Clone for Engine

fn clone(&self) -> Engine

Returns a copy of the value.

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

Performs copy-assignment from source.

impl From<&Engine> for Engine

fn from(engine_ref: &Engine) -> Engine

Converts to this type from the input type.

impl From<Box<dyn CompilerConfig + 'static, Global>> for Engine

fn from(config: Box<dyn CompilerConfig + 'static, Global>) -> Engine

Converts to this type from the input type.

impl From<Cranelift> for Engine

fn from(config: Cranelift) -> Engine

Converts to this type from the input type.

impl From<EngineBuilder> for Engine

fn from(engine_builder: EngineBuilder) -> Engine

Converts to this type from the input type.

impl From<Singlepass> for Engine

fn from(config: Singlepass) -> Engine

Converts to this type from the input type.