Struct sc_executor::WasmExecutor

pub struct WasmExecutor<H> { /* private fields */ }

An abstraction over Wasm code executor. Supports selecting execution backend and manages runtime cache.

Implementations

impl<H> WasmExecutor<H>where
    H: HostFunctions,

pub fn new(
    method: WasmExecutionMethod,
    default_heap_pages: Option<u64>,
    max_runtime_instances: usize,
    cache_path: Option<PathBuf>,
    runtime_cache_size: u8
) -> Self

Create new instance.

Parameters

method - Method used to execute Wasm code.

default_heap_pages - Number of 64KB pages to allocate for Wasm execution. Internally this will be mapped as HeapAllocStrategy::Static where default_heap_pages represent the static number of heap pages to allocate. Defaults to DEFAULT_HEAP_ALLOC_STRATEGY if None is provided.

max_runtime_instances - The number of runtime instances to keep in memory ready for reuse.

cache_path - A path to a directory where the executor can place its files for purposes of caching. This may be important in cases when there are many different modules with the compiled execution method is used.

runtime_cache_size - The capacity of runtime cache.

pub fn builder(method: WasmExecutionMethod) -> WasmExecutorBuilder<H>

Instantiate a builder for creating an instance of Self.

pub fn allow_missing_host_functions(
    &mut self,
    allow_missing_host_functions: bool
)

Ignore missing function imports if set true.

pub fn with_instance<R, F>(
    &self,
    runtime_code: &RuntimeCode<'_>,
    ext: &mut dyn Externalities,
    heap_alloc_strategy: HeapAllocStrategy,
    f: F
) -> Result<R>where
    F: FnOnce(AssertUnwindSafe<&Arc<dyn WasmModule>>, AssertUnwindSafe<&mut dyn WasmInstance>, Option<&RuntimeVersion>, AssertUnwindSafe<&mut dyn Externalities>) -> Result<Result<R>>,

Execute the given closure f with the latest runtime (based on runtime_code).

The closure f is expected to return Err(_) when there happened a panic! in native code while executing the runtime in Wasm. If a panic! occurred, the runtime is invalidated to prevent any poisoned state. Native runtime execution does not need to report back any panic!.

Safety

runtime and ext are given as AssertUnwindSafe to the closure. As described above, the runtime is invalidated on any panic! to prevent a poisoned state. ext is already implicitly handled as unwind safe, as we store it in a global variable while executing the native runtime.

Trait Implementations

impl<H> Clone for WasmExecutor<H>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<H> CodeExecutor for WasmExecutor<H>where
    H: HostFunctions,

type Error = Error

Externalities error type.

fn call(
    &self,
    ext: &mut dyn Externalities,
    runtime_code: &RuntimeCode<'_>,
    method: &str,
    data: &[u8],
    _use_native: bool,
    context: CallContext
) -> (Result<Vec<u8>>, bool)

Call a given method in the runtime.

impl<H> ReadRuntimeVersion for WasmExecutor<H>where
    H: HostFunctions,

fn read_runtime_version(
    &self,
    wasm_code: &[u8],
    ext: &mut dyn Externalities
) -> Result<Vec<u8>, String>

Reads the runtime version information from the given wasm code.

impl<H> RuntimeVersionOf for WasmExecutor<H>where
    H: HostFunctions,

fn runtime_version(
    &self,
    ext: &mut dyn Externalities,
    runtime_code: &RuntimeCode<'_>
) -> Result<RuntimeVersion>

Extract RuntimeVersion of the given runtime_code.