X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/loba-papers.git/blobdiff_plain/fa2cdc28662b5efc4913918718eaf7a8beaa0919..332d8c14078d4972c9dd91472ad2da9cfbf1c42c:/loba-besteffort/loba-besteffort.tex

diff --git a/loba-besteffort/loba-besteffort.tex b/loba-besteffort/loba-besteffort.tex
index 55e877c..78524f7 100644
--- 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{\makhoul}{\emph{naive}}
+\newcommand{\makhoul}{\emph{Bertsekas and Tsitsiklis}}
 
 \begin{document}
 
@@ -219,8 +219,7 @@ both single and multiple task assignment problem. An online stochastic dual grad
 
 In~\cite{tripathi2017non} a LB algorithm based on game theory is proposed for distributed data centers. The authors formulate the LB problem as a non-cooperative game among front-end proxy servers and characterize the structure of Nash equilibrium. Based on the obtained Nash equilibrium structure, they derive a LB algorithm for computing the Nash equilibrium. They show through simulations that the proposed algorithm ensures fairness among the users and good average latency across all client regions. A hybrid task scheduling and load balancing dependent and independent tasks for master-slaves platforms is addressed in~In~\cite{liu2017dems}. To minimize the response time of the submitted jobs, the proposed algorithm which is called DeMS is splitted in three stages: i) communication overhead reduction between masters and slaves,  ii) task migration to keep the workload balanced iii) and precedence task graphs partitioning. 
 
-
-In~\cite{GrosuC05}, the authors formulate the load balancing problem as a non-cooperative game among users. They use the Nash equilibrium as the solution of this game to optimize the response time of all jobs in the entire system. The proposed scheme guarantees the optimal task allocation for each user with low time complexity. A game theoretic approach to tackle the static load balancing problem is also investigated in~\cite{PenmatsaC11}. To provide fairness to all users in  the system, the load balancing problem is formulated as a non-cooperative game among the users to minimize the response time of the submitted users' jobs. As in~\cite{GrosuC05}, the authors use the concept of Nash equilibrium as the solution of a non-cooperative game. Simulations results show that the proposed scheme perform near optimal solutions compared to other existing techniques in terms of fairness.
+Several LB techniques based on artificial intelligence have been also 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. Simulations results show that the proposed scheme perform near optimal solutions compared to other existing techniques in terms of fairness.
 
 
 
@@ -234,9 +233,7 @@ 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}.
+%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.
@@ -295,7 +292,8 @@ 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. 
 %(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   \\
@@ -429,7 +427,7 @@ a given prescribed threshold parameter which we call
 $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}]{}
 
 
 
@@ -502,14 +500,16 @@ received yet.
 \section{Implementation with SimGrid and 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
-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
@@ -519,22 +519,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
-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
-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
-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
-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
-\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
@@ -549,10 +548,10 @@ available at
 
 \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
-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
 messages.  The buffers are implemented with a lock-free FIFO
 \cite{sutter.2008.writing} to avoid contention between the threads.
@@ -581,13 +580,13 @@ messages.  The buffers are implemented with a lock-free FIFO
 
 \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;
-\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
@@ -629,8 +628,8 @@ 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 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 to
   iterate too fast.
 \end{itemize}
@@ -659,16 +658,16 @@ iteratively runs the following operations:
 \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
-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},
-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}
@@ -682,9 +681,10 @@ To summarize the different load balancing strategies, we have:
 
 \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.
+The simulations were run until reaching the global equilibrium threshold. 
+%the load was nearly balanced among the participating nodes.  
+More precisely the simulation stops when each node holds
+an amount of load at least less than 1\% of the load average.
 %, during an arbitrary
 %number of computing iterations (2000 in our case).
 
@@ -709,35 +709,39 @@ an amount of load at less than 1\% of the load average.
 %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.
 
