Graphs: rename makhoul -> Bertsekas and Tsitsiklis.

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

diff --git a/loba-besteffort/loba-besteffort.tex b/loba-besteffort/loba-besteffort.tex
index dae1d4176f8d638068b34577525dc3702592aff1..55e877c52f0e96dd4b0069d47659a9c497e2e4f6 100644 (file)
--- a/loba-besteffort/loba-besteffort.tex
+++ b/loba-besteffort/loba-besteffort.tex
@@ -2,7 +2,7 @@
 
 \usepackage[utf8]{inputenc}
 \usepackage[T1]{fontenc}
 
 \usepackage[utf8]{inputenc}
 \usepackage[T1]{fontenc}

-
+\usepackage{comment}

 %\usepackage{newtxtext}
 %\usepackage[cmintegrals]{newtxmath}
 \usepackage{mathptmx,helvet,courier}
 %\usepackage{newtxtext}
 %\usepackage[cmintegrals]{newtxmath}
 \usepackage{mathptmx,helvet,courier}


@@ -63,19 +63,18 @@
   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
   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
-  involved by the load balancing phase have the same amount of load. Moreover, since 
+  propose a new strategy called \besteffort{} which aims to balance the load
+  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 

   asynchronous iterative algorithms are less sensitive to communications delays 
   asynchronous iterative algorithms are less sensitive to communications delays 

-  and their variations, both load transfer and load information messages are dissociated. 
+  and their variations \cite{bcvc07:bc}, 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 
   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
+  a node receiving 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 at each iteration of the load balancing process.  Consequently, the notified 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}
   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}


@@ -93,7 +92,7 @@ applications to achieve high performances in terms of response time, throughput
 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 
 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 
+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. 
 
 general forms and heuristics are required to achieve sub-optimal solutions but in 
 polynomial time complexity. 
 


@@ -104,11 +103,11 @@ a wide range of real-world applications. Common examples among many, include sig
 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 ;-)
 
 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 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. 
+\begin{comment}
+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.
+\end{comment}

 %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  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.


@@ -120,8 +119,6 @@ In the literature, the problem of load balancing has been formulated and studied
 %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. 
 %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
 %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


@@ -132,12 +129,10 @@ In the literature, the problem of load balancing has been formulated and studied
 %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 ?}
 %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
 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{}
+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
 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,
 that tries to balance the load of  a node to all its less loaded neighbors while
 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,


@@ -165,16 +160,15 @@ neighbors if required. We call this trick the \emph{clairvoyant virtual load} tr
 \medskip 
 The main contributions and novelties of our work are summarized in the following section. 
 
 \medskip 
 The main contributions and novelties of our work are summarized in the following section. 
 

-\subsection{Our contributions}
-
-
+\section{Our contributions}
+\label{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.  
 
 \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 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. 

 
 %\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}
 
 %\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}


@@ -193,11 +187,11 @@ This leads to a noticeable speedup of the global convergence time of the load ba
 %\end{itemize}
 
 The reminder of the paper is organized as follows. 
 %\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
+In Section~\ref{sec.related.works}, we review the relevant approaches in the literature. 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
 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.
+efficient local loads equilibrium. %This strategy will be compared with the one 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}.
 
 
 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}.
 
 


@@ -205,43 +199,31 @@ We provide in Section~\ref{sec.simulations}, a comprehensive set of numerical re
 \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. 
 
 \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. 
 

+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.

 
 

-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.  
-
+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.

 
 

-Bidding is a market-technique for task scheduling and load balancing in 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
 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.
-
+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.

 
 

+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. 

 
 

-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.

 
 

-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}


@@ -250,8 +232,9 @@ In this section, we present a brief description of Bertsekas and Tsitsiklis' alg
 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
 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.
+$j$ is denoted by $(i, j)\in A$. The set of neighbors of processor $i$ is denoted by $V(i)$.
+%In this work, we consider that  
+Processors are  considered to be homogeneous for the 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
 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


@@ -264,86 +247,121 @@ by scaling the processor's load by its computing power~\cite{ElsMonPre02}.
 %consider that  processors are  homogeneous for sake  of simplicity. It  is quite
 %easy to tackle the  heterogeneous case~\cite{ElsMonPre02}. 
 Load of processor $i$
 %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)$  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.
 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.  

 
 

