[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 ed478e4b2422f6f1c57c555f70610c330335fb1e..ee788a5d85719fd08bb84528b60d6bc0c8fb7a52 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{naive}}
+\newcommand{\makhoul}{\emph{Bertsekas and Tsitsiklis}}

 
 \begin{document}
 
 
 \begin{document}
 


@@ -54,28 +54,21 @@
 \cortext[cor]{Corresponding author.}
 
 \begin{abstract}
 \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'
+  Most of the time, asynchronous load balancing algorithms are extensively 
+  studied from a theoretical point of view. The Bertsekas and Tsitsiklis'

   algorithm~\cite
   %[section~7.4]
   algorithm~\cite
   %[section~7.4]

-  {bertsekas+tsitsiklis.1997.parallel} is undeniably 
-  the most well known algorithm for which the asymptotic convergence proof is given. 
+  {bertsekas+tsitsiklis.1997.parallel} is undeniably the best 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 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 
   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 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 

-  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 receiving a load
+  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. This heuristic allows 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
   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
+  its neighbors taking into account the virtual load it will receive in the subsequent time-steps. Based on the SimGrid simulator, some series of test-bed scenarios are considered and 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}
 
  % simulator based on SimGrid which allowed us to conduct many experiments.
 \end{abstract}
 


@@ -90,63 +83,37 @@
 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). 
 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 objective of load balancing is to orchestrate the distribution of the global load so that 

 the load difference between the computational resources of the network is 
 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 
+minimized as much as possible. Unfortunately, this problem is known to be {\bf NP-hard} in its 
+general form 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 
 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 ;-)
+that can be processed independently of each other~\cite{Bharadwaj1996, Drozdowski1998, Casanova2008}. This model of divisible loads arises 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 huge databases, 
+average consensus in WSN, pattern search in Big data and so on. 

 
 
 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. 
 
 
 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  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. 
+
+
+Although  Bertsekas  and Tsitsiklis  describe  the necessary conditions to
+ensure the algorithm's convergence,  there is no indication nor any strategy to really implement
+the load distribution. 

 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
 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,
-%using  asynchronous load  balancing  algorithms  can  reduce   the  execution
-%times. 
-most of the times, it is simpler to dissociate load information messages
+amount of  load.  Moreover, most of the time, 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 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
+neighbors about its  current load. These messages are in fact very small and can often be sent 
+very quickly.  For example, if a computing iteration takes  a significant time

 (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 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
+message to each involved neighbor at each iteration. Then, the load is sent, but the reception may take time when the amount of load is huge and when communication links are slow.  Depending on the application, it may make sense or not for the nodes to try to balance  a part of their load  at each computing

 iteration. But the time to transfer a load message from a node to another one is
 iteration. But the time to transfer a load message from a node to another one is

-often much more longer that the  time to transfer a load information message. So,
+often much longer than 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,
 when a node is notified 
 %receives the information  
 that later it will receive a data message,


@@ -165,62 +132,47 @@ The main contributions and novelties of our work are summarized in the following
 \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.     
 
 \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. 
+\item Unlike earlier works, we use a new concept of virtual loads transfer which allows nodes to predict the future loads they will receive in the subsequent iterations. 

 This leads to a noticeable speedup of the global convergence time of the load balancing process.  
 
 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}
 
 
 \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 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. 
+
+The reminder of the paper is organized as follows. Section~\ref{sec.related.works} offers a review of the relevant approaches in the literature. Section~\ref{sec.bt-algo} describes the
+Bertsekas and Tsitsiklis' asynchronous load balancing algorithm. 

 Section~\ref{sec.besteffort} presents the best effort strategy which provides
 Section~\ref{sec.besteffort} presents the best effort strategy which provides

-efficient local loads equilibrium. %This strategy will be compared with the one presented in Section~\ref{sec.other}.  
+efficient local loads equilibrium. 

 In Section~\ref{sec.virtual-load}, the clairvoyant virtual load scheme is proposed to speedup the convergence time of the load balancing process.
 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}.
+In Section~\ref{sec.simulations}, a comprehensive set of numerical results that exhibit the usefulness of our proposal when dealing with realistic models of computation and communication is provided. Finally, some concluding remarks are made in Section~\ref{conclusions-remarks}.

 
 
 \section{Related works}
 \label{sec.related.works}
 
 
 \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 this section, the relevant techniques proposed in the literature to tackle the problem of load balancing in a general context of distributed systems are reviewed. 

 
 

-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.
+As pointed above, the most interesting approach to this issue has been proposed by Bertsekas  and Tsitsiklis~\cite{bertsekas+tsitsiklis.1997.parallel}. This algorithm which is outlined in Section~\ref{sec.bt-algo} for the sake of comparison, has been borrowed and adapted in many works. For instance, in~\cite{CortesRCSL02} a static load balancing (called DASUD) for non negative integer number of divisible loads in arbitrary networks topologies is investigated. The term {\it "static"} stems from the fact that no loads are added or consumed during the load balancing process. The theoretical correctness proofs of the convergence property are given. Some generalizations of the same authors' own work for partially asynchronous discrete load balancing model are presented in~\cite{cedo+cortes+ripoll+al.2007.convergence}. The authors prove that the algorithm's convergence is finite and bounded by the straightforward network's diameter of the global equilibrium threshold in the network. In~\cite{bahi+giersch+makhoul.2008.scalable}, a fault tolerant communication version is addressed to deal with average consensus in wireless sensor networks. The objective is to have all nodes converging to the average of their initial measurements based only on nodes' local information. A slight adaptation is also considered  in~\cite{BahiCG10} for dynamic networks with bounded delays asynchronous diffusion. The dynamical aspect stands at the communication level as links between the network's resources may be intermittent.

 
 

