\begin{frontmatter}
-\journal{Parallel Computing}
+\journal{Journal of Computational Science}
\title{Best effort strategy and virtual load for\\
asynchronous iterative load balancing}
\begin{abstract}
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]
- {bertsekas+tsitsiklis.1997.parallel} is undeniably the best known algorithm for which the asymptotic convergence proof is given.
+ algorithm~\cite{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
+ 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 made. In this paper, we
+ propose a new strategy called \besteffort{} which aims at balancing the load
of a node to all its less loaded neighbors while ensuring that all involved nodes by the load balancing phase have the same amount of load. Moreover, since
- asynchronous iterative algorithms are less sensitive to communications delays
+ asynchronous iterative algorithms are less sensitive to communication delays
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
- 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.
+ 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 several QoS metrics are evaluated to show the usefulness of the proposed algorithm.
\end{abstract}
% \begin{keywords}
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 arises in
+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.
-%%RAPH Attention cette partie n'apparait plus
-\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}
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. %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.
+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
-amount of load. Moreover, %when real-world asynchronous applications are considered,
-%using asynchronous load balancing algorithms can reduce the execution
-%times.
-most of the time, 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
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
-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
-often much longer than the time to transfer a load information message. So,
+message to each involved neighbor at each iteration. The load is then 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 or may not make sense for the nodes to try to balance a part of their load at each computing
+iteration. But the time needed to transfer a load message from one node to another is
+often much longer than the time needed to transfer a load information message. So,
when a node is notified
%receives the information
that later it will receive a data message,
\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.
-\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 The SimGrid simulator, which is known to handle realistic models of computation and communication in different types of platforms was used. 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.
\end{itemize}
\label{sec.related.works}
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 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.
+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 the links between the network's resources may be intermittent.
Cybenko~\cite{Cybenko89} proposes a {\it diffusion} approach for hypercube multiprocessor networks.
The author targets both static and dynamic random models of work distribution.
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, 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
-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.
+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: the average remaining time and the remaining resources for bidding. Based on JADE simulator, the proposed algorithm exhibits better performances in terms of successful execution rates, resource utilization rates and fair profit allocation.
Choi et al.~\cite{ChoiBH09} address the problem of robust task allocation in arbitrary networks. The proposed
approaches combine 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 problems. 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.
+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 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{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~\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.
-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.
+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 proposed to tackle the load balancing problem using the multi-agent approach where each agent is responsible for the load balancing of a subset of nodes in the network. The objective of the agent is to minimize the jobs' response time and the 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 an 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.
\section{Bertsekas and Tsitsiklis' asynchronous load balancing algorithm}
\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.
+In this section, a brief description of Bertsekas and Tsitsiklis' algorithm~\cite{bertsekas+tsitsiklis.1997.parallel} is given, using its original notations.
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
$j$ is denoted by $(i, j)\in A$. The set of processor $i$'s neighbors 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}.
-Load of processor $i$
+
+The 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
+each of its neighbors $j \in V(i)$ denoted by $x_j^i(t)$. 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
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
-amount of loads received by $j$ from $i$ at time $t$. Then
+amount of load received by $j$ from $i$ at time $t$. Then
the amount of load of processor $i$ at time $t+1$ is given by:
\begin{equation}
\medskip
Nevertheless, we think that this condition may lead to deadlocks in some
-cases. For example, consider a linear chain graph network of only three processors in which processor $1$
+cases. For example, let us 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).
\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 specifications, processor $2$ can either send
-loads to processor $1$ or processor
-$3$. If it sends loads to processor $1$, it will not satisfy condition
+Owing to the algorithm's specifications, processor $2$ can either send a part of its load to processor $1$ or to processor
+$3$. If it sends its load to processor $1$, it will not satisfy condition
\eqref{eq.ping-pong} because after that sending it will be less loaded than
$x_3^2(t)$. So we consider that the \emph{ping-pong} condition is probably too
strong. %Currently, we did not try to make another convergence proof without this condition or with a weaker condition.
\smallskip
-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
+In spite of this, a weaker condition can be conjectured to exist since
+there does not seem to be any scenario that does not lead to convergence, even with
load-balancing strategies that are not exactly fulfilling the authors' own conditions. %se two conditions.
%It may be the subject of future work to express weaker conditions, and to prove
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 decisions
-are taken. To our knowledge, the only first attempt for a possible
+are made. 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 previous
-work. More precisely, we will use the algorithm~2 from
-\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.
+of the new \besteffort{}, it seemed natural to compare it with this previous
+work. More precisely, algorithm~2 from
+\cite{bahi+giersch+makhoul.2008.scalable} will be used and, throughout the paper, will be
+referenced under the original name {\it Bertsekas and Tsitsiklis} for the sake of convenience and readability.
\smallskip
Here is an outline of the main principle of the borrowed algorithm. When a given node $i$ has to take
the load of each of its neighbors. Finally, taking the neighbors following the
order defined before, the amount of load to send $s_{ij}$ is computed as
$1/(|V(i)|+1)$ of the load difference%, with $n$ being the number of neighbors
-. This process is iterated as long as the node is more loaded than the considered
+. This process is iterated as long as a node is more loaded than its considered
neighbors.
\section{Best effort strategy}
\label{sec.besteffort}
-In this section, we describe a new load-balancing strategy that we call
-\besteffort{}. First, we explain the general idea behind this strategy,
-and then we present some variants of this basic strategy.
+In this section, a new load-balancing strategy that is called
+\besteffort{} is described. First, the general idea behind this strategy is given,
+and then some variants of this basic strategy are presented.
\subsection{Basic strategy}
-The description of our algorithm will be given from the point of view a processor~$i$.
+The description of our algorithm will be given from the point of view of a processor~$i$.
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
+detecting itself to be more loaded than some of its neighbors, sends part of its 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,
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 might concurrently send
+how to 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,
there is a risk that a node will receive loads from
This is particularly true with strongly connected applications.
-
-In order to reduce this effect, we add the ability to level the amount of loads to send.
+In order to reduce this effect, the ability to level the amount of load to send is added.
The idea, here, is to make as few steps as possible toward the equilibrium, such that a
potentially unsuitable decision pointed above has a lower impact on the local equilibrium.
-Roughly speaking, once $s_{ij}$ is estimated as previously explained, it is simply weighted by
-a given prescribed threshold parameter which we call
-%. This parameter is called
-$k$ in
-Section~\ref{sec.results}. The amount of data to send is then $s_{ij}(t) =
-(\bar{x} - x^i_j(t))/k$.
-%\FIXME[check that it's still named $k$ in Sec.~\ref{sec.results}]{}
-
+A weighting system parameter $k$ is introduced to orchestrate the right balance between the topology structure and the computation to communication ratios (CCR) values of the deployed application. Indeed, to speedup the convergence time of the load balancing process, one is faced with a difficult trade-off to choose an appropriate amount of load to send between node neighbors upon load imbalance detection. On the one hand, if $k$ is small, faster convergence times are expected for sparsely connected applications and large CCR values. On the other hand, for strongly connected applications and small CCR values, a large value of $k$ will enable us to better balance the load locally and therefore minimize the number of iterations toward the global equilibrium. In the experiments section (Section~\ref{sec.results}), it can be observed that choosing $k$ in $\{1, 2, 4\}$ leads to good results for the considered CCR values and the targeted topology structures.
+So the amount of data to send is then $s_{ij}(t) = (\bar{x} - x^i_j(t))/k$.
-%\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.
-%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
+In this section, the new concept of \emph{virtual load} is presented. It aims at improving the global convergence time. For that purpose, both load transfer messages and load information messages are dissociated.
+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
The concept of \emph{virtual load} allows a node receiving a load
information message to integrate (virtually) the future load it will receive later in its load's list
even if the load has not been received yet. Consequently, the notified node can send a (real) part of its load to some of its
-neighbors when needed. By and large, this allows a node on the one hand, to predict the load it will receive in the subsequent time steps, and on the other hand, to take suitable decisions when detecting load imbalance in its closed neighborhoods. Doing so, we expect faster convergence time since nodes can take
-into account the information about the predictive loads not
-received yet.
-
-% repetition !
-%In fact, a node that receives a load information message knows that
-%later it will receive the corresponding load balancing message containing the
-%corresponding data. So, if this node detects it is too loaded compared to some
-%of its neighbors and if it has enough load (real load), then it can send more
-%load to some of its neighbors without waiting the reception of the load
-%balancing message.
-
-%Doing this, we can expect a faster convergence since nodes have a faster
-%information of the load they will receive, so they can take it into account.
-
-%\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.
-
-
+neighbors when needed. By and large, this allows a node on the one hand, to predict the load it will receive in the subsequent time steps, and on the other hand, to make suitable decisions when detecting load imbalance in its closed neighborhoods. Doing so, faster convergence times are expected since nodes can take
+into account the information about the predictive loads even if these have not yet been received.
-%\FIXME{describe integer mode}
\section{Implementation with SimGrid and simulations}
\label{sec.simulations}
-In order to test and validate our approache, we wrote a simulator
+In order to test and validate our approach, a simulator
using the SimGrid
-framework~\cite{simgrid.web,casanova+giersch+legrand+al.2014.simgrid}. This
+framework~\cite{simgrid.web,casanova+giersch+legrand+al.2014.simgrid} was written. 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
\label{sec.model}
In the simulation model the processors exchange messages which are of
-two types. First, there are \emph{control messages} which carry only the information exchanged between processors, such as the
+two types. First, there are \emph{control messages} which only carry the information exchanged between processors, such as the
current load, or the virtual load transfers if this option is
considered. These messages are rather small, and their size is
constant. Then, there are \emph{data messages} that carry the real
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 hereafter.
+\emph{load-balancing thread}, which will be briefly described hereafter.
For the sake of simplicity, a few details were voluntary omitted from
-these descriptions. For an exhaustive presentation, we refer to the
+these descriptions. For an exhaustive presentation, interested readers are referred to the
actual source code that was used for the experiments%
\footnote{As mentioned before, our simulator relies on the SimGrid
framework~\cite{casanova+giersch+legrand+al.2014.simgrid}. For the
\subsubsection{Load balancing strategies}
Several load balancing strategies were compared. Experiments with
-the \besteffort{}, and with the \makhoul{} strategies have been performed. First the \emph{best
+the \besteffort{}, and with the \makhoul{} strategies have been compared. 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 values is considered.
+and with \emph{integer} load values was considered.
To summarize the different load balancing strategies, we have:
\begin{description}
\item[\textbf{variants:}] with, or without virtual loads
%\item[\textbf{domain:}] real load, or integer load
\end{description}
-%
-%This gives us as many as $4\times 2\times 2 = 16$ different strategies.
\subsubsection{End of the simulation}
-The simulations were run until reaching the global equilibrium threshold.
-%the load was nearly balanced among the participating nodes.
+The simulations were run until the global equilibrium threshold was reached.
+
More precisely, the simulation stops when each node holds
an amount of load at least inferior to 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{Platform}
-%In order to show the behavior of the different strategies
-%in different
-%settings, we simulated the executions on two sorts of platforms. These two
-%sorts of platforms differ by their network topology. On the one hand,
-%we have homogeneous platforms, modeled as a cluster. On the other hand, we have
-%heterogeneous platforms, modeled as the interconnection of a number of clusters.
-
-
-%The clusters are modeled by a fixed number of computing nodes interconnected
-%through a backbone link. Each computing node has a computing power of
-%1~GFlop/s, and is connected to the backbone by a network link whose bandwidth is
-%of 125~MB/s, with a latency of 50~$\mu$s. The backbone has a network bandwidth
-%of 2.25~GB/s, with a latency of 500~$\mu$s.
-In order to make our experiments, an heterogeneous grid platform description were created by taking a subset of the
+In order to make our experiments, an heterogeneous grid platform description was 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
The distributed processes of the application were then logically organized along
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
+participating nodes of the platform. The total amount of load 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
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
+have two different CCR, and hence characterize
two different types of applications:
\begin{itemize}
\item mainly communicating, with a CCR of $1/10$;
%\item balanced, with a computation/communication cost ratio of $1/1$.
\end{itemize}
-% To summarize the various configurations, we have:
-% \begin{description}
-% \item[\textbf{platforms:}] homogeneous (cluster), or heterogeneous (subset of
-% Grid'5000)
-% \item[\textbf{platform sizes:}] platforms with 16, 64, 256, or 1024 nodes
-% \item[\textbf{process topologies:}] line, torus, or hypercube
-% \item[\textbf{initial load distribution:}] initially on a only node, or
-% initially randomly distributed over all nodes
-% \item[\textbf{computation/communication cost ratio:}] $10/1$, $1/1$, or $1/10$
-% \end{description}
-% %
-% This gives us as many as $2\times 4\times 3\times 2\times 3 = 144$ different
-% configurations.
-% %
-% Combined with the various load balancing strategies, $16\times 144 =
-% 2,304$ distinct settings have been evaluated. In fact, as it will be shown later, only configurations with a maximum number of 1,024 nodes are considered in order to limit the time of experiments.
-
\subsubsection{Metrics}
\label{sec.metrics}
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, the goal is to
+something tending to a constant value, i.e. to have a measure which does not
+change 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}
\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
- %that can be compared between simulations of different sizes.
- %This metric is expected to give an idea of the ability of the strategy to
- %diffuse the load quickly.
- A smaller value is better.
+ 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[\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.
+ reached the final stable equilibrium. 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}
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}
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. %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 Figure, ~\ref{fig.results1} and~\ref{fig.resultsN}, the results
+In both figures, the CCR is $10/1$ on the left
+column, and $1/10$ on the right column.
+In 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.
-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
+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
platform sizes. Some bars are missing, especially for large platforms. This is
-because the algorithm did not reach the convergence state in the
+because the algorithm did not manage to reach the convergence state in the
allocated time.
-%\FIXME{annoncer le plan de la suite}
\subsubsection{The \besteffort{} and \makhoul{} strategies without virtual load}
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},
+strategy. In 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
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.
+tries to give more load to a small number of 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
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
+it quickly distributes significant amount of load, 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.
\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. %Sometimes it has no effect but, based on our observations, it has never a negative effect on the load balancing we tested.
+The impact of virtual load schemes 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
-than the simple version. This can be explained by the fact that, with virtual load,
+than the simple version. This can be explained by the fact that, with a 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. As a consequence, they
-cannot compute at the beginning. This is especially noticeable when the
+cannot compute from the beginning. This is especially noticeable when the
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 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.
+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 schemes 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.
\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.
+Taken as a whole, the results illustrated in Figures~\ref{fig.results1} and ~\ref{fig.resultsN} clearly show that our proposal outperforms the Bertsekas and Tsitsiklis 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.
+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 the {\it Bertsekas and Tsitsiklis} 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. Therefore, loads are not really assigned to neighboring processors which would allow them to be fairly balanced.
\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.
+Unlike the {\it Bertsekas and Tsitsiklis} 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.
\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.
+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 make 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}),
+Finally, it is worth 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 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
+As expected, the obtained results globally have the same behavior, that is why similar figures do not appear in this paper. The most
+interesting result is that the virtual mode allows
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).
\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.
+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 Tsitsiklis} 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.
\label{conclusions-remarks}
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}
+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.
-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.
+Based on SimGrid simulator, it was shown 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}
\bibliographystyle{elsarticle-num}
\bibliography{biblio}
-%\FIXME{find and add more references}
+
\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
+