+%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.  
+\medskip

 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
 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
+amount of  load received by  $j$  from  $i$ at  time $t$. Then

 the amount of load of processor $i$ at time $t+1$ is given by:
 the amount of load of processor $i$ at time $t+1$ is given by:

+

 \begin{equation}
 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}
 
 \begin{equation}
 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}
 

-\medskip 
-{\bf ****** je suis arrivé ici ******** la conclusion est déjà écrite ******}
+
+%Some  conditions are  required to  ensure the  convergence. One  of them  can be
+%called the \emph{ping-pong} condition which specifies that:

 \medskip
 \medskip

+The asymptotic convergence is derived based on the {\it ping-pong} awareness 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:

 \begin{equation}
 x_i(t)-\sum _{k\in V(i)} s_{ik}(t) \geq x_j^i(t)+s_{ij}(t)
 \end{equation}
 \begin{equation}
 x_i(t)-\sum _{k\in V(i)} s_{ik}(t) \geq x_j^i(t)+s_{ij}(t)
 \end{equation}

-for any  processor $i$ and any  $j \in V(i)$ such  that $x_i(t)>x_j^i(t)$.  This
-condition aims  at avoiding a processor  to send a  part of its load  and being
-less loaded after that.

 
 

+for any  processor $i$ and any  $j \in V(i)$ such  that $x_i(t)>x_j^i(t)$.  
+%This condition aims  at avoiding a processor  to send a  part of its load  and being
+%less loaded after that.
+
+\medskip
+This condition prohibits the possibility that two nodes keep sending load to each
+other back and forth, without reaching equilibrium. 
+
+\medskip

 Nevertheless,  we  think that  this  condition may  lead  to  deadlocks in  some
 Nevertheless,  we  think that  this  condition may  lead  to  deadlocks in  some

-cases. For example, if we consider  only three processors and that processor $1$
-is linked to processor $2$ which is  also linked to processor $3$ (i.e. a simple
-chain which 3 processors). Now consider we have the following values at time $t$:
+cases. For example, if we consider a linear chain graph network of only three processors and that processor $1$
+is linked to processor $2$ which is  also linked to processor $3$, but processors $1$ and $3$ are not neighbors. 
+%(i.e. a simple chain which 3 processors). 
+Now consider that we have the following load values at time~$t$:

 \begin{align*}
   x_1(t)   &= 10    \\
   x_2(t)   &= 100   \\
   x_3(t)   &= 99.99 \\
 \begin{align*}
   x_1(t)   &= 10    \\
   x_2(t)   &= 100   \\
   x_3(t)   &= 99.99 \\

-  x_3^2(t) &= 99.99 \\
+  x_3^2(t) &= 99.99 

 \end{align*}
 \end{align*}

