Distributed Selfish Load Balancing with Weights and Speeds

Queueing Systems, 2012

In this paper, we analyze the performance of random load resampling and migration strategies in parallel server systems. Clients initially attach to an arbitrary server, but may switch servers independently at random instants of time in an attempt to improve their service rate. This approach to load balancing contrasts with traditional approaches where clients make smart server selections upon arrival (e.g., Join-the-Shortest-Queue policy and variants thereof). Load resampling is particularly relevant in scenarios where clients cannot predict the load of a server before being actually attached to it. An important example is in wireless spectrum sharing where clients try to share a set of frequency bands in a distributed manner.

2007

We introduce several congestion games and study the speed of convergence to Nash Equilibria under reasonable reallocation protocols. We focus on a particular atomic congestion game, distributed selfish load balancing, in which a set of resources are to be allocated to tasks with selfish agents willing to minimize their own latency. We revisit and improve the previous results for the uniform case where tasks share identical resources, and the latency function of a resource is the number of tasks utilizing it. Moreover we introduce two variations of this setting. In the first variation we consider the case where tasks have different weights and the latency of each resource is the total weights of the tasks utilizing it. Another variation is the case where tasks are identical, but resources have arbitrary latency functions. We give upper bounds for the convergence time of these models,

2021

Inspired by applications on search engines and web servers, we consider a load balancing problem with a general convex objective function. In this problem, we are given a bipartite graph on a set of sources S and a set of workers W and the goal is to distribute the load from each source among its neighboring workers such that the total load of workers are as balanced as possible. We present a new distributed algorithm that works with any symmetric non-decreasing convex function for evaluating the balancedness of the workers’ load. Our algorithm computes a nearly optimal allocation of loads in O(logn log2 d/ 3) rounds where n is the number of nodes, d is the maximum degree, and is the desired precision. If the objective is to minimize the maximum load, we modify the algorithm to obtain a nearly optimal solution in O(logn log d/ 2) rounds. This improves a line of algorithms that require a polynomial number of rounds in n and d and appear to encounter a fundamental barrier that prevent...

2009 American Control Conference, 2009

In this paper we consider the problem of load balancing over heterogeneous networks, i.e. networks whose nodes have different speeds. We assume that tasks are indivisible and with different weights. Our goal is that of minimizing the maximum execution time over nodes.

International Journal of Electrical and Computer Engineering (IJECE), 2018

In networks with lot of computation, load balancing gains increasing significance. To offer various resources, services and applications, the ultimate aim is to facilitate the sharing of services and resources on the network over the Internet. A key issue to be focused and addressed in networks with large amount of computation is load balancing. Load is the number of tasks"t" performed by a computation system. The load can be categorized as network load and CPU load. For an efficient load balancing strategy, the process of assigning the load between the nodes should enhance the resource utilization and minimize the computation time. This can be accomplished by a uniform distribution of load of to all the nodes. A Load balancing method should guarantee that, each node in a network performs almost equal amount of work pertinent to their capacity and availability of resources. Relying on task subtraction, this work has presented a pioneering algorithm termed as E-TS (Efficient-Task Subtraction). This algorithm has selected appropriate nodes for each task. The proposed algorithm has improved the utilization of computing resources and has preserved the neutrality in assigning the load to the nodes in the network.

Concurrency and Computation-Practice and Experience, 2008

A serious difficulty in concurrent programming of a distributed system is how to deal with scheduling and load balancing of such a system which may consist of heterogeneous computers. In this paper, we formulate the static load‐balancing problem in single class job distributed systems as a cooperative game among computers. The computers comprising the distributed system are modeled as M/M/1 queueing systems. It is shown that the Nash bargaining solution (NBS) provides an optimal solution (operation point) for the distributed system and it is also a fair solution. We propose a cooperative load‐balancing game and present the structure of NBS. For this game an algorithm for computing NBS is derived. We show that the fairness index is always equal to 1 using NBS, which means that the solution is fair to all jobs. Finally, the performance of our cooperative load‐balancing scheme is compared with that of other existing schemes.

Journal of the ACM, 2002

In completely symmetric systems that have homogeneous nodes (hosts, computers, or processors) with identical arrival processes, an optimal static load balancing scheme does not involve the forwarding of jobs among nodes. Using an appropriate analytic model of a distributed computer system, we examine the following three decision schemes for load balancing: completely distributed, intermediately distributed, and completely centralized. We show that there is no forwarding of jobs in the completely centralized and completely distributed schemes, but that in an intermediately distributed decision scheme, mutual forwarding of jobs among nodes is possible, leading to degradation in system performance for every decision maker. This result appears paradoxical, because by adding communication capacity to the system for the sharing of jobs between nodes, the overall system performance is degraded. We characterize conditions under which such paradoxical behavior occurs, and we give examples in which the degradation of performance may increase without bound. We show that the degradation reduces and finally disappears in the limit as the intermediately distributed decision scheme tends to a completely distributed one.

