Weighted Round-Robin Load Balancing Memory Optimization
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing weighted round-robin load balancing algorithms in distributed computing systems require significant memory to generate large arrays, which can lead to memory inefficiencies and performance issues, especially when dealing with numerous nodes and varying weights.
Innovation Solution
A memory-efficient technique that uses a mapping of keys to offsets and a list of node identifiers to determine which nodes receive data, reducing memory consumption by using only N elements for N nodes, where N is the number of nodes, and allowing for efficient weighted round-robin load balancing.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If traditional weighted round-robin algorithms generate large arrays to track node weights and distribute loads, then load balancing functionality is achieved, but memory consumption increases significantly
Solution Approach 1:
The patent extracts only the essential information needed for load balancing by removing the large array structure. Instead of maintaining a complete array of node identifiers indexed by weight, the invention extracts just the node identifier list and uses a hash function to compute indices on-demand, eliminating the memory-intensive data structure while preserving load balancing functionality.
Solution Approach 2:
The patent creates a simplified copy of the traditional approach by using a hash function to generate virtual array indices from node identifiers. This virtual copying allows the system to simulate array-based weight distribution without actually storing large arrays in memory, achieving the same load balancing effect with minimal memory overhead.
2Adaptability or versatility
If large arrays are used to accommodate numerous nodes with varying weights, then comprehensive node coverage is achieved, but system performance degrades due to memory management overhead
Solution Approach 1:
The patent introduces dynamic index computation through hash functions that calculate array indices on-demand based on node identifiers and current position. This dynamic approach replaces static large arrays with computational logic that adapts to any number of nodes and weight configurations, maintaining comprehensive node coverage while eliminating memory management overhead that degrades performance.
3Reliability
If memory resources are allocated for load balancing arrays, then load distribution is maintained, but resources available for other processes are reduced
Solution Approach 1:
The patent extracts the load distribution functionality from the memory-intensive array structure and implements it through lightweight hash-based index computation. This extraction maintains reliable load distribution across nodes while removing the large memory allocation requirement, thereby preserving resources for other system processes.
Data Source
AI summary
A memory-efficient technique for performing weighted round-robin load balancing in a distributed computing system is described. In one example of the present disclosure, a system can determine an offset to apply to a list of node identifiers based on a counter value. The system can select a subset of node identifiers from the list of node identifiers based on the offset. The system can then select a node identifier from the subset of node identifiers based on the counter value and a length of the subset of node identifiers. The system can transmit data to a node that corresponds to the node identifier and increment the counter value. The system can repeat this process any number of times to distribute data among a group of nodes in the distributed computing system.