Struct SpmdParallelWorkers 

pub struct SpmdParallelWorkers { /* private fields */ }

SPMD (Single Program, Multiple Data) parallel worker group.

Wraps a set of rank-indexed Workers and executes every operation on all of them in parallel. Each worker has its own rank, physical layout handles, and TransferManager, but they all receive the same logical commands (transfer, connect, import/export metadata).

Transfer completion notifications from individual workers are aggregated into a single notification via the event system, so callers see one completion event per logical operation regardless of worker count.

Remote handle mappings are stored per (InstanceId, worker_idx, LogicalLayoutHandle) so that each rank resolves to its own peer handle during RDMA transfers.

Implementations

impl SpmdParallelWorkers

pub fn new( workers: Vec<Arc<dyn Worker>>, events: Arc<EventManager>, runtime: Handle, ) -> Self

Create a new SpmdParallelWorkers.

Arguments

• workers - The underlying workers (one per rank)
• events - The event system for aggregating completion notifications
• runtime - The tokio runtime handle for spawning aggregation tasks

pub fn worker_count(&self) -> usize

Get the number of workers.

Trait Implementations

impl ObjectBlockOps for SpmdParallelWorkers

fn has_blocks( &self, keys: Vec<SequenceHash>, ) -> BoxFuture<'static, Vec<(SequenceHash, Option<usize>)>>

Check if blocks exist in object storage.

fn put_blocks( &self, keys: Vec<SequenceHash>, src_layout: LogicalLayoutHandle, block_ids: Vec<BlockId>, ) -> BoxFuture<'static, Vec<Result<SequenceHash, SequenceHash>>>

Put blocks to object storage.

fn get_blocks( &self, keys: Vec<SequenceHash>, dst_layout: LogicalLayoutHandle, block_ids: Vec<BlockId>, ) -> BoxFuture<'static, Vec<Result<SequenceHash, SequenceHash>>>

Get blocks from object storage.

fn put_blocks_with_layout( &self, keys: Vec<SequenceHash>, _layout: PhysicalLayout, _block_ids: Vec<BlockId>, ) -> BoxFuture<'static, Vec<Result<SequenceHash, SequenceHash>>>

Put blocks to object storage using a resolved physical layout.

fn get_blocks_with_layout( &self, keys: Vec<SequenceHash>, _layout: PhysicalLayout, _block_ids: Vec<BlockId>, ) -> BoxFuture<'static, Vec<Result<SequenceHash, SequenceHash>>>

Get blocks from object storage into a resolved physical layout.

impl ParallelWorkers for SpmdParallelWorkers

fn export_metadata(&self) -> Result<Vec<SerializedLayoutResponse>>

Export the local metadata for a set of workers.

fn import_metadata( &self, metadata: Vec<SerializedLayout>, ) -> Result<Vec<ImportMetadataResponse>>

Import the remote metadata for this worker.

fn worker_count(&self) -> usize

Get the number of workers.

fn workers(&self) -> &[Arc<dyn Worker>]

Get access to the underlying workers for metadata/handle queries.

impl WorkerTransfers for SpmdParallelWorkers

fn execute_local_transfer( &self, src: LogicalLayoutHandle, dst: LogicalLayoutHandle, src_block_ids: Arc<[BlockId]>, dst_block_ids: Arc<[BlockId]>, options: TransferOptions, ) -> Result<TransferCompleteNotification>

Execute a local transfer between two logical layouts.

fn execute_remote_onboard( &self, src: RemoteDescriptor, dst: LogicalLayoutHandle, dst_block_ids: Arc<[BlockId]>, options: TransferOptions, ) -> Result<TransferCompleteNotification>

Execute a remote transfer from a remote layout to a local logical layout.

fn execute_remote_offload( &self, src: LogicalLayoutHandle, src_block_ids: Arc<[BlockId]>, dst: RemoteDescriptor, options: TransferOptions, ) -> Result<TransferCompleteNotification>

Execute a remote offload from a local logical layout to a remote descriptor.

fn connect_remote( &self, instance_id: InstanceId, metadata: Vec<SerializedLayout>, ) -> Result<ConnectRemoteResponse>

Connect to a remote instance by importing its metadata and storing handle mappings.

fn has_remote_metadata(&self, instance_id: InstanceId) -> bool

Check if remote metadata has been imported for an instance.

fn execute_remote_onboard_for_instance( &self, instance_id: InstanceId, remote_logical_type: LogicalLayoutHandle, src_block_ids: Vec<BlockId>, dst: LogicalLayoutHandle, dst_block_ids: Arc<[BlockId]>, options: TransferOptions, ) -> Result<TransferCompleteNotification>

Execute a remote onboard transfer using stored handle mapping.