-In order to make our experiments, an heterogeneous platform descriptions were created by taking a subset of the
+In order to make our experiments, an heterogeneous grid platform descriptions were created by taking a subset of the
 Grid'5000 infrastructure\footnote{Grid'5000 is a French large scale experimental
   Grid (see \url{https://www.grid5000.fr/}).}, as described in the platform file
 \texttt{g5k.xml} distributed with SimGrid.  Note that the heterogeneity of the
-platform here only comes from the network topology.  Indeed, since our
-algorithms currently do not handle heterogeneous computing resources, the
+platform here only comes from the network topology.  Indeed, 
+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}.
+%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
+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
-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
+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) 
+Tests were performed with the total load initially on only one node%(at one end for the line topology)
+, ii) and other tests for which the load was initially randomly distributed across all the
+participating nodes of the platform.  The total amount of load was fixed to a number of load
 units equal to 1000 times the number of node.  The average load is then of 1000
 load units.
 
 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:
+have two different computation to communication ratios (CCR), and hence characterize 
+two different types of applications:
 \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}
 
 % To summarize the various configurations, we have:
@@ -761,16 +765,14 @@ three different kinds of applications:
 \subsubsection{Metrics}
 \label{sec.metrics}
 
-In order to evaluate and compare the different load balancing strategies we define several metrics.  Our goal, when choosing these metrics, is 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
 changing anymore once the convergence state is reached.  Moreover, we want to
 have some normalized value, in order to be able to compare them across different
-settings.
-
-With these constraints in mind, we define the following metrics:
+settings. With these constraints in mind, we define the following metrics:
 %
 \begin{description}
-\item[\textbf{average idle time:}] that is the total time spent, when the nodes
+\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. 
   %This total
   %time is divided by the number of participating nodes, such as to have a number
@@ -779,12 +781,12 @@ With these constraints in mind, we define the following metrics:
   %diffuse the load quickly.  
   A smaller value is better.
 
-\item[\textbf{average convergence time:}] that is the average of the times when
-  all nodes reached the convergence state.  Times are measured as a number
-  of (simulated) seconds since the beginning of the simulation.
+\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{maximum convergence time:}] that is the time when the last node
-  reached the convergence state.
+\item[\it{maximum convergence time:}] that is the time when the last node
+  reached the final stable equilibrium.
   %These two dates give an idea of the time needed by the strategy to reach the
   %equilibrium state.  
   A smaller value is better.
@@ -833,7 +835,7 @@ and our observations are explained.
   \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). For each bar, from bottom to top, the first part represents the average idle
+  \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*}
@@ -846,31 +848,32 @@ time, the second part represents the average convergence time, and then the thir
   \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*}
 
-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
+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 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 both figures, the CCR 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
+On each of Figures~\ref{fig.results1} and~\ref{fig.resultsN}, the results
 are given for the process topology being, from top to bottom, a line, a torus or
 an hypercube.
 
-Finally, on the graphs, the vertical bars show the measured times for each of
-the algorithms.  These measured times are, from bottom to top, the average idle
+Finally, the vertical bars show the measured times for the evaluated metrics
+%each of the algorithms
+. 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
 platform sizes.  Some bars are missing, especially for large platforms.  This is
-either because the algorithm did not reach the convergence state in the
+because the algorithm did not reach the convergence state in the
 allocated time.
 
 
@@ -878,21 +881,26 @@ allocated time.
 
 \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 algorithm, 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
-influenced by  the application topology.  It  is for the line  topology that the
+influenced by  the application topology structure.  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
+readily faster than the \makhoul{} strategy.  This can  be explained by the
 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 are 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
+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
@@ -901,30 +909,54 @@ 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.
 
-Globally   the  number  of   interconnection  is   very  important.    The  more
+Generally speaking,  the  number  of   interconnection  is   very  important.  Indeed, 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.
-
+all the  neighbors.  However,  the \besteffort{} strategy  distributes the
+load fairly when needed and is is better for sparse connected applications.
 
 
 
 
-\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.
+\subsubsection{With virtual load}
 
