X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/loba-papers.git/blobdiff_plain/31bff00ae28d5928a2a488e207cac24bcd2a11d7..74af592b15adb8ca1304b5252bea0d7163c544cb:/supercomp11/supercomp11.tex?ds=inline

diff --git a/supercomp11/supercomp11.tex b/supercomp11/supercomp11.tex
index 2d6b32f..8770bab 100644
--- a/supercomp11/supercomp11.tex
+++ b/supercomp11/supercomp11.tex
@@ -5,17 +5,26 @@
 \usepackage{amsmath}
 \usepackage{courier}
 \usepackage{graphicx}
+\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{[FIXME]}\marginpar{\flushleft\footnotesize\bfseries$\triangleright$ #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
@@ -25,10 +34,6 @@
               \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
@@ -79,7 +84,7 @@ been extended by many authors. For example, Cortés et al., with
 DASUD~\cite{cortes+ripoll+cedo+al.2002.asynchronous}, propose a
 version working with integer load.  This work was later generalized by
 the same authors in \cite{cedo+cortes+ripoll+al.2007.convergence}.
-{\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
@@ -236,24 +241,28 @@ he proceeds as following.
   \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
@@ -273,10 +282,10 @@ 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 transfered.
+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 transfered.
+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
@@ -291,7 +300,9 @@ 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.
 
-\textbf{Question} Est ce qu'on donne l'algo avec virtual load?
+\FIXME{Est ce qu'on donne l'algo avec virtual load?}
+
+\FIXME{describe integer mode}
 
 \section{Simulations}
 \label{Simulations}
@@ -306,8 +317,9 @@ characteristics of the running platform, etc.  Then several metrics
 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}
@@ -332,14 +344,38 @@ a \emph{receiving thread}, a \emph{computing thread}, and a
 
 \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;
@@ -348,7 +384,35 @@ real load management.  It iteratively runs the following operations:
 \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
@@ -362,6 +426,61 @@ control messages.  It iteratively runs the following operations:
   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 code that was used for the experiments, and which is
+available at \FIXME{URL}.
+
+\FIXME{ajouter des détails sur la gestion de la charge virtuelle ?}
+
+\subsection{Experimental contexts}
+\label{Contexts}
+
+\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{Algorithms}
+\begin{description}
+\item[\textbf{strategies}] makhoul; besteffort with $k\in \{1,2,4\}$
+\item[\textbf{variants}] with, and without virtual load (bookkeeping)
+\item[\textbf{domain}] real load, and integer load
+\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}
 
@@ -409,4 +528,4 @@ Taille : 10 100 très gros
 
 % 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