Struct WasiProcessInner

pub struct WasiProcessInner {

    pub pid: WasiProcessId,
    pub(crate) waiting: Arc<AtomicU32>,
    pub threads: HashMap<WasiThreadId, WasiThread>,
    pub thread_count: u32,
    pub signal_intervals: HashMap<Signal, WasiSignalInterval>,
    pub children: Vec<WasiProcess>,
    pub checkpoint: WasiProcessCheckpoint,
    pub disable_journaling_after_checkpoint: bool,
    pub stop_running_after_checkpoint: bool,
    pub snapshot_on: HashSet<SnapshotTrigger>,
    pub wakers: Vec<Waker>,
    pub snapshot_memory_hash: HashMap<MemorySnapshotRegion, u64>,
    pub(super) backoff: WasiProcessCpuBackoff,
}

Fields

pid: WasiProcessId

Unique ID of this process

waiting: Arc<AtomicU32>

Number of threads waiting for children to exit

threads: HashMap<WasiThreadId, WasiThread>

The threads that make up this process

thread_count: u32

Number of threads running for this process

signal_intervals: HashMap<Signal, WasiSignalInterval>

Signals that will be triggered at specific intervals

children: Vec<WasiProcess>

List of all the children spawned from this thread

checkpoint: WasiProcessCheckpoint

Represents a checkpoint which blocks all the threads and then executes some maintenance action

disable_journaling_after_checkpoint: bool

If true then the journaling will be disabled after the next snapshot is taken

stop_running_after_checkpoint: bool

If true then the process will stop running after the next snapshot is taken

snapshot_on: HashSet<SnapshotTrigger>

List of situations that the process will checkpoint on

wakers: Vec<Waker>

Any wakers waiting on this process (for example for a checkpoint)

snapshot_memory_hash: HashMap<MemorySnapshotRegion, u64>

The snapshot memory significantly reduce the amount of duplicate entries in the journal for memory that has not changed

backoff: WasiProcessCpuBackoff

Represents all the backoff properties for this process which will be used to determine if the CPU should be throttled or not

Implementations

impl WasiProcessInner

pub fn checkpoint<M: MemorySize>( inner: LockableWasiProcessInner, ctx: FunctionEnvMut<'_, WasiEnv>, for_what: WasiProcessCheckpoint, ) -> WasiResult<MaybeCheckpointResult<'_>>

Checkpoints the process which will cause all other threads to pause and for the thread and memory state to be saved

pub fn maybe_checkpoint<M: MemorySize>( inner: LockableWasiProcessInner, ctx: FunctionEnvMut<'_, WasiEnv>, ) -> WasiResult<MaybeCheckpointResult<'_>>

If a checkpoint has been started this will block the current process until the checkpoint operation has completed

pub fn do_checkpoints_from_outside(ctx: &mut FunctionEnvMut<'_, WasiEnv>)

Trait Implementations

impl Debug for WasiProcessInner

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

Formats the value using the given formatter.