-On Figure~\ref{fig.results1}, when the load is  initially on one node, it can be
+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. %Sometimes  it  has no  effect  but, based on our observations,  it has never a negative effect on the load balancing we tested.
+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
-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
-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
-communication are slow (on the left part of Figure ~\ref{fig.results1}.
+communication are slow (on the left part of Figure ~\ref{fig.results1}).
+
+\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 plays quite a significant role. However, the impact of
+communication becomes less important as the CCR values increases, since larger CCR values result in smaller communication times. We also tested the impact of CCR values on the performance of each algorithm in terms of idle times. From Figures~\ref{fig.results1} and ~\ref{fig.resultsN} we can find that our virtual load scheme achieves 
+a 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 the most of times compared to fine grain applications. 
+
+\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 has 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.  
+
+\smallskip 
+Unlike {\it Betsekas and Tsistlikis} algorithm, our approach is not really sensitive when 
+we deal with realistic models of computation and communication. This is due to two main features: i) the use of "virtual load" transfers winch 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 load difference between the computational resources is minimized as low as possible. 
 
-On Figure \ref{fig.resultsN} when the load to balance is initially randomly distributed over all nodes, we can see that the effect of virtual load is not significant for the line. For the torus with the mainly communicating case (on the left of the figure), the effect of the virtual load is very significant. For the hypercube, in any case, the effect of the virtual load is visible. It is more visible when communications have a more important role (i.e. with the mainly communicating case).
+\smallskip 
+Comparing the results of the extended version (with virtual load) to the results of the simple one, we observe 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 optimize 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 reveals 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 network's size. 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 not 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. 
+
+%For the hypercube, in any case, the effect of the virtual load is visible. It is more visible when communications have a more important role (i.e. with the mainly communicating case).
 
 
 %Dans ce cas  lÃ©gÃ¨re amÃ©lioration de la cvg. max.  Temps  moyen de cvg. amÃ©liorÃ©,
@@ -951,27 +983,33 @@ On Figure \ref{fig.resultsN} when the load to balance is initially randomly dist
 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 transferred between
-processors.  In this situation, it is possible to reduce the convergence time by
+processors.  In this case, it is possible to reduce the convergence time by
 using  the leveler  parameter  (parameter  $k$).  The  advantage  of using  this
 solution is particularly efficient when the initial load is randomly distributed
 on  the nodes with  torus and  hypercube topologies  and slow  communication. When
-virtual load  mechanism is used,  the effect of  this parameter is  also visible
-with the same condition. However, sometimes this parameter may have a negative effect on the convergence time.
-
+virtual load  scheme is used,  the effect of  this parameter is  also perceptible
+with the same conditions. %However, sometimes this parameter may have a negative effect on the convergence time.
 
 
 
-\subsubsection{With integer load}
 
-We also performed  some experiments with integer load instead  of load with real
-value.  In  this case, the  results have globally  the same behavior, that is why we decided not to show similar figures.   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, we also carried out further experiments with integer load values to assess the performance of our proposal.
+%We also performed  some experiments with integer load instead  of load with real
+%number values.  
+As expected,
+%In  this case, 
+the  obtained results have globally the same behavior, that is why we decided not to show similar figures.   The most
 interesting  result, from  our point  of view,  is that  the virtual  mode allows
-processors in a line topology to converge to the uniform load balancing. Without
+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 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
+``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).
 
+\smallskip 
+To summarize and broadly speaking, the simulation results led us to show that, with 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 corroborate 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.
+
+
 %Cas normal, ligne -> converge pas (effet d'escalier).
 %Avec vload, Ã§a converge.
 
@@ -1028,10 +1066,10 @@ obtain 10 9 8 7 6 6 7 8 9 10 instead of 8 8 8 8 8 8 8 8 8 8).
 
 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 
+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. 
-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 we deal 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}
 
