Results 1 
5 of
5
The Round Complexity of Distributed Sorting [Extended Abstract]
"... We consider the model of fully connected networks, where in each round each node can send an O(log n)bit message to each other node (this is the congest model with diameter 1). It is known that in this model, minweight spanning trees can be found in O(log log n) rounds. In this paper we show that ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
We consider the model of fully connected networks, where in each round each node can send an O(log n)bit message to each other node (this is the congest model with diameter 1). It is known that in this model, minweight spanning trees can be found in O(log log n) rounds. In this paper we show that distributed sorting, where each node has at most n items, can be done in time O(log log n) as well. It is also shown that selection can be done in O(1) time. (Using a concurrent result by Lenzen and Wattenhofer, the complexity of sorting is further reduced to constant.) Our algorithms are randomized, and the stated complexity bounds hold with high probability.
Multiplechoice Balanced Allocation in (almost) Parallel ⋆
"... Abstract. We consider the problem of resource allocation in a parallel environment where new incoming resources are arriving online in groups or batches. We study this scenario in an abstract framework of allocating balls into bins. We revisit the allocation algorithm GREEDY[2] due to Azar, Broder, ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
Abstract. We consider the problem of resource allocation in a parallel environment where new incoming resources are arriving online in groups or batches. We study this scenario in an abstract framework of allocating balls into bins. We revisit the allocation algorithm GREEDY[2] due to Azar, Broder, Karlin, and Upfal (SIAM J. Comput. 1999), in which, for sequentially arriving balls, each ball chooses two bins at random, and gets placed into one of those two bins with minimum load. The maximum load of any bin after the last ball is allocated by GREEDY[2] is well understood, as is, indeed, the entire load distribution, for a wide range of settings. The main goal of our paper is to study balls and bins allocation processes in a parallel environment with the balls arriving in batches. In our model, m balls arrive in batches of size n each (with n being also equal to the number of bins), and the balls in each batch are to be distributed among the bins simultaneously. In this setting, we consider an algorithm that uses GREEDY[2] for all balls within a given batch, the answers to those balls ’ load queries are with respect to the bin loads at the end of the previous batch, and do not in any way depend on decisions made by other balls from the same batch. Our main contribution is a tight analysis of the new process allocating balls in batches: we show that after the allocation of any number of batches, the gap between maximum and minimum load is O(log n) with high probability, and is therefore independent of the number of batches used. 1
Tight Bounds for Randomized Load Balancing on Arbitrary Network Topologies
, 1201
"... We consider the problem of balancing load items (tokens) on networks. Starting with an arbitrary load distribution, we allow in each round nodes to exchange tokens with their neighbors. Thegoalisto achieveadistribution whereall nodeshavenearlythe samenumber of tokens. For the continuous case where t ..."
Abstract
 Add to MetaCart
We consider the problem of balancing load items (tokens) on networks. Starting with an arbitrary load distribution, we allow in each round nodes to exchange tokens with their neighbors. Thegoalisto achieveadistribution whereall nodeshavenearlythe samenumber of tokens. For the continuous case where tokens are arbitrarily divisible, most load balancing schemes correspond to Markov chains whose convergence is rather wellunderstood in terms of their spectral gap. However, since for many applications load items cannot be divided arbitrarily, we focus on the discrete case where the load is composed of indivisible tokens. Unfortunately, this discretization entails a nonlinear behavior due to its rounding errors, which makes the analysis much harder than in the continuous case. Therefore, it has been a major open problem to understand the limitations of discrete load balancing and its relation to the continuous case. We investigate several randomized protocols for different communication models in the discrete case. Ourresults demonstratethat there is almost no deviationbetween the discrete
2.2 The Continuous Case.................................. 5
, 1201
"... We consider the problem of balancing load items (tokens) on networks. Starting with an arbitrary load distribution, we allow in each round nodes to exchange tokens with their neighbors. Thegoalisto achieveadistribution whereall nodeshavenearlythe samenumber of tokens. For the continuous case where t ..."
Abstract
 Add to MetaCart
We consider the problem of balancing load items (tokens) on networks. Starting with an arbitrary load distribution, we allow in each round nodes to exchange tokens with their neighbors. Thegoalisto achieveadistribution whereall nodeshavenearlythe samenumber of tokens. For the continuous case where tokens are arbitrarily divisible, most load balancing schemes correspond to Markov chains whose convergence is fairly wellunderstood 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 nonlinear behavior due to its rounding errors, which makes the analysis much harder than in the continuous case. Therefore, it has been a major open problem to understand the limitations of discrete load balancing and its relation to the continuous case. We investigate several randomized protocols for different communication models in the discretecase. Ourresultsdemonstratethatthere isalmostnodifferencebetweenthe discrete
Set Reconciliation via Counting Bloom Filters
"... In this paper, we study the set reconciliation problem, in which each member of a node pair has a set of objects and seeks to deliver its unique objects to the other member. How could each node compute the set difference, however, is challenging in the set reconciliation problem. To address such an ..."
Abstract
 Add to MetaCart
In this paper, we study the set reconciliation problem, in which each member of a node pair has a set of objects and seeks to deliver its unique objects to the other member. How could each node compute the set difference, however, is challenging in the set reconciliation problem. To address such an issue, we propose a lightweight but efficient method that only requires the pair of nodes to represent objects using a Counting Bloom filter (CBF) of size O(d) and exchange with each other, where d denotes the total size of the set differences. A receiving node then subtracts the received CBF from its local one via minus operation proposed in this paper. The resultant CBF can approximately represent the union of the set differences and thus the set difference to each node can be identified after querying the resultant CBF. In this paper we propose a novel estimator through which each node can accurately estimate not only the value of d but also the size of the set difference to each node. Such an estimation result can be used to optimize the parameter setting of the CBF in order to achieve less false positives and false negatives. Comprehensive analysis and evaluation demonstrates that our method is more efficient than prior BFbased methods in terms of achieving the same accuracy with much less communication cost. Moreover, our reconciliating method needs no prior context logs and it is very useful in networking and distributed applications.