The 16th International Parallel and Distributed Processing Symposium, 4th Workshop on Advances in Parallel and Distributed Computational Models (APDCM'02), Fort Lauderdale, Florida, pp. 146-153, 15-19 April 2002, 2002

Most of the previous studies on static load balancing considered as their main objective the minimization of overall expected response time. This is difficult to achieve in distributed systems where there is no central authority controlling the allocation and users are free to act in a selfish man-ner. Our goal is to find a formal framework for characterizing user-optimal allocation schemes in distributed systems. The framework was provided by noncooperative game theory which has been applied to routing and flow control problems in networks but not to load balancing in distributed systems. Using this framework we formulate the load balancing problem in distributed systems as a noncooperative game among users. The Nash equilibrium provides a user-optimal operation point for the distributed system. We give a characterization of the Nash equilibrium and a distributed algorithm for computing it. We compare the performance of our noncooperative load balancing scheme with that of other existing schemes. Our scheme guarantees the optimality of allocation for each user in the distributed system.

7th International Symposium on Parallel Architectures, Algorithms and Networks, 2004. Proceedings., 2004

Efficient load balancing algorithms are the key to many efficient parallel applications. Until now, research in this area mainly focused on static networks. However, observations show that diffusive algorithms, originally designed for these networks, can also be applied in non static scenarios. In this paper we prove that the general diffusion scheme can be deployed on dynamic networks and show that its convergence rate depends on the average value of the quotient of the second smallest eigenvalue and the maximum vertex degree of the networks occurring during the iterations. In the presented experiments we illustrate that even if communication links of static networks fail with high probability, load can still be balanced quite efficiently. Simulating diffusion on ad-hoc networks we demonstrate that diffusive schemes provide a reliable and efficient load balancing strategy also in mobile environments.

Lecture Notes in Computer Science, 2009

In this paper we consider altruism, a phenomenon widely observed in nature and practical applications, in the prominent model of selfish load balancing with coordination mechanisms. Our model of altruistic behavior follows recent work by assuming that agent incentives are a trade-off between selfish and social objectives. In particular, we assume agents optimize a linear combination of personal delay of a strategy and the resulting social cost. Our results show that even in very simple cases a variety of standard coordination mechanisms are not robust against altruistic behavior, as pure Nash equilibria are absent or better response dynamics cycle. In contrast, we show that a recently introduced Time-Sharing policy yields a potential game even for partially altruistic agents. In addition, for this policy a Nash equilibrium can be computed in polynomial time. In this way our work provides new insights on the robustness of coordination mechanisms. On a more fundamental level, our results highlight the limitations of stability and convergence when altruistic agents are introduced into games with weighted and lexicographical potential functions.

Lecture Notes in Computer Science, 2004

We consider the on-line load balancing problem where there are m identical machines (servers). Jobs arrive at arbitrary times, where each job has a weight and a duration. A job has to be assigned upon its arrival to exactly one of the machines. The duration of each job becomes known only upon its termination (this is called temporary tasks of unknown durations). Once a job has been assigned to a machine it cannot be reassigned to another machine. The goal is to minimize the maximum over time of the sum (over all machines) of the squares of the loads, instead of the traditional maximum load.

SIAM Journal on Computing, 2005

We study the long-term (steady state) performance of a simple, randomized, local load balancing technique under a broad range of input conditions. We assume a system of n processors connected by an arbitrary network topology. Jobs are placed in the processors by a deterministic or randomized adversary. The adversary knows the current and past load distribution in the network and can use this information to place the new tasks in the processors. A node can execute one job per step, and can also participate in one load balancing operation in which it can move tasks to a direct neighbor in the network. In the protocol we analyze here, a node equalizes its load with a random neighbor in the graph.

International Conference on Collaborative Computing: Networking, Applications and Worksharing, 2006

Load balancing has been an increasingly important issue for handling computational intensive tasks in a distributed system such as in grid and cluster computing. In such systems, multiple server instances are installed for handling requests from client applications, and each request (or task) typically needs to stay in a queue before an available server is assigned to process it. In

SIAM Journal on Computing, 1999

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 di erence in tokens between any two nodes to at most O((d 2 log n)= ), where is the maximum di erence between the number 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 di erence in tokens between any two neighbors is at most 2d), while the global imbalance remains ((d 2 log n)= ). Furthermore, we show that upon reaching a state with a global imbalance of O((d 2 log n)= ), 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.

Lecture Notes in Computer Science, 2007

We introduce the problem of load-distance balancing in assigning users of a delay-sensitive networked application to servers. We model the service delay experienced by a user as a sum of a network-incurred delay, which depends on its network distance from the server, and a server-incurred delay, stemming from the load on the server. The problem is to minimize the maximum service delay among all users. We address the challenge of finding a near-optimal assignment in a scalable distributed manner. The key to achieving scalability is using local solutions, whereby each server only communicates with a few close servers. Note, however, that the attainable locality of a solution depends on the workload -when some area in the network is congested, obtaining a near-optimal cost may require offloading users to remote servers, whereas when the network load is uniform, a purely local assignment may suffice. We present algorithms that exploit the opportunity to provide a local solution when possible, and thus have communication costs and stabilization times that vary according to the network congestion. We evaluate our algorithms with a detailed simulation case study of their application in assigning hosts to Internet gateways in an urban wireless mesh network (WMN).