]> AND Private Git Repository - loba-papers.git/blob - loba-besteffort/loba-besteffort.tex
Logo AND Algorithmique Numérique Distribuée

Private GIT Repository
[sharelatex-git-integration Best effort strategy and virtual load for asynchronous...
[loba-papers.git] / loba-besteffort / loba-besteffort.tex
1 \documentclass[preprint]{elsarticle}
2
3 \usepackage[utf8]{inputenc}
4 \usepackage[T1]{fontenc}
5 \usepackage{comment}
6 %\usepackage{newtxtext}
7 %\usepackage[cmintegrals]{newtxmath}
8 \usepackage{mathptmx,helvet,courier}
9
10 \usepackage{amsmath}
11 \usepackage{graphicx}
12 \usepackage{url}
13 \usepackage[ruled,lined]{algorithm2e}
14
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}
21
22 \newcommand{\abs}[1]{\lvert#1\rvert} % \abs{x} -> |x|
23
24 \newenvironment{algodata}{%
25   \begin{tabular}[t]{@{}l@{:~}l@{}}}{%
26   \end{tabular}}
27
28 \newcommand{\VAR}[1]{\textit{#1}}
29
30 \newcommand{\besteffort}{\emph{best effort}}
31 \newcommand{\makhoul}{\emph{naive}}
32
33 \begin{document}
34
35 \begin{frontmatter}
36
37 \journal{Parallel Computing}
38
39 \title{Best effort strategy and virtual load for\\
40   asynchronous iterative load balancing}
41
42 \author{Raphaël Couturier}
43 \ead{raphael.couturier@univ-fcomte.fr}
44
45 \author{Arnaud Giersch\corref{cor}}
46 \ead{arnaud.giersch@univ-fcomte.fr}
47
48 \author{Mourad Hakem}
49 \ead{mourad.hakem@univ-fcomte.fr}
50
51 \address{%
52   FEMTO-ST Institute, Univ Bourgogne Franche-Comté, Belfort, France}
53
54 \cortext[cor]{Corresponding author.}
55
56 \begin{abstract}
57   Most of the time, asynchronous load balancing algorithms have extensively been
58   studied in a theoretical point of view. The Bertsekas and Tsitsiklis'
59   algorithm~\cite
60   %[section~7.4]
61   {bertsekas+tsitsiklis.1997.parallel} is undeniably 
62   the most well known algorithm for which the asymptotic convergence proof is given. 
63   From a
64   practical point of view, when a node needs to balance a part of its load to
65   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
66   propose a new strategy called \besteffort{} which aims to balance the load
67   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 
68   asynchronous iterative algorithms are less sensitive to communications delays 
69   and their variations \cite{bcvc07:bc}, both load transfer and load information messages are dissociated. 
70   To speedup the convergence time of the load balancing process, we propose {\it a clairvoyant virtual load} heuristic which allows 
71   %asynchronous iterative algorithms, in which an asynchronous load balancing
72   %algorithm is implemented, can dissociate, most of the time, messages concerning
73   %load transfers and message concerning load information.  In order to increase
74   %the converge of a load balancing algorithm, we propose a simple heuristic
75   %called \emph{virtual load}. This heuristic allows 
76   a node receiving a load
77   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
78   its neighbors taking into account the virtual load it will receive in the subsequent time-steps. Based on SimGrid simulator, series of test-bed scenarios are considered and many QoS metrics are evaluated to show the usefulness of the proposed algorithm.  %In order to validate our approaches, we have defined a
79  % simulator based on SimGrid which allowed us to conduct many experiments.
80 \end{abstract}
81
82 % \begin{keywords}
83 %   %% keywords here, in the form: keyword \sep keyword
84 % \end{keywords}
85
86 \end{frontmatter}
87
88 \section{Introduction}
89
90 Load  balancing algorithms  are  widely used  in  parallel and  distributed
91 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 
92 computing systems to wireless sensor networks (WSN). 
93 The objective of load balancing is to orchestrate the distribution of the global workload so that 
94 the load difference between the computational resources of the network is 
95 minimized as low as possible. Unfortunately, this problem is known to be {\bf NP-hard} in its 
96 general forms and heuristics are required to achieve sub-optimal solutions but in 
97 polynomial time complexity. 
98
99 In this paper, we focus on asynchronous load balancing of non negative real numbers of {\it divisible loads}
100 in homogeneous distributed systems. Loads can be divided in arbitrary {\it fine-grain} parallel parts size 
101 that can be processed independently of each other. This model of divisible loads arise in 
102 a wide range of real-world applications. Common examples among many, include signal processing, 
103 feature extraction and edge detection in image processing, records search in a huge databases, 
104 average consensus in WSN, pattern search in Big data and so on. % c'est pout toi raphael ;-)
105
106
107 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. 
108 \begin{comment}
109 This algorithm 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 converged 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.
110 \end{comment}
111 %in  order to  reduce the  execution times. They  can be  applied in
112 %different scientific  fields from high  performance computation to  micro sensor
113 %networks.   In a distributed context (i.e. without centralization), they are  iterative by  nature.
114 %In  literature many  kinds  of load
115 %balancing  algorithms  have been  studied.   They  can  be classified  according
116 %different  criteria:   centralized  or  decentralized,  in   static  or  dynamic
117 %environment,  with  homogeneous  or  heterogeneous load,  using  synchronous  or
118 %asynchronous iterations, with  a static topology or a  dynamic one which evolves
119 %during time.  In  this work, we focus on  asynchronous load balancing algorithms
120 %where computing nodes  are considered homogeneous and with  homogeneous load with
121 %no external  load. 
122 %In  this context, Bertsekas  and Tsitsiklis have  proposed an
123 %algorithm which is definitively a reference for many works. In their work, they
124 %proved that under classical  hypotheses of asynchronous iterative algorithms and
125 %a  special  constraint   avoiding  \emph{ping-pong}  effect,  an  asynchronous
126 %iterative algorithm  converges to  the uniform load  distribution. This  work has
127 %been extended by many authors. For example, Cortés et al., with
128 %DASUD~\cite{cortes+ripoll+cedo+al.2002.asynchronous}, propose a
129 %version working with integer load.  This work was later generalized by
130 %the same authors in \cite{cedo+cortes+ripoll+al.2007.convergence}.
131 %\FIXME{Rajouter des choses ici.  Lesquelles ?}
132 Although  Bertsekas  and Tsitsiklis'  describe  the necessary conditions to
133 ensure the algorithm's convergence,  there is no indication or any strategy to really implement
134 the load distribution. %In other word, a node  can send some amount of its load to one or   many  of   its  neighbors   while  all   the  convergence   conditions  are followed. 
135 Consequently,  we propose a  new strategy called  \besteffort{}
136 that tries to balance the load of  a node to all its less loaded neighbors while
137 ensuring that all the nodes involved in the load balancing phase have the same
138 amount of  load.  Moreover, %when real-world asynchronous  applications are considered,
139 %using  asynchronous load  balancing  algorithms  can  reduce   the  execution
140 %times. 
141 most of the times, it is simpler to dissociate load information messages
142 from  data  migration  messages.  Former  ones  allow  a  node to  inform  its
143 neighbors about its  current load. These messages are in fact very small and can be sent 
144 often and very quickly.  For example, if a computing iteration takes  a significant times
145 (ranging from seconds to minutes), it is possible to send a new load information
146 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 have
147 sense or not  that nodes try to balance  a part of their load  at each computing
148 iteration. But the time to transfer a load message from a node to another one is
149 often much more longer that the  time to transfer a load information message. So,
150 when a node is notified 
151 %receives the information  
152 that later it will receive a data message,
153 it can take this information into account in its load's queue list for preventive purposes.
154 %and it can consider that its new load is larger.   
155 Consequently, it can  send a part  of its predictive
156 %real 
157 load to some  of its
158 neighbors if required. We call this trick the \emph{clairvoyant virtual load} transfer mechanism.
159
160 \medskip 
161 The main contributions and novelties of our work are summarized in the following section. 
162
163 \section{Our contributions}
164 \label{contributions}
165 \begin{itemize}
166 \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.     
167
168 \item Unlike earlier works, we use a new concept of virtual loads transfers which allows nodes to predict the future loads they will receive in the subsequent iterations. 
169 This leads to a noticeable speedup of the global convergence time of the load balancing process.  
170
171 \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. 
172
173 %\item We improve the straightforward network's diameter bound of the global equilibrium threshold in the network. % not sure, it depends on the remaining time before the paper submission ...
174 \end{itemize}
175
176
177 %{\bf The contributions of this paper are the following:}
178 %\begin{itemize}
179 %\item We propose a new strategy to improve the distribution of the
180 %load and a simple but efficient trick that also improves the load
181 %balancing.
182 %\item we have conducted many simulations with SimGrid in order to
183 %validate that our improvements are really efficient. Our simulations consider
184 %that in order to send a message, a latency delays the sending and according to
185 %the network performance and the message size, the time of the reception of the
186 %message also varies.
187 %\end{itemize}
188
189 The reminder of the paper is organized as follows. 
190 In Section~\ref{sec.related.works}, we review the relevant approaches in the literature. Section~\ref{sec.bt-algo} describes the
191 Bertsekas and Tsitsiklis' asynchronous load balancing algorithm. %Moreover, we  present a possible problem in the convergence conditions. 
192 Section~\ref{sec.besteffort} presents the best effort strategy which provides
193 efficient local loads equilibrium. %This strategy will be compared with the one presented in Section~\ref{sec.other}.  
194 In Section~\ref{sec.virtual-load}, the clairvoyant virtual load scheme is proposed to speedup the convergence time of the load balancing process.
195 We provide in Section~\ref{sec.simulations}, a comprehensive set of numerical results that exhibit the usefulness of our proposals when we deal with realistic models of computation and communication. Finally, we give some concluding remarks in Section~\ref{conclusions-remarks}.
196
197
198 \section{Related works}
199 \label{sec.related.works}
200 In this section, we fairly review the relevant techniques proposed in the literature to tackle the problem of load balancing in a general context of distributed systems. 
201
202 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 converged 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.
203
204 Cybenko~\cite{Cybenko89} propose a {\it diffusion} approach for hypercube multiprocessor networks. 
205 The author targets both static and dynamic random models of work distribution. 
206 The convergence proof is derived based on the {\it eigenstructure} of the 
207 iteration matrices that arise in load balancing of equal amount of
208 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, at most one token (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.
209
210 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
211 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.
212
213
214 Choi et al.~\cite{ChoiBH09} address the problem of robust task allocation in arbitrary networks. The proposed
215 approaches combine bidding approach for task selection and consensus procedure scheme for
216 decentralized conflict resolution. The developed algorithms are proven to converge to a conflict-free assignment in
217 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.
218
219
220 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 for computing the Nash equilibrium. They show through simulations that the proposed algorithm ensures fairness among the users and good average latency across all client regions. A hybrid task scheduling and load balancing dependent and independent tasks for master-slaves platforms is addressed in~In~\cite{liu2017dems}. To minimize the response time of the submitted jobs, the proposed algorithm which is called DeMS is splitted in three stages: i) communication overhead reduction between masters and slaves,  ii) task migration to keep the workload balanced iii) and precedence task graphs partitioning. 
221
222
223 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. Simulations results show that the proposed scheme perform near optimal solutions compared to other existing techniques in terms of fairness.
224
225
226
227
228 \section{Bertsekas  and Tsitsiklis' asynchronous load balancing algorithm}
229 \label{sec.bt-algo}
230
231 In this section, we present a brief description of Bertsekas and Tsitsiklis' algorithm~\cite{bertsekas+tsitsiklis.1997.parallel} using its original notations. 
232 A network is modeled as a connected undirected graph $G=(N,A)$, where $N$ is set 
233 of processors and $A$ is a set of communication links. The processors are 
234 labeled $i = 1,...,n$, and a link between processors $i$ and
235 $j$ is denoted by $(i, j)\in A$. The set of neighbors of processor $i$ is denoted by $V(i)$.
236 %In this work, we consider that  
237 Processors are  considered to be homogeneous for the sake of simplicity.
238 It is easily extendable to the case of heterogeneous platforms 
239 by scaling the processor's load by its computing power~\cite{ElsMonPre02}.
240 %In  order  prove  the  convergence  of  asynchronous  iterative  load  balancing
241 %Bertsekas         and        Tsitsiklis         proposed         a        model
242 %in~\cite{bertsekas+tsitsiklis.1997.parallel}.   Here we  recall  some notations.
243 %Consider  that  $N={1,...,n}$  processors   are  connected  through  a  network.
244 %Communication links  are represented by  a connected undirected  graph $G=(N,A)$
245 %where $A$ is the set of links connecting different processors. 
246 %In this work, we
247 %consider that  processors are  homogeneous for sake  of simplicity. It  is quite
248 %easy to tackle the  heterogeneous case~\cite{ElsMonPre02}. 
249 Load of processor $i$
250 at  time $t$  is  represented  by $x_i(t)\geq  0$.   
251 %Let $V(i)$  be  the set  of neighbors of processor  $i$.  
252 Each processor $i$ has an estimate  of the load of
253 each  of its  neighbors $j  \in V(i)$  denoted by  $x_j^i(t)$ and this estimate 
254 may be outdated due to %.  According to
255 asynchronism and communication  delays. 
256 %, this estimate may be  outdated.  
257 %We also
258 %consider that the load is described by a continuous variable.
259
260 %Since we deal with large  {\it fine grain} parallelism of divisible loads, 
261 %the processor's load is represented by a continuous variable for notational 
262 %convenience.  
263 \medskip
264 When a processor  sends a part of its  load to one or some of  its neighbors, the
265 transfer takes time to be completed.  Let $s_{ij}(t)$ be the amount of load that
266 processor $i$ has transferred to processor $j$ at time $t$ and let $r_{ij}(t)$ be the
267 amount of  load received by  $j$  from  $i$ at  time $t$. Then
268 the amount of load of processor $i$ at time $t+1$ is given by:
269
270 \begin{equation}
271 x_i(t+1)=x_i(t)-\sum_{j\in V(i)} s_{ij}(t) + \sum_{j\in V(i)} r_{ji}(t)
272 \label{eq.ping-pong}
273 \end{equation}
274
275
276 %Some  conditions are  required to  ensure the  convergence. One  of them  can be
277 %called the \emph{ping-pong} condition which specifies that:
278 \medskip
279 The asymptotic convergence is derived based on the {\it ping-pong} awareness condition which specifies that:
280
281 \begin{equation}
282 x_i(t)-\sum _{k\in V(i)} s_{ik}(t) \geq x_j^i(t)+s_{ij}(t)
283 \end{equation}
284
285 for any  processor $i$ and any  $j \in V(i)$ such  that $x_i(t)>x_j^i(t)$.  
286 %This condition aims  at avoiding a processor  to send a  part of its load  and being
287 %less loaded after that.
288
289 \medskip
290 This condition prohibits the possibility that two nodes keep sending load to each
291 other back and forth, without reaching equilibrium. 
292
293 \medskip
294 Nevertheless,  we  think that  this  condition may  lead  to  deadlocks in  some
295 cases. For example, if we consider a linear chain graph network of only three processors and that processor $1$
296 is linked to processor $2$ which is  also linked to processor $3$, but processors $1$ and $3$ are not neighbors. 
297 %(i.e. a simple chain which 3 processors). 
298 Now consider that we have the following load values at time~$t$:
299 \begin{align*}
300   x_1(t)   &= 10    \\
301   x_2(t)   &= 100   \\
302   x_3(t)   &= 99.99 \\
303   x_3^2(t) &= 99.99 
304 \end{align*}
305 %{\bf RAPH, pourquoi il y a $x_3^2$?. Sinon il faudra reformuler la suite, c'est mal dit}
306
307 Owing to the algorithm's specification, processor $2$ can either sends 
308 load to processor $1$ or processor
309 $3$.  If it sends load to processor $1$, it will not satisfy condition
310 \eqref{eq.ping-pong} because after that sending it will be less loaded than
311 $x_3^2(t)$.  So we consider that the \emph{ping-pong} condition is probably too
312 strong. %Currently, we did not try to make another convergence proof without this condition or with a weaker condition.
313
314 \smallskip  
315 Nevertheless, we conjecture that a weaker condition may exist since we
316 have never seen any scenario that is not leading to convergence, even with
317 load-balancing strategies that are not exactly fulfilling the authors' own conditions. %se two conditions.
318
319 %It may be the subject of future work to express weaker conditions, and to prove
320 %that they are sufficient to ensure the convergence of the load-balancing
321 %algorithm.
322
323 \smallskip
324
325 Although this approach is interesting, several practical
326 questions arise when dealing with realistic models of 
327 computation and communication. As reported above, the 
328 algorithm's description is too succinct and no details are 
329 given on what is really sent and how the load balancing decision 
330 are taken. To our knowledge, the only first attempt for a possible 
331 implementation of this algorithm is investigated in~\cite{bahi+giersch+makhoul.2008.scalable} under the same conditions. Thus, in order to assess the performances
332 of the new \besteffort{}, we naturally chose to compare it to this anterior
333 work.  More precisely, we will use the algorithm~2 from
334 \cite{bahi+giersch+makhoul.2008.scalable} and, through out the paper, we will
335 reference it under the original name {\it Bertsekas and Tsitsiklis} for the sake of convenience and readability. 
336
337 \smallskip 
338 Here is an outline of the main principle of the borrowed algorithm.  When a given node  $i$ has to take
339 a load balancing decision, it starts by sorting its neighbors by non-increasing
340 order of their loads.  Then, it computes the difference between its own load, and
341 the load of each of its neighbors.  Finally, taking the neighbors following the
342 order defined before, the amount of load to send $s_{ij}$ is computed as
343 $1/(|V(i)|+1)$ of the load difference%, with $n$ being the number of neighbors
344 . This process is iterated as long as the node is more loaded than the considered
345 neighbors.
346
347
348 \section{Best effort strategy}
349 \label{sec.besteffort}
350
351 In this section, we describe a new load-balancing strategy that we call
352 \besteffort{}.  First, we explain the general idea behind this strategy,
353 and then we present some variants of this basic strategy.
354
355 \subsection{Basic strategy}
356 The description of our algorithm will be given from the point of view a processor~$i$.
357 The principle of the \besteffort{} strategy is that each processor,
358 that detects it has more load than some of its neighbors, sends some load to the
359 most of its less loaded neighbors, doing its best to reach the equilibrium
360 between the involved neighbors and itself.
361
362 More precisely, %when a processor $i$ is in its load-balancing phase,
363 at each iteration of the load balancing process, processor~$i$ 
364  proceeds as follows.
365 \begin{enumerate}
366 \item First, the neighbors are sorted in non-decreasing order of their
367   known loads $x^i_j(t)$.
368
369 \item Then, this sorted list is used to find its largest
370   prefix such as the load of each selected neighbor is smaller than:
371   \begin{itemize}
372   \item the load of processor $i$, and
373   \item the mean of the loads of the selected neighbors and processor i.
374   \end{itemize}
375   Let $S_i(t)$ be the set of the selected neighbors, and
376   $\bar{x}(t)$ be the mean of the loads between the selected neighbors and processor $i$ is given as follows:
377   \begin{equation*}
378     \bar{x}(t) = \frac{1}{\abs{S_i(t)} + 1}
379       \left( x_i(t) + \sum_{j\in S_i(t)} x^i_j(t) \right)
380   \end{equation*}
381   so that the following properties hold: %{\bf RAPH : la suite tombe du ciel :-)}
382   \begin{equation*}
383     \begin{cases}
384       S_i(t) \subset V(i) \\
385       x^i_j(t) < x_i(t) & \forall j \in S_i(t) \\
386       x^i_j(t) < \bar{x} & \forall j \in S_i(t) \\
387       x^i_j(t) \leq x^i_k(t) & \forall j \in S_i(t), \forall k \in V(i) \setminus S_i(t) \\
388       \bar{x} \leq x_i(t)
389     \end{cases}
390   \end{equation*}
391
392 \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) =
393   \bar{x} - x^i_j(t)$.
394
395   %From the above equations, and notably from the definition of $\bar{x}$, it can easily be verified that:
396   
397   \smallskip
398   In this way we obtain: 
399   
400   \begin{equation*}
401     \begin{cases}
402       x_i(t) - \sum_{j\in S_i(t)} s_{ij}(t) = \bar{x} \\
403       x^i_j(t) + s_{ij}(t) = \bar{x} & \forall j \in S_i(t)
404     \end{cases}
405   \end{equation*}
406 \end{enumerate}
407
408
409
410 \subsection{Leveling the amount of load to move}
411
412 With the aforementioned basic strategy, each node does its best to reach the
413 equilibrium with its neighbors. However, one question should be outlined here:
414 How can we handle the case where two (or more) node initiators that may send 
415 concurrently some amount of loads to the the same less loaded neighbor? Indeed,  
416 %since each node may take the same kind of decision at the same time, 
417 there is a risk that a node will receive load from
418 several of its neighbors, and then is temporary going off the equilibrium state.
419 This is particularly true with strongly connected applications.
420
421
422
423 In order to reduce this effect, we add the ability to level the amount of load to send.
424 The idea, here, is to make as few steps as possible toward the equilibrium, such that a
425 potentially unsuitable decision pointed above has a lower impact on the local equilibrium.
426 Roughly speaking, once $s_{ij}$ is estimated as previously explained, it is simply weighted by
427 a given prescribed threshold parameter which we call 
428 %.  This parameter is called 
429 $k$ in
430 Section~\ref{sec.results}.  The amount of data to send is then $s_{ij}(t) =
431 (\bar{x} - x^i_j(t))/k$.
432 \FIXME[check that it's still named $k$ in Sec.~\ref{sec.results}]{}
433
434
435
436 %\section{Other strategies}
437 %\label{sec.other}
438
439 %Another load balancing strategy, working under the same conditions, was
440 %previously developed by Bahi, Giersch, and Makhoul in
441 %\cite{bahi+giersch+makhoul.2008.scalable}.  In order to assess the performances
442 %of the new \besteffort{}, we naturally chose to compare it to this anterior
443 %work.  More precisely, we will use the algorithm~2 from
444 %\cite{bahi+giersch+makhoul.2008.scalable} and, in the following, we will
445 %reference it under the name of naïve implementation of Bertsekas' load balancing algorithm.  {\bf : RAPH j'ai renommé MAKHOUL en naive, il faut valider !!!! LE SOUCI, il faudrait refaire les figures}
446
447 %Here is an outline of the \makhoul{} algorithm.  When a given node needs to take
448 %a load balancing decision, it starts by sorting its neighbors by increasing
449 %order of their load.  Then, it computes the difference between its own load, and
450 %the load of each of its neighbors.  Finally, taking the neighbors following the
451 %order defined before, the amount of load to send $s_{ij}$ is computed as
452 %$1/(n+1)$ of the load difference, with $n$ being the number of neighbors.  This
453 %process continues as long as the node is more loaded than the considered
454 %neighbor.
455
456
457 \section{Virtual load}
458 \label{sec.virtual-load}
459
460 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. 
461 %In order to
462 %use this concept, load balancing messages must be sent using two different kinds
463 %of  messages:  load information  messages  and  load  balancing messages.   
464 More
465 precisely, a node wanting to send some amount of its load to one (or more) of its neighbors
466 can first send a load information message about the load it will send, and
467 later it can send the load  message containing data to be transferred.
468 Load information  messages are in fact short
469 %, consequently they 
470 and will be received soon.
471 %very quickly.  
472 In contrast, load  transfer messages are often larger ones and thus
473 require more time to be transferred.
474
475 The  concept  of  \emph{virtual load}  allows  a  node receiving a  load
476 information message to integrate (virtually) the future load it will receive later in its load's list
477  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
478 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 
479 into account the information about the predictive loads not 
480 received yet.
481
482 % repetition !
483 %In fact,  a node that receives a load  information message knows that
484 %later it  will receive the  corresponding load balancing message  containing the
485 %corresponding data.  So, if this node detects it is too  loaded compared to some
486 %of its neighbors  and if it has enough  load (real load), then it  can send more
487 %load  to  some of  its  neighbors  without waiting  the  reception  of the  load
488 %balancing message.
489
490 %Doing  this, we  can  expect a  faster  convergence since  nodes  have a  faster
491 %information of the load they will receive, so they can take it into account.
492
493 %\FIXME{Est ce qu'on donne l'algo avec virtual load?}
494
495 %With integer load, this algorithm has been adapted by rounding the load value. In fact, we consider that the total amount of load is big enough and that it can be split with integer numbers.
496
497
498
499
500 %\FIXME{describe integer mode}
501
502 \section{Implementation with SimGrid and simulations}
503 \label{sec.simulations}
504
505 In order to test and validate our approaches, we wrote a simulator
506 using the SimGrid
507 framework~\cite{simgrid.web,casanova+giersch+legrand+al.2014.simgrid}.  This
508 simulator, which consists of about 2,700 lines of C++, allows to run
509 the different load-balancing strategies under various parameters, such
510 as the initial distribution of load, the interconnection topology, the
511 characteristics of the running platform, etc.  Then several metrics
512 are issued that permit to compare the strategies.
513
514 The simulation model is detailed in the next section (\ref{sec.model}), and the
515 experimental contexts are described in section~\ref{sec.exp-context}.  Then the
516 results of the simulations are presented in section~\ref{sec.results}.
517
518 \subsection{Simulation model}
519 \label{sec.model}
520
521 In the simulation model the processors exchange messages which are of
522 two kinds.  First, there are \emph{control messages} which only carry
523 information that is exchanged between the processors, such as the
524 current load, or the virtual load transfers if this option is
525 selected.  These messages are rather small, and their size is
526 constant.  Then, there are \emph{data messages} that carry the real
527 load transferred between the processors.  The size of a data message
528 is a function of the amount of load that it carries, and it can be
529 pretty large.  In order to receive the messages, each processor has
530 two receiving channels, one for each kind of messages.  Finally, when
531 a message is sent or received, this is done by using the non-blocking
532 primitives of SimGrid\footnote{That are \texttt{MSG\_task\_isend()},
533   and \texttt{MSG\_task\_irecv()}.}.
534
535 During the simulation, each processor concurrently runs three threads:
536 a \emph{receiving thread}, a \emph{computing thread}, and a
537 \emph{load-balancing thread}, which we will briefly describe now.
538
539 For the sake of simplicity, a few details were voluntary omitted from
540 these descriptions.  For an exhaustive presentation, we refer to the
541 actual source code that was used for the experiments%
542 \footnote{As mentioned before, our simulator relies on the SimGrid
543   framework~\cite{casanova+giersch+legrand+al.2014.simgrid}.  For the
544   experiments, we used a pre-release of SimGrid 3.7 (Git commit
545   67d62fca5bdee96f590c942b50021cdde5ce0c07, available from
546   \url{https://gforge.inria.fr/scm/?group_id=12})}, and which is
547 available at
548 \url{http://info.iut-bm.univ-fcomte.fr/staff/giersch/software/loba.tar.gz}.
549
550 \subsubsection{Receiving thread}
551
552 The receiving thread is in charge of waiting for messages to come, either on the
553 control channel, or on the data channel.  Its behavior is sketched by
554 Algorithm~\ref{algo.recv}.  When a message is received, it is pushed in a buffer
555 of received message, to be later consumed by one of the other threads.  There
556 are two such buffers, one for the control messages, and one for the data
557 messages.  The buffers are implemented with a lock-free FIFO
558 \cite{sutter.2008.writing} to avoid contention between the threads.
559
560 \begin{algorithm}
561   \caption{Receiving thread}
562   \label{algo.recv}
563   \KwData{
564     \begin{algodata}
565       \VAR{ctrl\_chan}, \VAR{data\_chan}
566       & communication channels (control and data) \\
567       \VAR{ctrl\_fifo}, \VAR{data\_fifo}
568       & buffers of received messages (control and data) \\
569     \end{algodata}}
570   \While{true}{%
571     wait for a message to be available on either \VAR{ctrl\_chan},
572     or \VAR{data\_chan}\;
573     \If{a message is available on \VAR{ctrl\_chan}}{%
574       get the message from \VAR{ctrl\_chan}, and push it into \VAR{ctrl\_fifo}\;
575     }
576     \If{a message is available on \VAR{data\_chan}}{%
577       get the message from \VAR{data\_chan}, and push it into \VAR{data\_fifo}\;
578     }
579   }
580 \end{algorithm}
581
582 \subsubsection{Computing thread}
583
584 The computing thread is in charge of the real load management.  As exposed in
585 Algorithm~\ref{algo.comp}, it iteratively runs the following operations:
586 \begin{itemize}
587 \item if some load was received from the neighbors, get it;
588 \item if there is some load to send to the neighbors, send it;
589 \item run some computations, whose duration is function of the current
590   load of the processor.
591 \end{itemize}
592 Practically, after the computation, the computing thread waits for a
593 small amount of time if the iterations are looping too fast (for
594 example, when the current load is near zero).
595
596 \begin{algorithm}
597   \caption{Computing thread}
598   \label{algo.comp}
599   \KwData{
600     \begin{algodata}
601       \VAR{data\_fifo} & buffer of received data messages \\
602       \VAR{real\_load} & current load \\
603     \end{algodata}}
604   \While{true}{%
605     \If{\VAR{data\_fifo} is empty and $\VAR{real\_load} = 0$}{%
606       wait until a message is pushed into \VAR{data\_fifo}\;
607     }
608     \While{\VAR{data\_fifo} is not empty}{%
609       pop a message from \VAR{data\_fifo}\;
610       get the load embedded in the message, and add it to \VAR{real\_load}\;
611     }
612     \ForEach{neighbor $n$}{%
613       \If{there is some amount of load $a$ to send to $n$}{%
614         send $a$ units of load to $n$, and subtract it from \VAR{real\_load}\;
615       }
616     }
617     \If{$\VAR{real\_load} > 0.0$}{
618       simulate some computation, whose duration is function of \VAR{real\_load}\;
619       ensure that the main loop does not iterate too fast\;
620     }
621   }
622 \end{algorithm}
623
624 \subsubsection{Load-balancing thread}
625
626 The load-balancing thread is in charge of running the load-balancing algorithm,
627 and exchange the control messages.  As shown in Algorithm~\ref{algo.lb}, it
628 iteratively runs the following operations:
629 \begin{itemize}
630 \item get the control messages that were received from the neighbors;
631 \item run the load-balancing algorithm;
632 \item send control messages to the neighbors, to inform them of the
633   processor's current load, and possibly of virtual load transfers;
634 \item wait a minimum (configurable) amount of time, to avoid to
635   iterate too fast.
636 \end{itemize}
637
638 \begin{algorithm}
639   \caption{Load-balancing}
640   \label{algo.lb}
641   \While{true}{%
642     \While{\VAR{ctrl\_fifo} is not empty}{%
643       pop a message from \VAR{ctrl\_fifo}\;
644       identify the sender of the message,
645       and update the current knowledge of its load\;
646     }
647     run the load-balancing algorithm to make the decision about load transfers\;
648     \ForEach{neighbor $n$}{%
649       send a control messages to $n$\;
650     }
651     ensure that the main loop does not iterate too fast\;
652   }
653 \end{algorithm}
654
655 %\paragraph{}\FIXME{ajouter des détails sur la gestion de la charge virtuelle ?
656 %  par ex, donner l'idée générale de l'implémentation.  l'idée générale est déja
657 %  décrite en section~\ref{sec.virtual-load}}
658
659 \subsection{Experimental contexts}
660 \label{sec.exp-context}
661
662 In order to assess the performances of our algorithms, simulations with various parameters have been achieved out, and several metrics are described in this section.
663
664 \subsubsection{Load balancing strategies}
665
666 Several load balancing strategies were compared.  Experiments with
667 the \besteffort{}, and with the \makhoul{} strategies have been performed.  \emph{Best
668   effort} was tested with parameter $k = 1$, $k = 2$, and $k = 4$.  Secondly,
669 each strategy was run in its two variants: with, and without the management of
670 \emph{virtual load}.  Finally, each configuration with \emph{real},
671 and with \emph{integer} load is considered.
672
673 To summarize the different load balancing strategies, we have:
674 \begin{description}
675 \item[\textbf{strategies:}] \makhoul{}, or \besteffort{} with $k\in
676   \{1,2,4\}$
677 \item[\textbf{variants:}] with, or without virtual load
678 %\item[\textbf{domain:}] real load, or integer load
679 \end{description}
680 %
681 %This gives us as many as $4\times 2\times 2 = 16$ different strategies.
682
683 \subsubsection{End of the simulation}
684
685 The simulations were run until the load was nearly balanced among the
686 participating nodes.  More precisely the simulation stops when each node holds
687 an amount of load at less than 1\% of the load average.
688 %, during an arbitrary
689 %number of computing iterations (2000 in our case).
690
691 %Note that this convergence detection was implemented in a centralized manner.
692 %This is easy to do within the simulator, but it is obviously not realistic.  In a
693 %real application we would have chosen a decentralized convergence detection
694 %algorithm, like the one described in \cite{ccl09:ij}.
695
696 \subsubsection{Platform}
697
698 %In order to show the behavior of the different strategies 
699 %in different
700 %settings, we simulated the executions on two sorts of platforms.  These two
701 %sorts of platforms differ by their network topology.  On the one hand,
702 %we have homogeneous platforms, modeled as a cluster.  On the other hand, we have
703 %heterogeneous platforms, modeled as the interconnection of a number of clusters.
704
705
706 %The clusters are modeled by a fixed number of computing nodes interconnected
707 %through a backbone link.  Each computing node has a computing power of
708 %1~GFlop/s, and is connected to the backbone by a network link whose bandwidth is
709 %of 125~MB/s, with a latency of 50~$\mu$s.  The backbone has a network bandwidth
710 %of 2.25~GB/s, with a latency of 500~$\mu$s.
711
712 In order to make our experiments, an heterogeneous platform descriptions were created by taking a subset of the
713 Grid'5000 infrastructure\footnote{Grid'5000 is a French large scale experimental
714   Grid (see \url{https://www.grid5000.fr/}).}, as described in the platform file
715 \texttt{g5k.xml} distributed with SimGrid.  Note that the heterogeneity of the
716 platform here only comes from the network topology.  Indeed, since our
717 algorithms currently do not handle heterogeneous computing resources, the
718 processor speeds were normalized, and we arbitrarily chose to fix them to
719 1~GFlop/s.
720
721 Then each kind of platform with four different numbers of computing
722 nodes: 16, 64, 256, and 1024 nodes is built in a similar way.
723
724 \subsubsection{Configurations}
725
726 The distributed processes of the application were then logically organized along
727 three possible topologies: a line, a torus or an hypercube.  Tests were performed with the total load initially on only one node (at one end for the line topology).
728 Other tests for which the load was initially randomly distributed across all the
729 participating nodes are also considered.  The total amount of load was fixed to a number of load
730 units equal to 1000 times the number of node.  The average load is then of 1000
731 load units.
732
733 For all the previous configurations, the
734 computation and communication costs of a load unit are defined.  We chose them, such as to
735 have three different computation over communication cost ratios, and hence model
736 three different kinds of applications:
737 \begin{itemize}
738 \item mainly communicating, with a computation/communication cost ratio of $1/10$;
739 \item mainly computing, with a computation/communication cost ratio of $10/1$ ;
740 \item balanced, with a computation/communication cost ratio of $1/1$.
741 \end{itemize}
742
743 % To summarize the various configurations, we have:
744 % \begin{description}
745 % \item[\textbf{platforms:}] homogeneous (cluster), or heterogeneous (subset of
746 %   Grid'5000)
747 % \item[\textbf{platform sizes:}] platforms with 16, 64, 256, or 1024 nodes
748 % \item[\textbf{process topologies:}] line, torus, or hypercube
749 % \item[\textbf{initial load distribution:}] initially on a only node, or
750 %   initially randomly distributed over all nodes
751 % \item[\textbf{computation/communication cost ratio:}] $10/1$, $1/1$, or $1/10$
752 % \end{description}
753 % %
754 % This gives us as many as $2\times 4\times 3\times 2\times 3 = 144$ different
755 % configurations.
756 % %
757 % Combined with the various load balancing strategies,  $16\times 144 =
758 % 2,304$ distinct settings have been evaluated.  In fact, as it will be shown later, only configurations with a maximum number of 1,024 nodes are considered in order to limit the time of experiments.
759
760
761 \subsubsection{Metrics}
762 \label{sec.metrics}
763
764 In order to evaluate and compare the different load balancing strategies we define several metrics.  Our goal, when choosing these metrics, is to have
765 something tending to a constant value, i.e. to have a measure which is not
766 changing anymore once the convergence state is reached.  Moreover, we want to
767 have some normalized value, in order to be able to compare them across different
768 settings.
769
770 With these constraints in mind, we define the following metrics:
771 %
772 \begin{description}
773 \item[\textbf{average idle time:}] that is the total time spent, when the nodes
774   do not hold any share of load, and thus have nothing to compute. 
775   %This total
776   %time is divided by the number of participating nodes, such as to have a number
777   %that can be compared between simulations of different sizes.
778   %This metric is expected to give an idea of the ability of the strategy to
779   %diffuse the load quickly.  
780   A smaller value is better.
781
782 \item[\textbf{average convergence time:}] that is the average of the times when
783   all nodes reached the convergence state.  Times are measured as a number
784   of (simulated) seconds since the beginning of the simulation.
785
786 \item[\textbf{maximum convergence time:}] that is the time when the last node
787   reached the convergence state.
788   %These two dates give an idea of the time needed by the strategy to reach the
789   %equilibrium state.  
790   A smaller value is better.
791
792 % \item[\textbf{data transfer amount:}] that is the sum of the amount of all data
793 %   transfers during the simulation.  This sum is then normalized by dividing it
794 %   by the total amount of data present in the system.
795
796 %   This metric is expected to give an idea of the efficiency of the strategy in
797 %   terms of data movements, i.e. its ability to reach the equilibrium with fewer
798 %   transfers.  Again, a smaller value is better.
799
800 \end{description}
801
802
803 \subsection{Experimental results}
804 \label{sec.results}
805
806 In this section, the results for the different simulations are presented,
807 and our observations are explained.
808
809 % \subsubsection{Cluster versus grid platforms}
810
811 % As mentioned earlier, different algorithms have been simulated on two kinds of
812 % physical platforms: clusters and grids.  A first observation,
813 % is that the graphs we draw from the data have a similar aspect for the two kinds
814 % of platforms.  The only noticeable difference is that the algorithms need a bit
815 % more time to achieve the convergence on the grid platforms, than on clusters.
816 % Nevertheless their relative performances remain generally similar.
817
818 % This suggests that the relative performances of the different strategies are not
819 % influenced by the characteristics of the physical platform.  The differences in
820 % the convergence times can be explained by the fact that on the grid platforms,
821 % distant sites are interconnected by links of smaller bandwidth.
822
823 % Therefore, in the following, we only discuss the results for the grid
824 % platforms.
825
826 \subsubsection{Main results}
827
828 \begin{figure*}[p]
829   \centering
830   \includegraphics[width=.5\linewidth]{data/graphs/R1-10:1-grid-line}%
831   \includegraphics[width=.5\linewidth]{data/graphs/R1-1:10-grid-line}
832   \includegraphics[width=.5\linewidth]{data/graphs/R1-10:1-grid-torus}%
833   \includegraphics[width=.5\linewidth]{data/graphs/R1-1:10-grid-torus}
834   \includegraphics[width=.5\linewidth]{data/graphs/R1-10:1-grid-hcube}%
835   \includegraphics[width=.5\linewidth]{data/graphs/R1-1:10-grid-hcube}
836   \caption{Real mode, initially on an only mode, comp/comm cost ratio = $10/1$ (left), or $1/10$ (right). For each bar, from bottom to top, the first part represents the average idle
837 time, the second part represents the average convergence time, and then the third part represents the maximum convergence time.}
838   \label{fig.results1}
839 \end{figure*}
840
841 \begin{figure*}[p]
842   \centering
843   \includegraphics[width=.5\linewidth]{data/graphs/RN-10:1-grid-line}%
844   \includegraphics[width=.5\linewidth]{data/graphs/RN-1:10-grid-line}
845   \includegraphics[width=.5\linewidth]{data/graphs/RN-10:1-grid-torus}%
846   \includegraphics[width=.5\linewidth]{data/graphs/RN-1:10-grid-torus}
847   \includegraphics[width=.5\linewidth]{data/graphs/RN-10:1-grid-hcube}%
848   \includegraphics[width=.5\linewidth]{data/graphs/RN-1:10-grid-hcube}
849   \caption{Real mode, random initial distribution, comp/comm cost ratio = $10/1$ (left), or $1/10$ (right).}
850   \label{fig.resultsN}
851 \end{figure*}
852
853 The main results for our simulations on grid platforms are presented on Figures~\ref{fig.results1} and~\ref{fig.resultsN}.
854 %
855 The results on Figure~\ref{fig.results1} are when the load to balance is
856 initially on an only node, while the results on Figure~\ref{fig.resultsN} are
857 when the load to balance is initially randomly distributed over all nodes.
858
859 On both figures, the computation/communication cost ratio is $10/1$ on the left
860 column, and $1/10$ on the right column.  With a computation/communication cost
861 ratio of $1/1$ the results are just between these two extrema, and definitely
862 don not give additional information, so we chose not to show them here.
863
864 On each of the figures~\ref{fig.results1} and~\ref{fig.resultsN}, the results
865 are given for the process topology being, from top to bottom, a line, a torus or
866 an hypercube.
867
868 Finally, on the graphs, the vertical bars show the measured times for each of
869 the algorithms.  These measured times are, from bottom to top, the average idle
870 time, the average convergence time, and the maximum convergence time (see
871 Section~\ref{sec.metrics}).  The measurements are repeated for the different
872 platform sizes.  Some bars are missing, especially for large platforms.  This is
873 either because the algorithm did not reach the convergence state in the
874 allocated time.
875
876
877 %\FIXME{annoncer le plan de la suite}
878
879 \subsubsection{The \besteffort{} and  \makhoul{} strategies without virtual load}
880
881 Before looking  at the different variations,  we will first show  that the plain
882 \besteffort{}  strategy  is valuable,  and  may be  as  good  as the  \makhoul{}
883 strategy.  On  Figures~\ref{fig.results1} and~\ref{fig.resultsN},
884 these strategies are respectively labeled ``b'' and ``a''.
885
886 We  can  see  that  the  relative  performance of  these  strategies  is  mainly
887 influenced by  the application topology.  It  is for the line  topology that the
888 difference is the  more important.  In this case,  the \besteffort{} strategy is
889 nearly faster than the \makhoul{} strategy.  This can  be explained by the
890 fact that the \besteffort{} strategy tries to distribute the load fairly between
891 all the nodes  and with the line topology,  it is easy to load  balance the load
892 fairly.
893
894 On the contrary, for the hypercube topology, the \besteffort{} strategy performs
895 worse than the \makhoul{} strategy. In this case, the \makhoul{} strategy which
896 tries to give more load to few neighbors reaches the equilibrium faster.
897
898 For the torus  topology, for which the  number of links is between  the line and
899 the hypercube, the \makhoul{} strategy  is slightly better but the difference is
900 more nuanced when the initial load is  only on one node. The only case where the
901 \makhoul{} strategy is really faster than the \besteffort{} strategy is with the
902 random initial distribution when the communication are slow.
903
904 Globally   the  number  of   interconnection  is   very  important.    The  more
905 the interconnection links are, the  faster the \makhoul{} strategy is because
906 it distributes quickly significant amount of load, even if this is unfair, between
907 all the  neighbors.  In opposition,  the \besteffort{} strategy  distributes the
908 load fairly so this strategy is better for low connected strategy.
909
910
911
912
913
914 \subsubsection{Virtual load}
915
916 The influence of virtual load is most of the time really significant compared to
917 the  same configuration  without  it. Sometimes  it  has no  effect  but, based on our observations,  it has never a negative effect on the load balancing we tested.
918
919 On Figure~\ref{fig.results1}, when the load is  initially on one node, it can be
920 noticed that the  average idle times are generally longer  with the virtual load
921 than without  it. This  can be explained  by the  fact that, with  virtual load,
922 processors  will exchange all  the load  they need  to exchange  as soon  as the
923 virtual load has been balanced  between all the processors. So consequently they
924 cannot  compute  at  the  beginning.  This is  especially  noticeable  when  the
925 communication are slow (on the left part of Figure ~\ref{fig.results1}.
926
927 On Figure \ref{fig.resultsN} when the load to balance is initially randomly distributed over all nodes, we can see that the effect of virtual load is not significant for the line. For the torus with the mainly communicating case (on the left of the figure), the effect of the virtual load is very significant. For the hypercube, in any case, the effect of the virtual load is visible. It is more visible when communications have a more important role (i.e. with the mainly communicating case).
928
929
930 %Dans ce cas  légère amélioration de la cvg. max.  Temps  moyen de cvg. amélioré,
931 %mais plus de temps passé en idle, surtout quand les comms coutent cher.
932
933 %\subsubsection{The \besteffort{} strategy with an initial random load
934 %  distribution, and larger platforms}
935
936 %In 
937 %Mêmes conclusions pour line et hcube.
938 %Sur tore, BE se fait exploser quand les comms coutent cher.
939
940 %\FIXME{virer les 1024 ?}
941
942 %\subsubsection{With the virtual load extension with an initial random load
943 %  distribution}
944
945 %Soit c'est équivalent, soit on gagne -> surtout quand les comms coutent cher et
946 %qu'il y a beaucoup de voisins.
947
948 \subsubsection{The $k$ parameter}
949 \label{results-k}
950
951 As  explained  previously when  the  communication  are  slow the  \besteffort{}
952 strategy is efficient. This is due to the fact that it tries to balance the load
953 fairly and consequently  a significant amount of the  load is transferred between
954 processors.  In this situation, it is possible to reduce the convergence time by
955 using  the leveler  parameter  (parameter  $k$).  The  advantage  of using  this
956 solution is particularly efficient when the initial load is randomly distributed
957 on  the nodes with  torus and  hypercube topologies  and slow  communication. When
958 virtual load  mechanism is used,  the effect of  this parameter is  also visible
959 with the same condition. However, sometimes this parameter may have a negative effect on the convergence time.
960
961
962
963
964 \subsubsection{With integer load}
965
966 We also performed  some experiments with integer load instead  of load with real
967 value.  In  this case, the  results have globally  the same behavior, that is why we decided not to show similar figures.   The most
968 interesting  result, from  our point  of view,  is that  the virtual  mode allows
969 processors in a line topology to converge to the uniform load balancing. Without
970 the virtual  load, most  of the time,  processors converge  to what we  call the
971 ``stairway effect'', that  is to say that  there is only a difference  of one in
972 the load of each processor and its neighbors (for example with 10 processors, we
973 obtain 10 9 8 7 6 6 7 8 9 10 instead of 8 8 8 8 8 8 8 8 8 8).
974
975 %Cas normal, ligne -> converge pas (effet d'escalier).
976 %Avec vload, ça converge.
977
978 %Dans les autres cas, résultats similaires au cas réel: redire que vload est
979 %intéressant.
980
981 %\FIXME{ajouter une courbe avec l'équilibrage en entier}
982
983 %\FIXME{virer la metrique volume de comms}
984
985 %\FIXME{ajouter une courbe ou on voit l'évolution de la charge en fonction du  temps : avec et sans vload}
986
987 % \begin{itemize}
988 % \item cluster ou grid, entier ou réel, ne font pas de grosses différences
989 % \item bookkeeping? améliore souvent les choses, parfois au prix d'un retard au démarrage
990 % \item makhoul? se fait battre sur les grosses plateformes
991 % \item taille de plateforme?
992 % \item ratio comp/comm?
993 % \item option $k$? peut-être intéressant sur des plateformes fortement interconnectées (hypercube)
994 % \item volume de comm? souvent, besteffort/plain en fait plus. pourquoi?
995 % \item répartition initiale de la charge ?
996 % \item integer mode sur topo. line n'a jamais fini en plain? vérifier si ce n'est
997 %   pas à cause de l'effet d'escalier que bk est capable de gommer.
998 % \end{itemize}}
999
1000 % On veut montrer quoi ? :
1001
1002 % 1) best plus rapide que les autres (simple, makhoul)
1003 % 2) avantage virtual load
1004
1005 % Est ce qu'on peut trouver des contre exemple?
1006 % Topologies variées
1007
1008
1009 % Simulation avec temps définies assez long et on mesure la qualité avec : volume de calcul effectué, volume de données échangées
1010 % Mais aussi simulation avec temps court qui montre que seul best converge
1011
1012 % Expés avec ratio calcul/comm rapide et lent
1013
1014 % Quelques expés avec charge initiale aléatoire plutot que sur le premier proc
1015
1016 % Cadre processeurs homogènes
1017
1018 % Topologies statiques
1019
1020 % On ne tient pas compte de la vitesse des liens donc on la considère homogène
1021
1022 % Prendre un réseau hétérogène et rendre processeur homogène
1023
1024 % Taille : 10 100 très gros
1025
1026 \section{Conclusion}
1027 \label{conclusions-remarks}
1028
1029 In this paper, we have presented a new asynchronous load balancing algorithm for non negative real numbers
1030 of divisible loads in distributed systems. The proposed algorithm which is called {\it best effort strategy} 
1031 seeks greedily for loads imbalance detection and tries to achieve efficient local equilibrium threshold 
1032 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. 
1033 This leads to a noticeable speedup of the global convergence time of the load balancing process. 
1034 Based on SimGrid simulator, we have demonstrated that, when we deal with realistic models of computation and communication, our algorithm exhibits better performances than its direct competitors 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.
1035
1036 \section*{Acknowledgments}
1037
1038 This  paper  is   partially  funded  by  the  Labex   ACTION  program  (contract
1039 ANR-11-LABX-01-01).  We also thank the supercomputer facilities of the Mésocentre de calcul de Franche-Comté.
1040  
1041 \bibliographystyle{elsarticle-num}
1042 \bibliography{biblio}
1043 %\FIXME{find and add more references}
1044
1045 \end{document}
1046
1047 %%% Local Variables:
1048 %%% mode: latex
1049 %%% TeX-master: t
1050 %%% fill-column: 80
1051 %%% ispell-local-dictionary: "american"
1052 %%% End:
1053
1054 % LocalWords:  Raphaël Couturier Arnaud Giersch Franche ij Bertsekas Tsitsiklis
1055 % LocalWords:  SimGrid DASUD Comté asynchronism ji ik isend irecv Cortés et al
1056 % LocalWords:  chan ctrl fifo Makhoul GFlop xml pre FEMTO Makhoul's fca bdee
1057 % LocalWords:  cdde Contassot Vivier underlaid du de Maréchal Juin cedex calcul
1058 % LocalWords:  biblio Institut UMR Université UFC Centre Scientifique CNRS des
1059 % LocalWords:  École Nationale Supérieure Mécanique Microtechniques ENSMM UTBM
1060 % LocalWords:  Technologie Bahi