Local Deal-Agreement Algorithms for Load Balancing in Dynamic General Graphs

Abstract

We study the classic load balancing problem on dynamic general graphs, where the graph changes arbitrarily between the computational rounds, remaining connected with no permanent cut. A lower bound of Ω(n²) for the running time bound in the dynamic setting, where n is the number of nodes in the graph, is known even for randomized algorithms. We solve the problem by deterministic distributed algorithms, based on a short local deal-agreement communication of proposal/deal in the neighborhood of each node. Our synchronous load balancing algorithms achieve a discrepancy of 𝜖 within the time of $O(nD \log (nK/\epsilon ))$ for the continuous setting and the discrepancy of at most 2D within the time of $O(n D \log (n K/D))$ and a 1-balanced state within the additional time of O(nD²) for the discrete setting, where K is the initial discrepancy, and D is a bound for the graph diameter. Also, the stability of the achieved 1-balanced state is studied. The above results are extended to the case of unbounded diameter, essentially keeping the time bounds, via special averaging of the graph diameter over time. Our algorithms can be considered anytime ones, in the sense that they can be stopped at any time during the execution, since they never make loads negative and never worsen the state as the execution progresses. In addition, we describe a version of our algorithms, where each node may transfer load to and from several neighbors at each round, as a heuristic for better performance. The algorithms are generalized to the asynchronous distributed model. We also introduce a self-stabilizing version of our asynchronous algorithms.

Appendix A: Related Work for Load Balancing in Static Graphs

Most of the research on the load balancing problem is for static graphs. Our contribution is primarily for the case of dynamic networks, still for the sake of completeness, we next review load balancing research in the static case too. For a summary of the results for both static and dynamic settings, see Table 1. The two pioneering papers solving the problem are those of Cybenko [29], and Boillat [30]. Both are based on the concept of diffusion: at any synchronized round, every node divides a certain part of its load equally among its neighbors, keeping the rest of its load for itself; for regular graphs, the load fraction kept for itself is usually set to be equal to that sent to each neighbor. Many further solutions are based on diffusion, see, e.g., [13, 16, 21, 31,32,33]. These papers use Markov chains and ergodic theory for deriving the rate of convergence; most of them consider d-regular graphs. This approach works smoothly for the continuous setting. In paper of Rabani et al. [13], the time bound $O\left (\frac {\log (Kn/\epsilon )}{(1-\lambda )}\right )$ was established for reaching the discrepancy of 𝜖, where λ is the second largest eigenvalue of the diffusion matrix. This bound enjoys using the graph-specific parameter λ. Note that the factor of $\frac 1{1-\lambda }$ is Θ(n²) in the worst case, e.g., for a graph that is a cycle.

In the discrete setting, diffusion methods require rounding of every transferred amount, which makes the analysis harder. Let us begin with the deterministic algorithms. Muthukrishnan et al. [34] refer to the usual continuous diffusion model as the first order scheme and extend it to the second-order scheme, which takes $O(\log (Kn))/(1-\lambda ))$ time for achieving a discrepancy of O(dn/(1 − λ)). Further progress was made by Rabani et al. [13], who introduced the so-called local divergence, which is an effective way to compute the deviation between the actual load and the deviation generated by a Markov chain. They proved that the local divergence yields a bound on the maximum deviation between the continuous and discrete case for both the diffusion and matching models. They proved that the local divergence can be reduced to $O (d \log (Kn)/(1 - \lambda ))$ in $O(\log (Kn))/(1-\lambda ))$ rounds for a d-regular graph. Note that the final discrepancy achieved by their method is not a constant. As mentioned in [19], the discrepancy cannot be reduced below ${\Omega }(d_{\min \limits } D)$ by a deterministic diffusion-based algorithm, where D is the diameter and $d_{\min \limits }$ is the minimum node degree, in the graph.

Table 1 Comparison of different load balancing algorithms

