Struct wasmer_compiler::Engine

pub struct Engine {
    inner: Arc<Mutex<EngineInner>>,
    target: Arc<Target>,
    engine_id: EngineId,
    tunables: Arc<dyn Tunables + Send + Sync>,
    name: String,
    hash_algorithm: Option<HashAlgorithm>,
}

A WebAssembly Universal Engine.

Fields

inner: Arc<Mutex<EngineInner>>

target: Arc<Target>

The target for the compiler

engine_id: EngineId

tunables: Arc<dyn Tunables + Send + Sync>

name: String

hash_algorithm: Option<HashAlgorithm>

Implementations

impl Engine

pub fn new( compiler_config: Box<dyn CompilerConfig>, target: Target, features: Features, ) -> Self

Create a new Engine with the given config

pub fn name(&self) -> &str

Returns the name of this engine

pub fn set_hash_algorithm(&mut self, hash_algorithm: Option<HashAlgorithm>)

Sets the hash algorithm

pub fn hash_algorithm(&self) -> Option<HashAlgorithm>

Returns the hash algorithm

pub fn deterministic_id(&self) -> &str

Returns the deterministic id of this engine

pub fn headless() -> Self

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]) -> Result<Arc<Artifact>, CompileError>

Compile a WebAssembly binary

pub unsafe fn deserialize_unchecked( &self, bytes: OwnedBuffer, ) -> Result<Arc<Artifact>, DeserializeError>

Deserializes a WebAssembly module which was previously serialized with [Module::serialize].

Safety

See Artifact::deserialize_unchecked.

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

Deserializes a WebAssembly module which was previously serialized with [Module::serialize].

Safety

See Artifact::deserialize.

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

Deserializes a WebAssembly module from a path.

Safety

See Artifact::deserialize.

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

Deserialize from a file path.

Safety

See Artifact::deserialize_unchecked.

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) -> Self

Clone the engine

pub fn set_tunables(&mut self, tunables: impl Tunables + Send + Sync + 'static)

Attach a Tunable to this engine

pub fn tunables(&self) -> &dyn Tunables

Get a reference to attached Tunable of this 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 Debug for Engine

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

Formats the value using the given formatter.

impl From<&Engine> for Engine

fn from(engine_ref: &Self) -> Self

Converts to this type from the input type.

impl From<Box<dyn CompilerConfig>> for Engine

fn from(config: Box<dyn CompilerConfig>) -> Self

Converts to this type from the input type.

impl From<EngineBuilder> for Engine

fn from(engine_builder: EngineBuilder) -> Self

Converts to this type from the input type.