-{\bf RAPH, pourquoi il y a $x_3^2$?. Sinon il faudra reformuler la suite, c'est mal dit}
+%{\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
-$x_3^2(t)$.  So we consider that the \emph{ping-pong} condition is probably to
-strong. Currently, we did not try to make another convergence proof without this
-condition or with a weaker condition.
+Owing to the algorithm's specification, 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 that sending it will be less loaded than
+$x_3^2(t)$.  So we consider that the \emph{ping-pong} condition is probably too
+strong. %Currently, we did not try to make another convergence proof without this condition or with a weaker condition.

 
 

-Nevertheless, we conjecture that such a weaker condition exists.  In fact, we
+\smallskip  
+Nevertheless, we conjecture that a weaker condition may exist since we

 have never seen any scenario that is not leading to convergence, even with
 have never seen any scenario that is not leading to convergence, even with

-load-balancing strategies that are not exactly fulfilling these two conditions.
+load-balancing strategies that are not exactly fulfilling the authors' own conditions. %se two conditions.
+
+%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.

 
 

-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.
+\smallskip

 
 

+Although this approach is interesting, several practical
+questions arise when dealing with realistic models of 
+computation and communication. As reported above, the 
+algorithm's description is too succinct and no details are 
+given on what is really sent and how the load balancing decision 
+are taken. To our knowledge, the only first attempt for a possible 
+implementation of this algorithm is investigated in~\cite{bahi+giersch+makhoul.2008.scalable} under the same conditions. Thus, in order to assess the performances
+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, through out the paper, we will
+reference it under the original name {\it Bertsekas and Tsitsiklis} for the sake of convenience and readability. 
+
+\smallskip 
+Here is an outline of the main principle of the borrowed algorithm.  When a given node  $i$ has to take
+a load balancing decision, it starts by sorting its neighbors by non-increasing
+order of their loads.  Then, it computes the difference between its own load, and
+the load of each of its neighbors.  Finally, taking the neighbors following the
+order defined before, the amount of load to send $s_{ij}$ is computed as
+$1/(|V(i)|+1)$ of the load difference%, with $n$ being the number of neighbors
+. This process is iterated as long as the node is more loaded than the considered
+neighbors.

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

-In this section we describe a new load-balancing strategy that we call
+In this section, we describe a new load-balancing strategy that we call

 \besteffort{}.  First, we explain the general idea behind this strategy,
 \besteffort{}.  First, we explain the general idea behind this strategy,

-and then we describe some variants of this basic strategy.
+and then we present some variants of this basic strategy.

 
 \subsection{Basic strategy}
 
 \subsection{Basic strategy}

-
-The general idea behind the \besteffort{} strategy is that each processor,
+The description of our algorithm will be given from the point of view a processor~$i$.
+The principle of the \besteffort{} strategy is that each processor,

 that detects it has more load than some of its neighbors, sends some load to the
 most of its less loaded neighbors, doing its best to reach the equilibrium
 that detects it has more load than some of its neighbors, sends some load to the
 most of its less loaded neighbors, doing its best to reach the equilibrium

-between those neighbors and himself.
+between the involved neighbors and itself.

 
 

-More precisely, when a processor $i$ is in its load-balancing phase,
-he proceeds as following.
+More precisely, %when a processor $i$ is in its load-balancing phase,
+at each iteration of the load balancing process, processor~$i$ 
+ proceeds as follows.

 \begin{enumerate}
 \item First, the neighbors are sorted in non-decreasing order of their
   known loads $x^i_j(t)$.
 \begin{enumerate}
 \item First, the neighbors are sorted in non-decreasing order of their
   known loads $x^i_j(t)$.


@@ -352,16 +370,15 @@ he proceeds as following.
   prefix such as the load of each selected neighbor is smaller than:
   \begin{itemize}
   \item the load of processor $i$, and
   prefix such as the load of each selected neighbor is smaller than:
   \begin{itemize}
   \item the load of processor $i$, and

-  \item the mean of the loads of the selected neighbors and of the
-    processor's load.
+  \item the mean of the loads of the selected neighbors and processor i.

   \end{itemize}
   Let $S_i(t)$ be the set of the selected neighbors, and
   \end{itemize}
   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$:
+  $\bar{x}(t)$ be the mean of the loads between the selected neighbors and processor $i$ is given as follows:

   \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: {\bf RAPH : la suite tombe du ciel :-)}
+  so that 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) \\


@@ -372,12 +389,14 @@ he proceeds as following.
     \end{cases}
   \end{equation*}
 
     \end{cases}
   \end{equation*}
 

-\item Once this selection is completed, processor $i$ sends to each of
-  the selected neighbor $j\in S_i(t)$ an amount of load $s_{ij}(t) =
+\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) =

   \bar{x} - x^i_j(t)$.
 
   \bar{x} - x^i_j(t)$.
 

-  From the above equations, and notably from the definition of
-  $\bar{x}$, it can easily be verified that:
+  %From the above equations, and notably from the definition of $\bar{x}$, it can easily be verified that:
+  
+  \smallskip
+  In this way we obtain: 
+  

   \begin{equation*}
     \begin{cases}
       x_i(t) - \sum_{j\in S_i(t)} s_{ij}(t) = \bar{x} \\
   \begin{equation*}
     \begin{cases}
       x_i(t) - \sum_{j\in S_i(t)} s_{ij}(t) = \bar{x} \\


@@ -386,78 +405,101 @@ he proceeds as following.
   \end{equation*}
 \end{enumerate}
 
   \end{equation*}
 \end{enumerate}
 

