Struct PartitionedTextExecution 

pub struct PartitionedTextExecution<E, G, R, I, T, U, V>(/* private fields */);

Stateless strategy marker selecting PartitionedTextRuntime in the shared session.

Implementations

impl<E, G, R, I, T, U, V> PartitionedTextExecution<E, G, R, I, T, U, V>

pub const fn new() -> Self

Creates the statically dispatched partition strategy.

Trait Implementations

impl<E, G, R, I, T, U, V> Default for PartitionedTextExecution<E, G, R, I, T, U, V>

fn default() -> Self

Returns the “default value” for a type.

impl<A, B, S, Resident, Bounded, E, G, R, I, T, U, V> ReplicatedTextExecutionStrategy<A, B, S, Resident, Bounded> for PartitionedTextExecution<E, G, R, I, T, U, V>

where B: CommunicationBackend, S: RuntimeState<B>, A: LayeredArchitecture<B, S>, Resident: LayerwisePolicy<B, A::Unit>, Bounded: LayerwisePolicy<B, A::Unit, Error = Resident::Error>, E: PartitionedGroupExecutor<A, B, S, G, R, I>, G: Borrow<B::CommunicationGroup>, R: Borrow<B::CommunicationRoute>, I: CommunicationTensorMetadata<B>, T: PartitionBoundaryTransport<B, G, R, I>, U: PartitionOutputPublisher<B, G, R, I>, V: PartitionCommitAgreement<B, G, R, I>, A::Error: Display, Resident::Error: Display,

const PARTITIONED_SESSION: bool = true

Whether this strategy executes one rank of a partitioned session.

const DISTRIBUTED_PHASE_AGREEMENT: bool = V::PHASE_FAILURE_AGREEMENT

Whether control phases use a selected bounded all-rank agreement.

type Runtime = PartitionedTextRuntime<A, B, S, Bounded, E, G, R, I, T, U, V>

Concrete execution runtime paired before the shared session lifecycle begins.

fn bounded_policy(runtime: &Self::Runtime) -> Option<&Bounded>

Returns bounded residency state for the shared session report.

fn execution_residency( runtime: &Self::Runtime, _selected: &SelectedReplicatedTextRealization, ) -> ExecutionResidency

Returns the execution residency actually installed on this rank.

fn forward_with_observer<'a, O>( &mut self, runtime: &mut Self::Runtime, input: A::Input<'a>, state: &mut S, pass_kind: ExpertPass, context: &<B::Tensor as Tensor>::Context, observer: &mut O, ) -> Result<(B::Tensor, A::ForwardContext), ReplicatedTextSessionError<A::Error, Resident::Error, Infallible>>

where O: ActivationObserver<B::Tensor, A::Error> + ?Sized,

Executes one complete layered pass through the selected unit strategy.

fn observe_output<O>( runtime: &mut Self::Runtime, output: &B::Tensor, observer: &mut O, _context: &<B::Tensor as Tensor>::Context, ) -> Result<B::Tensor, ReplicatedTextSessionError<A::Error, Resident::Error, Infallible>>

where O: ActivationObserver<B::Tensor, A::Error> + ?Sized,

Applies the architecture’s final-logits observation on the rank that owns the authoritative output. Ordinary replicated strategies observe locally; partitioned strategies may suppress the seam on destinations.

fn publish_observed_output( runtime: &mut Self::Runtime, output: B::Tensor, _context: &<B::Tensor as Tensor>::Context, ) -> Result<B::Tensor, ReplicatedTextSessionError<A::Error, Resident::Error, Infallible>>

Publishes an already-observed authoritative output after every rank has agreed that final observation succeeded.

fn prediction_target_capture( runtime: &mut Self::Runtime, forward: &A::ForwardContext, context: &<B::Tensor as Tensor>::Context, ) -> Result<Option<B::Tensor>, ReplicatedTextSessionError<A::Error, Resident::Error, Infallible>>

Resolves the rank-local tensor used by an additive prediction extension.

fn publish_prediction_target_capture( runtime: &mut Self::Runtime, capture: B::Tensor, _context: &<B::Tensor as Tensor>::Context, ) -> Result<B::Tensor, ReplicatedTextSessionError<A::Error, Resident::Error, Infallible>>

Publishes the output-owner capture to every prediction participant.

fn apply_prediction_target_operation<O>( runtime: &mut Self::Runtime, state: &mut S, operation: O, context: &<B::Tensor as Tensor>::Context, ) -> Result<Option<O::Output>, ReplicatedTextSessionError<A::Error, Resident::Error, Infallible>>

where O: PredictionTargetOperation<A, B, S>,

Runs one typed prediction-only operation against session-owned target modules and state.

fn commit_after_completion( runtime: &mut Self::Runtime, epoch: DistributedCommitEpoch, _context: &<B::Tensor as Tensor>::Context, ) -> DistributedCommitOutcome

Performs strategy-specific distributed commit only after output intervention and exact mechanism completion have succeeded.

fn agree_distributed_phase( runtime: &mut Self::Runtime, phase: DistributedExecutionPhase, local_success: bool, _context: &<B::Tensor as Tensor>::Context, ) -> Result<bool, ReplicatedTextSessionError<A::Error, Resident::Error, Infallible>>

Propagates one local shared-session phase result before the lifecycle can advance. Direct and unsupported strategies retain the local result.