Bhaskar Ghosh

Bio: Bhaskar Ghosh is an academic researcher from Yale University. The author has contributed to research in topics: Load balancing (computing) & Moving load. The author has an hindex of 7, co-authored 7 publications receiving 477 citations.

First- and Second-Order Diffusive Methods for Rapid, Coarse, Distributed Load Balancing

Abstract: We consider the following general problem modeling load balancing in a variety of distributed settings. Given an arbitrary undirected connected graph G=(V,E) and a weight distribution w 0 on the nodes, determine a schedule to move weights across edges in each step so as to (approximately) balance the weights on the nodes. We focus on diffusive schedules for this problem. All previously studied diffusive schedules can be modeled as w t+1 = M w t where w t is the weight distribution after t steps and M is a doubly stochastic matrix. We call these the first-order schedules. First-order schedules, although widely used in practice, are often slow. In this paper we introduce a new direction in diffusive schedules by considering schedules that are modeled as: w 1 =M w 0 ;w t+1 =β M w t + (1-β) w t-1 for some appropriate β; we call these the second-order schedules. In the idealized setting of weights being real numbers, we adopt known results to show that β can be chosen so that the second-order schedule involves significantly fewer steps than the first-order method for approximate load balancing. In the realistic setting when the weights are positive integers, we simulate the idealized schedules by maintaining I Owe You units on the edges. Extensive experiments with simulated data and real-life data from JOSTLE, a mesh-partitioning software, show that the resultant realistic schedule is close to the idealized schedule, and it again involves fewer steps than the first-order schedules for approximate load balancing. Our main result is therefore a fast algorithm for coarse load balancing that can be used in a variety of applications.

Dynamic Load Balancing by Random Matchings

Abstract: The fundamental problems in dynamic load balancing and job scheduling in parallel and distributed networks involve moving load between processors. In this paper we consider a new model for load movement in synchronous machines. In each step of our model, load can be moved across only a matching set of communication links but across each link any amount of load can be moved. We present an efficient local algorithm for the dynamic load balancing problem under our model of load movement. Our algorithm works on networks of arbitrary topology under possible failure of links. The running time of our algorithm is related to the eigenstructure of the underlying graph. We also present experimental results analyzing issues in load balancing related to our algorithms.

Tight analyses of two local load balancing algorithms

Abstract: This paper presents an analysis of the following load balancing algorithm. At each step, each node in a network examines the number of tokens at each of its neighbors and sends a token to each neighbor with at least 2d + 1 fewer tokens, where d is the maximum degree of any node in the network. We show that within O(=) steps, the algorithm reduces the maximum dierence in tokens between any two nodes to at most O((d 2 logn)=), where is the global imbalance in tokens (i.e., the maximum dierence between the number of tokens at any node initially and the average number of tokens), n is the number of nodes in the network, and is the edge expansion of the network. The time bound is tight in the sense that for any graph with edge expansion , and for any value , there exists an initial distribution of tokens with imbalance for which the time to reduce the imbalance to even =2 is at least ›(=). The bound on the nal imbalance is tight in the sense that there exists a class of networks that can be locally balanced everywhere (i.e., the maximum dierence in tokens between any two neighbors is at most 2d), while the global imbalance remains ›((d 2 logn)=). Furthermore, we show that upon reaching a state with a global imbalance of O((d 2 logn)=), the time for this algorithm to locally balance the network can be as large as ›(n 1=2 ). We extend our analysis to a variant of this algorithm for dynamic and asynchronous networks. We also present tight bounds for a randomized algorithm in which each node sends at most one token in each step.

Tight Analyses of Two Local Load Balancing Algorithms

Abstract: This paper presents an analysis of the following load balancing algorithm. At each step, each node in a network examines the number of tokens at each of its neighbors and sends a token to each neighbor with at least 2d+1 fewer tokens, where d is the maximum degree of any node in the network. We show that within $O(\Delta / \alpha)$ steps, the algorithm reduces the maximum difference in tokens between any two nodes to at most $O((d^2 \log n)/\alpha)$, where $\Delta$ is the global imbalance in tokens (i.e., the maximum difference between the number of tokens at any node initially and the average number of tokens), n is the number of nodes in the network, and $\alpha$ is the edge expansion of the network. The time bound is tight in the sense that for any graph with edge expansion $\alpha$, and for any value $\Delta$, there exists an initial distribution of tokens with imbalance $\Delta$ for which the time to reduce the imbalance to even $\Delta/2$ is at least $\Omega(\Delta/\alpha)$. The bound on the final imbalance is tight in the sense that there exists a class of networks that can be locally balanced everywhere (i.e., the maximum difference in tokens between any two neighbors is at most 2d), while the global imbalance remains $\Omega((d^2 \log n) / \alpha)$. Furthermore, we show that upon reaching a state with a global imbalance of $O((d^2 \log n)/\alpha)$, the time for this algorithm to locally balance the network can be as large as $\Omega(n^{1/2})$. We extend our analysis to a variant of this algorithm for dynamic and asynchronous networks. We also present tight bounds for a randomized algorithm in which each node sends at most one token in each step.

First and second order diffusive methods for rapid, coarse, distributed load balancing (extended abstract)