-\subsection{Leveling the amount to send}
+
+
+\subsection{Leveling the amount of load to move}

 
 With the aforementioned basic strategy, each node does its best to reach the
 
 With the aforementioned basic strategy, each node does its best to reach the

-equilibrium with its neighbors.  Since each node may be taking the same kind of
-decision at the same moment, there is the risk that a node receives load from
+equilibrium with its neighbors. However, one question should be outlined here:
+How can we handle the case where two (or more) node initiators that may send 
+concurrently some amount of loads to the the same less loaded neighbor? Indeed,  
+%since each node may take the same kind of decision at the same time, 
+there is a risk that a node will receive load from

 several of its neighbors, and then is temporary going off the equilibrium state.
 This is particularly true with strongly connected applications.
 
 several of its neighbors, and then is temporary going off the equilibrium state.
 This is particularly true with strongly connected applications.
 

-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.

 
 

-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
+
+In order to reduce this effect, we add the ability to level the amount of load to send.
+The idea, here, is to make as few steps as possible toward the equilibrium, such that a
+potentially unsuitable decision pointed above has a lower impact on the local equilibrium.
+Roughly speaking, once $s_{ij}$ is estimated as previously explained, it is simply weighted by
+a given prescribed threshold parameter which we call 
+%.  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}]{}
 

-\section{Other strategies}
-\label{sec.other}

 
 

-Another load balancing strategy, working under the same conditions, was
-previously developed by Bahi, Giersch, and Makhoul in
-\cite{bahi+giersch+makhoul.2008.scalable}.  In order to assess the performances
-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 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{} 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
-order defined before, the amount of load to send $s_{ij}$ is computed as
-$1/(n+1)$ of the load difference, with $n$ being the number of neighbors.  This
-process continues as long as the node is more loaded than the considered
-neighbor.
+%\section{Other strategies}
+%\label{sec.other}
+
+%Another load balancing strategy, working under the same conditions, was
+%previously developed by Bahi, Giersch, and Makhoul in
+%\cite{bahi+giersch+makhoul.2008.scalable}.  In order to assess the performances
+%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 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{} 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
+%order defined before, the amount of load to send $s_{ij}$ is computed as
+%$1/(n+1)$ of the load difference, with $n$ being the number of neighbors.  This
+%process continues as long as the node is more loaded than the considered
+%neighbor.

 
 
 \section{Virtual load}
 \label{sec.virtual-load}
 
 
 
 \section{Virtual load}
 \label{sec.virtual-load}
 

-In this section,  we present the concept of \emph{virtual load}.  In order to
-use this concept, load balancing messages must be sent using two different kinds
-of  messages:  load information  messages  and  load  balancing messages.   More
-precisely, a node wanting to send a part of its load to one of its neighbors
-can first send a load information message containing the load it will send, and
-then it can send the load  balancing message containing data  to be transferred.
-Load information  message are really  short, consequently they will  be received
-very quickly.  In opposition, load  balancing messages are often bigger and thus
+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. 
+%In order to
+%use this concept, load balancing messages must be sent using two different kinds
+%of  messages:  load information  messages  and  load  balancing messages.   
+More
+precisely, a node wanting to send some amount of its load to one (or more) of its neighbors
+can first send a load information message about the load it will send, and
+later it can send the load  message containing data to be transferred.
+Load information  messages are in fact short
+%, consequently they 
+and will be received soon.
+%very quickly.  
+In contrast, load  transfer messages are often larger ones and thus

 require more time to be transferred.
 
 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
-(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
-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.
+The  concept  of  \emph{virtual load}  allows  a  node receiving a  load
+information message to integrate (virtually) the future load it will receive later in its load's list
+ 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
+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 
+into account the information about the predictive loads not 
+received yet.
+
+% repetition !
+%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
+%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.

 
 

-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.
+%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}
+\section{Implementation with SimGrid and simulations}

 \label{sec.simulations}
 
 In order to test and validate our approaches, we wrote a simulator
 \label{sec.simulations}
 
 In order to test and validate our approaches, we wrote a simulator


