4,202 research outputs found
Balanced Allocations and Double Hashing
Double hashing has recently found more common usage in schemes that use
multiple hash functions. In double hashing, for an item , one generates two
hash values and , and then uses combinations for to generate multiple hash values from the initial two. We
first perform an empirical study showing that, surprisingly, the performance
difference between double hashing and fully random hashing appears negligible
in the standard balanced allocation paradigm, where each item is placed in the
least loaded of choices, as well as several related variants. We then
provide theoretical results that explain the behavior of double hashing in this
context.Comment: Further updated, small improvements/typos fixe
More Analysis of Double Hashing for Balanced Allocations
With double hashing, for a key , one generates two hash values and
, and then uses combinations for
to generate multiple hash values in the range from the initial two.
For balanced allocations, keys are hashed into a hash table where each bucket
can hold multiple keys, and each key is placed in the least loaded of
choices. It has been shown previously that asymptotically the performance of
double hashing and fully random hashing is the same in the balanced allocation
paradigm using fluid limit methods. Here we extend a coupling argument used by
Lueker and Molodowitch to show that double hashing and ideal uniform hashing
are asymptotically equivalent in the setting of open address hash tables to the
balanced allocation setting, providing further insight into this phenomenon. We
also discuss the potential for and bottlenecks limiting the use this approach
for other multiple choice hashing schemes.Comment: 13 pages ; current draft ; will be submitted to conference shortl
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
Balanced Allocation on Graphs: A Random Walk Approach
In this paper we propose algorithms for allocating sequential balls into
bins that are interconnected as a -regular -vertex graph , where
can be any integer.Let be a given positive integer. In each round
, , ball picks a node of uniformly at random and
performs a non-backtracking random walk of length from the chosen node.Then
it allocates itself on one of the visited nodes with minimum load (ties are
broken uniformly at random). Suppose that has a sufficiently large girth
and . Then we establish an upper bound for the maximum number
of balls at any bin after allocating balls by the algorithm, called {\it
maximum load}, in terms of with high probability. We also show that the
upper bound is at most an factor above the lower bound that is
proved for the algorithm. In particular, we show that if we set , for every constant , and
has girth at least , then the maximum load attained by the
algorithm is bounded by with high probability.Finally, we
slightly modify the algorithm to have similar results for balanced allocation
on -regular graph with and sufficiently large girth
Parallel Balanced Allocations: The Heavily Loaded Case
We study parallel algorithms for the classical balls-into-bins problem, in
which balls acting in parallel as separate agents are placed into bins.
Algorithms operate in synchronous rounds, in each of which balls and bins
exchange messages once. The goal is to minimize the maximal load over all bins
using a small number of rounds and few messages.
While the case of balls has been extensively studied, little is known
about the heavily loaded case. In this work, we consider parallel algorithms
for this somewhat neglected regime of . The naive solution of
allocating each ball to a bin chosen uniformly and independently at random
results in maximal load (for ) w.h.p. In contrast, for the sequential setting Berenbrink et al (SIAM J.
Comput 2006) showed that letting each ball join the least loaded bin of two
randomly selected bins reduces the maximal load to w.h.p.
To date, no parallel variant of such a result is known.
We present a simple parallel threshold algorithm that obtains a maximal load
of w.h.p. within rounds. The algorithm
is symmetric (balls and bins all "look the same"), and balls send
messages in expectation per round. The additive term of in the
complexity is known to be tight for such algorithms (Lenzen and Wattenhofer
Distributed Computing 2016). We also prove that our analysis is tight, i.e.,
algorithms of the type we provide must run for rounds w.h.p.
Finally, we give a simple asymmetric algorithm (i.e., balls are aware of a
common labeling of the bins) that achieves a maximal load of in a
constant number of rounds w.h.p. Again, balls send only a single message per
round, and bins receive messages w.h.p
Unbalanced Allocations
We consider the unbalanced allocation of balls into bins by a
randomized algorithm using the "power of two choices". For each ball, we select
a set of bins at random, then place the ball in the fullest bin within the set.
Applications of this generic algorithm range from cost minimization to
condensed matter physics. In this paper, we analyze the distribution of the bin
loads produced by this algorithm, considering, for example, largest and
smallest loads, loads of subsets of the bins, and the likelihood of bins having
equal loads
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
- …