1 \documentclass[preprint]{elsarticle}
3 \usepackage[utf8]{inputenc}
4 \usepackage[T1]{fontenc}
6 %\usepackage{newtxtext}
7 %\usepackage[cmintegrals]{newtxmath}
8 \usepackage{mathptmx,helvet,courier}
13 \usepackage[ruled,lined]{algorithm2e}
15 %%% Remove this before submission
16 \newcommand{\FIXMEmargin}[1]{%
17 \marginpar{\textbf{[FIXME]} {\footnotesize #1}}}
18 \newcommand{\FIXME}[2][]{%
19 \ifx #2\relax\relax \FIXMEmargin{#1}%
20 \else \textbf{$\triangleright$\FIXMEmargin{#1}~#2}\fi}
22 \newcommand{\abs}[1]{\lvert#1\rvert} % \abs{x} -> |x|
24 \newenvironment{algodata}{%
25 \begin{tabular}[t]{@{}l@{:~}l@{}}}{%
28 \newcommand{\VAR}[1]{\textit{#1}}
30 \newcommand{\besteffort}{\emph{best effort}}
31 \newcommand{\makhoul}{\emph{Bertsekas and Tsitsiklis}}
37 \journal{Parallel Computing}
39 \title{Best effort strategy and virtual load for\\
40 asynchronous iterative load balancing}
42 \author{Raphaël Couturier}
43 \ead{raphael.couturier@univ-fcomte.fr}
45 \author{Arnaud Giersch\corref{cor}}
46 \ead{arnaud.giersch@univ-fcomte.fr}
49 \ead{mourad.hakem@univ-fcomte.fr}
52 FEMTO-ST Institute, Univ Bourgogne Franche-Comté, Belfort, France}
54 \cortext[cor]{Corresponding author.}
57 Most of the time, asynchronous load balancing algorithms are extensively
58 studied from a theoretical point of view. The Bertsekas and Tsitsiklis'
59 algorithm~\cite{bertsekas+tsitsiklis.1997.parallel} is undeniably the best known algorithm for which the asymptotic convergence proof is given.
61 practical point of view, when a node needs to balance a part of its load to
62 some of its neighbors, the algorithm's description is unfortunately too succinct, and no details are given on what is really sent and how the load balancing decisions are taken. In this paper, we
63 propose a new strategy called \besteffort{} which aims to balance the load
64 of a node to all its less loaded neighbors while ensuring that all involved nodes by the load balancing phase have the same amount of load. Moreover, since
65 asynchronous iterative algorithms are less sensitive to communications delays
66 and their variations \cite{bcvc07:bc}, both load transfer and load information messages are dissociated.
67 To speedup the convergence time of the load balancing process, we propose {\it a clairvoyant virtual load} heuristic. This heuristic allows a node receiving a load
68 information message to integrate the future virtual load (if any) in its load's list, even if the load has not been received yet. This leads to have predictive snapshots of nodes' loads at each iteration of the load balancing process. Consequently, the notified node sends a real part of its load to some of
69 its neighbors taking into account the virtual load it will receive in the subsequent time-steps. Based on the SimGrid simulator, some series of test-bed scenarios are considered and several QoS metrics are evaluated to show the usefulness of the proposed algorithm.
73 % %% keywords here, in the form: keyword \sep keyword
78 \section{Introduction}
80 Load balancing algorithms are widely used in parallel and distributed
81 applications to achieve high performances in terms of response time, throughput and resources usage. They play an important role and arise in various fields ranging from parallel and distributed
82 computing systems to wireless sensor networks (WSN).
83 The objective of load balancing is to orchestrate the distribution of the global load so that
84 the load difference between the computational resources of the network is
85 minimized as much as possible. Unfortunately, this problem is known to be {\bf NP-hard} in its
86 general form and heuristics are required to achieve sub-optimal solutions but in
87 polynomial time complexity.
89 In this paper, we focus on asynchronous load balancing of non negative real numbers of {\it divisible loads}
90 in homogeneous distributed systems. Loads can be divided in arbitrary {\it fine-grain} parallel parts size
91 that can be processed independently of each other~\cite{Bharadwaj1996, Drozdowski1998, Casanova2008}. This model of divisible loads arises in
92 a wide range of real-world applications. Common examples, among many, include signal processing,
93 feature extraction and edge detection in image processing, records search in huge databases,
94 average consensus in WSN, pattern search in Big data and so on.
97 In the literature, the problem of load balancing has been formulated and studied in various ways. The first pioneering work is due to Bertsekas and Tsitsiklis~\cite{bertsekas+tsitsiklis.1997.parallel}. Under some specific hypothesis and {\it ping-pong} awareness conditions (see section~\ref{sec.bt-algo} for more details), an asymptotic convergence proof is derived.
100 Although Bertsekas and Tsitsiklis describe the necessary conditions to
101 ensure the algorithm's convergence, there is no indication nor any strategy to really implement
102 the load distribution.
103 Consequently, we propose a new strategy called \besteffort{}
104 that tries to balance the load of a node to all its less loaded neighbors while
105 ensuring that all the nodes involved in the load balancing phase have the same
106 amount of load. Moreover, most of the time, it is simpler to dissociate load information messages
107 from data migration messages. Former ones allow a node to inform its
108 neighbors about its current load. These messages are in fact very small and can often be sent
109 very quickly. For example, if a computing iteration takes a significant time
110 (ranging from seconds to minutes), it is possible to send a new load information
111 message to each involved neighbor at each iteration. Then, the load is sent, but the reception may take time when the amount of load is huge and when communication links are slow. Depending on the application, it may make sense or not for the nodes to try to balance a part of their load at each computing
112 iteration. But the time to transfer a load message from a node to another one is
113 often much longer than the time to transfer a load information message. So,
114 when a node is notified
115 %receives the information
116 that later it will receive a data message,
117 it can take this information into account in its load's queue list for preventive purposes.
118 %and it can consider that its new load is larger.
119 Consequently, it can send a part of its predictive
122 neighbors if required. We call this trick the \emph{clairvoyant virtual load} transfer mechanism.
125 The main contributions and novelties of our work are summarized in the following section.
127 \section{Our contributions}
128 \label{contributions}
130 \item We propose a {\it best effort strategy} which proceeds greedily to achieve efficient local neighborhoods equilibrium. Upon local load imbalance detection, a {\it significant amount} of load is moved from a highly loaded node (initiator) to less loaded neighbors.
132 \item Unlike earlier works, we use a new concept of virtual loads transfer which allows nodes to predict the future loads they will receive in the subsequent iterations.
133 This leads to a noticeable speedup of the global convergence time of the load balancing process.
135 \item We use SimGrid simulator which is known to be able to characterize and model realistic models of computation and communication in different types of platforms. We show that taking into account both loads transfers' costs and network contention is essential and has a real impact on the quality of the load balancing performances.
141 The reminder of the paper is organized as follows. Section~\ref{sec.related.works} offers a review of the relevant approaches in the literature. Section~\ref{sec.bt-algo} describes the
142 Bertsekas and Tsitsiklis' asynchronous load balancing algorithm.
143 Section~\ref{sec.besteffort} presents the best effort strategy which provides
144 efficient local loads equilibrium.
145 In Section~\ref{sec.virtual-load}, the clairvoyant virtual load scheme is proposed to speedup the convergence time of the load balancing process.
146 In Section~\ref{sec.simulations}, a comprehensive set of numerical results that exhibit the usefulness of our proposal when dealing with realistic models of computation and communication is provided. Finally, some concluding remarks are made in Section~\ref{conclusions-remarks}.
149 \section{Related works}
150 \label{sec.related.works}
151 In this section, the relevant techniques proposed in the literature to tackle the problem of load balancing in a general context of distributed systems are reviewed.
153 As pointed above, the most interesting approach to this issue has been proposed by Bertsekas and Tsitsiklis~\cite{bertsekas+tsitsiklis.1997.parallel}. This algorithm which is outlined in Section~\ref{sec.bt-algo} for the sake of comparison, has been borrowed and adapted in many works. For instance, in~\cite{CortesRCSL02} a static load balancing (called DASUD) for non negative integer number of divisible loads in arbitrary networks topologies is investigated. The term {\it "static"} stems from the fact that no loads are added or consumed during the load balancing process. The theoretical correctness proofs of the convergence property are given. Some generalizations of the same authors' own work for partially asynchronous discrete load balancing model are presented in~\cite{cedo+cortes+ripoll+al.2007.convergence}. The authors prove that the algorithm's convergence is finite and bounded by the straightforward network's diameter of the global equilibrium threshold in the network. In~\cite{bahi+giersch+makhoul.2008.scalable}, a fault tolerant communication version is addressed to deal with average consensus in wireless sensor networks. The objective is to have all nodes converging to the average of their initial measurements based only on nodes' local information. A slight adaptation is also considered in~\cite{BahiCG10} for dynamic networks with bounded delays asynchronous diffusion. The dynamical aspect stands at the communication level as links between the network's resources may be intermittent.
155 Cybenko~\cite{Cybenko89} proposes a {\it diffusion} approach for hypercube multiprocessor networks.
156 The author targets both static and dynamic random models of work distribution.
157 The convergence proof is derived based on the {\it eigenstructure} of the
158 iteration matrices that arise in load balancing of equal amount of
159 computational works. A static load balancing for both synchronous and asynchronous ring networks is addressed in~\cite{GehrkePR99}. The authors assume that at any time step, one token at the most (units of load) can be transmitted along any edge of the ring and no tokens are created during the balancing phase. They show that for every initial token distribution, the proposed algorithm converges to the stable equilibrium with tighter linear bounds of time step-complexity.
161 In order to achieve the load balancing of cloud data centers, a LB technique based on Bayes theorem and Clustering is proposed in~\cite{zhao2016heuristic}. The main idea of this approach is that, the Bayes theorem is combined with the clustering process to obtain the optimal clustering set of physical target hosts leading to the overall load balancing equilibrium. Bidding is a market-technique for task scheduling and load balancing in distributed systems
162 that characterize a set of negotiation rules for users' jobs. For instance, Izakian et al~\cite{IzakianAL10} formulate a double auction mechanism for tasks-resources matching in grid computing environments where resources are considered as provider agents and users as consumer ones. Each entity participates in the network independently and makes autonomous decisions. A provider agent determines its bid price based on its current workload and each consumer agent defines its bid value based on two main parameters: average remaining time and remaining resources for bidding. Based on JADE simulator, the proposed algorithm exhibits better performances in terms of successful execution rates, resource utilization rates and fair profit allocation.
165 Choi et al.~\cite{ChoiBH09} address the problem of robust task allocation in arbitrary networks. The proposed
166 approaches combine a bidding approach for task selection and a consensus procedure scheme for
167 decentralized conflict resolution. The developed algorithms are proven to converge to a conflict-free assignment in both single and multiple task assignment problem. An online stochastic dual gradient LB algorithm, which is called DGLB, is proposed in~\cite{chen2017dglb}. The authors deal with both workload and energy management for cloud networks consisting of multiple geo-distributed mapping nodes and data Centers. To enable online distributed implementation, tasks are decomposed both across time and space by leveraging a dual decomposition approach. Experimental results corroborate the merits of the proposed algorithm.
170 In~\cite{tripathi2017non} a LB algorithm based on game theory is proposed for distributed data centers. The authors formulate the LB problem as a non-cooperative game among front-end proxy servers and characterize the structure of Nash equilibrium. Based on the obtained Nash equilibrium structure, they derive a LB algorithm to compute the Nash equilibrium. They show through simulations that the proposed algorithm ensures fairness among the users and a good average latency across all client regions. A hybrid task scheduling and load balancing dependent and independent tasks for master-slaves platforms are addressed in~In~\cite{liu2017dems}. To minimize the response time of the submitted jobs, the proposed algorithm which is called DeMS is split into three stages: i) communication overhead reduction between masters and slaves, ii) task migration to keep the workload balanced iii) and precedence task graphs partitioning.
172 Several LB techniques, based on artificial intelligence, have also been proposed in the literature: genetic algorithm (GA) \cite{subrata2007artificial}, honey bee behavior \cite{krishna2013honey, kwok2004new}, tabu search \cite{subrata2007artificial} and fuzzy logic \cite{salimi2014task}. The main strength of these techniques comes from their ability to seek in large search spaces, which arises in many combinatorial optimization problems. For instance, the works in~\cite{cao2005grid, shen2014achieving} have been proposed to tackle the load balancing problem using the multi-agent approach where each agent is responsible for load balancing for a subset of nodes in the network. The agent objective is to minimize jobs' response time and host idle time dynamically. In~\cite{GrosuC05}, the authors formulate the load balancing problem as a non-cooperative game among users. They use the Nash equilibrium as the solution of this game to optimize the response time of all jobs in the entire system. The proposed scheme guarantees the optimal task allocation for each user with low time complexity. A game theoretic approach to tackle the static load balancing problem is also investigated in~\cite{PenmatsaC11}. To provide fairness to all users in the system, the load balancing problem is formulated as a non-cooperative game among the users to minimize the response time of the submitted users' jobs. As in~\cite{GrosuC05}, the authors use the concept of Nash equilibrium as the solution of a non-cooperative game. Simulation results show that the proposed scheme offers near optimal solutions compared to other existing techniques in terms of fairness.
177 \section{Bertsekas and Tsitsiklis' asynchronous load balancing algorithm}
180 In this section, we present a brief description of Bertsekas and Tsitsiklis' algorithm~\cite{bertsekas+tsitsiklis.1997.parallel} using its original notations.
181 A network is modeled as a connected undirected graph $G=(N,A)$, where $N$ is a set
182 of processors and $A$ is a set of communication links. The processors are
183 labeled $i = 1,...,n$, and a link between processors $i$ and
184 $j$ is denoted by $(i, j)\in A$. The set of processor $i$'s neighbors is denoted by $V(i)$.
186 Load of processor $i$
187 at time $t$ is represented by $x_i(t)\geq 0$.
188 Each processor $i$ has an estimate of the load of
189 each of its neighbors $j \in V(i)$ denoted by $x_j^i(t)$ and this estimate
190 may be outdated due to %. According to
191 asynchronism and communication delays.
194 When a processor sends a part of its load to one or to some of its neighbors, the
195 transfer takes time to be completed. Let $s_{ij}(t)$ be the amount of load that
196 processor $i$ has transferred to processor $j$ at time $t$ and let $r_{ij}(t)$ be the
197 amount of loads received by $j$ from $i$ at time $t$. Then
198 the amount of load of processor $i$ at time $t+1$ is given by:
201 x_i(t+1)=x_i(t)-\sum_{j\in V(i)} s_{ij}(t) + \sum_{j\in V(i)} r_{ji}(t)
206 %Some conditions are required to ensure the convergence. One of them can be
207 %called the \emph{ping-pong} condition which specifies that:
209 The asymptotic convergence is derived based on the {\it ping-pong} awareness condition which specifies that:
212 x_i(t)-\sum _{k\in V(i)} s_{ik}(t) \geq x_j^i(t)+s_{ij}(t)
215 for any processor $i$ and any $j \in V(i)$ such that $x_i(t)>x_j^i(t)$.
216 %This condition aims at avoiding a processor to send a part of its load and being
217 %less loaded after that.
220 This condition prohibits the possibility that two nodes keep sending loads to each
221 other back and forth, without reaching equilibrium.
224 Nevertheless, we think that this condition may lead to deadlocks in some
225 cases. For example, consider a linear chain graph network of only three processors in which processor $1$
226 is linked to processor $2$ which is also linked to processor $3$, but in which processors $1$ and $3$ are not neighbors.
227 %(i.e. a simple chain which 3 processors).
229 \noindent Now consider that we have the following load values at time~$t$:
236 %{\bf RAPH, pourquoi il y a $x_3^2$?. Sinon il faudra reformuler la suite, c'est mal dit}
238 Owing to the algorithm's specifications, processor $2$ can either send a part of its load to processor $1$ or processor
239 $3$. If it sends to processor $1$, it will not satisfy condition
240 \eqref{eq.ping-pong} because after that sending it will be less loaded than
241 $x_3^2(t)$. So we consider that the \emph{ping-pong} condition is probably too
242 strong. %Currently, we did not try to make another convergence proof without this condition or with a weaker condition.
245 Despite this, we conjecture that a weaker condition may exist since we
246 have never seen any scenario that is not leading to convergence, even with
247 load-balancing strategies that are not exactly fulfilling the authors' own conditions. %se two conditions.
249 %It may be the subject of future work to express weaker conditions, and to prove
250 %that they are sufficient to ensure the convergence of the load-balancing
255 Even though this approach is interesting, several practical
256 questions arise when dealing with realistic models of
257 computation and communication. As reported above, the
258 algorithm's description is too succinct and no details are
259 given on what is really sent and how the load balancing decisions
260 are taken. To our knowledge, the only first attempt for a possible
261 implementation of this algorithm is investigated in~\cite{bahi+giersch+makhoul.2008.scalable} under the same conditions. Thus, in order to assess the performances
262 of the new \besteffort{}, we naturally chose to compare it to this previous
263 work. More precisely, we will use the algorithm~2 from
264 \cite{bahi+giersch+makhoul.2008.scalable} and, throughout the paper, we will
265 reference it under the original name {\it Bertsekas and Tsitsiklis} for the sake of convenience and readability.
268 Here is an outline of the main principle of the borrowed algorithm. When a given node $i$ has to take
269 a load balancing decision, it starts by sorting its neighbors by non-increasing
270 order of their loads. Then, it computes the difference between its own load, and
271 the load of each of its neighbors. Finally, taking the neighbors following the
272 order defined before, the amount of load to send $s_{ij}$ is computed as
273 $1/(|V(i)|+1)$ of the load difference%, with $n$ being the number of neighbors
274 . This process is iterated as long as the node is more loaded than the considered
278 \section{Best effort strategy}
279 \label{sec.besteffort}
281 In this section, we describe a new load-balancing strategy that we call
282 \besteffort{}. First, we explain the general idea behind this strategy,
283 and then we present some variants of this basic strategy.
285 \subsection{Basic strategy}
286 The description of our algorithm will be given from the point of view a processor~$i$.
287 The principle of the \besteffort{} strategy is that each processor
288 detecting itself to be more loaded than some of its neighbors, sends some load to its less loaded neighbors, doing its best to reach the equilibrium
289 between the involved neighbors and itself.
291 More precisely, %when a processor $i$ is in its load-balancing phase,
292 at each iteration of the load balancing process, processor~$i$
295 \item First, the neighbors are sorted in non-decreasing order of their
296 known loads $x^i_j(t)$.
298 \item Then, this sorted list is used to find its largest
299 prefix such as the load of each selected neighbor is smaller than:
301 \item the load of processor $i$, and
302 \item the mean of the loads of the selected neighbors and processor i.
304 Let $S_i(t)$ be the set of the selected neighbors, and
305 $\bar{x}(t)$ be the mean of the loads between the selected neighbors and processor $i$ which is given as follows:
307 \bar{x}(t) = \frac{1}{\abs{S_i(t)} + 1}
308 \left( x_i(t) + \sum_{j\in S_i(t)} x^i_j(t) \right)
310 so that the following properties hold: %{\bf RAPH : la suite tombe du ciel :-)}
313 S_i(t) \subset V(i) \\
314 x^i_j(t) < x_i(t) & \forall j \in S_i(t) \\
315 x^i_j(t) < \bar{x} & \forall j \in S_i(t) \\
316 x^i_j(t) \leq x^i_k(t) & \forall j \in S_i(t), \forall k \in V(i) \setminus S_i(t) \\
321 \item Once this selection is done, processor $i$ sends to each selected neighbor $j\in S_i(t)$ an amount of load $s_{ij}(t) =
324 %From the above equations, and notably from the definition of $\bar{x}$, it can easily be verified that:
327 In this way we obtain:
331 x_i(t) - \sum_{j\in S_i(t)} s_{ij}(t) = \bar{x} \\
332 x^i_j(t) + s_{ij}(t) = \bar{x} & \forall j \in S_i(t)
339 \subsection{Leveling the amount of load to move}
341 With the aforementioned basic strategy, each node does its best to reach the
342 equilibrium with its neighbors. However, one question should be outlined here:
343 how can we handle the case where two (or more) node initiators might concurrently send
344 some loads to the same least loaded neighbor? Indeed,
345 %since each node may take the same kind of decision at the same time,
346 there is a risk that a node will receive loads from
347 several of its neighbors, and then might temporary go off the equilibrium state.
348 This is particularly true with strongly connected applications.
351 In order to reduce this effect, we add the ability to level the amount of loads to send.
352 The idea, here, is to make as few steps as possible toward the equilibrium, such that a
353 potentially unsuitable decision pointed above has a lower impact on the local equilibrium.
354 A weighting system parameter $k$ is introduced to orchestrate the right balance between the topology structure and the computation to communication ratios (CCR) values of the deployed application. Indeed, to speedup the convergence time of the load balancing process, one is faced with a difficult trade-off to choose an appropriate amount of load to send between node neighbors upon load imbalance detection. On the one hand, if $k$ is small, we expect faster convergence time for sparsely connected application and large CCR values. On the other hand, for strongly connected applications and small CCR values, a large value of $k$ will enable us to better balance the load locally and therefore minimize the number of iterations toward the global equilibrium. In the experiments section (Section~\ref{sec.results}), we observe that choosing $k$ in 1,2 or 4, leads to good results for the considered CCR values and the targeted topology structures.
355 So the amount of data to send is then $s_{ij}(t) = (\bar{x} - x^i_j(t))/k$.
362 \section{Virtual load}
363 \label{sec.virtual-load}
365 In this section, we present the new concept of \emph{virtual load} which aims to improve the global convergence time. For this end, both load transfer messages and load information messages are dissociated.
366 More precisely, a node wanting to send some amount of its load to one (or more) of its neighbors
367 can first send a load information message about the load it will send, and
368 later it can send the load message containing data to be transferred.
369 Load information messages are in fact short
371 and will be received soon.
373 In contrast, load transfer messages are often larger ones and thus
374 require more time to be transferred.
376 The concept of \emph{virtual load} allows a node receiving a load
377 information message to integrate (virtually) the future load it will receive later in its load's list
378 even if the load has not been received yet. Consequently, the notified node can send a (real) part of its load to some of its
379 neighbors when needed. By and large, this allows a node on the one hand, to predict the load it will receive in the subsequent time steps, and on the other hand, to take suitable decisions when detecting load imbalance in its closed neighborhoods. Doing so, we expect faster convergence time since nodes can take
380 into account the information about the predictive loads not
385 \section{Implementation with SimGrid and simulations}
386 \label{sec.simulations}
388 In order to test and validate our approach, we wrote a simulator
390 framework~\cite{simgrid.web,casanova+giersch+legrand+al.2014.simgrid}. This
391 simulator, which consists of about 2,700 lines of C++, allows to run
392 the different load-balancing strategies under various parameters, such
393 as the initial distribution of load, the interconnection topology, the
394 characteristics of the running platform, etc. Then several metrics
395 were considered to assess and compare the behavior of the different
396 %are issued that permit to compare the
399 The simulation model is detailed in the next section (\ref{sec.model}), and the
400 experimental contexts are described in section~\ref{sec.exp-context}. Then the
401 results of the simulations are presented in section~\ref{sec.results}.
403 \subsection{Simulation model}
406 In the simulation model the processors exchange messages which are of
407 two types. First, there are \emph{control messages} which carry only the information exchanged between processors, such as the
408 current load, or the virtual load transfers if this option is
409 considered. These messages are rather small, and their size is
410 constant. Then, there are \emph{data messages} that carry the real
411 load transferred between processors. The size of a data message
412 is a function of the amount of load that it carries, and it can be
413 pretty large. In order to receive the messages, each processor has
414 two receiving channels, one for each type of messages. Finally, when
415 a message is sent or received, this is done by using non-blocking
416 primitives of SimGrid\footnote{That are \texttt{MSG\_task\_isend()},
417 and \texttt{MSG\_task\_irecv()}.}.
419 During the simulation, each processor concurrently runs three threads:
420 a \emph{receiving thread}, a \emph{computing thread}, and a
421 \emph{load-balancing thread}, which we will briefly describe hereafter.
423 For the sake of simplicity, a few details were voluntary omitted from
424 these descriptions. For an exhaustive presentation, we refer to the
425 actual source code that was used for the experiments%
426 \footnote{As mentioned before, our simulator relies on the SimGrid
427 framework~\cite{casanova+giersch+legrand+al.2014.simgrid}. For the
428 experiments, we used a pre-release of SimGrid 3.7 (Git commit
429 67d62fca5bdee96f590c942b50021cdde5ce0c07, available from
430 \url{https://github.com/simgrid/simgrid})}, and which is
432 \url{http://info.iut-bm.univ-fcomte.fr/staff/giersch/software/loba.tar.gz}.
434 \subsubsection{Receiving thread}
436 The receiving thread is in charge of waiting for incoming messages, either on the
437 control channel, or on the data channel. Its behavior is sketched by
438 Algorithm~\ref{algo.recv}. When a message is received, it is pushed in a buffer
439 of received messages, to be later consumed by one of the other threads. There
440 are two such buffers, one for the control messages, and one for the data
442 The buffers are implemented with first-in, first-out queues (FIFO).
445 \caption{Receiving thread}
449 \VAR{ctrl\_chan}, \VAR{data\_chan}
450 & communication channels (control and data) \\
451 \VAR{ctrl\_fifo}, \VAR{data\_fifo}
452 & buffers of received messages (control and data) \\
455 wait for a message to be available on either \VAR{ctrl\_chan},
456 or \VAR{data\_chan}\;
457 \If{a message is available on \VAR{ctrl\_chan}}{%
458 get the message from \VAR{ctrl\_chan}, and push it into \VAR{ctrl\_fifo}\;
460 \If{a message is available on \VAR{data\_chan}}{%
461 get the message from \VAR{data\_chan}, and push it into \VAR{data\_fifo}\;
466 \subsubsection{Computing thread}
468 The computing thread is in charge of the real load management. As outlined in
469 Algorithm~\ref{algo.comp}, it iteratively runs the following operations:
471 \item if some load was received from the neighbors, get it;
472 \item if there is some load to send to the neighbors, send it;
473 \item run some computations, whose duration is a function of the processor's current
476 Practically, after the computation, the computing thread waits for a
477 small amount of time if the iterations are looping too fast (for
478 example, when the current load is near zero).
481 \caption{Computing thread}
485 \VAR{data\_fifo} & buffer of received data messages \\
486 \VAR{real\_load} & current load \\
489 \If{\VAR{data\_fifo} is empty and $\VAR{real\_load} = 0$}{%
490 wait until a message is pushed into \VAR{data\_fifo}\;
492 \While{\VAR{data\_fifo} is not empty}{%
493 pop a message from \VAR{data\_fifo}\;
494 get the load embedded in the message, and add it to \VAR{real\_load}\;
496 \ForEach{neighbor $n$}{%
497 \If{there is some amount of load $a$ to send to $n$}{%
498 send $a$ units of load to $n$, and subtract it from \VAR{real\_load}\;
501 \If{$\VAR{real\_load} > 0.0$}{
502 simulate some computation, whose duration is function of \VAR{real\_load}\;
503 ensure that the main loop does not iterate too fast\;
508 \subsubsection{Load-balancing thread}
510 The load-balancing thread is in charge of running the load-balancing algorithm,
511 and exchanging the control messages. As shown in Algorithm~\ref{algo.lb}, it
512 iteratively runs the following operations:
514 \item get the control messages that were received from the neighbors;
515 \item run the load-balancing algorithm;
516 \item send control messages to the neighbors, to inform them about the
517 processor's current load, and possibly the future virtual load transfers;
518 \item wait a minimum (configurable) amount of time, to avoid iterating too fast.
522 \caption{Load-balancing}
525 \While{\VAR{ctrl\_fifo} is not empty}{%
526 pop a message from \VAR{ctrl\_fifo}\;
527 identify the sender of the message,
528 and update the current knowledge of its load\;
530 run the load-balancing algorithm to make the decision about load transfers\;
531 \ForEach{neighbor $n$}{%
532 send a control messages to $n$\;
534 ensure that the main loop does not iterate too fast\;
538 %\paragraph{}\FIXME{ajouter des détails sur la gestion de la charge virtuelle ?
539 % par ex, donner l'idée générale de l'implémentation. l'idée générale est déja
540 % décrite en section~\ref{sec.virtual-load}}
542 \subsection{Experimental contexts}
543 \label{sec.exp-context}
545 In order to assess the performances of our algorithm, simulations with various parameters have been achieved out, and several metrics are described in this section.
547 \subsubsection{Load balancing strategies}
549 Several load balancing strategies were compared. Experiments with
550 the \besteffort{}, and with the \makhoul{} strategies have been performed. First the \emph{best
551 effort} was tested with parameter $k = 1$, $k = 2$, and $k = 4$. Then,
552 each strategy was run in its two variants: with, and without the management of
553 \emph{virtual load}. Finally, each configuration with \emph{real},
554 and with \emph{integer} load values is considered.
556 To summarize the different load balancing strategies, we have:
558 \item[\textbf{strategies:}] \makhoul{}, or \besteffort{} with $k\in
560 \item[\textbf{variants:}] with, or without virtual loads
561 %\item[\textbf{domain:}] real load, or integer load
564 \subsubsection{End of the simulation}
566 The simulations were run until reaching the global equilibrium threshold.
568 More precisely, the simulation stops when each node holds
569 an amount of load at least inferior to 1\% of the load average.
571 \subsubsection{Platform}
574 In order to make our experiments, an heterogeneous grid platform description were created by taking a subset of the
575 Grid'5000 infrastructure\footnote{Grid'5000 is a French large scale experimental
576 Grid (see \url{https://www.grid5000.fr/}).}, as described in the platform file
577 \texttt{g5k.xml} distributed with SimGrid. Note that the heterogeneity of the
578 platform here only comes from the network topology. Indeed,
579 processors are considered to be homogeneous for the sake of simplicity.
580 However, this situation is easily extendable to the case of heterogeneous platforms
581 by scaling the processor's load by its computing power~\cite{ElsMonPre02}.
583 %algorithms currently do not handle heterogeneous computing resources,
585 processor speeds were normalized, and we arbitrarily chose to fix them at
586 1~GFlop/s. Each type of platform with four different numbers of computing
587 nodes: 16, 64, 256, and 1024 nodes is built in a similar way.
589 \subsubsection{Configurations}
591 The distributed processes of the application were then logically organized along
592 three possible typologies: a line, a torus or an hypercube. Tests were divided into two groups on the basis of the initial distribution of the global load: i) some tests were performed with the total load initially on only one node, ii) and other tests were performed for which the load was initially randomly distributed across all the
593 participating nodes of the platform. The total amount of loads was fixed to a number of load
594 units equal to 1,000 times the number of node. The average load is then of 1,000
597 For all the previous configurations, the
598 computation and communication costs of a load unit are defined. They were chosen so as to
599 have two different CCR, and hence characterize
600 two different types of applications:
602 \item mainly communicating, with a CCR of $1/10$;
603 \item mainly computing, with a CCR of $10/1$.
604 %\item balanced, with a computation/communication cost ratio of $1/1$.
608 \subsubsection{Metrics}
611 In order to evaluate and compare the different load balancing strategies, several metrics were considered. Our goal, when choosing these metrics, is to have
612 something tending to a constant value, i.e. to have a measure which is not
613 changing anymore once the convergence state is reached. Moreover, the goal is to
614 have some normalized values, in order to be able to compare them across different
615 settings. With these constraints in mind, the following metrics are defined:
618 \item[\it{average idle time:}] that is the total time spent, when the nodes
619 do not hold any share of load, and thus have nothing to compute.
620 A smaller value is better.
622 \item[\it{average convergence time:}] that is the average of the times when
623 all nodes reached the final balanced load distribution. Times are measured as a number
624 of (simulated) seconds from the beginning of the simulation.
626 \item[\it{maximum convergence time:}] that is the time when the last node
627 reached the final stable equilibrium. A smaller value is better.
634 \subsection{Experimental results}
637 In this section, the results for the different simulations are presented,
638 and our observations are explained.
642 \subsubsection{Main results}
646 \includegraphics[width=.5\linewidth]{data/graphs/R1-10:1-grid-line}%
647 \includegraphics[width=.5\linewidth]{data/graphs/R1-1:10-grid-line}
648 \includegraphics[width=.5\linewidth]{data/graphs/R1-10:1-grid-torus}%
649 \includegraphics[width=.5\linewidth]{data/graphs/R1-1:10-grid-torus}
650 \includegraphics[width=.5\linewidth]{data/graphs/R1-10:1-grid-hcube}%
651 \includegraphics[width=.5\linewidth]{data/graphs/R1-1:10-grid-hcube}
652 \caption{Real mode, initially on an only mode, CCR = $10/1$ (left), or $1/10$ (right). For each bar, from bottom to top starting at $t=0$, the first part represents the average idle
653 time, the second part represents the average convergence time, and then the third part represents the maximum convergence time.}
659 \includegraphics[width=.5\linewidth]{data/graphs/RN-10:1-grid-line}%
660 \includegraphics[width=.5\linewidth]{data/graphs/RN-1:10-grid-line}
661 \includegraphics[width=.5\linewidth]{data/graphs/RN-10:1-grid-torus}%
662 \includegraphics[width=.5\linewidth]{data/graphs/RN-1:10-grid-torus}
663 \includegraphics[width=.5\linewidth]{data/graphs/RN-10:1-grid-hcube}%
664 \includegraphics[width=.5\linewidth]{data/graphs/RN-1:10-grid-hcube}
665 \caption{Real mode, random initial distribution, CCR = $10/1$ (left), or $1/10$ (right).}
669 The main results for our simulations on grid platforms are presented in Figures~\ref{fig.results1} and~\ref{fig.resultsN}.
671 The results in Figure~\ref{fig.results1} are when the load to balance is
672 initially on only one node, while the results in Figure~\ref{fig.resultsN} are
673 when the load to balance is initially randomly distributed over all nodes.
674 On both figures, the CCR is $10/1$ on the left
675 column, and $1/10$ on the right column.
676 On each Figure, ~\ref{fig.results1} and~\ref{fig.resultsN}, the results
677 are given for the process topology being, from top to bottom, a line, a torus or
680 Finally, the vertical bars show the measured times for the evaluated metrics. These measured times are, starting at $t=0$ and from bottom to top, the average idle
681 time, the average convergence time, and the maximum convergence time (see
682 Section~\ref{sec.metrics}). The measurements are repeated for the different
683 platform sizes. Some bars are missing, especially for large platforms. This is
684 because the algorithm did not reach the convergence state in the
689 \subsubsection{The \besteffort{} and \makhoul{} strategies without virtual load}
691 The {\it simple} ({\it plain}) version of each strategy is defined as the load balancing
692 algorithm without virtual load's transfers. For each strategy, we compare the simple
693 version (without virtual load) and the improved one (with virtual load).
694 Each algorithm is evaluated in terms of achieved idle time and convergence time.
696 Before looking at the different variations, we will first show that the simple
697 \besteffort{} strategy is valuable, and may be as good as the \makhoul{}
698 strategy. On Figures~\ref{fig.results1} and~\ref{fig.resultsN},
699 these strategies are respectively labeled ``b'' and ``a''.
701 We can see that the relative performance of these strategies is mainly
702 influenced by the application topology structure. It is for the line topology that the
703 difference is the most important. In this case, the \besteffort{} strategy is
704 really faster than the \makhoul{} strategy. This can be explained by the
705 fact that the \besteffort{} strategy tries to distribute the load fairly between
706 all the nodes and is in a good agreement with the line topology since it is easy
707 to load balance the load efficiently.
709 In contrast, for the hypercube topology, the \besteffort{}' performances are lower than
710 the \makhoul{} strategy. In this case, the \makhoul{} strategy, which
711 tries to give more load to few neighbors, reaches the equilibrium faster.
713 For the torus topology, for which the number of links is between the line and
714 the hypercube, the \makhoul{} strategy is slightly better but the difference is
715 more nuanced when the initial load is only on one node. The only case where the
716 \makhoul{} strategy is really faster than the \besteffort{} strategy is with the
717 random initial distribution when communications are slow.
719 Generally speaking, the number of interconnection is very important. Indeed, the more
720 numerous the interconnection links are, the faster the \makhoul{} strategy is because
721 it distributes quickly significant amount of loads, even if the distribution may be unfair, between
722 all neighbors. However, the \besteffort{} strategy distributes the
723 load fairly when needed and is better for sparse connected applications.
729 \subsubsection{With virtual load}
731 The impact of virtual load scheme is most of the time really significant compared to
732 the simple version of the algorithm with the same configuration.
733 For instance, as can be seen from Figure~\ref{fig.results1}, when the load is initially on one node, it can be
734 noticed that the average idle times are generally longer with the virtual load
735 than the simple version. This can be explained by the fact that, with virtual load,
736 processors will exchange all the load they need to exchange as soon as the
737 virtual load has been balanced between all the processors. As a consequence, they
738 cannot compute at the beginning. This is especially noticeable when the
739 communication are slow (on the left part of Figure ~\ref{fig.results1}).
742 When the load to balance is initially randomly distributed over all nodes, we can see from Figure \ref{fig.resultsN} that the effect of virtual load is not significant for the line topology structure. However, for both torus and hypercube structures with CCR = 1/10 (on the left of the figure), the performance of virtual load transfers is significantly better. This is explained by the fact
743 that for small CCR values, high communication costs play quite a significant role. Moreover, the impact of
744 communication becomes less important as the CCR values increase, since larger CCR values result in smaller communication times. The impact of CCR values were also tested on the performance of each algorithm in terms of idle times. From Figures~\ref{fig.results1} and ~\ref{fig.resultsN} virtual load scheme can be seen to achieve really good average idle times, which is quite close to both its own simple version and its direct competitor {\it Bertsekas and Tsitsiklis} algorithm. As expected, for coarse grain applications (CCR =10/1), idle times are close to 0 since processors are inactive most of the time compared to fine grain applications.
747 Taken as a whole, the results illustrated in Figures~\ref{fig.results1} and ~\ref{fig.resultsN} clearly show that our proposal outperforms the Bertsekas and Tsitsiklis algorithm.
748 These results indicate that local load balancing decisions have a significant impact on the global
749 convergence time achieved by the compared strategies. This is because, upon load imbalance detection, assigning an amount of load in an unfair way between neighbors will severely increase the total number of iterations required by the algorithm before reaching the final stable distributions. The reason of the poorer performance of {\it Bertsekas and Tsitsiklis} algorithm can be explained by the inconvenience of the iterative load balance policy adopted for load distribution between neighbors. Neighbors are selected in such a way that the {\it ping-pong} condition holds. Doing so, loads are not really assigned to processor neighbors which would allow them to be fairly balanced.
752 Unlike the {\it Bertsekas and Tsitsiklis} algorithm, our approach is not really sensitive when dealing with realistic models of computation and communication. This is due to two main features: i) the use of "virtual load" transfers which allows nodes to predict the load they receive in the subsequent iterations steps, ii) and the greedy neighbors selection adopted by our algorithm at each time step in the load balancing process. The involved neighbors are selected in such a way that the load difference between the computational resources is minimized as much as possible.
755 Comparing the results of the extended version (with virtual load) to the results of the simple one, it can be observed in Figs.~\ref{fig.results1} and ~\ref{fig.resultsN} that the improved version gives the best performances. It always improves both convergence and idle times significantly in all figures. This is because, with virtual load transfers, the algorithm seeks greedily to ensure a certain degree of load balancing for processors by taking into account the information about the predictive loads not received yet. Consequently, this leads to optimizing the final convergence time of the load balancing process. Similarly, the extended version achieves much better results than the simple one when considering larger platforms, as shown in Figs.~\ref{fig.results1} and ~\ref{fig.resultsN}.
758 We also find in Figs.~\ref{fig.results1} and ~\ref{fig.resultsN} that the performance difference between the improved version of our proposal and its simple version (without virtual load) increases when the CCR increases. This interesting result comes from the fact that larger CCR values reveal that we are dealing with intensive computations applications in grid platforms. Thus, in order to reduce the convergence time of the load balancing for such applications, it is important to take suitable decisions upon local load imbalance detection. That is why we added {\it virtual load} transfers scheme to the {\it best effort} strategy to perfectly balance the load of processors at each step of the load balancing process.
761 Finally, it is worthwhile noting from Figures~\ref{fig.results1} and ~\ref{fig.resultsN}, that the algorithm's convergence time increases together with the size of the network. We also see that the idle time increases together with the size of the network when a load is initially on a single node (Figure~\ref{fig.results1}),
762 as expected. In addition, it is interesting to note that when the number of nodes increases, there is no substantial difference in the increase of the convergence time, compared to the simple version without virtual load. This is explained by the fact that the increase in the convergence time is already absorbed by the virtual load transfers between processors being in line with the network's size.
766 \subsubsection{The $k$ parameter}
769 As explained previously when the communication are slow the \besteffort{}
770 strategy is efficient. This is due to the fact that it tries to balance the load
771 fairly and consequently a significant amount of the load is transferred between
772 processors. In this case, it is possible to reduce the convergence time by
773 using the leveler parameter (parameter $k$). The advantage of using this
774 solution is particularly true when the initial load is randomly distributed
775 on the nodes with torus and hypercube topologies and slow communication. When
776 a virtual load scheme is used, the effect of this parameter is also perceptible
777 in the same conditions.
782 \subsubsection{With non negative integer load values}
783 In addition to the first tests devoted to the case of non negative real load values, further experiments were also carried with integer load values to assess the performance of our proposal.
784 As expected, the obtained results globally have the same behavior, that is why we decided not to show similar figures. The most
785 interesting result, from our point of view, is that the virtual mode allows
786 processors in a line topology to converge to the uniform load balancing state. Without
787 the virtual load, most of the time, processors converge to what is called the
788 ``stairway effect'', that is to say that there is only a difference of at most one unit load between any pairs of neighbor nodes, i.e. the load difference between each processor and its neighbors is within one unit load (for example with 10 processors, we
789 obtain 10 9 8 7 6 6 7 8 9 10 instead of 8 8 8 8 8 8 8 8 8 8).
792 To summarize the simulation results led us to show that, with a few exceptions (without virtual load), our proposal is superior to the {\it Bertsekas and Tsitsiklis} algorithm in all the tested scenarios. The illustrated results indicate that network size, CCR values and initial load distribution have a significant impact on the algorithm's performances. Thus, this experimental study corroborates the usefulness of our algorithm, and confirms that when dealing with realistic model platforms, both {\it best effort} strategy and {\it virtual load} transfers play an important role on the achieved idle and convergence times.
797 \label{conclusions-remarks}
799 In this paper, a new asynchronous load balancing algorithm for non negative real numbers
800 of divisible loads in distributed systems was presented. The proposed algorithm which is called {\it best effort strategy}
801 seeks greedily for loads imbalance detection and tries to achieve efficient local load equilibrium
802 between neighbors. Our proposal is based on {\it a clairvoyant virtual loads' transfer} scheme which allows nodes to predict the future loads they will receive in the subsequent iterations.
803 This leads to a noticeable speedup of the global convergence time of the load balancing process.
804 Based on SimGrid simulator, we have demonstrated that, when dealing with realistic models of computation and communication, our algorithm exhibits better performances than its direct competitor from the literature. This makes it a viable choice for load balancing of both non negative real and integer divisible loads in distributed computing systems. % un peu gonflé peut être pour la dernière phrase.
806 \section*{Acknowledgments}
808 This paper is partially funded by the Labex ACTION program (contract
809 ANR-11-LABX-01-01). We also thank the supercomputer facilities of the Mésocentre de calcul de Franche-Comté.
811 \bibliographystyle{elsarticle-num}
812 \bibliography{biblio}
