Struct ActorMeshRef 

pub struct ActorMeshRef<A: Referable> { /* private fields */ }

A reference to a stable snapshot of an ActorMesh.

Implementations

impl<A: Referable> ActorMeshRef<A>

pub fn cast<M>(&self, cx: &impl Actor, message: M) -> Result<()>

where A: RemoteHandles<M> + RemoteHandles<IndexedErasedUnbound<M>>, M: Castable + RemoteMessage + Clone,

Cast a message to all the actors in this mesh

pub fn cast_with_headers<M>( &self, cx: &impl Actor, caller_headers: &Flattrs, message: M, ) -> Result<()>

where A: RemoteHandles<M> + RemoteHandles<IndexedErasedUnbound<M>>, M: Castable + RemoteMessage + Clone,

Cast a message to all the actors in this mesh, merging caller-supplied caller_headers into the per-rank envelope headers before send. Used to propagate caller-known context (e.g. operation-context keys marked with OPERATION_CONTEXT_HEADER) onto the outgoing request so receivers can project it back onto replies.

pub fn cast_for_tensor_engine_only_do_not_use<M>( &self, cx: &impl Actor, sel: Selection, message: M, ) -> Result<()>

where A: RemoteHandles<M> + RemoteHandles<IndexedErasedUnbound<M>>, M: Castable + RemoteMessage + Clone,

Cast a message to the actors in this mesh according to the provided selection. This should only be used for temporary support for selections in the tensor engine. If you use this for anything else, you will be fired (you too, OSS contributor).

pub async fn actor_states( &self, cx: &impl Actor, ) -> Result<ValueMesh<State<ActorState>>>

Query the state of all actors in this mesh. If keepalive is Some, use a message that indicates to the recipient that the owner of the mesh is still alive, along with the expiry time after which the actor should be considered orphaned. Else, use a normal state query.

pub fn id(&self) -> &ActorMeshId

pub fn proc_mesh(&self) -> &ProcMeshRef

pub fn controller(&self) -> &Option<ActorRef<ActorMeshController<A>>>

pub async fn next_supervision_event( &self, cx: &impl Actor, ) -> Result<MeshFailure, Error>

Returns the next supervision event occurring on this mesh. Await this simultaneously with the return result of a message (such as awaiting a reply after a cast) to get back a message that indicates the actor that failed, instead of waiting forever for a reply. If there are multiple simultaneous awaits of next_supervision_event, all of them will receive the same event.

pub fn clone_with_supervision_receiver(&self) -> Self

Same as Clone, but includes a shared supervision receiver. This copy will share the same health state and get the same supervision events. Will have a separate cache.

Trait Implementations

impl<A: Referable> Clone for ActorMeshRef<A>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Referable> Controlled for ActorMeshRef<A>

Controlled implementation for an actor mesh.

type StateInner = ActorState

Inner payload carried in resource::State<Self::StateInner>.

fn stall_counter() -> &'static Counter<u64>

Counter bumped when the supervision loop detects a stall.

fn id(&self) -> &ResourceId

The mesh’s resource identifier.

fn region(&self) -> &Region

The region of ranks in this mesh.

fn subscribe_to_stream( &self, cx: &impl Actor, subscriber: PortRef<State<ActorState>>, ) -> Result<()>

Subscribe the given port to StreamState<StateInner> updates from the underlying agents.

fn forward_wait_rank_status( &self, cx: &impl Actor, msg: WaitRankStatus, ) -> Result<()>

Forward a WaitRankStatus message to the underlying agents.

fn poll_states<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, cx: &'life1 (impl 'async_trait + Actor), supervision_display_name: &'life2 str, health_state: &'life3 mut HealthState, ) -> Pin<Box<dyn Future<Output = PollResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Mesh-specific polling step for the supervision loop. Implementations may do pre-checks (such as the actor mesh’s proc-aliveness check) before querying rank states; updates to health_state happen in-place. supervision_display_name is used for synthesised supervision events (e.g., when a proc dies).

fn process_state( &self, cx: &impl Actor, state: State<ActorState>, health_state: &mut HealthState, ) -> bool

Process a single streamed or polled state. Updates the health state and notifies owner/subscribers as appropriate. Returns true if a notification was emitted (used to suppress heartbeats).

fn handle_stop_request<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, cx: &'life1 (impl 'async_trait + Actor), _supervision_display_name: &'life2 str, reason: String, health_state: &'life3 mut HealthState, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Perform the mesh-specific stop: issue stop messages to the underlying agents and, where appropriate, update health_state and notify subscribers. The caller has already taken the monitor and logged.

fn cleanup_stop<'life0, 'life1, 'async_trait>( &'life0 self, cx: &'life1 (impl 'async_trait + Actor), reason: String, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Stop this mesh on controller cleanup (when Stop was not received but the actor is shutting down).

impl<A: Referable> Debug for ActorMeshRef<A>

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

Formats the value using the given formatter.

impl<'de, A: Referable> Deserialize<'de> for ActorMeshRef<A>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A: Referable> Display for ActorMeshRef<A>

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

Formats the value using the given formatter.

impl<A: Referable> Hash for ActorMeshRef<A>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<A: Referable + Named> Named for ActorMeshRef<A>

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 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.

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

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

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<A: Referable> PartialEq for ActorMeshRef<A>

fn eq(&self, other: &Self) -> 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<A: Referable> Ranked for ActorMeshRef<A>

type Item = ActorRef<A>

The type of item in this view.

fn region(&self) -> &Region

The ranks contained in this view.

fn get(&self, rank: usize) -> Option<&Self::Item>

Return the item at rank

impl<A: Referable> RankedSliceable for ActorMeshRef<A>

fn sliced(&self, region: Region) -> Self

Construct a new Ranked containing the ranks in this view that are part of region. The caller guarantees that region.is_subset(self.region()).

impl<A: Referable> Serialize for ActorMeshRef<A>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<A: Referable> Eq for ActorMeshRef<A>