]> AND Private Git Repository - loba-papers.git/blobdiff - supercomp11/supercomp11.tex
Logo AND Algorithmique Numérique Distribuée

Private GIT Repository
Description best effort.
[loba-papers.git] / supercomp11 / supercomp11.tex
index a566b8a33d1718e8b8a655ecc4c47e21a6b451e8..4cc971b10807fc488c28411157c48385fa20b3fd 100644 (file)
@@ -1,29 +1,34 @@
-
 \documentclass[smallextended]{svjour3}
 \usepackage[utf8]{inputenc}
 \usepackage[T1]{fontenc}
 \usepackage{mathptmx}
 \documentclass[smallextended]{svjour3}
 \usepackage[utf8]{inputenc}
 \usepackage[T1]{fontenc}
 \usepackage{mathptmx}
+\usepackage{amsmath}
 \usepackage{courier}
 \usepackage{graphicx}
 
 \usepackage{courier}
 \usepackage{graphicx}
 
+\newcommand{\abs}[1]{\lvert#1\rvert} % \abs{x} -> |x|
+
 \begin{document}
 
 \begin{document}
 
-\title{Best effort strategy and virtual load for asynchronous iterative load balancing}
+\title{Best effort strategy and virtual load
+  for asynchronous iterative load balancing}
 
 \author{Raphaël Couturier \and
         Arnaud Giersch \and
         Abderrahmane Sider
 }
 
 
 \author{Raphaël Couturier \and
         Arnaud Giersch \and
         Abderrahmane Sider
 }
 
-\institute{F. Author \at
-              first address \\
-              Tel.: +123-45-678910\\
-              Fax: +123-45-678910\\
-              \email{fauthor@example.com}           %  \\
-%             \emph{Present address:} of F. Author  %  if needed
+\institute{R. Couturier \and A. Giersch \at
+              LIFC, University of Franche-Comté, Belfort, France \\
+              % Tel.: +123-45-678910\\
+              % Fax: +123-45-678910\\
+              \email{%
+                raphael.couturier@univ-fcomte.fr,
+                arnaud.giersch@univ-fcomte.fr}
            \and
            \and
-           S. Author \at
-              second address
+           A. Sider \at
+              University of Béjaïa, Béjaïa, Algeria \\
+              \email{ar.sider@univ-bejaia.dz}
 }
 
 \maketitle
 }
 
 \maketitle
@@ -37,14 +42,14 @@ algorithm~\cite[section~7.4]{bertsekas+tsitsiklis.1997.parallel}
 is certainly  the most well known  algorithm for which the  convergence proof is
 given. From a  practical point of view, when  a node wants to balance  a part of
 its  load to some  of its  neighbors, the  strategy is  not described.   In this
 is certainly  the most well known  algorithm for which the  convergence proof is
 given. From a  practical point of view, when  a node wants to balance  a part of
 its  load to some  of its  neighbors, the  strategy is  not described.   In this
-paper, we propose a strategy  called \texttt{best effort} which tries to balance
+paper, we propose a strategy  called \emph{best effort} which tries to balance
 the load of a node to all  its less loaded neighbors while ensuring that all the
 nodes  concerned by  the load  balancing  phase have  the same  amount of  load.
 Moreover,  asynchronous  iterative  algorithms  in which  an  asynchronous  load
 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
 the load of a node to all  its less loaded neighbors while ensuring that all the
 nodes  concerned by  the load  balancing  phase have  the same  amount of  load.
 Moreover,  asynchronous  iterative  algorithms  in which  an  asynchronous  load
 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 \texttt{virtual load} which allows a node that receives an load
+heuristic called \emph{virtual load} which allows a node that receives an 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
 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
@@ -68,7 +73,7 @@ where computer nodes  are considered homogeneous and with  homogeneous load with
 no external  load. In  this context, Bertsekas  and Tsitsiklis have  proposed an
 algorithm which is definitively a reference  for many works. In their work, they
 proved that under classical  hypotheses of asynchronous iterative algorithms and
 no external  load. In  this context, Bertsekas  and Tsitsiklis have  proposed an
 algorithm which is definitively a reference  for many works. In their work, they
 proved that under classical  hypotheses of asynchronous iterative algorithms and
-a  special  constraint   avoiding  \texttt{ping-pong}  effect,  an  asynchronous
+a  special  constraint   avoiding  \emph{ping-pong}  effect,  an  asynchronous
 iterative algorithm  converge to  the uniform load  distribution. This  work has
 been extended by many authors. For example,
 DASUD~\cite{cortes+ripoll+cedo+al.2002.asynchronous} propose a version working
 iterative algorithm  converge to  the uniform load  distribution. This  work has
 been extended by many authors. For example,
 DASUD~\cite{cortes+ripoll+cedo+al.2002.asynchronous} propose a version working
@@ -78,7 +83,7 @@ Although  the Bertsekas  and Tsitsiklis'  algorithm describes  the  condition to
 ensure the convergence,  there is no indication or  strategy to really implement
 the load distribution. In other word, a node  can send a part of its load to one
 or   many  of   its  neighbors   while  all   the  convergence   conditions  are
 ensure the convergence,  there is no indication or  strategy to really implement
 the load distribution. In other word, a node  can send a part of its load to one
 or   many  of   its  neighbors   while  all   the  convergence   conditions  are
-followed. Consequently,  we propose a  new strategy called  \texttt{best effort}
+followed. Consequently,  we propose a  new strategy called  \emph{best effort}
 that tries to balance the load of  a node to all its less loaded neighbors while
 ensuring that all the nodes concerned  by the load balancing phase have the same
 amount of  load.  Moreover, when real asynchronous  applications are considered,
 that tries to balance the load of  a node to all its less loaded neighbors while
 ensuring that all the nodes concerned  by the load balancing phase have the same
 amount of  load.  Moreover, when real asynchronous  applications are considered,
@@ -96,7 +101,7 @@ often much nore longer that to  time to transfer a load information message. So,
 when a node receives the information  that later it will receive a data message,
 it can take this information into account  and it can consider that its new load
 is larger.   Consequently, it can  send a part  of it real  load to some  of its
 when a node receives the information  that later it will receive a data message,
 it can take this information into account  and it can consider that its new load
 is larger.   Consequently, it can  send a part  of it real  load to some  of its
-neighbors if required. We call this trick the \texttt{virtual load} mecanism.
+neighbors if required. We call this trick the \emph{virtual load} mecanism.
 
 
 
 
 
 
@@ -149,7 +154,7 @@ x_i(t+1)=x_i(t)-\sum_{j\in V(i)} s_{ij}(t) + \sum_{j\in V(i)} r_{ji}(t)
 
 
 Some  conditions are  required to  ensure the  convergence. One  of them  can be
 
 
 Some  conditions are  required to  ensure the  convergence. One  of them  can be
-called the \texttt{ping-pong} condition which specifies that:
+called the \emph{ping-pong} condition which specifies that:
 \begin{equation}
 x_i(t)-\sum _{k\in V(i)} s_{ik}(t) \geq x_j^i(t)+s_{ij}(t)
 \end{equation}
 \begin{equation}
 x_i(t)-\sum _{k\in V(i)} s_{ik}(t) \geq x_j^i(t)+s_{ij}(t)
 \end{equation}
@@ -170,7 +175,7 @@ x_3(t)=99.99\\
 In this case, processor $2$ can  either sends load to processor $1$ or processor
 $3$.   If  it  sends  load  to  processor $1$  it  will  not  satisfy  condition
 (\ref{eq:ping-pong})  because  after the  sending  it  will  be less  loaded  that
 In this case, processor $2$ can  either sends load to processor $1$ or processor
 $3$.   If  it  sends  load  to  processor $1$  it  will  not  satisfy  condition
 (\ref{eq:ping-pong})  because  after the  sending  it  will  be less  loaded  that
-$x_3^2(t)$.  So we consider that the \texttt{ping-pong} condition is probably to
+$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.
 
 strong. Currently, we did not try to make another convergence proof without this
 condition or with a weaker condition.
 
@@ -178,16 +183,60 @@ condition or with a weaker condition.
 \section{Best effort strategy}
 \label{Best-effort}
 
 \section{Best effort strategy}
 \label{Best-effort}
 
-\textbf{À traduire} Ordonne les voisins du moins chargé au plus chargé.
-Trouve ensuite, en les prenant dans ce ordre, le nombre maximal de
-voisins tels que tous ont une charge inférieure à la moyenne des
-charges des voisins sélectionnés, et de soi-même.
-
-Les transferts de charge sont ensuite fait en visant cette moyenne pour
-tous les voisins sélectionnés.  On envoie une quantité de charge égale
-à (moyenne - charge\_du\_voisin).
-
-~\\\textbf{Question} faut-il décrire les stratégies makhoul et simple ?
+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
+best to reach the equilibrium between those neighbors and himself.
+
+More precisely, when a processors $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
+  known loads $x^i_j(t)$.
+
+\item Then, this sorted list is traversed in order to find its largest
+  prefix such as the load of each selected neighbor is lesser than:
+  \begin{itemize}
+  \item the processor's own load, and
+  \item the mean of the loads of the selected neighbors and of the
+    processor's load.
+  \end{itemize}
+  Let's call $S_i(t)$ the set of the selected neighbors, and
+  $\bar{x}(t)$ the mean of the loads of the selected neighbors and of
+  the processor load:
+  \begin{equation*}
+    \bar{x}(t) = \frac{1}{\abs{S_i(t)} + 1}
+      \left( x_i(t) + \sum_{j\in S_i(t)} x^i_j(t) \right)
+  \end{equation*}
+  The following properties hold:
+  \begin{equation*}
+    \begin{cases}
+      S_i(t) \subset V(i) \\
+      x^i_j(t) < x_i(t) & \forall j \in S_i(t) \\
+      x^i_j(t) < \bar{x} & \forall j \in S_i(t) \\
+      x^i_j(t) \leq x^i_k(t) & \forall j \in S_i(t), \forall k \in V(i) \setminus S_i(t) \\
+      \bar{x} \leq x_i(t)
+    \end{cases}
+  \end{equation*}
+
+\item Once this selection is completed, processor $i$ sends to each of
+  the selected neighbor $j\in S_i(t)$ an amount of load $s_{ij}(t) =
+  \bar{x} - x^i_j(t)$.
+
+  From the above equations, and notably from the definition of
+  $\bar{x}$, it can easily be verified that:
+  \begin{equation*}
+    \begin{cases}
+      x_i(t) - \sum_{j\in S_i(t)} s_{ij}(t) = \bar{x} \\
+      x^i_j(t) + s_{ij}(t) = \bar{x} & \forall j \in S_i(t)
+    \end{cases}
+  \end{equation*}
+\end{enumerate}
+
+\section{Other strategies}
+\label{Other}
+
+\textbf{Question} 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 :
 
 \paragraph{simple} Tentative de respecter simplement les conditions de Bertsekas.
 Parmi les voisins moins chargés que soi, on sélectionne :