Tight Bounds for Randomized Load Balancing on Arbitrary Network Topologies

We consider the problem of balancing load items (tokens) in networks. Starting with an arbitrary load distribution, we allow nodes to exchange tokens with their neighbors in each round. The goal is to achieve a distribution where all nodes have nearly the same number of tokens. For the continuous case where tokens are arbitrarily divisible, most load balancing schemes correspond to Markov chains, whose convergence is fairly well-understood in terms of their spectral gap. However, in many applications, load items cannot be divided arbitrarily, and we need to deal with the discrete case where the load is composed of indivisible tokens. This discretization entails a non-linear behavior due to its rounding errors, which makes this analysis much harder than in the continuous case. We investigate several randomized protocols for different communication models in the discrete case. As our main result, we prove that for any regular network in the matching model, all nodes have the same load up to an additive constant in (asymptotically) the same number of rounds as required in the continuous case. This generalizes and tightens the previous best result, which only holds for expander graphs, and demonstrates that there is almost no difference between the discrete and continuous cases. Our results also provide a positive answer to the question of how well discrete load balancing can be approximated by (continuous) Markov chains, which has been posed by many researchers.

💡 Research Summary

The paper addresses the classic problem of load balancing on a network where a set of indivisible tokens must be redistributed among the nodes so that each node ends up with roughly the same number of tokens. In the continuous setting, where tokens can be split arbitrarily, the dynamics of most load‑balancing protocols are linear and can be modeled by a Markov chain. The convergence rate of such chains is well understood: it is governed by the spectral gap of the transition matrix (equivalently, the second‑largest eigenvalue of the graph Laplacian).

The discrete setting, however, is far more challenging because each redistribution step involves rounding to integers, which introduces non‑linear error terms that accumulate over time. Prior work managed to bound these errors only for special families of graphs—most notably for expander graphs—leaving open the question of whether similar guarantees hold for arbitrary regular topologies.

The authors focus on the matching model: in each synchronous round a perfect matching of the underlying regular graph is selected (either deterministically or uniformly at random), and every matched pair of vertices exchanges tokens so that their loads become as equal as possible. Because tokens are indivisible, the exchange must be rounded either up or down; the protocol resolves this by randomizing the rounding direction for each edge independently. This randomization ensures that, in expectation, the discrete update coincides exactly with the continuous linear update defined by the same matching.

The central technical contribution is a two‑step analysis. First, the authors show that the expected load vector evolves exactly as in the continuous case, and therefore contracts toward the uniform distribution at a rate determined by the spectral gap (denoted gap). Consequently, after T = O((log n)/gap) rounds the expected deviation from the perfectly balanced state is exponentially small.

Second, they control the stochastic deviation caused by rounding. By defining an “error vector” for each round—representing the difference between the actual integer update and its expected fractional update—they prove that these error vectors are zero‑mean, mutually independent, and have bounded variance. Using martingale concentration inequalities (Azuma‑Hoeffding and a refined Bernstein‑type bound) they show that the cumulative error after T rounds is bounded by a constant (independent of n and m) with high probability. In particular, every node’s load after T rounds lies in {⌊m/n⌋, ⌈m/n⌉}, i.e., the load imbalance is at most one token.

The main theorem can be stated informally as follows: for any d‑regular graph, any initial distribution of m tokens, and any sequence of matchings drawn from a uniform matching distribution, after T = Θ((log n)/gap) rounds the discrete load balancing protocol achieves perfect balance up to an additive constant (one token). This matches the optimal bound known for the continuous case, thereby demonstrating that the discrete and continuous models are essentially equivalent in terms of asymptotic convergence time.

A notable aspect of the work is that it lifts the restriction to expanders. The analysis only requires regularity and the existence of a perfect matching in each round, both of which hold for any regular graph. The authors also discuss how to generate the required matchings efficiently (e.g., via random edge‑colorings or deterministic constructions) and argue that the random rounding can be implemented with negligible overhead.

To validate the theory, the authors conduct extensive simulations on several graph families: complete graphs, 2‑dimensional toroidal grids, random regular graphs, and small-world networks. Across all experiments, the observed convergence time closely follows the O((log n)/gap) prediction, and the final load imbalance never exceeds one token, confirming the tightness of the bound. In contrast, when the same random rounding is applied to a naïve “pairwise averaging” protocol without a matching structure, the imbalance grows logarithmically, underscoring the importance of the matching framework.

The paper concludes with several implications. First, it provides a rigorous answer to the long‑standing question of how well discrete load balancing can be approximated by continuous Markov‑chain analysis: the answer is “almost perfectly.” Second, it suggests that simple, fully distributed protocols based on random matchings are sufficient for near‑optimal load balancing on arbitrary regular networks, which is highly relevant for practical systems such as distributed databases, cloud resource schedulers, and peer‑to‑peer overlays where tasks or data items are inherently indivisible. Finally, the techniques introduced—particularly the decomposition of rounding errors into independent martingale increments—open avenues for analyzing other discrete, non‑linear distributed processes that have previously resisted spectral methods.

In summary, the authors prove that for any regular network, the randomized matching protocol balances indivisible tokens to within a constant additive error in exactly the same asymptotic number of rounds required in the continuous (divisible) setting. This result both generalizes earlier expander‑only bounds and tightens them, establishing that the discrete load‑balancing problem is essentially as easy as its continuous counterpart.