Enum ProcState

pub enum ProcState {
    Created {
        create_key: ShortUuid,
        point: Point,
        pid: u32,
    },
    Running {
        create_key: ShortUuid,
        proc_id: ProcId,
        mesh_agent: ActorRef<ProcMeshAgent>,
        addr: ChannelAddr,
    },
    Stopped {
        create_key: ShortUuid,
        reason: ProcStopReason,
    },
    Failed {
        world_id: WorldId,
        description: String,
    },
}

A proc’s status. A proc can only monotonically move from Created to Running to Stopped.

Variants

Created

A proc was added to the alloc.

Fields

create_key: ShortUuid

A key to uniquely identify a created proc. The key is used again to identify the created proc as Running.

point: Point

Its assigned point (in the alloc’s extent).

pid: u32

The system process ID of the created child process.

Running

A proc was started.

Fields

create_key: ShortUuid

The key used to identify the created proc.

proc_id: ProcId

The proc’s assigned ID.

mesh_agent: ActorRef<ProcMeshAgent>

Reference to this proc’s mesh agent. In the future, we’ll reserve a ‘well known’ PID (0) for this purpose.

addr: ChannelAddr

The address of this proc. The endpoint of this address is the proc’s mailbox, which accepts hyperactor::mailbox::MessageEnvelopes.

Stopped

A proc was stopped.

Fields

create_key: ShortUuid

reason: ProcStopReason

Failed

Allocation process encountered an irrecoverable error. Depending on the implementation, the allocation process may continue transiently and calls to next() may return some events. But eventually the allocation will not be complete. Callers can use the description to determine the reason for the failure. Allocation can then be cleaned up by calling stop()`` on the Alloc` and drain the iterator for clean shutdown.

Fields

world_id: WorldId

The world ID of the failed alloc.

TODO: this is not meaningful with direct addressing.

description: String

A description of the failure.

Implementations

impl ProcState

pub fn is_created(&self) -> bool

Returns true if this is a ProcState::Created, otherwise false

pub fn as_created_mut( &mut self, ) -> Option<(&mut ShortUuid, &mut Point, &mut u32)>

Optionally returns mutable references to the inner fields if this is a ProcState::Created, otherwise None

pub fn as_created(&self) -> Option<(&ShortUuid, &Point, &u32)>

Optionally returns references to the inner fields if this is a ProcState::Created, otherwise None

pub fn into_created(self) -> Result<(ShortUuid, Point, u32), Self>

Returns the inner fields if this is a ProcState::Created, otherwise returns back the enum in the Err case of the result

pub fn is_running(&self) -> bool

Returns true if this is a ProcState::Running, otherwise false

pub fn as_running_mut( &mut self, ) -> Option<(&mut ShortUuid, &mut ProcId, &mut ActorRef<ProcMeshAgent>, &mut ChannelAddr)>

Optionally returns mutable references to the inner fields if this is a ProcState::Running, otherwise None

pub fn as_running( &self, ) -> Option<(&ShortUuid, &ProcId, &ActorRef<ProcMeshAgent>, &ChannelAddr)>

Optionally returns references to the inner fields if this is a ProcState::Running, otherwise None

pub fn into_running( self, ) -> Result<(ShortUuid, ProcId, ActorRef<ProcMeshAgent>, ChannelAddr), Self>

Returns the inner fields if this is a ProcState::Running, otherwise returns back the enum in the Err case of the result

pub fn is_stopped(&self) -> bool

Returns true if this is a ProcState::Stopped, otherwise false

pub fn as_stopped_mut( &mut self, ) -> Option<(&mut ShortUuid, &mut ProcStopReason)>

Optionally returns mutable references to the inner fields if this is a ProcState::Stopped, otherwise None

pub fn as_stopped(&self) -> Option<(&ShortUuid, &ProcStopReason)>

Optionally returns references to the inner fields if this is a ProcState::Stopped, otherwise None

pub fn into_stopped(self) -> Result<(ShortUuid, ProcStopReason), Self>

Returns the inner fields if this is a ProcState::Stopped, otherwise returns back the enum in the Err case of the result

pub fn is_failed(&self) -> bool

Returns true if this is a ProcState::Failed, otherwise false

pub fn as_failed_mut(&mut self) -> Option<(&mut WorldId, &mut String)>

Optionally returns mutable references to the inner fields if this is a ProcState::Failed, otherwise None

pub fn as_failed(&self) -> Option<(&WorldId, &String)>

Optionally returns references to the inner fields if this is a ProcState::Failed, otherwise None

pub fn into_failed(self) -> Result<(WorldId, String), Self>

Returns the inner fields if this is a ProcState::Failed, otherwise returns back the enum in the Err case of the result

Trait Implementations

impl AsRef<str> for ProcState

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for ProcState

fn clone(&self) -> ProcState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProcState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProcState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ProcState

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

Formats the value using the given formatter.

impl Named for ProcState

fn typename() -> &'static str

The globally unique type name for the type. This should typically be the fully qualified Rust name of the type.

fn typehash() -> u64

A globally unique hash for this type. TODO: actually enforce perfect hashing

fn arm(&self) -> Option<&'static str>

If the named type is an enum, this returns the name of the arm of the value self.

fn typeid() -> TypeId

The TypeId for this type. TypeIds are unique only within a binary, and should not be used for global identification.

fn port() -> u64

The globally unique port for this type. Typed ports are in the range of 1<<63..1<<64-1.

unsafe fn arm_unchecked(self_: *const ()) -> Option<&'static str>

An unsafe version of ‘arm’, accepting a pointer to the value, for use in type-erased settings.

impl PartialEq for ProcState

fn eq(&self, other: &ProcState) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ProcState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ProcState