Struct DistributedOptimizer 

pub struct DistributedOptimizer {
    pub strategy: AggregationStrategy,
    pub current_step: u64,
    pub dropped_updates: u64,
    /* private fields */
}

Coordinator for distributed gradient aggregation across multiple workers.

Fields

strategy: AggregationStrategy

Aggregation strategy that governs when and how updates are combined.

current_step: u64

The global training step counter.

dropped_updates: u64

Number of updates that were rejected (staleness or other).

Implementations

impl DistributedOptimizer

pub fn new(strategy: AggregationStrategy) -> Self

Create a new optimizer with the given aggregation strategy.

pub fn register_worker(&mut self, worker_id: WorkerId) -> bool

Register a worker.

Returns true if the worker was newly registered, false if it was already present (even if inactive).

pub fn deregister_worker(&mut self, worker_id: &WorkerId) -> bool

Mark a worker as inactive (soft-deregister).

Returns true if the worker existed and was marked inactive, false if it was not found.

pub fn submit_update( &mut self, update: GradientUpdate, now: u64, ) -> Result<(), OptimizerDistError>

Submit a gradient update from a worker.

Errors

• OptimizerDistError::WorkerNotFound if the worker is not registered.
• OptimizerDistError::StaleUpdate for async strategy when the update is too far behind the global step.
• OptimizerDistError::DimensionMismatch when the gradient dimension conflicts with an already-pending update for the same layer.

pub fn try_aggregate(&mut self, layer_id: &str) -> Option<AggregatedGradient>

Attempt to aggregate pending updates for layer_id.

Returns Some(AggregatedGradient) if the strategy’s quorum condition is satisfied, None otherwise. On success the pending queue for that layer is cleared and the result is stored in aggregated.

pub fn aggregate_gradients(updates: &[GradientUpdate]) -> Vec<f64>

Compute the element-wise mean of a slice of GradientUpdates.

Returns an empty vector if updates is empty or all gradient vectors are empty.

pub fn advance_step(&mut self)

Advance the global training step by one.

For the AggregationStrategy::Synchronous strategy this also clears all pending updates left over from the previous step (workers that did not submit in time are implicitly skipped).

pub fn active_workers(&self) -> Vec<&WorkerState>

Returns references to all active workers.

pub fn worker_count(&self) -> usize

Total number of registered workers (active and inactive).

pub fn active_worker_count(&self) -> usize

Number of currently active workers.

pub fn pending_updates_for(&self, layer_id: &str) -> usize

Number of pending (not-yet-aggregated) updates for a layer.

pub fn last_aggregated(&self, layer_id: &str) -> Option<&AggregatedGradient>

Returns the most recently aggregated gradient for a layer, if any.

pub fn evict_stale_workers(&mut self, max_age_ms: u64, now: u64) -> usize

Mark workers inactive if their last_seen timestamp is older than now - max_age_ms.

Returns the number of workers evicted.

pub fn stats(&self) -> DistOptimizerStats

Snapshot current optimizer statistics.