Struct wasmer_wasix::os::task::process::WasiProcess

pub struct WasiProcess {
    pub(crate) pid: WasiProcessId,
    pub(crate) module_hash: ModuleHash,
    pub(crate) parent: Option<Weak<RwLock<WasiProcessInner>>>,
    pub(crate) inner: LockableWasiProcessInner,
    pub(crate) compute: WasiControlPlaneHandle,
    pub(crate) finished: Arc<OwnedTaskStatus>,
    pub(crate) waiting: Arc<AtomicU32>,
    pub(crate) cpu_run_tokens: Arc<AtomicU32>,
}

Represents a process running within the compute state TODO: fields should be private and only accessed via methods.

Fields

pid: WasiProcessId

Unique ID of this process

module_hash: ModuleHash

Hash of the module that this process is using

parent: Option<Weak<RwLock<WasiProcessInner>>>

List of all the children spawned from this thread

inner: LockableWasiProcessInner

The inner protected region of the process with a conditional variable that is used for coordination such as snapshots.

compute: WasiControlPlaneHandle

Reference back to the compute engine

finished: Arc<OwnedTaskStatus>

Reference to the exit code for the main thread

waiting: Arc<AtomicU32>

Number of threads waiting for children to exit

cpu_run_tokens: Arc<AtomicU32>

Number of tokens that are currently active and thus the exponential backoff of CPU is halted (as in CPU is allowed to run freely)

Implementations

impl WasiProcess

pub fn acquire_cpu_run_token(&self) -> CpuRunToken

pub fn acquire_cpu_backoff_token( &self, tasks: &Arc<dyn VirtualTaskManager>, ) -> Option<CpuBackoffToken>

impl WasiProcess

pub fn new( pid: WasiProcessId, module_hash: ModuleHash, plane: WasiControlPlaneHandle, ) -> Self

pub(super) fn set_pid(&mut self, pid: WasiProcessId)

pub fn pid(&self) -> WasiProcessId

Gets the process ID of this process

pub fn ppid(&self) -> WasiProcessId

Gets the process ID of the parent process

pub fn lock(&self) -> MutexGuard<'_, WasiProcessInner>

Gains access to the process internals

pub fn new_thread( &self, layout: WasiMemoryLayout, start: ThreadStartType, ) -> Result<WasiThreadHandle, ControlPlaneError>

Creates a a thread and returns it

pub fn new_thread_with_id( &self, layout: WasiMemoryLayout, start: ThreadStartType, tid: WasiThreadId, ) -> Result<WasiThreadHandle, ControlPlaneError>

Creates a a thread and returns it

pub fn get_thread(&self, tid: &WasiThreadId) -> Option<WasiThread>

Gets a reference to a particular thread

pub fn signal_thread(&self, tid: &WasiThreadId, signal: Signal)

Signals a particular thread in the process

pub fn signal_process(&self, signal: Signal)

Signals all the threads in this process

pub fn snapshot_and_disable_journaling( &self, trigger: SnapshotTrigger, ) -> Pin<Box<dyn Future<Output = ()> + Send + Sync>>

Takes a snapshot of the process and disables journaling returning a future that can be waited on for the snapshot to complete

Note: If you ignore the returned future the checkpoint will still occur but it will execute asynchronously

pub fn snapshot( &self, trigger: SnapshotTrigger, ) -> Pin<Box<dyn Future<Output = ()> + Send + Sync>>

Takes a snapshot of the process

Note: If you ignore the returned future the checkpoint will still occur but it will execute asynchronously

pub fn disable_journaling_after_checkpoint(&self)

Disables the journaling functionality

pub fn wait_for_checkpoint( &self, ) -> Pin<Box<dyn Future<Output = ()> + Send + Sync>>

Wait for the checkout process to finish

pub fn wait_for_checkpoint_finish( &self, ) -> Pin<Box<dyn Future<Output = ()> + Send + Sync>>

Wait for the checkout process to finish

pub fn signal_interval( &self, signal: Signal, interval: Option<Duration>, repeat: bool, )

Signals one of the threads every interval

pub fn active_threads(&self) -> u32

Returns the number of active threads for this process

pub async fn join(&self) -> Result<ExitCode, Arc<WasiRuntimeError>>

Waits until the process is finished.

pub fn try_join(&self) -> Option<Result<ExitCode, Arc<WasiRuntimeError>>>

Attempts to join on the process

pub async fn join_children( &mut self, ) -> Option<Result<ExitCode, Arc<WasiRuntimeError>>>

Waits for all the children to be finished

pub async fn join_any_child( &mut self, ) -> Result<Option<(WasiProcessId, ExitCode)>, Errno>

Waits for any of the children to finished

pub fn terminate(&self, exit_code: ExitCode)

Terminate the process and all its threads

Trait Implementations

impl Clone for WasiProcess

fn clone(&self) -> WasiProcess

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WasiProcess

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

Formats the value using the given formatter.

impl SignalHandlerAbi for WasiProcess

fn signal(&self, sig: u8) -> Result<(), SignalDeliveryError>

Processes a signal