-Cybenko~\cite{Cybenko89} propose a {\it diffusion} approach for hypercube multiprocessor networks. 
+Cybenko~\cite{Cybenko89} proposes 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
 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.
+computational works. A static load balancing for  both synchronous and asynchronous ring networks is addressed in~\cite{GehrkePR99}. The authors assume that at any time step, one token at the most (units of load) can be transmitted along any edge of the ring and no tokens are created during the balancing phase. They show that for every initial token distribution, the proposed algorithm converges to the stable equilibrium with tighter linear bounds of time step-complexity.

 
 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
 
 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.
+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
 
 
 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.
+approaches combine a bidding approach for task selection and a 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{tripathi2017non} a LB algorithm based on game theory is proposed for distributed data centers. The authors formulate the LB problem as a non-cooperative game among front-end proxy servers and characterize the structure of Nash equilibrium. Based on the obtained Nash equilibrium structure, they derive a LB algorithm to compute the Nash equilibrium. They show through simulations that the proposed algorithm ensures fairness among the users and a good average latency across all client regions. A hybrid task scheduling and load balancing dependent and independent tasks for master-slaves platforms are addressed in~In~\cite{liu2017dems}. To minimize the response time of the submitted jobs, the proposed algorithm which is called DeMS is split into three stages: i) communication overhead reduction between masters and slaves,  ii) task migration to keep the workload balanced iii) and precedence task graphs partitioning. 

 
 

-
-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.
+Several LB techniques, based on artificial intelligence, have also been proposed in the literature:  genetic algorithm (GA) \cite{subrata2007artificial}, honey bee behavior \cite{krishna2013honey, kwok2004new},  tabu search  \cite{subrata2007artificial} and fuzzy logic \cite{salimi2014task}. The main strength of these techniques comes from their ability to seek in large search spaces, which arises in many combinatorial optimization problems. For instance, the works in~\cite{cao2005grid, shen2014achieving} have been proposed to tackle the load balancing problem using the multiagent approach where each agent is responsible for load balancing for a subset of nodes in the network. The agent objective is to minimize jobs' response time and host idle time dynamically. In~\cite{GrosuC05}, the authors formulate the load balancing problem as a non-cooperative game among users. They use the Nash equilibrium as the solution of this game to optimize the response time of all jobs in the entire system. The proposed scheme guarantees the optimal task allocation for each user with low time complexity. A game theoretic approach to tackle the static load balancing problem is also investigated in~\cite{PenmatsaC11}. To provide fairness to all users in  the system, the load balancing problem is formulated as a non-cooperative game among the users to minimize the response time of the submitted users' jobs. As in~\cite{GrosuC05}, the authors use the concept of Nash equilibrium as the solution of a non-cooperative game. Simulation results show that the proposed scheme offers near optimal solutions compared to other existing techniques in terms of fairness.

 
 
 
 
 
 


@@ -229,42 +181,23 @@ In~\cite{GrosuC05}, the authors formulate the load balancing problem as a non-co
 \label{sec.bt-algo}
 
 In this section, we present a brief description of Bertsekas and Tsitsiklis' algorithm~\cite{bertsekas+tsitsiklis.1997.parallel} using its original notations. 
 \label{sec.bt-algo}
 
 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 
+A network is modeled as a connected undirected graph $G=(N,A)$, where $N$ is a 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
 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$. 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
-%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}. 
+$j$ is denoted by $(i, j)\in A$. The set of processor $i$'s neighbors is denoted by $V(i)$.
+ 

 Load of processor $i$
 at  time $t$  is  represented  by $x_i(t)\geq  0$.   
 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
 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. 
 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.
-
-%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
 \medskip

-When a processor  sends a part of its  load to one or some of  its neighbors, the
+When a processor  sends a part of its  load to one or to 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
 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  $j$  from  $i$ at  time $t$. Then
+amount of  loads received by  $j$  from  $i$ at  time $t$. Then

 the amount of load of processor $i$ at time $t+1$ is given by:
 
 \begin{equation}
 the amount of load of processor $i$ at time $t+1$ is given by:
 
 \begin{equation}


@@ -287,15 +220,16 @@ for any  processor $i$ and any  $j \in V(i)$ such  that $x_i(t)>x_j^i(t)$.
 %less loaded after that.
 
 \medskip
 %less loaded after that.
 
 \medskip

-This condition prohibits the possibility that two nodes keep sending load to each
+This condition prohibits the possibility that two nodes keep sending loads to each

 other back and forth, without reaching equilibrium. 
 
 \medskip
 Nevertheless,  we  think that  this  condition may  lead  to  deadlocks in  some
 other back and forth, without reaching equilibrium. 
 
 \medskip
 Nevertheless,  we  think that  this  condition may  lead  to  deadlocks in  some

-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. 
+cases. For example, consider a linear chain graph network of only three processors in which processor $1$
+is linked to processor $2$ which is  also linked to processor $3$, but in which processors $1$ and $3$ are not neighbors. 

 %(i.e. a simple chain which 3 processors). 
 %(i.e. a simple chain which 3 processors). 

-Now consider that we have the following load values at time~$t$:
+
+\noindent Now consider that we have the following load values at time~$t$:

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


