Browse Source
This file has grown quite a lot with `Store` over time so this splits it up into three separate files, one for each of the main types defined in it: `Config`, `Engine`, and `Store`.pull/2407/head
Alex Crichton
4 years ago
committed by
GitHub
GitHub
5 changed files with 596 additions and 587 deletions
@ -0,0 +1,148 @@ |
|||
use crate::Config; |
|||
use std::sync::Arc; |
|||
#[cfg(feature = "cache")] |
|||
use wasmtime_cache::CacheConfig; |
|||
use wasmtime_jit::Compiler; |
|||
use wasmtime_runtime::debug_builtins; |
|||
|
|||
/// An `Engine` which is a global context for compilation and management of wasm
|
|||
/// modules.
|
|||
///
|
|||
/// An engine can be safely shared across threads and is a cheap cloneable
|
|||
/// handle to the actual engine. The engine itself will be deallocate once all
|
|||
/// references to it have gone away.
|
|||
///
|
|||
/// Engines store global configuration preferences such as compilation settings,
|
|||
/// enabled features, etc. You'll likely only need at most one of these for a
|
|||
/// program.
|
|||
///
|
|||
/// ## Engines and `Clone`
|
|||
///
|
|||
/// Using `clone` on an `Engine` is a cheap operation. It will not create an
|
|||
/// entirely new engine, but rather just a new reference to the existing engine.
|
|||
/// In other words it's a shallow copy, not a deep copy.
|
|||
///
|
|||
/// ## Engines and `Default`
|
|||
///
|
|||
/// You can create an engine with default configuration settings using
|
|||
/// `Engine::default()`. Be sure to consult the documentation of [`Config`] for
|
|||
/// default settings.
|
|||
#[derive(Clone)] |
|||
pub struct Engine { |
|||
inner: Arc<EngineInner>, |
|||
} |
|||
|
|||
struct EngineInner { |
|||
config: Config, |
|||
compiler: Compiler, |
|||
} |
|||
|
|||
impl Engine { |
|||
/// Creates a new [`Engine`] with the specified compilation and
|
|||
/// configuration settings.
|
|||
pub fn new(config: &Config) -> Engine { |
|||
debug_builtins::ensure_exported(); |
|||
Engine { |
|||
inner: Arc::new(EngineInner { |
|||
config: config.clone(), |
|||
compiler: config.build_compiler(), |
|||
}), |
|||
} |
|||
} |
|||
|
|||
/// Returns the configuration settings that this engine is using.
|
|||
pub fn config(&self) -> &Config { |
|||
&self.inner.config |
|||
} |
|||
|
|||
pub(crate) fn compiler(&self) -> &Compiler { |
|||
&self.inner.compiler |
|||
} |
|||
|
|||
#[cfg(feature = "cache")] |
|||
pub(crate) fn cache_config(&self) -> &CacheConfig { |
|||
&self.config().cache_config |
|||
} |
|||
|
|||
/// Returns whether the engine `a` and `b` refer to the same configuration.
|
|||
pub fn same(a: &Engine, b: &Engine) -> bool { |
|||
Arc::ptr_eq(&a.inner, &b.inner) |
|||
} |
|||
} |
|||
|
|||
impl Default for Engine { |
|||
fn default() -> Engine { |
|||
Engine::new(&Config::default()) |
|||
} |
|||
} |
|||
|
|||
#[cfg(test)] |
|||
mod tests { |
|||
use crate::{Config, Engine, Module, OptLevel}; |
|||
use anyhow::Result; |
|||
use tempfile::TempDir; |
|||
|
|||
#[test] |
|||
fn cache_accounts_for_opt_level() -> Result<()> { |
|||
let td = TempDir::new()?; |
|||
let config_path = td.path().join("config.toml"); |
|||
std::fs::write( |
|||
&config_path, |
|||
&format!( |
|||
" |
|||
[cache] |
|||
enabled = true |
|||
directory = '{}' |
|||
", |
|||
td.path().join("cache").display() |
|||
), |
|||
)?; |
|||
let mut cfg = Config::new(); |
|||
cfg.cranelift_opt_level(OptLevel::None) |
|||
.cache_config_load(&config_path)?; |
|||
let engine = Engine::new(&cfg); |
|||
Module::new(&engine, "(module (func))")?; |
|||
assert_eq!(engine.config().cache_config.cache_hits(), 0); |
|||
assert_eq!(engine.config().cache_config.cache_misses(), 1); |
|||
Module::new(&engine, "(module (func))")?; |
|||
assert_eq!(engine.config().cache_config.cache_hits(), 1); |
|||
assert_eq!(engine.config().cache_config.cache_misses(), 1); |
|||
|
|||
let mut cfg = Config::new(); |
|||
cfg.cranelift_opt_level(OptLevel::Speed) |
|||
.cache_config_load(&config_path)?; |
|||
let engine = Engine::new(&cfg); |
|||
Module::new(&engine, "(module (func))")?; |
|||
assert_eq!(engine.config().cache_config.cache_hits(), 0); |
|||
assert_eq!(engine.config().cache_config.cache_misses(), 1); |
|||
Module::new(&engine, "(module (func))")?; |
|||
assert_eq!(engine.config().cache_config.cache_hits(), 1); |
|||
assert_eq!(engine.config().cache_config.cache_misses(), 1); |
|||
|
|||
let mut cfg = Config::new(); |
|||
cfg.cranelift_opt_level(OptLevel::SpeedAndSize) |
|||
.cache_config_load(&config_path)?; |
|||
let engine = Engine::new(&cfg); |
|||
Module::new(&engine, "(module (func))")?; |
|||
assert_eq!(engine.config().cache_config.cache_hits(), 0); |
|||
assert_eq!(engine.config().cache_config.cache_misses(), 1); |
|||
Module::new(&engine, "(module (func))")?; |
|||
assert_eq!(engine.config().cache_config.cache_hits(), 1); |
|||
assert_eq!(engine.config().cache_config.cache_misses(), 1); |
|||
|
|||
// FIXME(#1523) need debuginfo on aarch64 before we run this test there
|
|||
if !cfg!(target_arch = "aarch64") { |
|||
let mut cfg = Config::new(); |
|||
cfg.debug_info(true).cache_config_load(&config_path)?; |
|||
let engine = Engine::new(&cfg); |
|||
Module::new(&engine, "(module (func))")?; |
|||
assert_eq!(engine.config().cache_config.cache_hits(), 0); |
|||
assert_eq!(engine.config().cache_config.cache_misses(), 1); |
|||
Module::new(&engine, "(module (func))")?; |
|||
assert_eq!(engine.config().cache_config.cache_hits(), 1); |
|||
assert_eq!(engine.config().cache_config.cache_misses(), 1); |
|||
} |
|||
|
|||
Ok(()) |
|||
} |
|||
} |
|||
@ -0,0 +1,426 @@ |
|||
use crate::sig_registry::SignatureRegistry; |
|||
use crate::trampoline::StoreInstanceHandle; |
|||
use crate::Engine; |
|||
use crate::Module; |
|||
use anyhow::{bail, Result}; |
|||
use std::cell::RefCell; |
|||
use std::fmt; |
|||
use std::hash::{Hash, Hasher}; |
|||
use std::rc::{Rc, Weak}; |
|||
use std::sync::Arc; |
|||
use wasmtime_environ::wasm; |
|||
use wasmtime_runtime::{ |
|||
InstanceHandle, RuntimeMemoryCreator, SignalHandler, StackMapRegistry, VMExternRef, |
|||
VMExternRefActivationsTable, VMInterrupts, VMSharedSignatureIndex, |
|||
}; |
|||
|
|||
/// A `Store` is a collection of WebAssembly instances and host-defined items.
|
|||
///
|
|||
/// All WebAssembly instances and items will be attached to and refer to a
|
|||
/// `Store`. For example instances, functions, globals, and tables are all
|
|||
/// attached to a `Store`. Instances are created by instantiating a [`Module`]
|
|||
/// within a `Store`.
|
|||
///
|
|||
/// `Store` is not thread-safe and cannot be sent to other threads. All items
|
|||
/// which refer to a `Store` additionally are not threadsafe and can only be
|
|||
/// used on the original thread that they were created on.
|
|||
///
|
|||
/// A `Store` is not intended to be a long-lived object in a program. No form of
|
|||
/// GC is implemented at this time so once an instance is created within a
|
|||
/// `Store` it will not be deallocated until all references to the `Store` have
|
|||
/// gone away (this includes all references to items in the store). This makes
|
|||
/// `Store` unsuitable for creating an unbounded number of instances in it
|
|||
/// because `Store` will never release this memory. It's instead recommended to
|
|||
/// have a long-lived [`Engine`] and instead create a `Store` for a more scoped
|
|||
/// portion of your application.
|
|||
///
|
|||
/// # Stores and `Clone`
|
|||
///
|
|||
/// Using `clone` on a `Store` is a cheap operation. It will not create an
|
|||
/// entirely new store, but rather just a new reference to the existing object.
|
|||
/// In other words it's a shallow copy, not a deep copy.
|
|||
///
|
|||
/// ## Stores and `Default`
|
|||
///
|
|||
/// You can create a store with default configuration settings using
|
|||
/// `Store::default()`. This will create a brand new [`Engine`] with default
|
|||
/// ocnfiguration (see [`Config`](crate::Config) for more information).
|
|||
#[derive(Clone)] |
|||
pub struct Store { |
|||
inner: Rc<StoreInner>, |
|||
} |
|||
|
|||
pub(crate) struct StoreInner { |
|||
engine: Engine, |
|||
interrupts: Arc<VMInterrupts>, |
|||
signatures: RefCell<SignatureRegistry>, |
|||
instances: RefCell<Vec<InstanceHandle>>, |
|||
signal_handler: RefCell<Option<Box<SignalHandler<'static>>>>, |
|||
jit_code_ranges: RefCell<Vec<(usize, usize)>>, |
|||
externref_activations_table: VMExternRefActivationsTable, |
|||
stack_map_registry: StackMapRegistry, |
|||
} |
|||
|
|||
struct HostInfoKey(VMExternRef); |
|||
|
|||
impl PartialEq for HostInfoKey { |
|||
fn eq(&self, rhs: &Self) -> bool { |
|||
VMExternRef::eq(&self.0, &rhs.0) |
|||
} |
|||
} |
|||
|
|||
impl Eq for HostInfoKey {} |
|||
|
|||
impl Hash for HostInfoKey { |
|||
fn hash<H>(&self, hasher: &mut H) |
|||
where |
|||
H: Hasher, |
|||
{ |
|||
VMExternRef::hash(&self.0, hasher); |
|||
} |
|||
} |
|||
|
|||
impl Store { |
|||
/// Creates a new store to be associated with the given [`Engine`].
|
|||
pub fn new(engine: &Engine) -> Store { |
|||
// Ensure that wasmtime_runtime's signal handlers are configured. Note
|
|||
// that at the `Store` level it means we should perform this
|
|||
// once-per-thread. Platforms like Unix, however, only require this
|
|||
// once-per-program. In any case this is safe to call many times and
|
|||
// each one that's not relevant just won't do anything.
|
|||
wasmtime_runtime::init_traps(); |
|||
|
|||
Store { |
|||
inner: Rc::new(StoreInner { |
|||
engine: engine.clone(), |
|||
interrupts: Arc::new(Default::default()), |
|||
signatures: RefCell::new(Default::default()), |
|||
instances: RefCell::new(Vec::new()), |
|||
signal_handler: RefCell::new(None), |
|||
jit_code_ranges: RefCell::new(Vec::new()), |
|||
externref_activations_table: VMExternRefActivationsTable::new(), |
|||
stack_map_registry: StackMapRegistry::default(), |
|||
}), |
|||
} |
|||
} |
|||
|
|||
pub(crate) fn from_inner(inner: Rc<StoreInner>) -> Store { |
|||
Store { inner } |
|||
} |
|||
|
|||
/// Returns the [`Engine`] that this store is associated with.
|
|||
pub fn engine(&self) -> &Engine { |
|||
&self.inner.engine |
|||
} |
|||
|
|||
/// Returns an optional reference to a ['RuntimeMemoryCreator']
|
|||
pub(crate) fn memory_creator(&self) -> Option<&dyn RuntimeMemoryCreator> { |
|||
self.engine() |
|||
.config() |
|||
.memory_creator |
|||
.as_ref() |
|||
.map(|x| x as _) |
|||
} |
|||
|
|||
pub(crate) fn signatures(&self) -> &RefCell<SignatureRegistry> { |
|||
&self.inner.signatures |
|||
} |
|||
|
|||
pub(crate) fn lookup_shared_signature<'a>( |
|||
&'a self, |
|||
module: &'a wasmtime_environ::Module, |
|||
) -> impl Fn(wasm::SignatureIndex) -> VMSharedSignatureIndex + 'a { |
|||
move |index| { |
|||
self.signatures() |
|||
.borrow() |
|||
.lookup(&module.signatures[index]) |
|||
.expect("signature not previously registered") |
|||
} |
|||
} |
|||
|
|||
/// Returns whether or not the given address falls within the JIT code
|
|||
/// managed by the compiler
|
|||
pub(crate) fn is_in_jit_code(&self, addr: usize) -> bool { |
|||
self.inner |
|||
.jit_code_ranges |
|||
.borrow() |
|||
.iter() |
|||
.any(|(start, end)| *start <= addr && addr < *end) |
|||
} |
|||
|
|||
pub(crate) fn register_module(&self, module: &Module) { |
|||
// All modules register their JIT code in a store for two reasons
|
|||
// currently:
|
|||
//
|
|||
// * First we only catch signals/traps if the program counter falls
|
|||
// within the jit code of an instantiated wasm module. This ensures
|
|||
// we don't catch accidental Rust/host segfaults.
|
|||
//
|
|||
// * Second when generating a backtrace we'll use this mapping to
|
|||
// only generate wasm frames for instruction pointers that fall
|
|||
// within jit code.
|
|||
self.register_jit_code(module); |
|||
|
|||
// We need to know about all the stack maps of all instantiated modules
|
|||
// so when performing a GC we know about all wasm frames that we find
|
|||
// on the stack.
|
|||
self.register_stack_maps(module); |
|||
|
|||
// Signatures are loaded into our `SignatureRegistry` here
|
|||
// once-per-module (and once-per-signature). This allows us to create
|
|||
// a `Func` wrapper for any function in the module, which requires that
|
|||
// we know about the signature and trampoline for all instances.
|
|||
self.register_signatures(module); |
|||
} |
|||
|
|||
fn register_jit_code(&self, module: &Module) { |
|||
let mut ranges = module.compiled_module().jit_code_ranges(); |
|||
// Checking of we already registered JIT code ranges by searching
|
|||
// first range start.
|
|||
match ranges.next() { |
|||
None => (), |
|||
Some(first) => { |
|||
if !self.is_in_jit_code(first.0) { |
|||
// The range is not registered -- add all ranges (including
|
|||
// first one) to the jit_code_ranges.
|
|||
let mut jit_code_ranges = self.inner.jit_code_ranges.borrow_mut(); |
|||
jit_code_ranges.push(first); |
|||
jit_code_ranges.extend(ranges); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
fn register_stack_maps(&self, module: &Module) { |
|||
let module = &module.compiled_module(); |
|||
self.stack_map_registry() |
|||
.register_stack_maps(module.stack_maps().map(|(func, stack_maps)| unsafe { |
|||
let ptr = (*func).as_ptr(); |
|||
let len = (*func).len(); |
|||
let start = ptr as usize; |
|||
let end = ptr as usize + len; |
|||
let range = start..end; |
|||
(range, stack_maps) |
|||
})); |
|||
} |
|||
|
|||
fn register_signatures(&self, module: &Module) { |
|||
let trampolines = module.compiled_module().trampolines(); |
|||
let module = module.compiled_module().module(); |
|||
let mut signatures = self.signatures().borrow_mut(); |
|||
for (index, wasm) in module.signatures.iter() { |
|||
signatures.register(wasm, trampolines[index]); |
|||
} |
|||
} |
|||
|
|||
pub(crate) unsafe fn add_instance(&self, handle: InstanceHandle) -> StoreInstanceHandle { |
|||
self.inner.instances.borrow_mut().push(handle.clone()); |
|||
StoreInstanceHandle { |
|||
store: self.clone(), |
|||
handle, |
|||
} |
|||
} |
|||
|
|||
pub(crate) fn existing_instance_handle(&self, handle: InstanceHandle) -> StoreInstanceHandle { |
|||
debug_assert!(self |
|||
.inner |
|||
.instances |
|||
.borrow() |
|||
.iter() |
|||
.any(|i| i.vmctx_ptr() == handle.vmctx_ptr())); |
|||
StoreInstanceHandle { |
|||
store: self.clone(), |
|||
handle, |
|||
} |
|||
} |
|||
|
|||
pub(crate) fn weak(&self) -> Weak<StoreInner> { |
|||
Rc::downgrade(&self.inner) |
|||
} |
|||
|
|||
pub(crate) fn upgrade(weak: &Weak<StoreInner>) -> Option<Self> { |
|||
let inner = weak.upgrade()?; |
|||
Some(Self { inner }) |
|||
} |
|||
|
|||
pub(crate) fn signal_handler(&self) -> std::cell::Ref<'_, Option<Box<SignalHandler<'static>>>> { |
|||
self.inner.signal_handler.borrow() |
|||
} |
|||
|
|||
pub(crate) fn signal_handler_mut( |
|||
&self, |
|||
) -> std::cell::RefMut<'_, Option<Box<SignalHandler<'static>>>> { |
|||
self.inner.signal_handler.borrow_mut() |
|||
} |
|||
|
|||
pub(crate) fn interrupts(&self) -> &VMInterrupts { |
|||
&self.inner.interrupts |
|||
} |
|||
|
|||
/// Returns whether the stores `a` and `b` refer to the same underlying
|
|||
/// `Store`.
|
|||
///
|
|||
/// Because the `Store` type is reference counted multiple clones may point
|
|||
/// to the same underlying storage, and this method can be used to determine
|
|||
/// whether two stores are indeed the same.
|
|||
pub fn same(a: &Store, b: &Store) -> bool { |
|||
Rc::ptr_eq(&a.inner, &b.inner) |
|||
} |
|||
|
|||
/// Creates an [`InterruptHandle`] which can be used to interrupt the
|
|||
/// execution of instances within this `Store`.
|
|||
///
|
|||
/// An [`InterruptHandle`] handle is a mechanism of ensuring that guest code
|
|||
/// doesn't execute for too long. For example it's used to prevent wasm
|
|||
/// programs for executing infinitely in infinite loops or recursive call
|
|||
/// chains.
|
|||
///
|
|||
/// The [`InterruptHandle`] type is sendable to other threads so you can
|
|||
/// interact with it even while the thread with this `Store` is executing
|
|||
/// wasm code.
|
|||
///
|
|||
/// There's one method on an interrupt handle:
|
|||
/// [`InterruptHandle::interrupt`]. This method is used to generate an
|
|||
/// interrupt and cause wasm code to exit "soon".
|
|||
///
|
|||
/// ## When are interrupts delivered?
|
|||
///
|
|||
/// The term "interrupt" here refers to one of two different behaviors that
|
|||
/// are interrupted in wasm:
|
|||
///
|
|||
/// * The head of every loop in wasm has a check to see if it's interrupted.
|
|||
/// * The prologue of every function has a check to see if it's interrupted.
|
|||
///
|
|||
/// This interrupt mechanism makes no attempt to signal interrupts to
|
|||
/// native code. For example if a host function is blocked, then sending
|
|||
/// an interrupt will not interrupt that operation.
|
|||
///
|
|||
/// Interrupts are consumed as soon as possible when wasm itself starts
|
|||
/// executing. This means that if you interrupt wasm code then it basically
|
|||
/// guarantees that the next time wasm is executing on the target thread it
|
|||
/// will return quickly (either normally if it were already in the process
|
|||
/// of returning or with a trap from the interrupt). Once an interrupt
|
|||
/// trap is generated then an interrupt is consumed, and further execution
|
|||
/// will not be interrupted (unless another interrupt is set).
|
|||
///
|
|||
/// When implementing interrupts you'll want to ensure that the delivery of
|
|||
/// interrupts into wasm code is also handled in your host imports and
|
|||
/// functionality. Host functions need to either execute for bounded amounts
|
|||
/// of time or you'll need to arrange for them to be interrupted as well.
|
|||
///
|
|||
/// ## Return Value
|
|||
///
|
|||
/// This function returns a `Result` since interrupts are not always
|
|||
/// enabled. Interrupts are enabled via the
|
|||
/// [`Config::interruptable`](crate::Config::interruptable) method, and if
|
|||
/// this store's [`Config`](crate::Config) hasn't been configured to enable
|
|||
/// interrupts then an error is returned.
|
|||
///
|
|||
/// ## Examples
|
|||
///
|
|||
/// ```
|
|||
/// # use anyhow::Result;
|
|||
/// # use wasmtime::*;
|
|||
/// # fn main() -> Result<()> {
|
|||
/// // Enable interruptable code via `Config` and then create an interrupt
|
|||
/// // handle which we'll use later to interrupt running code.
|
|||
/// let engine = Engine::new(Config::new().interruptable(true));
|
|||
/// let store = Store::new(&engine);
|
|||
/// let interrupt_handle = store.interrupt_handle()?;
|
|||
///
|
|||
/// // Compile and instantiate a small example with an infinite loop.
|
|||
/// let module = Module::new(&engine, r#"
|
|||
/// (func (export "run") (loop br 0))
|
|||
/// "#)?;
|
|||
/// let instance = Instance::new(&store, &module, &[])?;
|
|||
/// let run = instance
|
|||
/// .get_func("run")
|
|||
/// .ok_or(anyhow::format_err!("failed to find `run` function export"))?
|
|||
/// .get0::<()>()?;
|
|||
///
|
|||
/// // Spin up a thread to send us an interrupt in a second
|
|||
/// std::thread::spawn(move || {
|
|||
/// std::thread::sleep(std::time::Duration::from_secs(1));
|
|||
/// interrupt_handle.interrupt();
|
|||
/// });
|
|||
///
|
|||
/// let trap = run().unwrap_err();
|
|||
/// assert!(trap.to_string().contains("wasm trap: interrupt"));
|
|||
/// # Ok(())
|
|||
/// # }
|
|||
/// ```
|
|||
pub fn interrupt_handle(&self) -> Result<InterruptHandle> { |
|||
if self.engine().config().tunables.interruptable { |
|||
Ok(InterruptHandle { |
|||
interrupts: self.inner.interrupts.clone(), |
|||
}) |
|||
} else { |
|||
bail!("interrupts aren't enabled for this `Store`") |
|||
} |
|||
} |
|||
|
|||
pub(crate) fn externref_activations_table(&self) -> &VMExternRefActivationsTable { |
|||
&self.inner.externref_activations_table |
|||
} |
|||
|
|||
pub(crate) fn stack_map_registry(&self) -> &StackMapRegistry { |
|||
&self.inner.stack_map_registry |
|||
} |
|||
|
|||
/// Perform garbage collection of `ExternRef`s.
|
|||
pub fn gc(&self) { |
|||
// For this crate's API, we ensure that `set_stack_canary` invariants
|
|||
// are upheld for all host-->Wasm calls, and we register every module
|
|||
// used with this store in `self.inner.stack_map_registry`.
|
|||
unsafe { |
|||
wasmtime_runtime::gc( |
|||
&self.inner.stack_map_registry, |
|||
&self.inner.externref_activations_table, |
|||
); |
|||
} |
|||
} |
|||
} |
|||
|
|||
impl Default for Store { |
|||
fn default() -> Store { |
|||
Store::new(&Engine::default()) |
|||
} |
|||
} |
|||
|
|||
impl fmt::Debug for Store { |
|||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
|||
let inner = &*self.inner as *const StoreInner; |
|||
f.debug_struct("Store").field("inner", &inner).finish() |
|||
} |
|||
} |
|||
|
|||
impl Drop for StoreInner { |
|||
fn drop(&mut self) { |
|||
for instance in self.instances.get_mut().iter() { |
|||
unsafe { |
|||
instance.dealloc(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// A threadsafe handle used to interrupt instances executing within a
|
|||
/// particular `Store`.
|
|||
///
|
|||
/// This structure is created by the [`Store::interrupt_handle`] method.
|
|||
pub struct InterruptHandle { |
|||
interrupts: Arc<VMInterrupts>, |
|||
} |
|||
|
|||
impl InterruptHandle { |
|||
/// Flags that execution within this handle's original [`Store`] should be
|
|||
/// interrupted.
|
|||
///
|
|||
/// This will not immediately interrupt execution of wasm modules, but
|
|||
/// rather it will interrupt wasm execution of loop headers and wasm
|
|||
/// execution of function entries. For more information see
|
|||
/// [`Store::interrupt_handle`].
|
|||
pub fn interrupt(&self) { |
|||
self.interrupts.interrupt() |
|||
} |
|||
} |
|||
Loading…
Reference in new issue