Abstract: We consider the following general problem modeling load balancing in a variety of distributed settings. Given an arbitrary undirected connected graph G = (V. E) and a weight distribution W“ on the nodes, determine a schedule to move weights in each step across edges so as to (approximately) balance the weights on the nodes. We focus on dtflusivr schedules for this problem. All previously studied diffusive schedules can be modeled as wz+~ = .Lfwt where Wt is the weight distribution after the tth step and M is a doubly stochastic matrix. We call these the first order schedules. First order schedules, although widely used in practice, have a serious drawback that they are very slow. In this paper-, we introduce a new direction in diffusive schedules by considering schedules that are modeled as: WI = MwO; w~+~ ~ p~wt+(l —@wt-] for some appropriate ,d: we call these the second order schedules. In the idealized setting of weights being real numbers, we adopt known results to show that ,ti can be chosen so that the second order schedule is significantly (an order of magnitude) faster than the first, order method. *ghosh@informix. corn. Infornux Software, Inc, 4100 Boban~lon Drive, Bldg. 4600 Menlo Park, CA 94025. Major part of this work was done when the author was at the Departlnent of Computer Science. Yale University with support from ONFt under grant number 4-91J-1 576 and a Yale/IBM joint study. tnurthu@dcs Warwick. ac. uk; Supported by ALCOM-IT, Work partly done at DIMACS (Center for Discrete Mathematics and Theoretical Computer Science), a Natioual Science Foundation Science aud Technolog,v C;ent,er under NSF coutract STC-8809648. ~schultz@cs yale. edu: ,Supported by ONR under graut nun:ber 4-91 -J.1s76 and a Yale/If3M joint study. Permission to make digitallhard copies of all or part of this material for personal or classroom use is granted without fee provided that tire copies a$e not wade or ~stributed for pro~t or commercial advantage, the copy~,ght notice, tie .tde of the pub~tlon and Ita date appear, and notice is given that copyright IS by perrmsmon of the ACM, Inc. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires apecitic permission and/or fee. SPAA’96, Padua, Italy @ 1996 ACM o-s9791-809-6t96106 ..$3.50 In the realistic setting when the weights are positive integers, we simulate the idealized schedules by rnairltaining I Owe You units on the edges. Extensive experiments with simulated data and real-life data from JOSTLE, a mesh partitioning software, show that the resultant realistic schedule is close to the idealized schedule, and is again significantly faster than the first order schedules. The outcome is. therefore, an algorithm that, performs coarse load balancing rapidly and can be as such used in a number of applications.

Gossip Algorithms for Distributed Signal Processing

Abstract: Gossip algorithms are attractive for in-network processing in sensor networks because they do not require any specialized routing, there is no bottleneck or single point of failure, and they are robust to unreliable wireless network conditions. Recently, there has been a surge of activity in the computer science, control, signal processing, and information theory communities, developing faster and more robust gossip algorithms and deriving theoretical performance guarantees. This paper presents an overview of recent work in the area. We describe convergence rate results, which are related to the number of transmitted messages and thus the amount of energy consumed in the network for gossiping. We discuss issues related to gossiping over wireless links, including the effects of quantization and noise, and we illustrate the use of gossip algorithms for canonical signal processing tasks including distributed estimation, source localization, and compression.

Gossip-based aggregation in large dynamic networks

Abstract: As computer networks increase in size, become more heterogeneous and span greater geographic distances, applications must be designed to cope with the very large scale, poor reliability, and often, with the extreme dynamism of the underlying network. Aggregation is a key functional building block for such applications: it refers to a set of functions that provide components of a distributed system access to global information including network size, average load, average uptime, location and description of hotspots, and so on. Local access to global information is often very useful, if not indispensable for building applications that are robust and adaptive. For example, in an industrial control application, some aggregate value reaching a threshold may trigger the execution of certain actions; a distributed storage system will want to know the total available free space; load-balancing protocols may benefit from knowing the target average load so as to minimize the load they transfer. We propose a gossip-based protocol for computing aggregate values over network components in a fully decentralized fashion. The class of aggregate functions we can compute is very broad and includes many useful special cases such as counting, averages, sums, products, and extremal values. The protocol is suitable for extremely large and highly dynamic systems due to its proactive structure---all nodes receive the aggregate value continuously, thus being able to track any changes in the system. The protocol is also extremely lightweight, making it suitable for many distributed applications including peer-to-peer and grid computing systems. We demonstrate the efficiency and robustness of our gossip-based protocol both theoretically and experimentally under a variety of scenarios including node and communication failures.

Mercury: supporting scalable multi-attribute range queries

Abstract: This paper presents the design of Mercury, a scalable protocol for supporting multi-attribute range-based searches. Mercury differs from previous range-based query systems in that it supports multiple attributes as well as performs explicit load balancing. To guarantee efficient routing and load balancing, Mercury uses novel light-weight sampling mechanisms for uniformly sampling random nodes in a highly dynamic overlay network. Our evaluation shows that Mercury is able to achieve its goals of logarithmic-hop routing and near-uniform load balancing.We also show that Mercury can be used to solve a key problem for an important class of distributed applications: distributed state maintenance for distributed games. We show that the Mercury-based solution is easy to use, and that it reduces the game's messaging overheard significantly compared to a naive approach.

Distributed Kalman filtering based on consensus strategies

Abstract: In this paper, we consider the problem of estimating the state of a dynamical system from distributed noisy measurements. Each agent constructs a local estimate based on its own measurements and on the estimates from its neighbors. Estimation is performed via a two stage strategy, the first being a Kalman-like measurement update which does not require communication, and the second being an estimate fusion using a consensus matrix. In particular we study the interaction between the consensus matrix, the number of messages exchanged per sampling time, and the Kalman gain for scalar systems. We prove that optimizing the consensus matrix for fastest convergence and using the centralized optimal gain is not necessarily the optimal strategy if the number of exchanged messages per sampling time is small. Moreover, we show that although the joint optimization of the consensus matrix and the Kalman gain is in general a non-convex problem, it is possible to compute them under some relevant scenarios. We also provide some numerical examples to clarify some of the analytical results and compare them with alternative estimation strategies.