@@ -304,15 +238,15 @@ Now consider that we have the following load values at time~$t$:
 \end{align*}
 %{\bf RAPH, pourquoi il y a $x_3^2$?. Sinon il faudra reformuler la suite, c'est mal dit}
 
 \end{align*}
 %{\bf RAPH, pourquoi il y a $x_3^2$?. Sinon il faudra reformuler la suite, c'est mal dit}
 

-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
+Owing to the algorithm's specifications, processor $2$ can either send 
+a load to processor $1$ or processor
+$3$.  If it sends loads 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.
 
 \smallskip  
 \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.
 
 \smallskip  

-Nevertheless, we conjecture that a weaker condition may exist since we
+Despite this, we conjecture that a weaker condition may exist since we

 have never seen any scenario that is not leading to convergence, even with
 load-balancing strategies that are not exactly fulfilling the authors' own conditions. %se two conditions.
 
 have never seen any scenario that is not leading to convergence, even with
 load-balancing strategies that are not exactly fulfilling the authors' own conditions. %se two conditions.
 


@@ -322,16 +256,16 @@ load-balancing strategies that are not exactly fulfilling the authors' own condi
 
 \smallskip
 
 
 \smallskip
 

-Although this approach is interesting, several practical
+Even though 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 
 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 
+given on what is really sent and how the load balancing decisions 

 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
 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
+of the new \besteffort{}, we naturally chose to compare it to this previous

 work.  More precisely, we will use the algorithm~2 from
 work.  More precisely, we will use the algorithm~2 from

-\cite{bahi+giersch+makhoul.2008.scalable} and, through out the paper, we will
+\cite{bahi+giersch+makhoul.2008.scalable} and, throughout the paper, we will

 reference it under the original name {\it Bertsekas and Tsitsiklis} for the sake of convenience and readability. 
 
 \smallskip 
 reference it under the original name {\it Bertsekas and Tsitsiklis} for the sake of convenience and readability. 
 
 \smallskip 


@@ -354,9 +288,8 @@ and then we present some variants of this basic strategy.
 
 \subsection{Basic strategy}
 The description of our algorithm will be given from the point of view a processor~$i$.
 
 \subsection{Basic strategy}
 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
+The principle of the \besteffort{} strategy is that each processor
+detecting itself to be more loaded than some of its neighbors, sends some load to its less loaded neighbors, doing its best to reach the equilibrium

 between the involved neighbors and itself.
 
 More precisely, %when a processor $i$ is in its load-balancing phase,
 between the involved neighbors and itself.
 
 More precisely, %when a processor $i$ is in its load-balancing phase,


@@ -373,7 +306,7 @@ at each iteration of the load balancing process, processor~$i$
   \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
   \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

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


@@ -411,58 +344,33 @@ at each iteration of the load balancing process, processor~$i$
 
 With the aforementioned basic strategy, each node does its best to reach the
 equilibrium with its neighbors. However, one question should be outlined here:
 
 With the aforementioned basic strategy, each node does its best to reach the
 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,  
+how can we handle the case where two (or more) node initiators might concurrently send 
+ some loads to the same least loaded neighbor? Indeed,  

 %since each node may take the same kind of decision at the same time, 
 %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.
+there is a risk that a node will receive loads from
+several of its neighbors, and then might temporary go off the equilibrium state.

 This is particularly true with strongly connected applications.
 
 
 
 This is particularly true with strongly connected applications.
 
 
 

-In order to reduce this effect, we add the ability to level the amount of load to send.
+In order to reduce this effect, we add the ability to level the amount of loads 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.
 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.

-Roughtly speaking, once $s_{ij}$ is estimated as previously explained, it is simply weighted by
+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$.
 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}]{}
-
-
+%\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{Virtual load}
 \label{sec.virtual-load}
 
 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. 
 
 
 \section{Virtual load}
 \label{sec.virtual-load}
 
 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
+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
 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


@@ -479,40 +387,21 @@ neighbors when needed. By and large, this allows a node on the one hand, to pred
 into account the information about the predictive loads not 
 received yet.
 
 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.
