697 research outputs found
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.Comment: 74 pages, 4 figure
Parallel Load Balancing on Constrained Client-Server Topologies
We study parallel \emph{Load Balancing} protocols for a client-server
distributed model defined as follows.
There is a set \sC of clients and a set \sS of servers where each
client has
(at most) a constant number of requests that must be assigned to
some server. The client set and the server one are connected to each other via
a fixed bipartite graph: the requests of client can only be sent to the
servers in its neighborhood . The goal is to assign every client request
so as to minimize the maximum load of the servers.
In this setting, efficient parallel protocols are available only for dense
topolgies. In particular, a simple symmetric, non-adaptive protocol achieving
constant maximum load has been recently introduced by Becchetti et al
\cite{BCNPT18} for regular dense bipartite graphs. The parallel completion time
is \bigO(\log n) and the overall work is \bigO(n), w.h.p.
Motivated by proximity constraints arising in some client-server systems, we
devise a simple variant of Becchetti et al's protocol \cite{BCNPT18} and we
analyse it over almost-regular bipartite graphs where nodes may have
neighborhoods of small size. In detail, we prove that, w.h.p., this new version
has a cost equivalent to that of Becchetti et al's protocol (in terms of
maximum load, completion time, and work complexity, respectively) on every
almost-regular bipartite graph with degree .
Our analysis significantly departs from that in \cite{BCNPT18} for the
original protocol and requires to cope with non-trivial stochastic-dependence
issues on the random choices of the algorithmic process which are due to the
worst-case, sparse topology of the underlying graph
Self-Stabilizing Repeated Balls-into-Bins
We study the following synchronous process that we call "repeated
balls-into-bins". The process is started by assigning balls to bins in
an arbitrary way. In every subsequent round, from each non-empty bin one ball
is chosen according to some fixed strategy (random, FIFO, etc), and re-assigned
to one of the bins uniformly at random.
We define a configuration "legitimate" if its maximum load is
. We prove that, starting from any configuration, the
process will converge to a legitimate configuration in linear time and then it
will only take on legitimate configurations over a period of length bounded by
any polynomial in , with high probability (w.h.p.). This implies that the
process is self-stabilizing and that every ball traverses all bins in
rounds, w.h.p
Asymptotically Optimal Load Balancing Topologies
We consider a system of servers inter-connected by some underlying graph
topology . Tasks arrive at the various servers as independent Poisson
processes of rate . Each incoming task is irrevocably assigned to
whichever server has the smallest number of tasks among the one where it
appears and its neighbors in . Tasks have unit-mean exponential service
times and leave the system upon service completion.
The above model has been extensively investigated in the case is a
clique. Since the servers are exchangeable in that case, the queue length
process is quite tractable, and it has been proved that for any ,
the fraction of servers with two or more tasks vanishes in the limit as . For an arbitrary graph , the lack of exchangeability severely
complicates the analysis, and the queue length process tends to be worse than
for a clique. Accordingly, a graph is said to be -optimal or
-optimal when the occupancy process on is equivalent to that on
a clique on an -scale or -scale, respectively.
We prove that if is an Erd\H{o}s-R\'enyi random graph with average
degree , then it is with high probability -optimal and
-optimal if and as , respectively. This demonstrates that optimality can
be maintained at -scale and -scale while reducing the number of
connections by nearly a factor and compared to a
clique, provided the topology is suitably random. It is further shown that if
contains bounded-degree nodes, then it cannot be -optimal.
In addition, we establish that an arbitrary graph is -optimal when its
minimum degree is , and may not be -optimal even when its minimum
degree is for any .Comment: A few relevant results from arXiv:1612.00723 are included for
convenienc
Quasirandom Load Balancing
We propose a simple distributed algorithm for balancing indivisible tokens on
graphs. The algorithm is completely deterministic, though it tries to imitate
(and enhance) a random algorithm by keeping the accumulated rounding errors as
small as possible.
Our new algorithm surprisingly closely approximates the idealized process
(where the tokens are divisible) on important network topologies. On
d-dimensional torus graphs with n nodes it deviates from the idealized process
only by an additive constant. In contrast to that, the randomized rounding
approach of Friedrich and Sauerwald (2009) can deviate up to Omega(polylog(n))
and the deterministic algorithm of Rabani, Sinclair and Wanka (1998) has a
deviation of Omega(n^{1/d}). This makes our quasirandom algorithm the first
known algorithm for this setting which is optimal both in time and achieved
smoothness. We further show that also on the hypercube our algorithm has a
smaller deviation from the idealized process than the previous algorithms.Comment: 25 page
Tight Load Balancing via Randomized Local Search
We consider the following balls-into-bins process with bins and
balls: each ball is equipped with a mutually independent exponential clock of
rate 1. Whenever a ball's clock rings, the ball samples a random bin and moves
there if the number of balls in the sampled bin is smaller than in its current
bin. This simple process models a typical load balancing problem where users
(balls) seek a selfish improvement of their assignment to resources (bins).
From a game theoretic perspective, this is a randomized approach to the
well-known Koutsoupias-Papadimitriou model, while it is known as randomized
local search (RLS) in load balancing literature. Up to now, the best bound on
the expected time to reach perfect balance was due to Ganesh, Lilienthal, Manjunath, Proutiere, and Simatos
(Load balancing via random local search in closed and open systems, Queueing
Systems, 2012). We improve this to an asymptotically tight
. Our analysis is based on the crucial observation
that performing "destructive moves" (reversals of RLS moves) cannot decrease
the balancing time. This allows us to simplify problem instances and to ignore
"inconvenient moves" in the analysis.Comment: 24 pages, 3 figures, preliminary version appeared in proceedings of
2017 IEEE International Parallel and Distributed Processing Symposium
(IPDPS'17
- âŠ