Struct Engine 

pub struct Engine {
    pub(crate) be: BackendEngine,
    pub(crate) id: u64,
}

The Engine is the entrypoint type for the runtime. It defines the kind of steps the runtime must take to execute the WebAssembly module (compile, interpret..) and the place of execution (in-browser, host, ..).

Fields

be: BackendEngine

id: u64

Implementations

impl Engine

pub fn into_sys(self) -> Engine

Consume self into a crate::backend::sys::engine::Engine.

pub fn as_sys(&self) -> &Engine

Convert a reference to self into a reference crate::backend::sys::engine::Engine.

pub fn as_sys_mut(&mut self) -> &mut Engine

Convert a mutable reference to self into a mutable reference crate::backend::sys::engine::Engine.

pub fn is_sys(&self) -> bool

Return true if self is an engine from the sys runtime.

impl Engine

pub(crate) fn atomic_next_engine_id() -> u64

pub fn deterministic_id(&self) -> String

Returns the deterministic id of this engine.

pub fn id(&self) -> EngineId

Returns the unique id of this engine.

pub fn default_features_for_backend( backend: &BackendKind, target: &Target, ) -> Features

Returns the default WebAssembly features supported by this backend for a given target.

These are the features that will be enabled by default without any user configuration.

pub fn supported_features_for_backend( backend: &BackendKind, target: &Target, ) -> Features

Returns all WebAssembly features supported by the specified backend for a given target.

This static method allows checking features for any backend, not just the current one.

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

Deserializes a WebAssembly module which was previously serialized with Module::serialize,

Note

You should almost always prefer Self::deserialize.

Errors

Not every implementer supports serializing and deserializing modules. Currently, only the sys engines support it, and only when the target architecture is not wasm32.

Safety

See Artifact::deserialize_unchecked.

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

Deserializes a WebAssembly module which was previously serialized with Module::serialize,

Errors

Not every implementer supports serializing and deserializing modules. Currently, only the sys engines support it, and only when the target architecture is not wasm32.

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

Load a serialized WebAssembly module from a file and deserialize it.

Note

You should almost always prefer Self::deserialize_from_file.

Errors

Not every implementer supports serializing and deserializing modules. Currently, only the sys engines support it, and only when the target architecture is not wasm32.

Safety

See Artifact::deserialize_unchecked.

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

Load a serialized WebAssembly module from a file and deserialize it.

Errors

Not every implementer supports serializing and deserializing modules. Currently, only the sys engines support it, and only when the target architecture is not wasm32.

Safety

See Artifact::deserialize.

pub fn with_opts( &mut self, suggested_opts: &UserCompilerOptimizations, ) -> Result<(), CompileError>

Add suggested optimizations to this engine.

Note

Not every backend supports every optimization. This function may fail (i.e. not set the suggested optimizations) silently if the underlying engine backend does not support one or more optimizations.

pub fn supports_async(&self) -> bool

Returns true if the engine supports async operations.

Trait Implementations

impl AsEngineRef for Engine

fn as_engine_ref(&self) -> EngineRef<'_>

Create an EngineRef pointing to the underlying context.

fn maybe_as_store(&self) -> Option<StoreRef<'_>>

Create a StoreRef.

impl Clone for Engine

fn clone(&self) -> Engine

Returns a duplicate 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 Default for Engine

fn default() -> Self

Returns the “default value” for a type.

impl From<&Engine> for Engine

fn from(value: &Engine) -> Self

Converts to this type from the input type.

impl From<Cranelift> for Engine

fn from(value: Cranelift) -> Self

Converts to this type from the input type.

impl From<Engine> for Engine

fn from(value: Engine) -> Self

Converts to this type from the input type.

impl From<EngineBuilder> for Engine

fn from(value: EngineBuilder) -> Self

Converts to this type from the input type.

impl From<LLVM> for Engine

fn from(value: LLVM) -> Self

Converts to this type from the input type.

impl From<Singlepass> for Engine

fn from(value: Singlepass) -> Self

Converts to this type from the input type.

impl NativeEngineExt for Engine

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

Create a new Engine with the given config

fn headless() -> Self

Create a headless Engine

fn target(&self) -> &Target

Gets the target

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

Attach a Tunable to this engine

fn tunables(&self) -> &dyn Tunables

Get a reference to attached Tunable of this engine

fn new_module_with_progress( &self, bytes: &[u8], on_progress: CompilationProgressCallback, ) -> Result<Module, CompileError>

Compile a module from bytes with a progress callback.

unsafe fn deserialize_from_mmapped_file_unchecked( &self, file_ref: &Path, ) -> Result<Module, DeserializeError>

Load a serialized WebAssembly module from a memory mapped file and deserialize it.

unsafe fn deserialize_from_mmapped_file( &self, file_ref: &Path, ) -> Result<Module, DeserializeError>

Load a serialized WebAssembly module from a memory mapped file and deserialize it.