Struct PartitionCommunication 

pub struct PartitionCommunication<B, G, R, I>
where
    B: CommunicationBackend,
{ /* private fields */ }

Opaque native communication resources paired in manifest order.

Implementations

impl<B, G, R, I> PartitionCommunication<B, G, R, I>

where B: CommunicationBackend, G: Borrow<B::CommunicationGroup>, R: Borrow<B::CommunicationRoute>, I: CommunicationTensorMetadata<B>,

pub fn new( manifest: CommunicationManifest, groups: Vec<RealizedCommunicationGroup<G>>, routes: Vec<RealizedCommunicationRoute<R>>, inspector: I, ) -> Result<Self, PartitionExecutionError>

Pairs already-created opaque resources with their authoritative manifest order.

pub fn new_with_authority( manifest: CommunicationManifest, groups: Vec<RealizedCommunicationGroup<G>>, routes: Vec<RealizedCommunicationRoute<R>>, inspector: I, authority: PartitionCommunicationAuthority, ) -> Result<Self, PartitionExecutionError>

Pairs native resources with an authority already retained by adjacent session APIs.

pub const fn manifest(&self) -> &CommunicationManifest

Authoritative local-rank manifest.

pub fn authority(&self) -> PartitionCommunicationAuthority

Shares the selected deadline and terminal poison domain with adjacent operations.

pub fn all_reduce_sum( &self, value: B::Tensor, group: CollectiveGroupId, executor: &B::Executor, ) -> Result<B::Tensor, PartitionExecutionError>

where B: SumReductionBackend,

Executes one exact sum reduction using only its narrow backend capability.

pub fn all_reduce_sum_wave( &self, values: impl IntoIterator<Item = B::Tensor>, group: CollectiveGroupId, executor: &B::Executor, ) -> Result<Vec<B::Tensor>, PartitionExecutionError>

where B: SumReductionBackend,

Submits one globally ordered wave of exact sum reductions before waiting for any member of the wave.

This is required for zero-work pipeline participants: an active peer may retain a lazy chain containing the entire wave, so waiting after the first zero-work submission would prevent later matching submissions from ever entering the native executor.

pub fn all_gather_even( &self, value: B::Tensor, axis: usize, group: CollectiveGroupId, executor: &B::Executor, ) -> Result<B::Tensor, PartitionExecutionError>

where B: EvenGatherBackend,

Executes one exact equal-count gather.

pub fn all_gather_uneven( &self, value: B::Tensor, counts: &[usize], axis: usize, group: CollectiveGroupId, executor: &B::Executor, ) -> Result<B::Tensor, PartitionExecutionError>

where B: UnevenGatherBackend,

Executes one exact unequal-count gather.

pub fn variable_all_to_all( &self, value: B::Tensor, counts: &CommunicationPeerCounts, axis: usize, group: CollectiveGroupId, executor: &B::Executor, ) -> Result<B::Tensor, PartitionExecutionError>

where B: VariableAllToAllBackend,

Executes the selected expert plan’s exact variable-count exchange without exposing EP semantics.

pub fn complete_execution_dependencies<'a, V>( &self, values: V, executor: &B::Executor, ) -> Result<(), PartitionExecutionError>

where V: IntoIterator<Item = &'a B::Tensor>, B::Tensor: 'a,

Completes exact local tensor dependencies before the caller advances an architecture-declared distributed execution wave.

This is distinct from a collective: it contributes no tensor value and exists only to make lazy predecessors reach the selected bounded completion policy while every rank is still at the matching wave position.