\usepackage{amsmath}
\usepackage{courier}
\usepackage{graphicx}
+\usepackage{url}
+\usepackage[ruled,lined]{algorithm2e}
\newcommand{\abs}[1]{\lvert#1\rvert} % \abs{x} -> |x|
+\newenvironment{algodata}{%
+ \begin{tabular}[t]{@{}l@{:~}l@{}}}{%
+ \end{tabular}}
+
+\newcommand{\FIXME}[1]{%
+ \textbf{$\triangleright$\marginpar{\textbf{[FIXME]}}~#1}}
+
+\newcommand{\VAR}[1]{\textit{#1}}
+
\begin{document}
\title{Best effort strategy and virtual load
for asynchronous iterative load balancing}
\author{Raphaël Couturier \and
- Arnaud Giersch \and
- Abderrahmane Sider
+ Arnaud Giersch
}
\institute{R. Couturier \and A. Giersch \at
\email{%
raphael.couturier@univ-fcomte.fr,
arnaud.giersch@univ-fcomte.fr}
- \and
- A. Sider \at
- University of Béjaïa, Béjaïa, Algeria \\
- \email{ar.sider@univ-bejaia.dz}
}
\maketitle
balancing algorithm is implemented most of the time can dissociate messages
concerning load transfers and message concerning load information. In order to
increase the converge of a load balancing algorithm, we propose a simple
-heuristic called \emph{virtual load} which allows a node that receives an load
+heuristic called \emph{virtual load} which allows a node that receives a load
information message to integrate the load that it will receive later in its
load (virtually) and consequently sends a (real) part of its load to some of its
neighbors. In order to validate our approaches, we have defined a simulator
DASUD~\cite{cortes+ripoll+cedo+al.2002.asynchronous}, propose a
version working with integer load. This work was later generalized by
the same authors in \cite{cedo+cortes+ripoll+al.2007.convergence}.
-{\bf Rajouter des choses ici}.
+\FIXME{Rajouter des choses ici.}
Although the Bertsekas and Tsitsiklis' algorithm describes the condition to
ensure the convergence, there is no indication or strategy to really implement
amount of load. Moreover, when real asynchronous applications are considered,
using asynchronous load balancing algorithms can reduce the execution
times. Most of the times, it is simpler to distinguish load information messages
-from data migration messages. Formers ones allows a node to inform its
+from data migration messages. Former ones allows a node to inform its
neighbors of its current load. These messages are very small, they can be sent
quite often. For example, if an computing iteration takes a significant times
(ranging from seconds to minutes), it is possible to send a new load information
network performance and the message size, the time of the reception of the
message also varies.
-In the following of this paper, Section~\ref{BT algo} describes the Bertsekas
-and Tsitsiklis' asynchronous load balancing algorithm. Moreover, we present a
-possible problem in the convergence conditions. Section~\ref{Best-effort}
-presents the best effort strategy which provides an efficient way to reduce the
-execution times. In Section~\ref{Virtual load}, the virtual load mechanism is
-proposed. Simulations allowed to show that both our approaches are valid using a
-quite realistic model detailed in Section~\ref{Simulations}. Finally we give a
-conclusion and some perspectives to this work.
-
+In the following of this paper, Section~\ref{BT algo} describes the Bertsekas
+and Tsitsiklis' asynchronous load balancing algorithm. Moreover, we present a
+possible problem in the convergence conditions. Section~\ref{Best-effort}
+presents the best effort strategy which provides an efficient way to reduce the
+execution times. This strategy will be compared with other ones, presented in
+Section~\ref{Other}. In Section~\ref{Virtual load}, the virtual load mechanism
+is proposed. Simulations allowed to show that both our approaches are valid
+using a quite realistic model detailed in Section~\ref{Simulations}. Finally we
+give a conclusion and some perspectives to this work.
$x_3^2(t)$. So we consider that the \emph{ping-pong} condition is probably to
strong. Currently, we did not try to make another convergence proof without this
condition or with a weaker condition.
-
+%
+\FIXME{Develop: We have the feeling that such a weaker condition
+ exists, because (it's not a proof, but) we have never seen any
+ scenario that is not leading to convergence, even with LB-strategies
+ that are not fulfilling these two conditions.}
\section{Best effort strategy}
\label{Best-effort}
-We will describe here a new load-balancing strategy that we called
-\emph{best effort}. The general idea behind this strategy is, for a
-processor, to send some load to the most of its neighbors, doing its
+In this section we describe a new load-balancing strategy that we call
+\emph{best effort}. The general idea behind this strategy is that each
+processor, that detects it has more load than some of its neighbors,
+sends some load to the most of its less loaded neighbors, doing its
best to reach the equilibrium between those neighbors and himself.
-More precisely, when a processors $i$ is in its load-balancing phase,
+More precisely, when a processor $i$ is in its load-balancing phase,
he proceeds as following.
\begin{enumerate}
\item First, the neighbors are sorted in non-decreasing order of their
\end{equation*}
\end{enumerate}
+\FIXME{describe parameter $k$}
+
\section{Other strategies}
\label{Other}
-\textbf{Question} faut-il décrire les stratégies makhoul et simple ?
+\FIXME{Réécrire en angliche.}
-\paragraph{simple} Tentative de respecter simplement les conditions de Bertsekas.
-Parmi les voisins moins chargés que soi, on sélectionne :
-\begin{itemize}
-\item un des moins chargés (vmin) ;
-\item un des plus chargés (vmax),
-\end{itemize}
-puis on équilibre avec vmin en s'assurant que notre charge reste
-toujours supérieure à celle de vmin et à celle de vmax.
+% \FIXME{faut-il décrire les stratégies makhoul et simple ?}
+
+% \paragraph{simple} Tentative de respecter simplement les conditions de Bertsekas.
+% Parmi les voisins moins chargés que soi, on sélectionne :
+% \begin{itemize}
+% \item un des moins chargés (vmin) ;
+% \item un des plus chargés (vmax),
+% \end{itemize}
+% puis on équilibre avec vmin en s'assurant que notre charge reste
+% toujours supérieure à celle de vmin et à celle de vmax.
-On envoie donc (avec "self" pour soi-même) :
-\[
- \min\left(\frac{load(self) - load(vmin)}{2}, load(self) - load(vmax)\right)
-\]
+% On envoie donc (avec "self" pour soi-même) :
+% \[
+% \min\left(\frac{load(self) - load(vmin)}{2}, load(self) - load(vmax)\right)
+% \]
\paragraph{makhoul} Ordonne les voisins du moins chargé au plus chargé
puis calcule les différences de charge entre soi-même et chacun des
\section{Virtual load}
\label{Virtual load}
+In this section, we present the concept of \texttt{virtual load}. In order to
+use this concept, load balancing messages must be sent using two different kinds
+of messages: load information messages and load balancing messages. More
+precisely, a node wanting to send a part of its load to one of its neighbors,
+can first send a load information message containing the load it will send and
+then it can send the load balancing message containing data to be transferred.
+Load information message are really short, consequently they will be received
+very quickly. In opposition, load balancing messages are often bigger and thus
+require more time to be transferred.
+
+The concept of \texttt{virtual load} allows a node that received a load
+information message to integrate the load that it will receive later in its load
+(virtually) and consequently send a (real) part of its load to some of its
+neighbors. In fact, a node that receives a load information message knows that
+later it will receive the corresponding load balancing message containing the
+corresponding data. So if this node detects it is too loaded compared to some
+of its neighbors and if it has enough load (real load), then it can send more
+load to some of its neighbors without waiting the reception of the load
+balancing message.
+
+Doing this, we can expect a faster convergence since nodes have a faster
+information of the load they will receive, so they can take in into account.
+
+\FIXME{Est ce qu'on donne l'algo avec virtual load?}
+
+\FIXME{describe integer mode}
+
\section{Simulations}
\label{Simulations}
are issued that permit to compare the strategies.
The simulation model is detailed in the next section (\ref{Sim
- model}), then the results of the simulations are presented in
-section~\ref{Results}.
+ model}), and the experimental contexts are described in
+section~\ref{Contexts}. Then the results of the simulations are
+presented in section~\ref{Results}.
\subsection{Simulation model}
\label{Sim model}
\paragraph{Receiving thread} The receiving thread is in charge of
waiting for messages to come, either on the control channel, or on the
-data channel. When a message is received, it is pushed in a buffer of
+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 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.
+\begin{algorithm}
+ \caption{Receiving thread}
+ \label{algo.recv}
+ \KwData{
+ \begin{algodata}
+ \VAR{ctrl\_chan}, \VAR{data\_chan}
+ & communication channels (control and data) \\
+ \VAR{ctrl\_fifo}, \VAR{data\_fifo}
+ & buffers of received messages (control and data) \\
+ \end{algodata}}
+ \While{true}{%
+ wait for a message to be available on either \VAR{ctrl\_chan},
+ or \VAR{data\_chan}\;
+ \If{a message is available on \VAR{ctrl\_chan}}{%
+ get the message from \VAR{ctrl\_chan}, and push it into \VAR{ctrl\_fifo}\;
+ }
+ \If{a message is available on \VAR{data\_chan}}{%
+ get the message from \VAR{data\_chan}, and push it into \VAR{data\_fifo}\;
+ }
+ }
+\end{algorithm}
+
\paragraph{Computing thread} The computing thread is in charge of the
-real load management. It iteratively runs the following operations:
+real load management. As exposed 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;
\end{itemize}
Practically, after the computation, the computing thread waits for a
small amount of time if the iterations are looping too fast (for
-example, when the current load is zero).
+example, when the current load is near zero).
+
+\begin{algorithm}
+ \caption{Computing thread}
+ \label{algo.comp}
+ \KwData{
+ \begin{algodata}
+ \VAR{data\_fifo} & buffer of received data messages \\
+ \VAR{real\_load} & current load \\
+ \end{algodata}}
+ \While{true}{%
+ \If{\VAR{data\_fifo} is empty and $\VAR{real\_load} = 0$}{%
+ wait until a message is pushed into \VAR{data\_fifo}\;
+ }
+ \While{\VAR{data\_fifo} is not empty}{%
+ pop a message from \VAR{data\_fifo}\;
+ get the load embedded in the message, and add it to \VAR{real\_load}\;
+ }
+ \ForEach{neighbor $n$}{%
+ \If{there is some amount of load $a$ to send to $n$}{%
+ send $a$ units of load to $n$, and subtract it from \VAR{real\_load}\;
+ }
+ }
+ \If{$\VAR{real\_load} > 0.0$}{
+ simulate some computation, whose duration is function of \VAR{real\_load}\;
+ ensure that the main loop does not iterate too fast\;
+ }
+ }
+\end{algorithm}
\paragraph{Load-balancing thread} The load-balancing thread is in
charge of running the load-balancing algorithm, and exchange the
-control messages. It iteratively runs the following operations:
+control messages. As shown in Algorithm~\ref{algo.lb}, it iteratively
+runs the following operations:
\begin{itemize}
\item get the control messages that were received from the neighbors;
\item run the load-balancing algorithm;
iterate too fast.
\end{itemize}
+\begin{algorithm}
+ \caption{Load-balancing}
+ \label{algo.lb}
+ \While{true}{%
+ \While{\VAR{ctrl\_fifo} is not empty}{%
+ pop a message from \VAR{ctrl\_fifo}\;
+ identify the sender of the message,
+ and update the current knowledge of its load\;
+ }
+ run the load-balancing algorithm to make the decision about load transfers\;
+ \ForEach{neighbor $n$}{%
+ send a control messages to $n$\;
+ }
+ ensure that the main loop does not iterate too fast\;
+ }
+\end{algorithm}
+
+\paragraph{}
+For the sake of simplicity, a few details were voluntary omitted from
+these descriptions. For an exhaustive presentation, we refer to the
+actual source code that was used for the experiments%
+\footnote{As mentioned before, our simulator relies on the SimGrid
+ framework~\cite{casanova+legrand+quinson.2008.simgrid}. For the
+ experiments, we used a pre-release of SimGrid 3.7 (Git commit
+ 67d62fca5bdee96f590c942b50021cdde5ce0c07, available from
+ \url{https://gforge.inria.fr/scm/?group_id=12})}, and which is
+available at
+\url{http://info.iut-bm.univ-fcomte.fr/staff/giersch/software/loba.tar.gz}.
+
+\FIXME{ajouter des détails sur la gestion de la charge virtuelle ?}
+
+\subsection{Experimental contexts}
+\label{Contexts}
+
+In order to assess the performances of our algorithms, we ran our
+simulator with various parameters, and extracted several metrics, that
+we will describe in this section. Overall, the experiments represent
+more than 240 hours of computing time.
+
+\paragraph{Load balancing strategies}
+
+We ran the experiments with the \emph{Best effort}, and with the \emph{Makhoul}
+strategies. \emph{Best effort} was tested with parameter $k = 1$, $k = 2$, and
+$k = 4$. Secondly, each strategy was run in its two variants: with, and without
+the management of \emph{virtual load}. Finally, we tested each configuration
+with \emph{real}, and with \emph{integer} load.
+This gives us as many as 32 different strategies.
+
+\paragraph{Configurations}
+\begin{description}
+\item[\textbf{platforms}] homogeneous (cluster); heterogeneous (subset
+ of Grid5000)
+\item[\textbf{platform size}] platforms with 16, 64, 256, and 1024 nodes
+\item[\textbf{topologies}] line; torus; hypercube
+\item[\textbf{initial load distribution}] initially on a only node;
+ initially on all nodes
+\item[\textbf{comp/comm ratio}] $10/1$, $1/1$, $1/10$
+\end{description}
+
+\paragraph{Metrics}
+
+\begin{description}
+\item[\textbf{average idle time}]
+\item[\textbf{average convergence date}]
+\item[\textbf{maximum convergence date}]
+\item[\textbf{data transfer amount}] relative to the total data amount
+\end{description}
+
\subsection{Validation of our approaches}
\label{Results}
\section{Conclusion and perspectives}
+\begin{acknowledgements}
+ Computations have been performed on the supercomputer facilities of
+ the Mésocentre de calcul de Franche-Comté.
+\end{acknowledgements}
\bibliographystyle{spmpsci}
\bibliography{biblio}
%%% Local Variables:
%%% mode: latex
%%% TeX-master: t
+%%% fill-column: 80
%%% ispell-local-dictionary: "american"
%%% End:
% LocalWords: Raphaël Couturier Arnaud Giersch Abderrahmane Sider Franche ij
% LocalWords: Bertsekas Tsitsiklis SimGrid DASUD Comté Béjaïa asynchronism ji
-% LocalWords: ik isend irecv
+% LocalWords: ik isend irecv Cortés et al chan ctrl fifo
