Struct MessagePassingCoordinator 

pub struct MessagePassingCoordinator<F: Float> {
    pub coordinator_id: usize,
    pub worker_channels: HashMap<usize, Sender<MessageEnvelope<F>>>,
    pub coordinator_receiver: Receiver<MessageEnvelope<F>>,
    pub coordinator_sender: Sender<MessageEnvelope<F>>,
    pub message_counter: Arc<Mutex<u64>>,
    pub pending_messages: HashMap<u64, MessageEnvelope<F>>,
    pub message_timeouts: HashMap<u64, Instant>,
    pub worker_status: HashMap<usize, WorkerStatus>,
    pub sync_barriers: HashMap<usize, SynchronizationBarrier>,
    pub config: MessagePassingConfig,
}

Message passing coordinator for distributed clustering

Fields

coordinator_id: usize

worker_channels: HashMap<usize, Sender<MessageEnvelope<F>>>

coordinator_receiver: Receiver<MessageEnvelope<F>>

coordinator_sender: Sender<MessageEnvelope<F>>

message_counter: Arc<Mutex<u64>>

pending_messages: HashMap<u64, MessageEnvelope<F>>

message_timeouts: HashMap<u64, Instant>

worker_status: HashMap<usize, WorkerStatus>

sync_barriers: HashMap<usize, SynchronizationBarrier>

config: MessagePassingConfig

Implementations

impl<F: Float + Debug + Send + Sync + 'static> MessagePassingCoordinator<F>

pub fn new(coordinatorid: usize, config: MessagePassingConfig) -> Self

Create new message passing coordinator

pub fn register_worker( &mut self, workerid: usize, ) -> Receiver<MessageEnvelope<F>>

Register a new worker with the coordinator

pub fn send_message_to_worker( &mut self, workerid: usize, message: ClusteringMessage<F>, priority: MessagePriority, ) -> Result<u64>

Send message to a specific worker

pub fn broadcast_message( &mut self, message: ClusteringMessage<F>, priority: MessagePriority, ) -> Result<Vec<u64>>

Broadcast message to all workers

pub fn process_messages( &mut self, timeout: Duration, ) -> Result<Vec<MessageEnvelope<F>>>

Process incoming messages from workers

pub fn create_sync_barrier( &mut self, round: usize, expected_participants: usize, ) -> Result<()>

Create synchronization barrier

pub fn wait_for_barrier(&mut self, round: usize) -> Result<bool>

Wait for workers to reach synchronization barrier

pub fn register_barrier_arrival( &mut self, round: usize, workerid: usize, ) -> Result<()>

Register worker arrival at synchronization barrier

pub fn get_worker_status(&self, workerid: usize) -> Option<WorkerStatus>

Get worker status

pub fn update_worker_status(&mut self, workerid: usize, status: WorkerStatus)

Update worker status

pub fn get_active_workers(&self) -> Vec<usize>

Get active workers

pub fn get_failed_workers(&self) -> Vec<usize>

Get failed workers

pub fn shutdown(&mut self)

Shutdown coordinator and all worker channels

Trait Implementations

impl<F: Debug + Float> Debug for MessagePassingCoordinator<F>

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

Formats the value using the given formatter.