Struct LoadBalancer 

pub struct LoadBalancer {
    pub balancing_strategy: BalancingStrategy,
    pub worker_metrics: HashMap<String, WorkerMetrics>,
    pub scheduling_strategy: LoadBalancingStrategy,
    pub num_workers: usize,
    pub total_tasks: usize,
    pub next_worker: usize,
    pub pending_tasks: Vec<usize>,
}

Load balancer

Distributes tasks across a fixed pool of logical workers according to a LoadBalancingStrategy. This is purely logical scheduling — no real threads are spawned (actual parallelism is a Phase 2 concern).

Fields

balancing_strategy: BalancingStrategy

worker_metrics: HashMap<String, WorkerMetrics>

scheduling_strategy: LoadBalancingStrategy

Strategy used by LoadBalancer::assign_task to schedule tasks.

num_workers: usize

Number of logical workers to distribute tasks across.

total_tasks: usize

Total number of tasks in the current batch (used by Static partitioning).

next_worker: usize

Round-robin cursor: index of the next worker to assign (used by RoundRobin).

pending_tasks: Vec<usize>

Pending task count per worker (used by WorkStealing).

Implementations

impl LoadBalancer

pub fn new(strategy: LoadBalancingStrategy) -> Self

Create a load balancer that uses strategy to assign tasks.

The balancer starts with zero workers; call LoadBalancer::with_workers (or set LoadBalancer::num_workers directly) before invoking LoadBalancer::assign_task.

pub fn with_workers(self, num_workers: usize) -> Self

Builder-style setter for the worker count. Resizes the per-worker pending task vector to match and resets scheduling cursors.

pub fn set_workers(&mut self, num_workers: usize)

Set the worker count, resizing the per-worker pending task vector and resetting scheduling cursors.

pub fn prepare(&mut self, total_tasks: usize)

Prepare the balancer for a fresh batch of total_tasks tasks.

Resets the round-robin cursor and per-worker pending counts, and records the batch size used by LoadBalancingStrategy::Static partitioning. ParallelExecutor::execute_parallel calls this before assigning tasks; callers using LoadBalancer::assign_task directly should call it first (notably for Static).

pub fn assign_task(&mut self, task_id: usize) -> usize

Return the worker index to assign the next task to.

• LoadBalancingStrategy::RoundRobin: cycles through workers 0,1,…,N-1,0,1,… regardless of task_id.
• LoadBalancingStrategy::WorkStealing: assigns to the worker with the fewest pending tasks (ties broken by lowest index) and increments that worker’s pending count.
• LoadBalancingStrategy::Static: contiguous equal partition — worker = task_id * num_workers / total_tasks (falls back to task_id % num_workers when total_tasks is unset).

Returns 0 when the balancer has no workers configured.

Trait Implementations

impl Clone for LoadBalancer

fn clone(&self) -> LoadBalancer

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LoadBalancer

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

Formats the value using the given formatter.