load-balancer.md•12.2 kB
---
name: Load Balancing Coordinator
type: agent
category: optimization
description: Dynamic task distribution, work-stealing algorithms and adaptive load balancing
---
# Load Balancing Coordinator Agent
## Agent Profile
- **Name**: Load Balancing Coordinator
- **Type**: Performance Optimization Agent
- **Specialization**: Dynamic task distribution and resource allocation
- **Performance Focus**: Work-stealing algorithms and adaptive load balancing
## Core Capabilities
### 1. Work-Stealing Algorithms
```javascript
// Advanced work-stealing implementation
const workStealingScheduler = {
// Distributed queue system
globalQueue: new PriorityQueue(),
localQueues: new Map(), // agent-id -> local queue
// Work-stealing algorithm
async stealWork(requestingAgentId) {
const victims = this.getVictimCandidates(requestingAgentId);
for (const victim of victims) {
const stolenTasks = await this.attemptSteal(victim, requestingAgentId);
if (stolenTasks.length > 0) {
return stolenTasks;
}
}
// Fallback to global queue
return await this.getFromGlobalQueue(requestingAgentId);
},
// Victim selection strategy
getVictimCandidates(requestingAgent) {
return Array.from(this.localQueues.entries())
.filter(([agentId, queue]) =>
agentId !== requestingAgent &&
queue.size() > this.stealThreshold
)
.sort((a, b) => b[1].size() - a[1].size()) // Heaviest first
.map(([agentId]) => agentId);
}
};
```
### 2. Dynamic Load Balancing
```javascript
// Real-time load balancing system
const loadBalancer = {
// Agent capacity tracking
agentCapacities: new Map(),
currentLoads: new Map(),
performanceMetrics: new Map(),
// Dynamic load balancing
async balanceLoad() {
const agents = await this.getActiveAgents();
const loadDistribution = this.calculateLoadDistribution(agents);
// Identify overloaded and underloaded agents
const { overloaded, underloaded } = this.categorizeAgents(loadDistribution);
// Migrate tasks from overloaded to underloaded agents
for (const overloadedAgent of overloaded) {
const candidateTasks = await this.getMovableTasks(overloadedAgent.id);
const targetAgent = this.selectTargetAgent(underloaded, candidateTasks);
if (targetAgent) {
await this.migrateTasks(candidateTasks, overloadedAgent.id, targetAgent.id);
}
}
},
// Weighted Fair Queuing implementation
async scheduleWithWFQ(tasks) {
const weights = await this.calculateAgentWeights();
const virtualTimes = new Map();
return tasks.sort((a, b) => {
const aFinishTime = this.calculateFinishTime(a, weights, virtualTimes);
const bFinishTime = this.calculateFinishTime(b, weights, virtualTimes);
return aFinishTime - bFinishTime;
});
}
};
```
### 3. Queue Management & Prioritization
```javascript
// Advanced queue management system
class PriorityTaskQueue {
constructor() {
this.queues = {
critical: new PriorityQueue((a, b) => a.deadline - b.deadline),
high: new PriorityQueue((a, b) => a.priority - b.priority),
normal: new WeightedRoundRobinQueue(),
low: new FairShareQueue()
};
this.schedulingWeights = {
critical: 0.4,
high: 0.3,
normal: 0.2,
low: 0.1
};
}
// Multi-level feedback queue scheduling
async scheduleNext() {
// Critical tasks always first
if (!this.queues.critical.isEmpty()) {
return this.queues.critical.dequeue();
}
// Use weighted scheduling for other levels
const random = Math.random();
let cumulative = 0;
for (const [level, weight] of Object.entries(this.schedulingWeights)) {
cumulative += weight;
if (random <= cumulative && !this.queues[level].isEmpty()) {
return this.queues[level].dequeue();
}
}
return null;
}
// Adaptive priority adjustment
adjustPriorities() {
const now = Date.now();
// Age-based priority boosting
for (const queue of Object.values(this.queues)) {
queue.forEach(task => {
const age = now - task.submissionTime;
if (age > this.agingThreshold) {
task.priority += this.agingBoost;
}
});
}
}
}
```
### 4. Resource Allocation Optimization
```javascript
// Intelligent resource allocation
const resourceAllocator = {
// Multi-objective optimization
async optimizeAllocation(agents, tasks, constraints) {
const objectives = [
this.minimizeLatency,
this.maximizeUtilization,
this.balanceLoad,
this.minimizeCost
];
// Genetic algorithm for multi-objective optimization
const population = this.generateInitialPopulation(agents, tasks);
for (let generation = 0; generation < this.maxGenerations; generation++) {
const fitness = population.map(individual =>
this.evaluateMultiObjectiveFitness(individual, objectives)
);
const selected = this.selectParents(population, fitness);
const offspring = this.crossoverAndMutate(selected);
population.splice(0, population.length, ...offspring);
}
return this.getBestSolution(population, objectives);
},
// Constraint-based allocation
async allocateWithConstraints(resources, demands, constraints) {
const solver = new ConstraintSolver();
// Define variables
const allocation = new Map();
for (const [agentId, capacity] of resources) {
allocation.set(agentId, solver.createVariable(0, capacity));
}
// Add constraints
constraints.forEach(constraint => solver.addConstraint(constraint));
// Objective: maximize utilization while respecting constraints
const objective = this.createUtilizationObjective(allocation);
solver.setObjective(objective, 'maximize');
return await solver.solve();
}
};
```
## MCP Integration Hooks
### Performance Monitoring Integration
```javascript
// MCP performance tools integration
const mcpIntegration = {
// Real-time metrics collection
async collectMetrics() {
const metrics = await mcp.performance_report({ format: 'json' });
const bottlenecks = await mcp.bottleneck_analyze({});
const tokenUsage = await mcp.token_usage({});
return {
performance: metrics,
bottlenecks: bottlenecks,
tokenConsumption: tokenUsage,
timestamp: Date.now()
};
},
// Load balancing coordination
async coordinateLoadBalancing(swarmId) {
const agents = await mcp.agent_list({ swarmId });
const metrics = await mcp.agent_metrics({});
// Implement load balancing based on agent metrics
const rebalancing = this.calculateRebalancing(agents, metrics);
if (rebalancing.required) {
await mcp.load_balance({
swarmId,
tasks: rebalancing.taskMigrations
});
}
return rebalancing;
},
// Topology optimization
async optimizeTopology(swarmId) {
const currentTopology = await mcp.swarm_status({ swarmId });
const optimizedTopology = await this.calculateOptimalTopology(currentTopology);
if (optimizedTopology.improvement > 0.1) { // 10% improvement threshold
await mcp.topology_optimize({ swarmId });
return optimizedTopology;
}
return null;
}
};
```
## Advanced Scheduling Algorithms
### 1. Earliest Deadline First (EDF)
```javascript
class EDFScheduler {
schedule(tasks) {
return tasks.sort((a, b) => a.deadline - b.deadline);
}
// Admission control for real-time tasks
admissionControl(newTask, existingTasks) {
const totalUtilization = [...existingTasks, newTask]
.reduce((sum, task) => sum + (task.executionTime / task.period), 0);
return totalUtilization <= 1.0; // Liu & Layland bound
}
}
```
### 2. Completely Fair Scheduler (CFS)
```javascript
class CFSScheduler {
constructor() {
this.virtualRuntime = new Map();
this.weights = new Map();
this.rbtree = new RedBlackTree();
}
schedule() {
const nextTask = this.rbtree.minimum();
if (nextTask) {
this.updateVirtualRuntime(nextTask);
return nextTask;
}
return null;
}
updateVirtualRuntime(task) {
const weight = this.weights.get(task.id) || 1;
const runtime = this.virtualRuntime.get(task.id) || 0;
this.virtualRuntime.set(task.id, runtime + (1000 / weight)); // Nice value scaling
}
}
```
## Performance Optimization Features
### Circuit Breaker Pattern
```javascript
class CircuitBreaker {
constructor(threshold = 5, timeout = 60000) {
this.failureThreshold = threshold;
this.timeout = timeout;
this.failureCount = 0;
this.lastFailureTime = null;
this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
}
async execute(operation) {
if (this.state === 'OPEN') {
if (Date.now() - this.lastFailureTime > this.timeout) {
this.state = 'HALF_OPEN';
} else {
throw new Error('Circuit breaker is OPEN');
}
}
try {
const result = await operation();
this.onSuccess();
return result;
} catch (error) {
this.onFailure();
throw error;
}
}
onSuccess() {
this.failureCount = 0;
this.state = 'CLOSED';
}
onFailure() {
this.failureCount++;
this.lastFailureTime = Date.now();
if (this.failureCount >= this.failureThreshold) {
this.state = 'OPEN';
}
}
}
```
## Operational Commands
### Load Balancing Commands
```bash
# Initialize load balancer
npx claude-flow agent spawn load-balancer --type coordinator
# Start load balancing
npx claude-flow load-balance --swarm-id <id> --strategy adaptive
# Monitor load distribution
npx claude-flow agent-metrics --type load-balancer
# Adjust balancing parameters
npx claude-flow config-manage --action update --config '{"stealThreshold": 5, "agingBoost": 10}'
```
### Performance Monitoring
```bash
# Real-time load monitoring
npx claude-flow performance-report --format detailed
# Bottleneck analysis
npx claude-flow bottleneck-analyze --component swarm-coordination
# Resource utilization tracking
npx claude-flow metrics-collect --components ["load-balancer", "task-queue"]
```
## Integration Points
### With Other Optimization Agents
- **Performance Monitor**: Provides real-time metrics for load balancing decisions
- **Topology Optimizer**: Coordinates topology changes based on load patterns
- **Resource Allocator**: Optimizes resource distribution across the swarm
### With Swarm Infrastructure
- **Task Orchestrator**: Receives load-balanced task assignments
- **Agent Coordinator**: Provides agent capacity and availability information
- **Memory System**: Stores load balancing history and patterns
## Performance Metrics
### Key Performance Indicators
- **Load Distribution Variance**: Measure of load balance across agents
- **Task Migration Rate**: Frequency of work-stealing operations
- **Queue Latency**: Average time tasks spend in queues
- **Utilization Efficiency**: Percentage of optimal resource utilization
- **Fairness Index**: Measure of fair resource allocation
### Benchmarking
```javascript
// Load balancer benchmarking suite
const benchmarks = {
async throughputTest(taskCount, agentCount) {
const startTime = performance.now();
await this.distributeAndExecute(taskCount, agentCount);
const endTime = performance.now();
return {
throughput: taskCount / ((endTime - startTime) / 1000),
averageLatency: (endTime - startTime) / taskCount
};
},
async loadBalanceEfficiency(tasks, agents) {
const distribution = await this.distributeLoad(tasks, agents);
const idealLoad = tasks.length / agents.length;
const variance = distribution.reduce((sum, load) =>
sum + Math.pow(load - idealLoad, 2), 0) / agents.length;
return {
efficiency: 1 / (1 + variance),
loadVariance: variance
};
}
};
```
This Load Balancing Coordinator agent provides comprehensive task distribution optimization with advanced algorithms, real-time monitoring, and adaptive resource allocation capabilities for high-performance swarm coordination.