-
-%\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.
-
-\medskip 
-{\bf ****** je suis arrivé ici ******** la conclusion est déjà écrite ******}
-{\bf ****** ça serait, peut être, mieux de déplacer la section de "Threads manangement" ici dans cette section  et ll'appler éventuellement "Computation (ou Load) and message passing threads management" ******}
-\medskip
-

 
 

-%\FIXME{describe integer mode}

 
 

-\section{Simulations}
+\section{Implementation with SimGrid and simulations}

 \label{sec.simulations}
 
 \label{sec.simulations}
 

-In order to test and validate our approaches, we wrote a simulator
+In order to test and validate our approache, we wrote a simulator

 using the SimGrid
 framework~\cite{simgrid.web,casanova+giersch+legrand+al.2014.simgrid}.  This
 simulator, which consists of about 2,700 lines of C++, allows to run
 the different load-balancing strategies under various parameters, such
 as the initial distribution of load, the interconnection topology, the
 characteristics of the running platform, etc.  Then several metrics
 using the SimGrid
 framework~\cite{simgrid.web,casanova+giersch+legrand+al.2014.simgrid}.  This
 simulator, which consists of about 2,700 lines of C++, allows to run
 the different load-balancing strategies under various parameters, such
 as the initial distribution of load, the interconnection topology, the
 characteristics of the running platform, etc.  Then several metrics

-are issued that permit to compare the strategies.
+were considered to assess and compare the behavior of the different 
+%are issued that permit to compare the 
+strategies.

 
 The simulation model is detailed in the next section (\ref{sec.model}), and the
 experimental contexts are described in section~\ref{sec.exp-context}.  Then the
 
 The simulation model is detailed in the next section (\ref{sec.model}), and the
 experimental contexts are described in section~\ref{sec.exp-context}.  Then the


@@ -522,22 +411,21 @@ results of the simulations are presented in section~\ref{sec.results}.
 \label{sec.model}
 
 In the simulation model the processors exchange messages which are of
 \label{sec.model}
 
 In the simulation model the processors exchange messages which are of

-two kinds.  First, there are \emph{control messages} which only carry
-information that is exchanged between the processors, such as the
+two types.  First, there are \emph{control messages} which carry only the information exchanged between processors, such as the

 current load, or the virtual load transfers if this option is
 current load, or the virtual load transfers if this option is

-selected.  These messages are rather small, and their size is
+considered.  These messages are rather small, and their size is

 constant.  Then, there are \emph{data messages} that carry the real
 constant.  Then, there are \emph{data messages} that carry the real

-load transferred between the processors.  The size of a data message
+load transferred between processors.  The size of a data message

 is a function of the amount of load that it carries, and it can be
 pretty large.  In order to receive the messages, each processor has
 is a function of the amount of load that it carries, and it can be
 pretty large.  In order to receive the messages, each processor has

-two receiving channels, one for each kind of messages.  Finally, when
-a message is sent or received, this is done by using the non-blocking
+two receiving channels, one for each type of messages.  Finally, when
+a message is sent or received, this is done by using non-blocking

 primitives of SimGrid\footnote{That are \texttt{MSG\_task\_isend()},
   and \texttt{MSG\_task\_irecv()}.}.
 
 During the simulation, each processor concurrently runs three threads:
 a \emph{receiving thread}, a \emph{computing thread}, and a
 primitives of SimGrid\footnote{That are \texttt{MSG\_task\_isend()},
   and \texttt{MSG\_task\_irecv()}.}.
 
 During the simulation, each processor concurrently runs three threads:
 a \emph{receiving thread}, a \emph{computing thread}, and a

-\emph{load-balancing thread}, which we will briefly describe now.
+\emph{load-balancing thread}, which we will briefly describe hereafter.

 
 For the sake of simplicity, a few details were voluntary omitted from
 these descriptions.  For an exhaustive presentation, we refer to the
 
 For the sake of simplicity, a few details were voluntary omitted from
 these descriptions.  For an exhaustive presentation, we refer to the


@@ -546,19 +434,19 @@ actual source code that was used for the experiments%
   framework~\cite{casanova+giersch+legrand+al.2014.simgrid}.  For the
   experiments, we used a pre-release of SimGrid 3.7 (Git commit
   67d62fca5bdee96f590c942b50021cdde5ce0c07, available from
   framework~\cite{casanova+giersch+legrand+al.2014.simgrid}.  For the
   experiments, we used a pre-release of SimGrid 3.7 (Git commit
   67d62fca5bdee96f590c942b50021cdde5ce0c07, available from

-  \url{https://gforge.inria.fr/scm/?group_id=12})}, and which is
+  \url{https://github.com/simgrid/simgrid})}, and which is

 available at
 \url{http://info.iut-bm.univ-fcomte.fr/staff/giersch/software/loba.tar.gz}.
 
 \subsubsection{Receiving thread}
 
 available at
 \url{http://info.iut-bm.univ-fcomte.fr/staff/giersch/software/loba.tar.gz}.
 
 \subsubsection{Receiving thread}
 

-The receiving thread is in charge of waiting for messages to come, either on the
+The receiving thread is in charge of waiting for incoming messages, either on the

 control channel, or on the data channel.  Its behavior is sketched by
 Algorithm~\ref{algo.recv}.  When a message is received, it is pushed in a buffer
 control channel, or on the data channel.  Its behavior is sketched by
 Algorithm~\ref{algo.recv}.  When a message is received, it is pushed in a buffer

-of received message, to be later consumed by one of the other threads.  There
+of received messages, to be later consumed by one of the other threads.  There

 are two such buffers, one for the control messages, and one for the data
 are two such buffers, one for the control messages, and one for the data

-messages.  The buffers are implemented with a lock-free FIFO
-\cite{sutter.2008.writing} to avoid contention between the threads.
+messages.
+The buffers are implemented with first-in, first-out queues (FIFO).

 
 \begin{algorithm}
   \caption{Receiving thread}
 
 \begin{algorithm}
   \caption{Receiving thread}


@@ -584,13 +472,13 @@ messages.  The buffers are implemented with a lock-free FIFO
 
 \subsubsection{Computing thread}
 
 
 \subsubsection{Computing thread}
 

-The computing thread is in charge of the real load management.  As exposed in
+The computing thread is in charge of the real load management.  As outlined in

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

-\item run some computations, whose duration is function of the current
-  load of the processor.
+\item run some computations, whose duration is a function of the processor's current
+  load.

 \end{itemize}
 Practically, after the computation, the computing thread waits for a
 small amount of time if the iterations are looping too fast (for
 \end{itemize}
 Practically, after the computation, the computing thread waits for a
 small amount of time if the iterations are looping too fast (for


@@ -627,15 +515,14 @@ example, when the current load is near zero).
 \subsubsection{Load-balancing thread}
 
 The load-balancing thread is in charge of running the load-balancing algorithm,
 \subsubsection{Load-balancing thread}
 
 The load-balancing thread is in charge of running the load-balancing algorithm,

-and exchange the control messages.  As shown in Algorithm~\ref{algo.lb}, it
+and exchanging the control messages.  As shown in Algorithm~\ref{algo.lb}, it

 iteratively runs the following operations:
 \begin{itemize}
 \item get the control messages that were received from the neighbors;
 \item run the load-balancing algorithm;
 iteratively runs the following operations:
 \begin{itemize}
 \item get the control messages that were received from the neighbors;
 \item run the load-balancing algorithm;

-\item send control messages to the neighbors, to inform them of the
-  processor's current load, and possibly of virtual load transfers;
-\item wait a minimum (configurable) amount of time, to avoid to
-  iterate too fast.
+\item send control messages to the neighbors, to inform them about the
+  processor's current load, and possibly the future virtual load transfers;
+\item wait a minimum (configurable) amount of time, to avoid iterating too fast.

 \end{itemize}
 
 \begin{algorithm}
 \end{itemize}
 
 \begin{algorithm}


@@ -662,140 +549,91 @@ iteratively runs the following operations:
 \subsection{Experimental contexts}
 \label{sec.exp-context}
 
 \subsection{Experimental contexts}
 \label{sec.exp-context}
 

-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.
+In order to assess the performances of our algorithm, simulations with various parameters have been achieved out, and several metrics are described in this section.

 
 \subsubsection{Load balancing strategies}
 
 Several load balancing strategies were compared.  Experiments with
 
 \subsubsection{Load balancing strategies}
 
 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,
+the \besteffort{}, and with the \makhoul{} strategies have been performed.  First the \emph{best
+  effort} was tested with parameter $k = 1$, $k = 2$, and $k = 4$.  Then,

 each strategy was run in its two variants: with, and without the management of
 \emph{virtual load}.  Finally, each configuration with \emph{real},
 each strategy was run in its two variants: with, and without the management of
 \emph{virtual load}.  Finally, each configuration with \emph{real},

-and with \emph{integer} load is considered.
+and with \emph{integer} load values is considered.

 
 To summarize the different load balancing strategies, we have:
 \begin{description}
 \item[\textbf{strategies:}] \makhoul{}, or \besteffort{} with $k\in
   \{1,2,4\}$
 
 To summarize the different load balancing strategies, we have:
 \begin{description}
 \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{variants:}] with, or without virtual loads
+%\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.

 
 \subsubsection{End of the simulation}
 
 
 \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).
-
-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{Platforms}
+The simulations were run until reaching the global equilibrium threshold. 
+  
+More precisely, the simulation stops when each node holds
+an amount of load at least inferior to 1\% of the load average.

 
 

-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.
+\subsubsection{Platform}

 
 

-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 grid platform description 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

-platform here only comes from the network topology.  Indeed, since our
-algorithms currently do not handle heterogeneous computing resources, the
-processor speeds were normalized, and we arbitrarily chose to fix them to
-1~GFlop/s.
-
-Then each kind of platform with four different numbers of computing
+platform here only comes from the network topology.  Indeed, 
+processors are  considered to be homogeneous for the sake of simplicity.
+However, this situation is easily extendable to the case of heterogeneous platforms 
+by scaling the processor's load by its computing power~\cite{ElsMonPre02}.
+%since our
+%algorithms currently do not handle heterogeneous computing resources, 
+ The
+processor speeds were normalized, and we arbitrarily chose to fix them at
+1~GFlop/s. Each type 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
 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

-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
+three possible typologies: a line, a torus or an hypercube.  Tests were divided into two groups on the basis of the initial distribution of the global load: i) some tests were performed with the total load initially on only one node, ii) and other tests were performed for which the load was initially randomly distributed across all the
+participating nodes of the platform.  The total amount of loads was fixed to a number of load
+units equal to 1,000 times the number of node.  The average load is then of 1,000

 load units.
 
 For all the previous configurations, the
 load units.
 
 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:
+computation and communication costs of a load unit are defined.  They were chosen so as to
+have two different computation to communication ratios (CCR), and hence characterize 
+two different types of applications:

 \begin{itemize}
 \begin{itemize}

-\item mainly communicating, with a computation/communication cost ratio of $1/10$;
-\item mainly computing, with a computation/communication cost ratio of $10/1$ ;
-\item balanced, with a computation/communication cost ratio of $1/1$.
+\item mainly communicating, with a CCR of $1/10$;
+\item mainly computing, with a CCR of $10/1$.
+%\item balanced, with a computation/communication cost ratio of $1/1$.

 \end{itemize}
 
 \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 =
-2,304$ 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.
-

 
 \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, several metrics were considered. 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
-have some normalized value, in order to be able to compare them across different
-settings.
-
-With these constraints in mind, we define the following metrics:
+changing anymore once the convergence state is reached.  Moreover, the goal is to 
+have some normalized values, in order to be able to compare them across different
+settings. With these constraints in mind, the following metrics are defined:

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

-\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.
+\item[\it{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. 
+   A smaller value is better.

 
 

-  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[\it{average convergence time:}] that is the average of the times when
+  all nodes reached the final balanced load distribution.  Times are measured as a number
+  of (simulated) seconds from the beginning of the simulation.

 
 

-\item[\textbf{average convergence date:}] that is the average of the dates when
-  all nodes reached the convergence state.  The dates are measured as a number
-  of (simulated) seconds since the beginning of the simulation.
+\item[\it{maximum convergence time:}] that is the time when the last node
+  reached the final stable equilibrium.  A smaller value is better.

 
 

-\item[\textbf{maximum convergence date:}] that is the date when the last node
-  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.
-
-\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.

 
 \end{description}
 
 
 \end{description}
 


@@ -806,22 +644,7 @@ With these constraints in mind, we define the following metrics:
 In this section, the results for the different simulations are presented,
 and our observations are explained.
 
 In this section, the results for the different simulations are presented,
 and our observations are explained.
 

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

 
 

-Therefore, in the following, we only discuss the results for the grid
-platforms.

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


@@ -833,7 +656,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, CCR = $10/1$ (left), or $1/10$ (right). For each bar, from bottom to top starting at $t=0$, the first part represents the average idle
+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*}
 


@@ -845,208 +669,156 @@ platforms.
   \includegraphics[width=.5\linewidth]{data/graphs/RN-1:10-grid-torus}
   \includegraphics[width=.5\linewidth]{data/graphs/RN-10:1-grid-hcube}%
   \includegraphics[width=.5\linewidth]{data/graphs/RN-1:10-grid-hcube}
   \includegraphics[width=.5\linewidth]{data/graphs/RN-1:10-grid-torus}
   \includegraphics[width=.5\linewidth]{data/graphs/RN-10:1-grid-hcube}%
   \includegraphics[width=.5\linewidth]{data/graphs/RN-1:10-grid-hcube}

-  \caption{Real mode, random initial distribution, comp/comm cost ratio = $10/1$ (left), or $1/10$ (right).}
+  \caption{Real mode, random initial distribution, CCR = $10/1$ (left), or $1/10$ (right).}

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

-The main results for our simulations on grid platforms are presented on Figures~\ref{fig.results1} and~\ref{fig.resultsN}.
+The main results for our simulations on grid platforms are presented in 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
-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
-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
+The results in Figure~\ref{fig.results1} are when the load to balance is
+initially on only one node, while the results in Figure~\ref{fig.resultsN} are
+when the load to balance is initially randomly distributed over all nodes. 
+On both figures, the CCR is $10/1$ on the left
+column, and $1/10$ on the right column.  
+On each Figure, ~\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
 an hypercube.
 
 are given for the process topology being, from top to bottom, a line, a torus or
 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
-time, the average convergence date, and the maximum convergence date (see
+Finally, the vertical bars show the measured times for the evaluated metrics. These measured times are, starting at $t=0$ and from bottom to top, the average idle
+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
-either because the algorithm did not reach the convergence state in the
-allocated time, or because we simply decided not to run it.
+platform sizes.  Some bars are missing, especially for large platforms.  This is
+because the algorithm did not reach the convergence state in the
+allocated time.
+

 
 

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

-Before looking  at the different variations,  we will first show  that the plain
+The {\it simple} ({\it plain}) version of each strategy is defined as the load balancing 
+algorithm without virtual load's transfers. For each strategy, we compare the simple 
+version (without virtual load) and the improved one (with virtual load). 
+Each algorithm is evaluated in terms of achieved idle time and convergence time. 
+
+Before looking  at the different variations,  we will first show  that the simple

 \besteffort{}  strategy  is valuable,  and  may be  as  good  as the  \makhoul{}
 strategy.  On  Figures~\ref{fig.results1} and~\ref{fig.resultsN},
 these strategies are respectively labeled ``b'' and ``a''.
 
 We  can  see  that  the  relative  performance of  these  strategies  is  mainly
 \besteffort{}  strategy  is valuable,  and  may be  as  good  as the  \makhoul{}
 strategy.  On  Figures~\ref{fig.results1} and~\ref{fig.resultsN},
 these strategies are respectively labeled ``b'' and ``a''.
 
 We  can  see  that  the  relative  performance of  these  strategies  is  mainly

-influenced by  the application topology.  It  is for the line  topology that the
-difference is the  more important.  In this case,  the \besteffort{} strategy is
-nearly faster than the \makhoul{} strategy.  This can  be explained by the
+influenced by  the application topology structure.  It  is for the line  topology that the
+difference is the  most important.  In this case,  the \besteffort{} strategy is
+really faster than the \makhoul{} strategy.  This can  be explained by the

 fact that the \besteffort{} strategy tries to distribute the load fairly between
 fact that the \besteffort{} strategy tries to distribute the load fairly between

-all the nodes  and with the line topology,  it is easy to load  balance the load
-fairly.
+all the nodes  and is in a good agreement with the line topology since  it is easy 
+to load  balance the load efficiently.

 
 

-On the contrary, for the hypercube topology, the \besteffort{} strategy performs
-worse than the \makhoul{} strategy. In this case, the \makhoul{} strategy which
-tries to give more load to few neighbors reaches the equilibrium faster.
+In contrast, for the hypercube topology, the \besteffort{}' performances are lower than
+the \makhoul{} strategy. In this case, the \makhoul{} strategy, which
+tries to give more load to few neighbors, reaches the equilibrium faster.

 
 For the torus  topology, for which the  number of links is between  the line and
 the hypercube, the \makhoul{} strategy  is slightly better but the difference is
 more nuanced when the initial load is  only on one node. The only case where the
 \makhoul{} strategy is really faster than the \besteffort{} strategy is with the
 
 For the torus  topology, for which the  number of links is between  the line and
 the hypercube, the \makhoul{} strategy  is slightly better but the difference is
 more nuanced when the initial load is  only on one node. The only case where the
 \makhoul{} strategy is really faster than the \besteffort{} strategy is with the

-random initial distribution when the communication are slow.
+random initial distribution when communications are slow.
+
+Generally speaking,  the  number  of   interconnection  is   very  important.  Indeed, the  more
+numerous the interconnection links are, the  faster the \makhoul{} strategy is because
+it distributes quickly significant amount of loads, even if the distribution may be unfair, between
+all neighbors.  However,  the \besteffort{} strategy  distributes the
+load fairly when needed and is better for sparse connected applications.

 
 

-Globally   the  number  of   interconnection  is   very  important.    The  more
-the interconnection links are, the  faster the \makhoul{} strategy is because
-it distributes quickly significant amount of load, even if this is unfair, between
-all the  neighbors.  In opposition,  the \besteffort{} strategy  distributes the
-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
-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
+\subsubsection{With virtual load}
+
+The impact of virtual load scheme is most of the time really significant compared to
+the simple version of the algorithm with the same configuration. 
+For instance, as can be seen from 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
 noticed that the  average idle times are generally longer  with the virtual load

-than without  it. This  can be explained  by the  fact that, with  virtual load,
+than the simple version. This  can be explained  by the  fact that, with  virtual load,

 processors  will exchange all  the load  they need  to exchange  as soon  as the
 processors  will exchange all  the load  they need  to exchange  as soon  as the

-virtual load has been balanced  between all the processors. So consequently they
+virtual load has been balanced  between all the processors. As a consequence, they

 cannot  compute  at  the  beginning.  This is  especially  noticeable  when  the
 cannot  compute  at  the  beginning.  This is  especially  noticeable  when  the

-communication are slow (on the left part of Figure ~\ref{fig.results1}.
+communication are slow (on the left part of Figure ~\ref{fig.results1}).

 
 

-%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.
+\smallskip 
+When the load to balance is initially randomly distributed over all nodes, we can see from Figure \ref{fig.resultsN} that the effect of virtual load is not significant for the line topology structure. However, for both torus and hypercube structures with CCR = 1/10 (on the left of the figure), the performance of virtual load transfers is significantly better. This is explained by the fact 
+that for small CCR values,  high communication costs play quite a significant role. Moreover, the impact of
+communication becomes less important as the CCR values increase, since larger CCR values result in smaller communication times. The impact of CCR values were also tested on the performance of each algorithm in terms of idle times. From Figures~\ref{fig.results1} and ~\ref{fig.resultsN} virtual load scheme can be seen to achieve really good  average idle times, which is quite close to both its own simple version and its direct competitor {\it Bertsekas and Tsitsiklis} algorithm.  As expected, for coarse grain applications (CCR =10/1), idle times are close to 0 since processors are inactive most of the time compared to fine grain applications. 

 
 

-%\subsubsection{The \besteffort{} strategy with an initial random load
-%  distribution, and larger platforms}
+\smallskip 
+Taken as a whole, the results illustrated in Figures~\ref{fig.results1} and ~\ref{fig.resultsN} clearly show that our proposal outperforms the Betsekas and Tsistlikis algorithm. 
+These results indicate that local load balancing decisions have a significant impact on the global 
+convergence time achieved by the compared strategies. This is because, upon load imbalance detection, assigning  an amount of load in an unfair way between neighbors will severely increase the total number of iterations required by the algorithm before reaching the final stable distributions. The reason of the poorer performance of {\it Bertsekas and tsistsilikis} algorithm  can be explained by the inconvenience of the iterative load balance policy adopted for load distribution between neighbors. Neighbors are selected in such a way that the {\it ping-pong} condition holds. Doing so, loads are not really assigned to processor neighbors which would allow them to be fairly balanced.  

 
 

-%In 
-%Mêmes conclusions pour line et hcube.
-%Sur tore, BE se fait exploser quand les comms coutent cher.
+\smallskip 
+Unlike the {\it Betsekas and Tsistlikis} algorithm, our approach is not really sensitive when dealing with realistic models of computation and communication. This is due to two main features: i) the use of "virtual load" transfers which allows nodes to predict the load they receive in the subsequent iterations steps, ii) and the greedy neighbors selection adopted by our algorithm at each time step in the load balancing process. The involved neighbors are selected in such a way that the load difference between the computational resources is minimized as much as possible. 

 
 

-%\FIXME{virer les 1024 ?}
+\smallskip 
+Comparing the results of the extended version (with virtual load) to the results of the simple one, it can be observed in Figs.~\ref{fig.results1} and ~\ref{fig.resultsN} that the improved version gives the best performances. It always improves both convergence and idle times significantly in all figures. This is because, with virtual load transfers, the algorithm seeks greedily to ensure a certain degree of load balancing for processors by taking into account the information about the predictive loads not received yet. Consequently, this leads to optimizing the final convergence time of the load balancing process. Similarly, the extended version achieves much better results than the simple one when considering larger platforms, as shown in Figs.~\ref{fig.results1} and ~\ref{fig.resultsN}.
+
+\smallskip 
+We also find in Figs.~\ref{fig.results1} and ~\ref{fig.resultsN} that the performance difference between the improved version of our proposal and its simple version (without virtual load) increases when the CCR increases. This interesting result comes from the fact that larger CCR values reveal that we are dealing with intensive computations applications in grid platforms. Thus, in order to reduce the convergence time of the load balancing for such applications, it is important to take suitable decisions upon local load imbalance detection. That is why we added {\it virtual load} transfers scheme to the {\it best effort} strategy to perfectly balance the load of processors at each step of the load balancing process.
+
+\smallskip 
+Finally, it is worthwhile noting from Figures~\ref{fig.results1} and ~\ref{fig.resultsN}, that the algorithm's convergence time increases together with the size of the network. We also see that the idle time increases together with the size of the network when a load is initially on a single node (Figure~\ref{fig.results1}),
+as expected. In addition, it is interesting to note that when the number of nodes increases, there is no substantial difference in the increase of the convergence time, compared to the simple version without virtual load. This is explained by the fact that the increase in the convergence time is already absorbed by the virtual load transfers between processors being in line with the network's size. 

 
 

-%\subsubsection{With the virtual load extension with an initial random load
-%  distribution}

 
 

-%Soit c'est équivalent, soit on gagne -> surtout quand les comms coutent cher et
-%qu'il y a beaucoup de voisins.

 
 \subsubsection{The $k$ parameter}
 \label{results-k}
 
 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
 
 \subsubsection{The $k$ parameter}
 \label{results-k}
 
 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
-processors.  In this situation, it is possible to reduce the convergence time by
+fairly and consequently  a significant amount of the  load is transferred between
+processors.  In this case, it is possible to reduce the convergence time by

 using  the leveler  parameter  (parameter  $k$).  The  advantage  of using  this
 using  the leveler  parameter  (parameter  $k$).  The  advantage  of using  this

-solution is particularly efficient when the initial load is randomly distributed
+solution is particularly true when the initial load is randomly distributed

 on  the nodes with  torus and  hypercube topologies  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
-with the same condition.
+a virtual load  scheme is used,  the effect of  this parameter is  also perceptible
+in the same conditions. 

 
 
 
 
 
 

-\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
+\subsubsection{With non negative integer load values}
+In addition to the first tests devoted to the case of non negative real load values, further experiments were also carried with integer load values to assess the performance of our proposal.
+As expected, the  obtained results globally have 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
 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
-the load of each processor and its neighbors (for example with 10 processors, we
+processors in a line topology to converge to the uniform load balancing state. Without
+the virtual  load, most  of the time,  processors converge  to what is  called the
+``stairway effect'', that  is to say that  there is only a difference of at most one unit load between any pairs of neighbor nodes, i.e. the load difference between each processor and its neighbors is within one unit load (for example with 10 processors, we

 obtain 10 9 8 7 6 6 7 8 9 10 instead of 8 8 8 8 8 8 8 8 8 8).
 
 obtain 10 9 8 7 6 6 7 8 9 10 instead of 8 8 8 8 8 8 8 8 8 8).
 

-%Cas normal, ligne -> converge pas (effet d'escalier).
-%Avec vload, ça converge.
-
-%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{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}
-
-% \begin{itemize}
-% \item cluster ou grid, entier ou réel, ne font pas de grosses différences
-% \item bookkeeping? améliore souvent les choses, parfois au prix d'un retard au démarrage
-% \item makhoul? se fait battre sur les grosses plateformes
-% \item taille de plateforme?
-% \item ratio comp/comm?
-% \item option $k$? peut-être intéressant sur des plateformes fortement interconnectées (hypercube)
-% \item volume de comm? souvent, besteffort/plain en fait plus. pourquoi?
-% \item répartition initiale de la charge ?
-% \item integer mode sur topo. line n'a jamais fini en plain? vérifier si ce n'est
-%   pas à cause de l'effet d'escalier que bk est capable de gommer.
-% \end{itemize}}
-
-% On veut montrer quoi ? :
-
-% 1) best plus rapide que les autres (simple, makhoul)
-% 2) avantage virtual load
-
-% Est ce qu'on peut trouver des contre exemple?
-% Topologies variées
-
-
-% Simulation avec temps définies assez long et on mesure la qualité avec : volume de calcul effectué, volume de données échangées
-% Mais aussi simulation avec temps court qui montre que seul best converge
-
-% Expés avec ratio calcul/comm rapide et lent
-
-% Quelques expés avec charge initiale aléatoire plutot que sur le premier proc
-
-% Cadre processeurs homogènes
-
-% Topologies statiques
-
-% On ne tient pas compte de la vitesse des liens donc on la considère homogène
+\smallskip 
+To summarize  the simulation results led us to show that, with a few exceptions (without virtual load), our proposal is superior to the {\it Bertsekas and Tsiltsikis} algorithm in all the tested scenarios. The illustrated results indicate that network size, CCR values and initial load distribution have a significant impact on the algorithm's performances. Thus, this experimental study corroborates the usefulness of our algorithm, and confirms that when dealing with realistic model platforms, both  {\it best effort} strategy and {\it virtual load} transfers play an important role on the achieved idle and convergence times.

 
 

-% Prendre un réseau hétérogène et rendre processeur homogène

 
 

-% Taille : 10 100 très gros

 
 \section{Conclusion}
 \label{conclusions-remarks}
 
 
 \section{Conclusion}
 \label{conclusions-remarks}
 

-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 
+In this paper, a new asynchronous load balancing algorithm for non negative real numbers
+of divisible loads in distributed systems was presented. The proposed algorithm which is called {\it best effort strategy} 
+seeks greedily for loads imbalance detection and tries to achieve efficient local load equilibrium  

 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. 
 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.
+Based on SimGrid simulator, we have demonstrated that, when dealing with realistic models of computation and communication, our algorithm exhibits better performances than its direct competitor from the literature. This makes it a viable choice for load balancing of both non negative real and integer divisible loads in distributed computing systems. % un peu gonflé peut être pour la dernière phrase.

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

 
 \end{document}
 
 
 \end{document}
 

-%%% Local Variables:
-%%% mode: latex
-%%% TeX-master: t
-%%% fill-column: 80
-%%% ispell-local-dictionary: "american"
-%%% End:
-
-% LocalWords:  Raphaël Couturier Arnaud Giersch Franche ij Bertsekas Tsitsiklis
-% LocalWords:  SimGrid DASUD Comté asynchronism ji ik isend irecv Cortés et al
-% LocalWords:  chan ctrl fifo Makhoul GFlop xml pre FEMTO Makhoul's fca bdee
-% LocalWords:  cdde Contassot Vivier underlaid du de Maréchal Juin cedex calcul
-% LocalWords:  biblio Institut UMR Université UFC Centre Scientifique CNRS des
-% LocalWords:  École Nationale Supérieure Mécanique Microtechniques ENSMM UTBM
-% LocalWords:  Technologie Bahi
+