Randomized diffusion-based algorithms for the discrete setting [20, 21, 32] are algorithms in which every node distributes its load as evenly as possible among its neighbors and itself, and if the remaining load is impossible to distribute without dividing some load unit, then the node redistributes the remaining loads to its neighbors randomly. The bounds for the discrepancy are achieved w.h.p. (with high probability). In Berenbrink et al. [32], the authors show randomized diffusion-based discrete load balancing algorithm for which the discrepancy depends on the expansion property of the graph (depending, e.g., on λ and maximum degree d). Another quasi-random diffusion-based algorithm for general graphs [20] considered bounded-error property, where the sum of rounding errors on each edge is bounded by some constant all the time. The discrepancy results of the randomized algorithms in [20, 32] are further improved to $O(d^{2} \sqrt {\log n})$ and $O(d \sqrt {\log n})$, respectively, by applying the results from [15], where tighter bounds are obtained for certain graph parameters used in discrepancy bounds of [20, 32]. Akbari et al. [21] discussed a randomized discrete load balancing algorithm for general graphs that balances the load up to a discrepancy of $O(\sqrt {d \log n})$ in $O (\log (Kn)/(1 - \lambda ))$ time, where d is the maximum degree. Using the algorithm of Akbari et al. [21], the discrepancy is also reduced for specific graph topologies. E.g., the discrepancy reduces to $O(\log n)$ for hypercubes and to $O(\sqrt {\log n})$ for expanders and tori.

Elsässer et al. [19, 35] propose load balancing algorithms based on randomized post-processing, using random walks, for decreasing the discrepancy to a constant w.h.p. Elsässer et al. [35] present an approach achieving a constant discrepancy after $O((\log K) + (\log n)^{2}(1- \lambda ))$ steps. Elsässer et al. [19] improved that result by reducing the time to $O \left (\frac {\log (Kn)}{1 - \lambda }\right )$ w.h.p.. Berenbrink et al. [14] introduced the cumulatively fair balancer algorithms, which include the rotor-router model and give an upper bound of $O(d \cdot \min \limits (\sqrt {\log n/(1- \lambda )}, \sqrt {n}))$ for d-regular graphs.

One of the alternatives to diffusion is the matching approach, also known as the dimension exchange model. There, a node matching is chosen at the beginning of each synchronized round, and after that, every two matched nodes balance their loads. In known deterministic algorithms, those matchings are usually chosen in advance according to the graph structure; in randomized algorithms, they are chosen randomly. The randomized algorithm of Friedrich et al. [36] reaches the discrepancy of $O \left (\sqrt { \log ^{3} n / (1- \lambda )} \right )$ in $O(\log (Kn)/ (1-\lambda ))$ steps w.h.p. for general graphs. This result is improved by Sauerwald et al. [15], where they achieve a constant discrepancy in $O(\log (Kn)/(1-\lambda ))$ steps w.h.p. for regular graphs. The above constant is independent of the graph and of the discrepancy K. The deterministic matching algorithms of Feuilloley et al. [8] extensively use communication between nodes; they also use graph preprocessing. They achieve a 1-balanced final state for general graphs, in time not depending on the graph size n, but depending cubically, and also exponentially for the discrete setting, on the initial discrepancy K.

Yet another balancing circuits [13, 37] approach is based on sorting circuits [13], where each 2-input comparator balances the loads of its input nodes (instead of the comparison), see, e.g., [38]. The randomized balancing circuits algorithm of [15] achieves a constant final discrepancy w.h.p.

In the asynchronous load balancing model, both local computations and messages may be delayed, but each message is eventually delivered and each computation is eventually performed. Aiello et al. [16] and Ghosh et al. [33] introduced matching-based asynchronous load balancing algorithms with the restriction that in each round, only one unit load transfers between two nodes. By this restriction, these asynchronous load balancing algorithms require more time to converge. The algorithms [16, 33] suggest turning the asynchronous setting into synchronous by appropriately enlarging the time unit.

There is a literature on self-stabilizing token distribution problem [39], where any number of tokens are arbitrarily distributed and each node has an arbitrary state. The goal is that each node will have exactly k tokens after the execution of the algorithm. Sudo et al. [39] introduced the algorithm for asynchronous model and rooted tree networks, where the root can push/pull tokens to/from the external store, and each node knows the value of k. Two self-stabilizing algorithms for transferring the load (tasks) around the network are presented by Flatebo et al. [40]. These algorithms are in terms of a new task received from the environment that triggers send task or start task, rather than being activated when no task is received, which is our scope here.