@@ -633,38 +675,41 @@ To summarize the different load balancing strategies, we have:
 \item[\textbf{strategies:}] \makhoul{}, or \besteffort{} with $k\in
   \{1,2,4\}$
 \item[\textbf{variants:}] with, or without virtual load
 \item[\textbf{strategies:}] \makhoul{}, or \besteffort{} with $k\in
   \{1,2,4\}$
 \item[\textbf{variants:}] with, or without virtual load

-\item[\textbf{domain:}] real load, or integer load
+%\item[\textbf{domain:}] real load, or integer load

 \end{description}
 %
 \end{description}
 %

-This gives us as many as $4\times 2\times 2 = 16$ different strategies.
+%This gives us as many as $4\times 2\times 2 = 16$ different strategies.

 
 \subsubsection{End of the simulation}
 
 The simulations were run until the load was nearly balanced among the
 participating nodes.  More precisely the simulation stops when each node holds
 
 \subsubsection{End of the simulation}
 
 The simulations were run until the load was nearly balanced among the
 participating nodes.  More precisely the simulation stops when each node holds

-an amount of load at less than 1\% of the load average, during an arbitrary
-number of computing iterations (2000 in our case).
+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.
+%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
+%algorithm, like the one described in \cite{ccl09:ij}.

 
 

-Note that this convergence detection was implemented in a centralized manner.
-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
-algorithm, like the one described in \cite{ccl09:ij}.
+\subsubsection{Platform}

 
 

-\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 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.

 
 

-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 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.

 
 

-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
-of 2.25~GB/s, with a latency of 500~$\mu$s.
+%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
+%of 2.25~GB/s, with a latency of 500~$\mu$s.

 
 

