Struct LoadBalancer 

pub struct LoadBalancer { /* private fields */ }

Load balancer for distributing work across GPUs

Implementations

impl LoadBalancer

pub fn new(devices: Vec<Arc<GpuDevice>>, strategy: SelectionStrategy) -> Self

Create a new load balancer

pub fn migration_config(&self) -> MigrationConfig

Get the migration configuration

pub fn set_migration_config(&self, config: MigrationConfig)

Update migration configuration

pub fn select_device(&self) -> Result<Arc<GpuDevice>>

Select a device using the configured strategy

pub fn select_weighted(&self) -> Result<Arc<GpuDevice>>

Select device using weighted strategy based on device performance

pub fn get_device_loads(&self) -> Vec<DeviceLoad>

Get current load information for all devices

pub fn identify_overloaded_devices(&self) -> Vec<DeviceLoad>

Identify overloaded devices

pub fn identify_underutilized_devices(&self) -> Vec<DeviceLoad>

Identify underutilized devices

pub fn is_imbalanced(&self) -> bool

Check if load is imbalanced (requires rebalancing)

pub fn calculate_transfer_cost( &self, source_device: usize, target_device: usize, data_size: u64, ) -> Result<f64>

Calculate data transfer cost between two devices

pub fn create_migration_plan( &self, workload: MigratableWorkload, target_device: usize, ) -> Result<MigrationPlan>

Create a migration plan for a workload

pub fn find_migration_target( &self, source_device: usize, ) -> Result<Option<usize>>

Find best migration target for an overloaded device

pub fn select_workload_for_migration( &self, source_device: usize, ) -> Option<MigratableWorkload>

Select workload to migrate from an overloaded device

pub fn execute_migration(&self, plan: &MigrationPlan) -> Result<MigrationResult>

Execute a migration (simulated - actual data transfer would use sync module)

pub fn rebalance(&self) -> Result<Vec<MigrationResult>>

Rebalance workloads across devices

This method implements the core workload migration logic:

1. Monitor GPU utilization across all devices
2. Identify overloaded and underutilized GPUs
3. Calculate transfer costs for potential migrations
4. Execute migrations that improve overall balance

pub fn register_workload( &self, device_index: usize, memory_size: u64, compute_intensity: f32, priority: u32, ) -> Result<u64>

Register a new workload on a device

pub fn unregister_workload( &self, device_index: usize, workload_id: u64, ) -> Result<()>

Unregister a workload (completed or cancelled)

pub fn task_started(&self, device_index: usize)

Mark task started on device

pub fn task_completed(&self, device_index: usize, duration_us: u64)

Mark task completed on device

pub fn get_stats(&self) -> LoadStats

Get load statistics

pub fn print_stats(&self)

Print load statistics

pub fn reset_stats(&self)

Reset statistics

pub fn get_device_utilization(&self, device_index: usize) -> f32

Get device utilization (0.0 to 1.0)

pub fn get_cluster_utilization(&self) -> f32

Get overall cluster utilization (0.0 to 1.0)

pub fn suggest_device(&self, estimated_memory: u64) -> Result<Arc<GpuDevice>>

Suggest optimal device for next task

pub fn get_migration_stats(&self) -> (usize, usize, f64)

Get migration history statistics

pub fn device_count(&self) -> usize

Get device count