Enum ControllerMessage

pub enum ControllerMessage {
    Attach {
        client_actor: ActorRef<ClientActor>,
        response_port: OncePortRef<()>,
    },
    Node {
        seq: Seq,
        defs: Vec<Ref>,
        uses: Vec<Ref>,
    },
    DropRefs {
        refs: Vec<Ref>,
    },
    Send {
        ranks: Ranks,
        message: Serialized,
    },
    RemoteFunctionFailed {
        seq: Seq,
        error: WorkerError,
    },
    Status {
        seq: Seq,
        worker_actor_id: ActorId,
        controller: bool,
    },
    FetchResult {
        seq: Seq,
        value: Result<Serialized, WorkerError>,
    },
    GetFirstIncompleteSeqsUnitTestsOnly {
        response_port: OncePortRef<Vec<Seq>>,
    },
    CheckSupervision {},
    DebuggerMessage {
        debugger_actor_id: ActorId,
        action: DebuggerAction,
    },
}

Controller messages. These define the contract that the controller has with the client and workers.

Variants

Attach

Attach a client to the controller. This is used to send messages to the controller and allow the controller to send messages back to the client.

Fields

client_actor: ActorRef<ClientActor>

The client actor that is being attached.

response_port: OncePortRef<()>

The response to indicate if the client was successfully attached.

Node

Notify the controller of the dependencies for a worker operation with the same seq. It is the responsibility of the caller to ensure the seq is unique and strictly increasing and matches the right message. This will be used by the controller for history / data dependency tracking. TODO: Support mutates here as well for proper dep management

Fields

seq: Seq

defs: Vec<Ref>

The set of references defined (or re-defined) by the operation. These are the operation’s outputs.

uses: Vec<Ref>

The set of references used by the operation. These are the operation’s inputs.

DropRefs

Fields

refs: Vec<Ref>

Send

Send a message to the workers mapping to the ranks provided in the given slice. The message is serialized bytes with the underlying datatype being crate::worker::WorkerMessage and serialization has been done in a hyperactor compatible way i.e. using [bincode]. These bytes will be forwarded to the workers as is. This helps provide isolation between the controller and the workers and avoids the need to pay the cost to deserialize pytrees in the controller.

Fields

ranks: Ranks

message: Serialized

RemoteFunctionFailed

Response to a crate::worker::WorkerMessage::CallFunction message if the function errored.

Fields

seq: Seq

error: WorkerError

Status

Response to a crate::worker::WorkerMessage::RequestStatus message. The payload will be set to the seq provided in the original message + 1.

Fields

seq: Seq

worker_actor_id: ActorId

controller: bool

FetchResult

Response to a crate::worker::WorkerMessage::SendValue message, containing the requested value. The value is serialized as a Serialized and deserialization is the responsibility of the caller. It should be deserialized as monarch_types::PyTree<RValue> using the Serialized::deserialized method.

Fields

seq: Seq

value: Result<Serialized, WorkerError>

GetFirstIncompleteSeqsUnitTestsOnly

This is used in unit tests to get the first incomplete seq for each rank as captured by the controller.

Fields

response_port: OncePortRef<Vec<Seq>>

CheckSupervision

The message to schedule next supervision check task on the controller.

DebuggerMessage

Debugger message sent from a debugger to be forwarded back to the client.

Fields

debugger_actor_id: ActorId

action: DebuggerAction

Trait Implementations

impl Debug for ControllerMessage

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ControllerMessage

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Named for ControllerMessage

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 Serialize for ControllerMessage

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl RemoteHandles<ControllerMessage> for ControllerActor