[sharelatex-git-integration Best effort strategy and virtual load for asynchronous...

[loba-papers.git] / loba-besteffort / loba-besteffort.tex

diff --git a/loba-besteffort/loba-besteffort.tex b/loba-besteffort/loba-besteffort.tex
index c387ad6e62bee5e66175f1220104360944bb12e4..dae1d4176f8d638068b34577525dc3702592aff1 100644 (file)
--- a/loba-besteffort/loba-besteffort.tex
+++ b/loba-besteffort/loba-besteffort.tex
@@ -28,7 +28,7 @@
 \newcommand{\VAR}[1]{\textit{#1}}
 
 \newcommand{\besteffort}{\emph{best effort}}
 \newcommand{\VAR}[1]{\textit{#1}}
 
 \newcommand{\besteffort}{\emph{best effort}}

-\newcommand{\makhoul}{\emph{Makhoul}}
+\newcommand{\makhoul}{\emph{naive}}

 
 \begin{document}
 
 
 \begin{document}
 


@@ -40,40 +40,44 @@
   asynchronous iterative load balancing}
 
 \author{Raphaël Couturier}
   asynchronous iterative load balancing}
 
 \author{Raphaël Couturier}

-\ead{raphael.couturier@femto-st.fr}
+\ead{raphael.couturier@univ-fcomte.fr}

 
 \author{Arnaud Giersch\corref{cor}}
 
 \author{Arnaud Giersch\corref{cor}}

-\ead{arnaud.giersch@femto-st.fr}
+\ead{arnaud.giersch@univ-fcomte.fr}
+
+\author{Mourad Hakem}
+\ead{mourad.hakem@univ-fcomte.fr}

 
 \address{%
 
 \address{%

-  Institut FEMTO-ST (UMR 6174),
-  Université de Franche-Comté (UFC),
-  Centre National de la Recherche Scientifique (CNRS),
-  École Nationale Supérieure de Mécanique et des Microtechniques (ENSMM),
-  Université de Technologie de Belfort Montbéliard (UTBM)\\
-  19 avenue du Maréchal Juin, BP 527, 90016 Belfort cedex, France}
+  FEMTO-ST Institute, Univ Bourgogne Franche-Comté, Belfort, France}

 
 \cortext[cor]{Corresponding author.}
 
 \begin{abstract}
   Most of the time, asynchronous load balancing algorithms have extensively been
   studied in a theoretical point of view. The Bertsekas and Tsitsiklis'
 
 \cortext[cor]{Corresponding author.}
 
 \begin{abstract}
   Most of the time, asynchronous load balancing algorithms have extensively been
   studied in a theoretical point of view. The Bertsekas and Tsitsiklis'

-  algorithm~\cite[section~7.4]{bertsekas+tsitsiklis.1997.parallel} is certainly
-  the most well known algorithm for which the convergence proof is given. From a
-  practical point of view, when a node wants to balance a part of its load to
-  some of its neighbors, the strategy is not described.  In this paper, we
-  propose a strategy called \besteffort{} which tries to balance the load
+  algorithm~\cite
+  %[section~7.4]
+  {bertsekas+tsitsiklis.1997.parallel} is undeniably 
+  the most well known algorithm for which the asymptotic convergence proof is given. 
+  From a
+  practical point of view, when a node needs to balance a part of its load to
+  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
+  propose a new strategy called \besteffort{} which tries to balance the load

   of a node to all its less loaded neighbors while ensuring that all the nodes
   of a node to all its less loaded neighbors while ensuring that all the nodes

-  concerned by the load balancing phase have the same amount of load.  Moreover,
-  asynchronous iterative algorithms in which an asynchronous load balancing
-  algorithm is implemented most of the time can dissociate messages concerning
-  load transfers and message concerning load information.  In order to increase
-  the converge of a load balancing algorithm, we propose a simple heuristic
-  called \emph{virtual load} which allows a node that receives a load
-  information message to integrate the load that it will receive later in its
-  load (virtually) and consequently sends a (real) part of its load to some of
-  its neighbors.  In order to validate our approaches, we have defined a
-  simulator based on SimGrid which allowed us to conduct many experiments.
+  involved by the load balancing phase have the same amount of load. Moreover, since 
+  asynchronous iterative algorithms are less sensitive to communications delays 
+  and their variations, both load transfer and load information messages are dissociated. 
+  To speedup the convergence time of the load balancing process, we propose {\it a clairvoyant virtual load} heuristic which allows 
+  %asynchronous iterative algorithms, in which an asynchronous load balancing
+  %algorithm is implemented, can dissociate, most of the time, messages concerning
+  %load transfers and message concerning load information.  In order to increase
+  %the converge of a load balancing algorithm, we propose a simple heuristic
+  %called \emph{virtual load}. This heuristic allows 
+  a node that receives a load
+  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.  Consequently the node sends a real part of its load to some of
+  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
+ % simulator based on SimGrid which allowed us to conduct many experiments.

 \end{abstract}
 
 % \begin{keywords}
 \end{abstract}
 
 % \begin{keywords}


@@ -84,91 +88,195 @@
 
 \section{Introduction}
 
 
 \section{Introduction}
 

-Load  balancing algorithms  are  extensively used  in  parallel and  distributed
-applications in  order to  reduce the  execution times. They  can be  applied in
-different scientific  fields from high  performance computation to  micro sensor
-networks.   They are  iterative by  nature.\FIXME{really?}
-In  literature many  kinds  of load
-balancing  algorithms  have been  studied.   They  can  be classified  according
-different  criteria:   centralized  or  decentralized,  in   static  or  dynamic
-environment,  with  homogeneous  or  heterogeneous load,  using  synchronous  or
-asynchronous iterations, with  a static topology or a  dynamic one which evolves
-during time.  In  this work, we focus on  asynchronous load balancing algorithms
-where computer nodes  are considered homogeneous and with  homogeneous load with
-no external  load. In  this context, Bertsekas  and Tsitsiklis have  proposed an
-algorithm which is definitively a reference  for many works. In their work, they
-proved that under classical  hypotheses of asynchronous iterative algorithms and
-a  special  constraint   avoiding  \emph{ping-pong}  effect,  an  asynchronous
-iterative algorithm  converge to  the uniform load  distribution. This  work has
-been extended by many authors. For example, Cortés et al., with
-DASUD~\cite{cortes+ripoll+cedo+al.2002.asynchronous}, propose a
-version working with integer load.  This work was later generalized by
-the same authors in \cite{cedo+cortes+ripoll+al.2007.convergence}.
-\FIXME{Rajouter des choses ici.  Lesquelles ?}
-
-Although  the Bertsekas  and Tsitsiklis'  algorithm describes  the  condition to
-ensure the convergence,  there is no indication or  strategy to really implement
-the load distribution. In other word, a node  can send a part of its load to one
+Load  balancing algorithms  are  widely used  in  parallel and  distributed
+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 
+computing systems to wireless sensor networks (WSN). 
+The objective of load balancing is to orchestrate the distribution of the global workload so that 
+the load difference between the computational resources of the network is 
+minimized as low as possible. Unfortunately, this problem is known to be {\bf NP-Hard} in its 
+general forms and heuristics are required to achieve sub-optimal solutions but in 
+polynomial time complexity. 
+
+In this paper, we focus on asynchronous load balancing of non negative real numbers of {\it divisible loads}
+in homogeneous distributed systems. Loads can be divided in arbitrary {\it fine-grain} parallel parts size 
+that can be processed independently of each other. This model of divisible loads arise in 
+a wide range of real-world applications. Common examples among many, include signal processing, 
+feature extraction and edge detection in image processing, records search in a huge databases, 
+average consensus in WSN, pattern search in Big data and so on. % c'est pout toi raphael ;-)
+
+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. 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.
+
+
+
+
+%in  order to  reduce the  execution times. They  can be  applied in
+%different scientific  fields from high  performance computation to  micro sensor
+%networks.   In a distributed context (i.e. without centralization), they are  iterative by  nature.
+%In  literature many  kinds  of load
+%balancing  algorithms  have been  studied.   They  can  be classified  according
+%different  criteria:   centralized  or  decentralized,  in   static  or  dynamic
+%environment,  with  homogeneous  or  heterogeneous load,  using  synchronous  or
+%asynchronous iterations, with  a static topology or a  dynamic one which evolves
+%during time.  In  this work, we focus on  asynchronous load balancing algorithms
+%where computing nodes  are considered homogeneous and with  homogeneous load with
+%no external  load. 
+
+
+%In  this context, Bertsekas  and Tsitsiklis have  proposed an
+%algorithm which is definitively a reference for many works. In their work, they
+%proved that under classical  hypotheses of asynchronous iterative algorithms and
+%a  special  constraint   avoiding  \emph{ping-pong}  effect,  an  asynchronous
+%iterative algorithm  converges to  the uniform load  distribution. This  work has
+%been extended by many authors. For example, Cortés et al., with
+%DASUD~\cite{cortes+ripoll+cedo+al.2002.asynchronous}, propose a
+%version working with integer load.  This work was later generalized by
+%the same authors in \cite{cedo+cortes+ripoll+al.2007.convergence}.
+%\FIXME{Rajouter des choses ici.  Lesquelles ?}
+
+Although  Bertsekas  and Tsitsiklis'  describe  the necessary conditions to
+ensure the algorithm's convergence,  there is no indication or any strategy to really implement
+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. Consequently,  we propose a  new strategy called  \besteffort{}
 that tries to balance the load of  a node to all its less loaded neighbors while
 or   many  of   its  neighbors   while  all   the  convergence   conditions  are
 followed. Consequently,  we propose a  new strategy called  \besteffort{}
 that tries to balance the load of  a node to all its less loaded neighbors while

-ensuring that all the nodes concerned  by the load balancing phase have the same
-amount of  load.  Moreover, when real asynchronous  applications are considered,
-using  asynchronous   load  balancing   algorithms  can  reduce   the  execution
-times. Most of the times, it is simpler to distinguish load information messages
+ensuring that all the nodes involved in the load balancing phase have the same
+amount of  load.  Moreover, %when real-world asynchronous  applications are considered,
+%using  asynchronous load  balancing  algorithms  can  reduce   the  execution
+%times. 
+most of the times, it is simpler to dissociate load information messages

 from  data  migration  messages.  Former  ones  allow  a  node to  inform  its
 from  data  migration  messages.  Former  ones  allow  a  node to  inform  its

-neighbors of its  current load. These messages are very small,  they can be sent
-quite often.  For example, if a computing iteration takes  a significant times
+neighbors about its  current load. These messages are in fact very small and can be sent 
+often and very quickly.  For example, if a computing iteration takes  a significant times

 (ranging from seconds to minutes), it is possible to send a new load information
 (ranging from seconds to minutes), it is possible to send a new load information

-message to each  neighbor at each iteration. Latter  messages contain data that
-migrates from one node to another one. Depending on the application, it may have
+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

 sense or not  that nodes try to balance  a part of their load  at each computing
 iteration. But the time to transfer a load message from a node to another one is
 sense or not  that nodes try to balance  a part of their load  at each computing
 iteration. But the time to transfer a load message from a node to another one is

-often much more longer that to  time to transfer a load information message. So,
-when a node receives the information  that later it will receive a data message,
-it can take this information into account  and it can consider that its new load
-is larger.   Consequently, it can  send a part  of it real  load to some  of its
-neighbors if required. We call this trick the \emph{virtual load} mechanism.
-
-So, in this work, we propose a new strategy to improve the distribution of the
-load and a simple but efficient trick that also improves the load
-balancing. Moreover, we have conducted many simulations with SimGrid in order to
-validate that our improvements are really efficient. Our simulations consider
-that in order to send a message, a latency delays the sending and according to
-the network performance and the message size, the time of the reception of the
-message also varies.
-
-In the following of this paper, Section~\ref{sec.bt-algo} describes the
-Bertsekas and Tsitsiklis' asynchronous load balancing algorithm. Moreover, we
-present a possible problem in the convergence conditions.
-Section~\ref{sec.besteffort} presents the best effort strategy which provides an
-efficient way to reduce the execution times.  This strategy will be compared
-with other ones, presented in Section~\ref{sec.other}.  In
-Section~\ref{sec.virtual-load}, the virtual load mechanism is proposed.
-Simulations allowed to show that both our approaches are valid using a quite
-realistic model detailed in Section~\ref{sec.simulations}.  Finally we give a
-conclusion and some perspectives to this work.
+often much more longer that the  time to transfer a load information message. So,
+when a node is notified 
+%receives the information  
+that later it will receive a data message,
+it can take this information into account in its load's queue list for preventive purposes.
+%and it can consider that its new load is larger.   
+Consequently, it can  send a part  of its predictive
+%real 
+load to some  of its
+neighbors if required. We call this trick the \emph{clairvoyant virtual load} transfer mechanism.
+
+\medskip 
+The main contributions and novelties of our work are summarized in the following section. 
+
+\subsection{Our contributions}
+
+
+\begin{itemize}
+\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.     
+
+\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. 
+This leads to a noticeable speedup of the global convergence time of the load balancing process.  
+
+\item We use SimGrid simulator which is known to be able to characterize and modelize 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. 
+
+%\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 ...
+\end{itemize}
+
+
+%{\bf The contributions of this paper are the following:}
+%\begin{itemize}
+%\item We propose a new strategy to improve the distribution of the
+%load and a simple but efficient trick that also improves the load
+%balancing.
+%\item we have conducted many simulations with SimGrid in order to
+%validate that our improvements are really efficient. Our simulations consider
+%that in order to send a message, a latency delays the sending and according to
+%the network performance and the message size, the time of the reception of the
+%message also varies.
+%\end{itemize}
+
+The reminder of the paper is organized as follows. 
+In Section~\ref{sec.related.works}, we review the relevant related works in load balancing. Section~\ref{sec.bt-algo} describes the
+Bertsekas and Tsitsiklis' asynchronous load balancing algorithm. %Moreover, we  present a possible problem in the convergence conditions. 
+Section~\ref{sec.besteffort} presents the best effort strategy which provides
+efficient local loads equilibrium. This strategy will be compared with other existing competitor ones, presented in Section~\ref{sec.other}.  In
+Section~\ref{sec.virtual-load}, the clairvoyant virtual load scheme is proposed to speedup the convergence time of the load balancing process.
+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}.
+
+
+\section{Related works}
+\label{sec.related.works}
+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. 
+
+
+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
+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.

 
 
 
 

+Choi et al.~\cite{ChoiBH09} address the problem of robust task allocation in arbitrary networks. The proposed
+approaches combine bidding approach for task selection and consensus procedure scheme for
+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.
+
+
+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. 
+
+
+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.
+
+
+Cybenko~\cite{Cybenko89} propose a {\it diffusion} approach for hypercube multiprocessor networks. 
+The author targets both static and dynamic random models of work distribution. 
+The convergence proof is derived based on the {\it eigenstructure} of the 
+iteration matrices that arise in load balancing of equal amount of
+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.
+
+%\medskip 
+%{\bf ****** 2 references will be added ******}

 
 \section{Bertsekas  and Tsitsiklis' asynchronous load balancing algorithm}
 \label{sec.bt-algo}
 
 
 \section{Bertsekas  and Tsitsiklis' asynchronous load balancing algorithm}
 \label{sec.bt-algo}
 

-In  order  prove  the  convergence  of  asynchronous  iterative  load  balancing
-Bertsekas         and        Tsitsiklis         proposed         a        model
-in~\cite{bertsekas+tsitsiklis.1997.parallel}.   Here we  recall  some notations.
-Consider  that  $N={1,...,n}$  processors   are  connected  through  a  network.
-Communication links  are represented by  a connected undirected  graph $G=(N,A)$
-where $A$ is the set of links connecting different processors. In this work, we
-consider that  processors are  homogeneous for sake  of simplicity. It  is quite
-easy to tackle the  heterogeneous case~\cite{ElsMonPre02}. Load of processor $i$
+In this section, we present a brief description of Bertsekas and Tsitsiklis' algorithm~\cite{bertsekas+tsitsiklis.1997.parallel} using its original notations. 
+A network is modeled as a connected undirected graph $G=(N,A)$, where $N$ is set 
+of processors and $A$ is a set of communication links. The processors are 
+labeled $i = 1,...,n$, and a link between processors $i$ and
+$j$ is denoted by $(i, j)\in A$. In this work, we
+consider that  processors are  homogeneous for sake of simplicity.
+It is easily extendable to the case of heterogeneous platforms 
+by scaling the processor's load by its computing power~\cite{ElsMonPre02}.
+%In  order  prove  the  convergence  of  asynchronous  iterative  load  balancing
+%Bertsekas         and        Tsitsiklis         proposed         a        model
+%in~\cite{bertsekas+tsitsiklis.1997.parallel}.   Here we  recall  some notations.
+%Consider  that  $N={1,...,n}$  processors   are  connected  through  a  network.
+%Communication links  are represented by  a connected undirected  graph $G=(N,A)$
+%where $A$ is the set of links connecting different processors. 
+%In this work, we
+%consider that  processors are  homogeneous for sake  of simplicity. It  is quite
+%easy to tackle the  heterogeneous case~\cite{ElsMonPre02}. 
+Load of processor $i$

 at  time $t$  is  represented  by $x_i(t)\geq  0$.   Let $V(i)$  be  the set  of
 neighbors of processor  $i$.  Each processor $i$ has an estimate  of the load of
 at  time $t$  is  represented  by $x_i(t)\geq  0$.   Let $V(i)$  be  the set  of
 neighbors of processor  $i$.  Each processor $i$ has an estimate  of the load of

-each  of its  neighbors $j  \in V(i)$  represented by  $x_j^i(t)$.  According to
-asynchronism and communication  delays, this estimate may be  outdated.  We also
-consider that the load is described by a continuous variable.
-
-When a processor  send a part of its  load to one or some of  its neighbors, the
+each  of its  neighbors $j  \in V(i)$  denoted by  $x_j^i(t)$ and this estimate 
+may be outdated due to %.  According to
+asynchronism and communication  delays. 
+%, this estimate may be  outdated.  
+%We also
+%consider that the load is described by a continuous variable.
+Since we deal with large  {\it fine grain} parallelism of divisible loads, 
+the processor's load is represented by a continuous variable for notational 
+convenience.  
+
+When a processor  sends a part of its  load to one or some of  its neighbors, the

 transfer takes time to be completed.  Let $s_{ij}(t)$ be the amount of load that
 processor $i$ has transferred to processor $j$ at time $t$ and let $r_{ij}(t)$ be the
 amount of  load received by processor $j$  from processor $i$ at  time $t$. Then
 transfer takes time to be completed.  Let $s_{ij}(t)$ be the amount of load that
 processor $i$ has transferred to processor $j$ at time $t$ and let $r_{ij}(t)$ be the
 amount of  load received by processor $j$  from processor $i$ at  time $t$. Then


@@ -178,6 +286,9 @@ x_i(t+1)=x_i(t)-\sum_{j\in V(i)} s_{ij}(t) + \sum_{j\in V(i)} r_{ji}(t)
 \label{eq.ping-pong}
 \end{equation}
 
 \label{eq.ping-pong}
 \end{equation}
 

+\medskip 
+{\bf ****** je suis arrivé ici ******** la conclusion est déjà écrite ******}
+\medskip

 
 Some  conditions are  required to  ensure the  convergence. One  of them  can be
 called the \emph{ping-pong} condition which specifies that:
 
 Some  conditions are  required to  ensure the  convergence. One  of them  can be
 called the \emph{ping-pong} condition which specifies that:


@@ -198,6 +309,8 @@ chain which 3 processors). Now consider we have the following values at time $t$
   x_3(t)   &= 99.99 \\
   x_3^2(t) &= 99.99 \\
 \end{align*}
   x_3(t)   &= 99.99 \\
   x_3^2(t) &= 99.99 \\
 \end{align*}

+{\bf RAPH, pourquoi il y a $x_3^2$?. Sinon il faudra reformuler la suite, c'est mal dit}
+

 In this case, processor $2$ can either sends load to processor $1$ or processor
 $3$.  If it sends load to processor $1$ it will not satisfy condition
 \eqref{eq.ping-pong} because after the sending it will be less loaded that
 In this case, processor $2$ can either sends load to processor $1$ or processor
 $3$.  If it sends load to processor $1$ it will not satisfy condition
 \eqref{eq.ping-pong} because after the sending it will be less loaded that


@@ -213,6 +326,8 @@ It may be the subject of future work to express weaker conditions, and to prove
 that they are sufficient to ensure the convergence of the load-balancing
 algorithm.
 
 that they are sufficient to ensure the convergence of the load-balancing
 algorithm.
 

+
+

 \section{Best effort strategy}
 \label{sec.besteffort}
 
 \section{Best effort strategy}
 \label{sec.besteffort}
 


@@ -233,21 +348,20 @@ he proceeds as following.
 \item First, the neighbors are sorted in non-decreasing order of their
   known loads $x^i_j(t)$.
 
 \item First, the neighbors are sorted in non-decreasing order of their
   known loads $x^i_j(t)$.
 

-\item Then, this sorted list is traversed in order to find its largest
-  prefix such as the load of each selected neighbor is lesser than:
+\item Then, this sorted list is used to find its largest
+  prefix such as the load of each selected neighbor is smaller than:

   \begin{itemize}
   \begin{itemize}

-  \item the processor's own load, and
+  \item the load of processor $i$, and

   \item the mean of the loads of the selected neighbors and of the
     processor's load.
   \end{itemize}
   \item the mean of the loads of the selected neighbors and of the
     processor's load.
   \end{itemize}

-  Let's call $S_i(t)$ the set of the selected neighbors, and
-  $\bar{x}(t)$ the mean of the loads of the selected neighbors and of
-  the processor load:
+  Let $S_i(t)$ be the set of the selected neighbors, and
+  $\bar{x}(t)$ be the mean of the loads of the selected neighbors plus the load of processor $i$:

   \begin{equation*}
     \bar{x}(t) = \frac{1}{\abs{S_i(t)} + 1}
       \left( x_i(t) + \sum_{j\in S_i(t)} x^i_j(t) \right)
   \end{equation*}
   \begin{equation*}
     \bar{x}(t) = \frac{1}{\abs{S_i(t)} + 1}
       \left( x_i(t) + \sum_{j\in S_i(t)} x^i_j(t) \right)
   \end{equation*}

-  The following properties hold:
+  The following properties hold: {\bf RAPH : la suite tombe du ciel :-)}

   \begin{equation*}
     \begin{cases}
       S_i(t) \subset V(i) \\
   \begin{equation*}
     \begin{cases}
       S_i(t) \subset V(i) \\


@@ -284,8 +398,8 @@ In order to reduce this effect, we add the ability to level the amount to send.
 The idea, here, is to make smaller steps toward the equilibrium, such that a
 potentially wrong decision has a lower impact.
 
 The idea, here, is to make smaller steps toward the equilibrium, such that a
 potentially wrong decision has a lower impact.
 

-Concretely, once $s_{ij}$ has been evaluated as before, it is simply divided by
-some configurable factor.  That's what we named the ``parameter $k$'' in
+Roughtly speaking, once $s_{ij}$ has been evaluated as previously explained, it is simply divided by
+a given factor.  This parameter is called $k$ in

 Section~\ref{sec.results}.  The amount of data to send is then $s_{ij}(t) =
 (\bar{x} - x^i_j(t))/k$.
 \FIXME[check that it's still named $k$ in Sec.~\ref{sec.results}]{}
 Section~\ref{sec.results}.  The amount of data to send is then $s_{ij}(t) =
 (\bar{x} - x^i_j(t))/k$.
 \FIXME[check that it's still named $k$ in Sec.~\ref{sec.results}]{}


@@ -299,9 +413,9 @@ previously developed by Bahi, Giersch, and Makhoul in
 of the new \besteffort{}, we naturally chose to compare it to this anterior
 work.  More precisely, we will use the algorithm~2 from
 \cite{bahi+giersch+makhoul.2008.scalable} and, in the following, we will
 of the new \besteffort{}, we naturally chose to compare it to this anterior
 work.  More precisely, we will use the algorithm~2 from
 \cite{bahi+giersch+makhoul.2008.scalable} and, in the following, we will

-reference it under the name of Makhoul's.
+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}

 
 

-Here is an outline of the Makhoul's algorithm.  When a given node needs to take
+Here is an outline of the \makhoul{} algorithm.  When a given node needs to take

 a load balancing decision, it starts by sorting its neighbors by increasing
 order of their load.  Then, it computes the difference between its own load, and
 the load of each of its neighbors.  Finally, taking the neighbors following the
 a load balancing decision, it starts by sorting its neighbors by increasing
 order of their load.  Then, it computes the difference between its own load, and
 the load of each of its neighbors.  Finally, taking the neighbors following the


@@ -326,10 +440,10 @@ require more time to be transferred.
 
 The  concept  of  \emph{virtual load}  allows  a  node  that received  a  load
 information message to integrate the load that it will receive later in its load
 
 The  concept  of  \emph{virtual load}  allows  a  node  that received  a  load
 information message to integrate the load that it will receive later in its load

-(virtually)  and consequently send  a (real)  part of  its load  to some  of its
+(virtually). Consequently the considered node can send  a (real)  part of  its load  to some  of its

 neighbors. In fact,  a node that receives a load  information message knows that
 later it  will receive the  corresponding load balancing message  containing the
 neighbors. In fact,  a node that receives a load  information message knows that
 later it  will receive the  corresponding load balancing message  containing the

-corresponding data.  So  if this node detects it is too  loaded compared to some
+corresponding data.  So, if this node detects it is too  loaded compared to some

 of its neighbors  and if it has enough  load (real load), then it  can send more
 load  to  some of  its  neighbors  without waiting  the  reception  of the  load
 balancing message.
 of its neighbors  and if it has enough  load (real load), then it  can send more
 load  to  some of  its  neighbors  without waiting  the  reception  of the  load
 balancing message.


@@ -337,9 +451,11 @@ balancing message.
 Doing  this, we  can  expect a  faster  convergence since  nodes  have a  faster
 information of the load they will receive, so they can take it into account.
 
 Doing  this, we  can  expect a  faster  convergence since  nodes  have a  faster
 information of the load they will receive, so they can take it into account.
 

-\FIXME{Est ce qu'on donne l'algo avec virtual load?}
+%\FIXME{Est ce qu'on donne l'algo avec virtual load?}
+
+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.

 
 

-\FIXME{describe integer mode}
+%\FIXME{describe integer mode}

 
 \section{Simulations}
 \label{sec.simulations}
 
 \section{Simulations}
 \label{sec.simulations}


@@ -428,7 +544,7 @@ Algorithm~\ref{algo.comp}, it iteratively runs the following operations:
 \begin{itemize}
 \item if some load was received from the neighbors, get it;
 \item if there is some load to send to the neighbors, send it;
 \begin{itemize}
 \item if some load was received from the neighbors, get it;
 \item if there is some load to send to the neighbors, send it;

-\item run some computation, whose duration is function of the current
+\item run some computations, whose duration is function of the current

   load of the processor.
 \end{itemize}
 Practically, after the computation, the computing thread waits for a
   load of the processor.
 \end{itemize}
 Practically, after the computation, the computing thread waits for a


@@ -494,25 +610,23 @@ iteratively runs the following operations:
   }
 \end{algorithm}
 
   }
 \end{algorithm}
 

-\paragraph{}\FIXME{ajouter des détails sur la gestion de la charge virtuelle ?
-  par ex, donner l'idée générale de l'implémentation.  l'idée générale est déja
-  décrite en section~\ref{sec.virtual-load}}
+%\paragraph{}\FIXME{ajouter des détails sur la gestion de la charge virtuelle ?
+%  par ex, donner l'idée générale de l'implémentation.  l'idée générale est déja
+%  décrite en section~\ref{sec.virtual-load}}

 
 \subsection{Experimental contexts}
 \label{sec.exp-context}
 
 
 \subsection{Experimental contexts}
 \label{sec.exp-context}
 

-In order to assess the performances of our algorithms, we ran our
-simulator with various parameters, and extracted several metrics, that
-we will describe in this section.
+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.

 
 \subsubsection{Load balancing strategies}
 
 
 \subsubsection{Load balancing strategies}
 

-Several load balancing strategies were compared.  We ran the experiments with
-the \besteffort{}, and with the \makhoul{} strategies.  \emph{Best
+Several load balancing strategies were compared.  Experiments with
+the \besteffort{}, and with the \makhoul{} strategies have been performed.  \emph{Best

   effort} was tested with parameter $k = 1$, $k = 2$, and $k = 4$.  Secondly,
 each strategy was run in its two variants: with, and without the management of
   effort} was tested with parameter $k = 1$, $k = 2$, and $k = 4$.  Secondly,
 each strategy was run in its two variants: with, and without the management of

-\emph{virtual load}.  Finally, we tested each configuration with \emph{real},
-and with \emph{integer} load.
+\emph{virtual load}.  Finally, each configuration with \emph{real},
+and with \emph{integer} load is considered.

 
 To summarize the different load balancing strategies, we have:
 \begin{description}
 
 To summarize the different load balancing strategies, we have:
 \begin{description}


@@ -532,20 +646,19 @@ an amount of load at less than 1\% of the load average, during an arbitrary
 number of computing iterations (2000 in our case).
 
 Note that this convergence detection was implemented in a centralized manner.
 number of computing iterations (2000 in our case).
 
 Note that this convergence detection was implemented in a centralized manner.

-This is easy to do within the simulator, but it's obviously not realistic.  In a
+This is easy to do within the simulator, but it is obviously not realistic.  In a

 real application we would have chosen a decentralized convergence detection
 real application we would have chosen a decentralized convergence detection

-algorithm, like the one described by Bahi, Contassot-Vivier, Couturier, and
-Vernier in \cite{10.1109/TPDS.2005.2}.
+algorithm, like the one described in \cite{ccl09:ij}.

 
 \subsubsection{Platforms}
 
 In order to show the behavior of the different strategies in different
 settings, we simulated the executions on two sorts of platforms.  These two
 
 \subsubsection{Platforms}
 
 In order to show the behavior of the different strategies in different
 settings, we simulated the executions on two sorts of platforms.  These two

-sorts of platforms differ by their underlaid network topology.  On the one hand,
+sorts of platforms differ by their network topology.  On the one hand,

 we have homogeneous platforms, modeled as a cluster.  On the other hand, we have
 heterogeneous platforms, modeled as the interconnection of a number of clusters.
 
 we have homogeneous platforms, modeled as a cluster.  On the other hand, we have
 heterogeneous platforms, modeled as the interconnection of a number of clusters.
 

-The clusters were modeled by a fixed number of computing nodes interconnected
+The clusters are modeled by a fixed number of computing nodes interconnected

 through a backbone link.  Each computing node has a computing power of
 1~GFlop/s, and is connected to the backbone by a network link whose bandwidth is
 of 125~MB/s, with a latency of 50~$\mu$s.  The backbone has a network bandwidth
 through a backbone link.  Each computing node has a computing power of
 1~GFlop/s, and is connected to the backbone by a network link whose bandwidth is
 of 125~MB/s, with a latency of 50~$\mu$s.  The backbone has a network bandwidth


@@ -560,21 +673,20 @@ algorithms currently do not handle heterogeneous computing resources, the
 processor speeds were normalized, and we arbitrarily chose to fix them to
 1~GFlop/s.
 
 processor speeds were normalized, and we arbitrarily chose to fix them to
 1~GFlop/s.
 

-Then we derived each kind of platform with four different numbers of computing
-nodes: 16, 64, 256, and 1024 nodes.
+Then each kind of platform with four different numbers of computing
+nodes: 16, 64, 256, and 1024 nodes is built in a similar way.

 
 \subsubsection{Configurations}
 
 The distributed processes of the application were then logically organized along
 
 \subsubsection{Configurations}
 
 The distributed processes of the application were then logically organized along

-three possible topologies: a line, a torus or an hypercube.  We ran tests where
-the total load was initially on an only node (at one end for the line topology),
-and other tests where the load was initially randomly distributed across all the
-participating nodes.  The total amount of load was fixed to a number of load
+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).
+Other tests for which the load was initially randomly distributed across all the
+participating nodes are also considered.  The total amount of load was fixed to a number of load

 units equal to 1000 times the number of node.  The average load is then of 1000
 load units.
 
 units equal to 1000 times the number of node.  The average load is then of 1000
 load units.
 

-For each of the preceding configuration, we finally had to choose the
-computation and communication costs of a load unit.  We chose them, such as to
+For all the previous configurations, the
+computation and communication costs of a load unit are defined.  We chose them, such as to

 have three different computation over communication cost ratios, and hence model
 three different kinds of applications:
 \begin{itemize}
 have three different computation over communication cost ratios, and hence model
 three different kinds of applications:
 \begin{itemize}


@@ -597,14 +709,9 @@ To summarize the various configurations, we have:
 This gives us as many as $2\times 4\times 3\times 2\times 3 = 144$ different
 configurations.
 %
 This gives us as many as $2\times 4\times 3\times 2\times 3 = 144$ different
 configurations.
 %

-Combined with the various load balancing strategies, we had $16\times 144 =
-2304$ distinct settings to evaluate.  In fact, as it will be shown later, we
-didn't run all the strategies, nor all the configurations for the bigger
-platforms with 1024 nodes, since to simulations would have run for a too long
-time.
+Combined with the various load balancing strategies,  $16\times 144 =
+2304$ distinct settings have been evaluated.  In fact, as it will be shown later, only configations with a maximum number of 1,024 nodes are considered in order to limit the time of experiments.

 
 

-Anyway, all these the experiments represent more than 240 hours of computing
-time.

 
 \subsubsection{Metrics}
 \label{sec.metrics}
 
 \subsubsection{Metrics}
 \label{sec.metrics}


@@ -656,19 +763,19 @@ and we will try to explain our observations.
 
 \subsubsection{Cluster vs grid platforms}
 
 
 \subsubsection{Cluster vs grid platforms}
 

-As mentioned earlier, we simulated the different algorithms on two kinds of
+As mentioned earlier, different algorithms have been simulated on two kinds of

 physical platforms: clusters and grids.  A first observation that we can make,
 is that the graphs we draw from the data have a similar aspect for the two kinds
 of platforms.  The only noticeable difference is that the algorithms need a bit
 more time to achieve the convergence on the grid platforms, than on clusters.
 physical platforms: clusters and grids.  A first observation that we can make,
 is that the graphs we draw from the data have a similar aspect for the two kinds
 of platforms.  The only noticeable difference is that the algorithms need a bit
 more time to achieve the convergence on the grid platforms, than on clusters.

-Nevertheless their relative performances remain generally identical.
+Nevertheless their relative performances remain generally similar.

 
 This suggests that the relative performances of the different strategies are not
 influenced by the characteristics of the physical platform.  The differences in
 the convergence times can be explained by the fact that on the grid platforms,
 distant sites are interconnected by links of smaller bandwidth.
 
 
 This suggests that the relative performances of the different strategies are not
 influenced by the characteristics of the physical platform.  The differences in
 the convergence times can be explained by the fact that on the grid platforms,
 distant sites are interconnected by links of smaller bandwidth.
 

-Therefore, in the following, we'll only discuss the results for the grid
+Therefore, in the following, we will only discuss the results for the grid

 platforms.
 
 \subsubsection{Main results}
 platforms.
 
 \subsubsection{Main results}


@@ -707,7 +814,7 @@ when the load to balance is initially randomly distributed over all nodes.
 On both figures, the computation/communication cost ratio is $10/1$ on the left
 column, and $1/10$ on the right column.  With a computation/communication cost
 ratio of $1/1$ the results are just between these two extrema, and definitely
 On both figures, the computation/communication cost ratio is $10/1$ on the left
 column, and $1/10$ on the right column.  With a computation/communication cost
 ratio of $1/1$ the results are just between these two extrema, and definitely

-don't give additional information, so we chose not to show them here.
+don not give additional information, so we chose not to show them here.

 
 On each of the figures~\ref{fig.results1} and~\ref{fig.resultsN}, the results
 are given for the process topology being, from top to bottom, a line, a torus or
 
 On each of the figures~\ref{fig.results1} and~\ref{fig.resultsN}, the results
 are given for the process topology being, from top to bottom, a line, a torus or


@@ -865,9 +972,15 @@ obtain 10 9 8 7 6 6 7 8 9 10 instead of 8 8 8 8 8 8 8 8 8 8).
 
 % Taille : 10 100 très gros
 
 
 % Taille : 10 100 très gros
 

-\section{Conclusion and perspectives}
+\section{Conclusion}
+\label{conclusions-remarks}

 
 

-\FIXME{conclude!}
+In this paper, we have presented a new asynchronous load balancing algorithm for non negative real numbers
+of divisible loads in distributed systems. The proposed algorithm which is called {\it best effort strategy} 
+seeks greedily for loads imbalance detection and tries to achieve efficient local equilibrium threshold 
+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. 
+This leads to a noticeable speedup of the global convergence time of the load balancing process. 
+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.

 
 \section*{Acknowledgments}
 
 
 \section*{Acknowledgments}