Trait PartitionCommitAgreement 

pub trait PartitionCommitAgreement<B, G, R, I>
where
    B: CommunicationBackend,
    G: Borrow<B::CommunicationGroup>,
    R: Borrow<B::CommunicationRoute>,
    I: CommunicationTensorMetadata<B>,
{
    const ENABLED: bool;
    const PHASE_FAILURE_AGREEMENT: bool = false;

    // Required method
    fn commit(
        &mut self,
        communication: &PartitionCommunication<B, G, R, I>,
        group: CollectiveGroupId,
        epoch: DistributedCommitEpoch,
        executor: &B::Executor,
    ) -> DistributedCommitOutcome;

    // Provided methods
    fn agree_phase(
        &mut self,
        _communication: &PartitionCommunication<B, G, R, I>,
        _group: CollectiveGroupId,
        _phase: DistributedExecutionPhase,
        local_success: bool,
        _executor: &B::Executor,
    ) -> Result<bool, PartitionExecutionError> { ... }
    fn agree_phase_after_prior_failure(
        &mut self,
        communication: &PartitionCommunication<B, G, R, I>,
        group: CollectiveGroupId,
        phase: DistributedExecutionPhase,
        local_success: bool,
        executor: &B::Executor,
    ) -> Result<bool, PartitionExecutionError> { ... }
}

Additive policy for optional distributed state-commit agreement.

Required Associated Constants

const ENABLED: bool

Whether this policy admits distributed commit agreement.

Provided Associated Constants

const PHASE_FAILURE_AGREEMENT: bool = false

Whether this policy propagates an explicit success status at every canonical shared-session phase.

Required Methods

fn commit( &mut self, communication: &PartitionCommunication<B, G, R, I>, group: CollectiveGroupId, epoch: DistributedCommitEpoch, executor: &B::Executor, ) -> DistributedCommitOutcome

Returns this rank’s honest observation of the globally identified final decision.

Provided Methods

fn agree_phase( &mut self, _communication: &PartitionCommunication<B, G, R, I>, _group: CollectiveGroupId, _phase: DistributedExecutionPhase, local_success: bool, _executor: &B::Executor, ) -> Result<bool, PartitionExecutionError>

Returns the conjunction of every member’s local phase status.

Barrier-only policies intentionally retain the local status here; they do not claim failure propagation.

fn agree_phase_after_prior_failure( &mut self, communication: &PartitionCommunication<B, G, R, I>, group: CollectiveGroupId, phase: DistributedExecutionPhase, local_success: bool, executor: &B::Executor, ) -> Result<bool, PartitionExecutionError>

Performs the canonical all-rank agreement after an earlier subgroup communication failure poisoned the local session authority.

Implementations may bypass the prior poison only for this bounded recovery agreement. The selected session remains poisoned afterwards.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<B, G, R, I> PartitionCommitAgreement<B, G, R, I> for NoCommitAgreement

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

const ENABLED: bool = false

impl<B, G, R, I> PartitionCommitAgreement<B, G, R, I> for OpaqueCommitAgreement

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

const ENABLED: bool = true

impl<B, G, R, I> PartitionCommitAgreement<B, G, R, I> for OpaqueFailureAgreement

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

const ENABLED: bool = true

const PHASE_FAILURE_AGREEMENT: bool = true