# A simple approach for adapting continuous load balancing processes to discrete settings

TL;DR: A general method that converts a wide class of continuous neighborhood load balancing algorithms into a discrete version that achieves asymptotically lower discrepancies and presents a randomized version of the algorithm balancing the load if the initial load on every node is large enough.

Abstract: We introduce a general method that converts a wide class of continuous neighborhood load balancing algorithms into a discrete version. Assume that initially the tasks are arbitrarily distributed among the nodes of a graph. In every round every node is allowed to communicate and exchange load with an arbitrary subset of its neighbors. The goal is to balance the load as evenly as possible. Continuous load balancing algorithms that are allowed to split tasks arbitrarily can balance the load perfectly, so that every node has exactly the same load. Discrete load balancing algorithms are not allowed to split tasks and therefore cannot balance the load perfectly. In this paper we consider the problem in a very general setting, where the tasks can have arbitrary weights and the nodes can have different speeds. Given a neighborhood load balancing algorithm that balances the load perfectly in t rounds, we convert the algorithm into a discrete version. This new algorithm is deterministic and balances the load in t rounds so that the difference between the average and the maximum load is at most 2d•wmax, where d is the maximum degree of the network and wmax is the maximum weight of any task. Compared to the previous methods that work for general graphs [12], our method achieves asymptotically lower discrepancies (e.g. O(1) vs. O(log n) for constant-degree expanders and O(r) vs. O(n1/r) for r-dimensional tori) in the same number of rounds. For the case of uniform weights we present a randomized version of our algorithm balancing the load so that the difference between the minimum and the maximum load is at most O√dlog n) if the initial load on every node is large enough.

## Summary (2 min read)

### 1 Introduction

- In this paper the authors consider the problem of neighbourhood load balancing in arbitrary networks.
- The tasks can have arbitrary weights; the weight of ∗This paper is an extended version of [6].
- Neighbourhood load balancing algorithms usually work in synchronous rounds.
- These matchings are then used periodically (periodic matching model).
- Here all the nodes balance their load with all their neighbours.

### 1.1 New Results

- In every round the discrete algorithm imitates the continuous algorithm as closely as possible by trying to send the same amount of load over every edge as the continuous algorithm.
- That would incur communication overhead proportional to the number of dummy tokens.
- Furthermore, let T be the time it takes for the continuous process to balance the load (more or less) completely (see Section 3 for details).
- An additive algorithm, starting with a load distribution D = D1 +D2, transmits the same amount of tasks over every edge as the sum of the amounts it would transmit in 1The discrete version of the algorithm has to know the continuous flow f ce (t) for every edge e = (u,v).
- Algorithm 1 achieves a final max-min discrepancy independent of n and graph expansion, and in particular, the only algorithm achieving constant max-min discrepancy for all constant-degree graphs.

### 2 Existing Algorithms and Techniques

- The authors give an overview of the results on continuous (Section 2.1) and discrete neighbourhood load balancing (Section 2.2) only.
- The authors will not consider these models here any further.
- When not stated otherwise, the results are for the uniform case without speeds and weights.
- In the following the authors will consider the results both in the discrete and the continuous settings.

### 2.1 Continuous Load Balancing

- The first diffusion algorithm (also called first order schedule, FOS) was independently introduced by Cybenko [15] and Boillat [12].
- Their results were later generalized to the case of non-uniform speeds in [20].
- To introduce the FOS process the authors first need some additional notation.
- The SOS method is inspired by a numerical iterative method called successive over-relaxation.
- The model was originally introduced in [30], together with a distributed edge-colouring algorithm (see also [35, 36]) that can be used to construct the matchings.

### 2.2 Discrete Load Balancing

- As far as the authors know, existing papers consider only discrete algorithms in the uniform task model.
- (7) For FOS schemes, [34] left it as an open question to analyze the potential drop when the potential is smaller than O(d2n2).
- All the edges are assigned weights proportional to their scheduled load transfer.
- When the continuous flow is rounded down, the final discrepancy is Ω(d · diam(G)) for a discrete FOS process [26, 27] and Ω(diam(G)) for a discrete process in the matching model [27].

### 2.3 Improved Processes for Discrete Load Balancing

- The next three subsections discuss three different approaches that were used in order to reduce the difference (caused by the rounding error) in the load distribution between discrete and continuous balancing processes.
- The authors combine the approach of [37] with analysis techniques for randomized algorithms to show improved discrepancy bounds for general graphs.
- Note that it is possible to get similar results if the excess tokens are sent to neighbours chosen randomly with replacement or if the neighbours are chosen in a roundrobin fashion with a random starting point [5].
- Note that this algorithm might also create negative load on some of the nodes.

### 3 Notation and Basic Facts

- Initially there are in total m tasks which are assigned arbitrarily to the n nodes of the graph G. Tasks may be of different integer weights and the maximum task weight is denoted by wmax.
- Consider a continuous process A. For the transformations introduced by Algorithm 1 and Algorithm 2, the authors require initial load vectors that do not lead to negative load in the continuous case; that is, they need to ensure that when executing A, the outgoing demand of a node never exceeds its available load.
- Consider a load balancing process A. Let x′, and x′′ be nonnegative load vectors.
- The next lemma shows that the class of additive terminating processes includes several well known existing processes.

### 4 Deterministic Flow Imitation

- The authors present and analyze an algorithm that transforms a continuous process A into its discrete counterpart which they call D(A).
- The authors also note that in actual implementation they do not need to create and transfer workload units and consume communication bandwidth for each dummy token.
- For other algorithms, the result in part (1) of the above theorem automatically holds, and the condition in part (2) can be translated as having sufficient initial load.
- Now, the result can be obtained using Observation 4.

### 5 Randomized Flow Imitation

- Instead of always rounding down the flow that has to be sent over an edge, Algorithm 2 uses randomized rounding.
- Then each of the random variables Ei, j(t) can assume at most two different values and rounding up or down is independent of other edges (see part (3) of Observation 9).
- The next lemma provides the two main ingredients for proving the Theorem 8.

Did you find this useful? Give us your feedback

...read more

##### Citations

39 citations

### Additional excerpts

...Neighborhood load balancing algorithms Akbari et al., 2012) are diffusion algorithm that have the advantage hat they are very simple and that the vertices do not need any global nformation to base their balancing decisions on....

[...]

32 citations

^{1}, University of Bordeaux

^{2}, Paris Diderot University

^{3}, Aalto University

^{4}

19 citations

12 citations

12 citations

##### References

8,475 citations

^{1}

1,039 citations

324 citations

316 citations

223 citations