-The heterogeneous platform descriptions were created by taking a subset of the
+In order to make our experiments, an heterogeneous platform descriptions were created by taking a subset of the

 Grid'5000 infrastructure\footnote{Grid'5000 is a French large scale experimental
   Grid (see \url{https://www.grid5000.fr/}).}, as described in the platform file
 \texttt{g5k.xml} distributed with SimGrid.  Note that the heterogeneity of the
 Grid'5000 infrastructure\footnote{Grid'5000 is a French large scale experimental
   Grid (see \url{https://www.grid5000.fr/}).}, as described in the platform file
 \texttt{g5k.xml} distributed with SimGrid.  Note that the heterogeneity of the


@@ -695,62 +740,62 @@ three different kinds of applications:
 \item balanced, with a computation/communication cost ratio of $1/1$.
 \end{itemize}
 
 \item balanced, with a computation/communication cost ratio of $1/1$.
 \end{itemize}
 

-To summarize the various configurations, we have:
-\begin{description}
-\item[\textbf{platforms:}] homogeneous (cluster), or heterogeneous (subset of
-  Grid'5000)
-\item[\textbf{platform sizes:}] platforms with 16, 64, 256, or 1024 nodes
-\item[\textbf{process topologies:}] line, torus, or hypercube
-\item[\textbf{initial load distribution:}] initially on a only node, or
-  initially randomly distributed over all nodes
-\item[\textbf{computation/communication cost ratio:}] $10/1$, $1/1$, or $1/10$
-\end{description}
-%
-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,  $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.
+% To summarize the various configurations, we have:
+% \begin{description}
+% \item[\textbf{platforms:}] homogeneous (cluster), or heterogeneous (subset of
+%   Grid'5000)
+% \item[\textbf{platform sizes:}] platforms with 16, 64, 256, or 1024 nodes
+% \item[\textbf{process topologies:}] line, torus, or hypercube
+% \item[\textbf{initial load distribution:}] initially on a only node, or
+%   initially randomly distributed over all nodes
+% \item[\textbf{computation/communication cost ratio:}] $10/1$, $1/1$, or $1/10$
+% \end{description}
+% %
+% 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,  $16\times 144 =
+% 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.

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

-In order to evaluate and compare the different load balancing strategies we had
-to define several metrics.  Our goal, when choosing these metrics, was to have
+In order to evaluate and compare the different load balancing strategies we define several metrics.  Our goal, when choosing these metrics, is to have

 something tending to a constant value, i.e. to have a measure which is not
 something tending to a constant value, i.e. to have a measure which is not

-changing anymore once the convergence state is reached.  Moreover, we wanted to
+changing anymore once the convergence state is reached.  Moreover, we want to

 have some normalized value, in order to be able to compare them across different
 settings.
 
 have some normalized value, in order to be able to compare them across different
 settings.
 

-With these constraints in mind, we defined the following metrics:
+With these constraints in mind, we define the following metrics:

 %
 \begin{description}
 %
 \begin{description}

-\item[\textbf{average idle time:}] that's the total time spent, when the nodes
-  don't hold any share of load, and thus have nothing to compute.  This total
-  time is divided by the number of participating nodes, such as to have a number
-  that can be compared between simulations of different sizes.
-
-  This metric is expected to give an idea of the ability of the strategy to
-  diffuse the load quickly.  A smaller value is better.
-
-\item[\textbf{average convergence date:}] that's the average of the dates when
-  all nodes reached the convergence state.  The dates are measured as a number
+\item[\textbf{average idle time:}] that is the total time spent, when the nodes
+  do not hold any share of load, and thus have nothing to compute. 
+  %This total
+  %time is divided by the number of participating nodes, such as to have a number
+  %that can be compared between simulations of different sizes.
+  %This metric is expected to give an idea of the ability of the strategy to
+  %diffuse the load quickly.  
+  A smaller value is better.
+
+\item[\textbf{average convergence time:}] that is the average of the times when
+  all nodes reached the convergence state.  Times are measured as a number

   of (simulated) seconds since the beginning of the simulation.
 
   of (simulated) seconds since the beginning of the simulation.
 

-\item[\textbf{maximum convergence date:}] that's the date when the last node
+\item[\textbf{maximum convergence time:}] that is the time when the last node

   reached the convergence state.
   reached the convergence state.

+  %These two dates give an idea of the time needed by the strategy to reach the
+  %equilibrium state.  
+  A smaller value is better.

 
 

-  These two dates give an idea of the time needed by the strategy to reach the
-  equilibrium state.  A smaller value is better.
-
-\item[\textbf{data transfer amount:}] that's the sum of the amount of all data
-  transfers during the simulation.  This sum is then normalized by dividing it
-  by the total amount of data present in the system.
+% \item[\textbf{data transfer amount:}] that is the sum of the amount of all data
+%   transfers during the simulation.  This sum is then normalized by dividing it
+%   by the total amount of data present in the system.

 
 

-  This metric is expected to give an idea of the efficiency of the strategy in
-  terms of data movements, i.e. its ability to reach the equilibrium with fewer
-  transfers.  Again, a smaller value is better.
+%   This metric is expected to give an idea of the efficiency of the strategy in
+%   terms of data movements, i.e. its ability to reach the equilibrium with fewer
+%   transfers.  Again, a smaller value is better.

 
 \end{description}
 
 
 \end{description}
 


@@ -758,25 +803,25 @@ With these constraints in mind, we defined the following metrics:
 \subsection{Experimental results}
 \label{sec.results}
 
 \subsection{Experimental results}
 \label{sec.results}
 

-In this section, the results for the different simulations will be presented,
-and we will try to explain our observations.
+In this section, the results for the different simulations are presented,
+and our observations are explained.

 
 

-\subsubsection{Cluster vs grid platforms}
+% \subsubsection{Cluster versus grid platforms}

 
 

-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.
-Nevertheless their relative performances remain generally similar.
+% As mentioned earlier, different algorithms have been simulated on two kinds of
+% physical platforms: clusters and grids.  A first observation,
+% 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 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 will only discuss the results for the grid
-platforms.
+% Therefore, in the following, we only discuss the results for the grid
+% platforms.

 
 \subsubsection{Main results}
 
 
 \subsubsection{Main results}
 


@@ -788,7 +833,8 @@ platforms.
   \includegraphics[width=.5\linewidth]{data/graphs/R1-1:10-grid-torus}
   \includegraphics[width=.5\linewidth]{data/graphs/R1-10:1-grid-hcube}%
   \includegraphics[width=.5\linewidth]{data/graphs/R1-1:10-grid-hcube}
   \includegraphics[width=.5\linewidth]{data/graphs/R1-1:10-grid-torus}
   \includegraphics[width=.5\linewidth]{data/graphs/R1-10:1-grid-hcube}%
   \includegraphics[width=.5\linewidth]{data/graphs/R1-1:10-grid-hcube}

-  \caption{Real mode, initially on an only mode, comp/comm cost ratio = $10/1$ (left), or $1/10$ (right).}
+  \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
+time, the second part represents the average convergence time, and then the third part represents the maximum convergence time.}

   \label{fig.results1}
 \end{figure*}
 
   \label{fig.results1}
 \end{figure*}
 


@@ -804,11 +850,10 @@ platforms.
   \label{fig.resultsN}
 \end{figure*}
 
   \label{fig.resultsN}
 \end{figure*}
 

-The main results for our simulations on grid platforms are presented on the
-figures~\ref{fig.results1} and~\ref{fig.resultsN}.
+The main results for our simulations on grid platforms are presented on Figures~\ref{fig.results1} and~\ref{fig.resultsN}.

 %
 %

-The results on figure~\ref{fig.results1} are when the load to balance is
-initially on an only node, while the results on figure~\ref{fig.resultsN} are
+The results on Figure~\ref{fig.results1} are when the load to balance is
+initially on an only node, while the results on Figure~\ref{fig.resultsN} are

 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
 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


@@ -822,13 +867,14 @@ an hypercube.
 
 Finally, on the graphs, the vertical bars show the measured times for each of
 the algorithms.  These measured times are, from bottom to top, the average idle
 
 Finally, on the graphs, the vertical bars show the measured times for each of
 the algorithms.  These measured times are, from bottom to top, the average idle

-time, the average convergence date, and the maximum convergence date (see
+time, the average convergence time, and the maximum convergence time (see

 Section~\ref{sec.metrics}).  The measurements are repeated for the different
 Section~\ref{sec.metrics}).  The measurements are repeated for the different

-platform sizes.  Some bars are missing, specially for large platforms.  This is
+platform sizes.  Some bars are missing, especially for large platforms.  This is

 either because the algorithm did not reach the convergence state in the
 either because the algorithm did not reach the convergence state in the

-allocated time, or because we simply decided not to run it.
+allocated time.

 
 

-\FIXME{annoncer le plan de la suite}
+
+%\FIXME{annoncer le plan de la suite}

 
 \subsubsection{The \besteffort{} and  \makhoul{} strategies without virtual load}
 
 
 \subsubsection{The \besteffort{} and  \makhoul{} strategies without virtual load}
 


@@ -862,11 +908,13 @@ all the  neighbors.  In opposition,  the \besteffort{} strategy  distributes the
 load fairly so this strategy is better for low connected strategy.
 
 
 load fairly so this strategy is better for low connected strategy.
 
 

+
+
+

 \subsubsection{Virtual load}
 
 The influence of virtual load is most of the time really significant compared to
 \subsubsection{Virtual load}
 
 The influence of virtual load is most of the time really significant compared to

-the  same configuration  without  it. Sometimes  it  has no  effect  but {\bf  A
-  VERIFIER} it has never a negative effect on the load balancing we tested.
+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.

 
 On Figure~\ref{fig.results1}, when the load is  initially on one node, it can be
 noticed that the  average idle times are generally longer  with the virtual load
 
 On Figure~\ref{fig.results1}, when the load is  initially on one node, it can be
 noticed that the  average idle times are generally longer  with the virtual load


@@ -876,6 +924,9 @@ virtual load has been balanced  between all the processors. So consequently they
 cannot  compute  at  the  beginning.  This is  especially  noticeable  when  the
 communication are slow (on the left part of Figure ~\ref{fig.results1}.
 
 cannot  compute  at  the  beginning.  This is  especially  noticeable  when  the
 communication are slow (on the left part of Figure ~\ref{fig.results1}.
 

+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).
+
+

 %Dans ce cas  légère amélioration de la cvg. max.  Temps  moyen de cvg. amélioré,
 %mais plus de temps passé en idle, surtout quand les comms coutent cher.
 
 %Dans ce cas  légère amélioration de la cvg. max.  Temps  moyen de cvg. amélioré,
 %mais plus de temps passé en idle, surtout quand les comms coutent cher.
 


@@ -899,21 +950,22 @@ communication are slow (on the left part of Figure ~\ref{fig.results1}.
 
 As  explained  previously when  the  communication  are  slow the  \besteffort{}
 strategy is efficient. This is due to the fact that it tries to balance the load
 
 As  explained  previously when  the  communication  are  slow the  \besteffort{}
 strategy is efficient. This is due to the fact that it tries to balance the load

-fairly and consequently  a significant amount of the  load is transfered between
+fairly and consequently  a significant amount of the  load is transferred between

 processors.  In this situation, it is possible to reduce the convergence time by
 using  the leveler  parameter  (parameter  $k$).  The  advantage  of using  this
 solution is particularly efficient when the initial load is randomly distributed
 processors.  In this situation, it is possible to reduce the convergence time by
 using  the leveler  parameter  (parameter  $k$).  The  advantage  of using  this
 solution is particularly efficient when the initial load is randomly distributed

-on  the nodes with  torus and  hypercube topology  and slow  communication. When
+on  the nodes with  torus and  hypercube topologies  and slow  communication. When

 virtual load  mechanism is used,  the effect of  this parameter is  also visible
 virtual load  mechanism is used,  the effect of  this parameter is  also visible

-with the same condition.
+with the same condition. However, sometimes this parameter may have a negative effect on the convergence time.
+

 
 
 
 \subsubsection{With integer load}
 
 We also performed  some experiments with integer load instead  of load with real
 
 
 
 \subsubsection{With integer load}
 
 We also performed  some experiments with integer load instead  of load with real

-value.  In  this case, the  results have globally  the same behavior.   The most
-intereting  result, from  our point  of view,  is that  the virtual  mode allows
+value.  In  this case, the  results have globally  the same behavior, that is why we decided not to show similar figures.   The most
+interesting  result, from  our point  of view,  is that  the virtual  mode allows

 processors in a line topology to converge to the uniform load balancing. Without
 the virtual  load, most  of the time,  processors converge  to what we  call the
 ``stairway effect'', that  is to say that  there is only a difference  of one in
 processors in a line topology to converge to the uniform load balancing. Without
 the virtual  load, most  of the time,  processors converge  to what we  call the
 ``stairway effect'', that  is to say that  there is only a difference  of one in


@@ -926,12 +978,11 @@ obtain 10 9 8 7 6 6 7 8 9 10 instead of 8 8 8 8 8 8 8 8 8 8).
 %Dans les autres cas, résultats similaires au cas réel: redire que vload est
 %intéressant.
 
 %Dans les autres cas, résultats similaires au cas réel: redire que vload est
 %intéressant.
 

-\FIXME{ajouter une courbe avec l'équilibrage en entier}
+%\FIXME{ajouter une courbe avec l'équilibrage en entier}

 
 

-\FIXME{virer la metrique volume de comms}
+%\FIXME{virer la metrique volume de comms}

 
 

-\FIXME{ajouter une courbe ou on voit l'évolution de la charge en fonction du
-  temps : avec et sans vload}
+%\FIXME{ajouter une courbe ou on voit l'évolution de la charge en fonction du  temps : avec et sans vload}

 
 % \begin{itemize}
 % \item cluster ou grid, entier ou réel, ne font pas de grosses différences
 
 % \begin{itemize}
 % \item cluster ou grid, entier ou réel, ne font pas de grosses différences


@@ -984,12 +1035,12 @@ Based on SimGrid simulator, we have demonstrated that, when we deal with realist
 
 \section*{Acknowledgments}
 
 
 \section*{Acknowledgments}
 

-Computations have been performed on the supercomputer facilities of the
-Mésocentre de calcul de Franche-Comté.
-
+This  paper  is   partially  funded  by  the  Labex   ACTION  program  (contract
+ANR-11-LABX-01-01).  We also thank the supercomputer facilities of the Mésocentre de calcul de Franche-Comté.
+ 

 \bibliographystyle{elsarticle-num}
 \bibliography{biblio}
 \bibliographystyle{elsarticle-num}
 \bibliography{biblio}

-\FIXME{find and add more references}
+%\FIXME{find and add more references}

 
 \end{document}
 
 
 \end{document}