Decentralized Load Balancing via Shared Cache Agents
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing host clusters face challenges in balancing loads without a centralized controller or load balancer, leading to inefficiencies and single points of failure, especially when service agents have varying availability and task completion times.
Innovation Solution
A decentralized load balancing system where service agents on host instances use a shared cache to dynamically adjust their states and workload distribution based on timers, timestamps, and load differences between host instances, allowing them to automatically balance tasks without a centralized controller.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If a centralized controller or load balancer is used to balance loads, then workload distribution can be managed, but single points of failure are created and system reliability decreases
Solution Approach 1:
The patent extracts the centralized controller from the system architecture and replaces it with decentralized service agents on each host instance. Each agent independently manages load balancing decisions using local state information and shared cache data, eliminating the single point of failure while maintaining workload distribution capabilities
Solution Approach 2:
The system segments the centralized load balancing function into distributed service agents on individual host instances. Each agent operates autonomously with its own state machine and decision-making logic, dividing the monolithic control function into modular, fault-isolated units that can operate independently
2Productivity
If service agents continuously monitor and adjust workload distribution, then load balancing efficiency improves, but system complexity and resource consumption increase
Solution Approach 1:
Service agents use timers to transition between sleep and active states periodically, rather than continuously monitoring. During sleep state, agents consume minimal resources; during active state, they perform load balancing decisions based on current system conditions, achieving efficient periodic control without continuous overhead
Solution Approach 2:
Each service agent autonomously manages its own state transitions, workload acceptance, and timestamp updates without requiring complex external coordination. The agents self-regulate their activity based on local state information and shared cache data, reducing overall system complexity through decentralized autonomy
3Speed
If service agents remain in active state to handle tasks, then task completion speed improves, but resource consumption and system load increase
Solution Approach 1:
Service agents alternate between sleep and active states using timers. When active, they can immediately handle tasks without delay; when in sleep state, they conserve resources. This periodic activation pattern ensures rapid task response when needed while minimizing resource consumption during idle periods
Solution Approach 2:
The service agents dynamically transition between operational states based on system conditions and timer expiration. The system adapts agent availability in real-time, activating agents when workload requires rapid response and placing them in sleep state when resources need conservation, optimizing the trade-off between speed and energy use
Data Source
AI summary
Various embodiments are generally directed to decentralized load balancing in a host cluster utilized to coordinate performance of processing tasks in a workload, such as via service agents and/or host instances included in the host cluster, for instance. Some embodiments are particularly directed to a set of service agents on one or more host instances that utilize a shared cache to coordinate among themselves to automatically balance a workload without a centralized controller or a centralized load balancer. In one or more embodiments, a set of service agents may automatically and cooperatively balance a workload among themselves using the shared cache.