hpcc.tex

   1 \documentclass[conference]{IEEEtran}
   2
   3 \usepackage[T1]{fontenc}
   4 \usepackage[utf8]{inputenc}
   5 \usepackage{amsfonts,amssymb}
   6 \usepackage{amsmath}
   7 %\usepackage{algorithm}
   8 \usepackage{algpseudocode}
   9 %\usepackage{amsthm}
  10 \usepackage{graphicx}
  11 \usepackage[american]{babel}
  12 % Extension pour les liens intra-documents (tagged PDF)
  13 % et l'affichage correct des URL (commande \url{http://example.com})
  14 %\usepackage{hyperref}
  15
  16 \usepackage{url}
  17 \DeclareUrlCommand\email{\urlstyle{same}}
  18
  19 \usepackage[autolanguage,np]{numprint}
  20 \AtBeginDocument{%
  21   \renewcommand*\npunitcommand[1]{\text{#1}}
  22   \npthousandthpartsep{}}
  23
  24 \usepackage{xspace}
  25 \usepackage[textsize=footnotesize]{todonotes}
  26 \newcommand{\AG}[2][inline]{%
  27   \todo[color=green!50,#1]{\sffamily\textbf{AG:} #2}\xspace}
  28 \newcommand{\DL}[2][inline]{%
  29   \todo[color=yellow!50,#1]{\sffamily\textbf{DL:} #2}\xspace}
  30 \newcommand{\LZK}[2][inline]{%
  31   \todo[color=blue!10,#1]{\sffamily\textbf{LZK:} #2}\xspace}
  32 \newcommand{\RC}[2][inline]{%
  33   \todo[color=red!10,#1]{\sffamily\textbf{RC:} #2}\xspace}
  34
  35 \algnewcommand\algorithmicinput{\textbf{Input:}}
  36 \algnewcommand\Input{\item[\algorithmicinput]}
  37
  38 \algnewcommand\algorithmicoutput{\textbf{Output:}}
  39 \algnewcommand\Output{\item[\algorithmicoutput]}
  40
  41 \newcommand{\MI}{\mathit{MaxIter}}
  42
  43 \begin{document}
  44
  45 \title{Simulation of Asynchronous Iterative Numerical Algorithms Using SimGrid}
  46
  47 \author{%
  48   \IEEEauthorblockN{%
  49     Charles Emile Ramamonjisoa\IEEEauthorrefmark{1},
  50     David Laiymani\IEEEauthorrefmark{1},
  51     Arnaud Giersch\IEEEauthorrefmark{1},
  52     Lilia Ziane Khodja\IEEEauthorrefmark{2} and
  53     Raphaël Couturier\IEEEauthorrefmark{1}
  54   }
  55   \IEEEauthorblockA{\IEEEauthorrefmark{1}%
  56     Femto-ST Institute -- DISC Department\\
  57     Université de Franche-Comté,
  58     IUT de Belfort-Montbéliard\\
  59     19 avenue du Maréchal Juin, BP 527, 90016 Belfort cedex, France\\
  60     Email: \email{{charles.ramamonjisoa,david.laiymani,arnaud.giersch,raphael.couturier}@univ-fcomte.fr}
  61   }
  62   \IEEEauthorblockA{\IEEEauthorrefmark{2}%
  63     Inria Bordeaux Sud-Ouest\\
  64     200 avenue de la Vieille Tour, 33405 Talence cedex, France \\
  65     Email: \email{lilia.ziane@inria.fr}
  66   }
  67 }
  68
  69 \maketitle
  70
  71 \RC{Ordre des autheurs pas définitif.}
  72 \begin{abstract}
  73 In recent years, the scalability of large-scale implementation in a
  74 distributed environment of algorithms becoming more and more complex has
  75 always been hampered by the limits of physical computing resources
  76 capacity. One solution is to run the program in a virtual environment
  77 simulating a real interconnected computers architecture. The results are
  78 convincing and useful solutions are obtained with far fewer resources
  79 than in a real platform. However, challenges remain for the convergence
  80 and efficiency of a class of algorithms that concern us here, namely
  81 numerical parallel iterative algorithms executed in asynchronous mode,
  82 especially in a large scale level. Actually, such algorithm requires a
  83 balance and a compromise between computation and communication time
  84 during the execution. Two important factors determine the success of the
  85 experimentation: the convergence of the iterative algorithm on a large
  86 scale and the execution time reduction in asynchronous mode. Once again,
  87 from the current work, a simulated environment like SimGrid provides
  88 accurate results which are difficult or even impossible to obtain in a
  89 physical platform by exploiting the flexibility of the simulator on the
  90 computing units clusters and the network structure design. Our
  91 experimental outputs showed a saving of up to \np[\%]{40} for the algorithm
  92 execution time in asynchronous mode compared to the synchronous one with
  93 a residual precision up to \np{E-11}. Such successful results open
  94 perspectives on experimentations for running the algorithm on a
  95 simulated large scale growing environment and with larger problem size.
  96
  97 % no keywords for IEEE conferences
  98 % Keywords: Algorithm distributed iterative asynchronous simulation SimGrid
  99 \end{abstract}
 100
 101 \section{Introduction}
 102
 103 Parallel computing and high performance computing (HPC) are becoming  more and more imperative for solving various
 104 problems raised by  researchers on various scientific disciplines but also by industrial in  the field. Indeed, the
 105 increasing complexity of these requested  applications combined with a continuous increase of their sizes lead to  write
 106 distributed and parallel algorithms requiring significant hardware  resources (grid computing, clusters, broadband
 107 network, etc.) but also a non-negligible CPU execution time. We consider in this paper a class of highly efficient
 108 parallel algorithms called \texttt{numerical iterative algorithms} executed in a distributed environment. As their name
 109 suggests, these algorithm solves a given problem by successive iterations ($X_{n +1} = f(X_{n})$) from an initial value
 110 $X_{0}$ to find an approximate value $X^*$ of the solution with a very low residual error. Several well-known methods
 111 demonstrate the convergence of these algorithms \cite{BT89,Bahi07}.
 112
 113 Parallelization of such algorithms generally involved the division of the problem into several \emph{blocks} that will
 114 be solved in parallel on multiple processing units. The latter will communicate each intermediate results before a new
 115 iteration starts and until the approximate solution is reached. These parallel  computations can be performed either in
 116 \emph{synchronous} mode where a new iteration begin only when all nodes communications are completed,
 117 either \emph{asynchronous} mode where processors can continue independently without or few synchronization points. For
 118 instance in the \textit{Asynchronous Iterations - Asynchronous   Communications (AIAC)} model \cite{bcvc06:ij}, local
 119 computations do not need to wait for required data. Processors can then perform their iterations with the data present
 120 at that time. Even if the number of iterations required before the convergence is generally greater than for the
 121 synchronous case, AIAC algorithms can significantly reduce overall execution times by suppressing idle times due to
 122 synchronizations especially in a grid computing context (see \cite{Bahi07} for more details).
 123
 124 Parallel numerical applications (synchronous or asynchronous) may have different configuration and deployment
 125 requirements.  Quantifying their resource allocation policies and application scheduling algorithms in
 126 grid computing environments under varying load, CPU power and network speeds is very costly, very labor intensive and very time
 127 consuming \cite{Calheiros:2011:CTM:1951445.1951450}. The case of AIAC algorithms is even more problematic since they are very sensible to the
 128 execution environment context. For instance, variations in the network bandwith (intra and inter- clusters), in the
 129 number and the power of nodes, in the number of clusters... can lead to very different number of iterations and so to
 130 very different execution times. Then, it appears that the use of simulation tools to explore various platform
 131 scenarios and to run large numbers of experiments quickly can be very promising. In this way, the use of a simulation
 132 environment to execute parallel  iterative algorithms found some interests in reducing the highly cost of  access to
 133 computing resources: (1) for the applications development life  cycle and in code debugging (2) and in production to get
 134 results in a reasonable execution time with a simulated infrastructure not accessible  with physical resources. Indeed,
 135 the launch of distributed iterative  asynchronous algorithms to solve a given problem on a large-scale  simulated
 136 environment challenges to find optimal configurations giving the best results with a lowest residual error and in the
 137 best of execution time.
 138
 139 To our knowledge, there is no existing work on the large-scale simulation of a real AIAC application. The aim of this
 140 paper is twofold. First we give a first approach of the simulation of AIAC algorithms using a simulation tool (i.e. the
 141 SimGrid toolkit \cite{SimGrid}). Second, we confirm the effectiveness of asynchronous mode algorithms by comparing their
 142 performance with the synchronous mode. More precisely, we had implemented a program for solving large non-symmetric
 143 linear system of equations by numerical method GMRES (Generalized Minimal Residual) []. We show, that with minor
 144 modifications of the initial MPI code, the SimGrid toolkit allows us to perform a test campain of a real AIAC
 145 application on different computing architectures. The simulated results we obtained are in line with real results
 146 exposed in ??. SimGrid had allowed us to launch the application from a modest computing infrastructure by simulating
 147 different distributed architectures composed by clusters nodes interconnected by variable speed networks. It has been
 148 permitted to show  With selected parameters on the network platforms (bandwidth, latency of inter  cluster network) and
 149 on the clusters architecture (number, capacity calculation power) in the simulated environment, the experimental results
 150 have demonstrated not only the algorithm convergence within a reasonable time compared with the physical environment
 151 performance, but also a time saving of up to \np[\%]{40} in asynchronous mode.
 152
 153 This article is structured as follows: after this introduction, the next  section will give a brief description of
 154 iterative asynchronous model.  Then, the simulation framework SimGrid is presented with the settings to create various
 155 distributed architectures. The algorithm of  the multi-splitting method used by GMRES written with MPI primitives and
 156 its adaptation to SimGrid with SMPI (Simulated MPI) is detailed in the next section. At last, the experiments results
 157 carried out will be presented before some concluding remarks and future works.
 158
 159 \section{Motivations and scientific context}
 160
 161 As exposed in the introduction, parallel iterative methods are now widely used in many scientific domains. They can be
 162 classified in three main classes depending on how iterations and communications are managed (for more details readers
 163 can refer to \cite{bcvc06:ij}). In the \textit{Synchronous Iterations - Synchronous Communications (SISC)} model data
 164 are exchanged at the end of each iteration. All the processors must begin the same iteration at the same time and
 165 important idle times on processors are generated. The \textit{Synchronous Iterations - Asynchronous Communications
 166 (SIAC)} model can be compared to the previous one except that data required on another processor are sent asynchronously
 167 i.e.  without stopping current computations. This technique allows to partially overlap communications by computations
 168 but unfortunately, the overlapping is only partial and important idle times remain.  It is clear that, in a grid
 169 computing context, where the number of computational nodes is large, heterogeneous and widely distributed, the idle
 170 times generated by synchronizations are very penalizing. One way to overcome this problem is to use the
 171 \textit{Asynchronous Iterations - Asynchronous   Communications (AIAC)} model. Here, local computations do not need to
 172 wait for required data. Processors can then perform their iterations with the data present at that time. Figure
 173 \ref{fig:aiac} illustrates this model where the grey blocks represent the computation phases, the white spaces the idle
 174 times and the arrows the communications. With this algorithmic model, the number of iterations required before the
 175 convergence is generally greater than for the two former classes. But, and as detailed in \cite{bcvc06:ij}, AIAC
 176 algorithms can significantly reduce overall execution times by suppressing idle times due to synchronizations especially
 177 in a grid computing context.
 178
 179 \begin{figure}[!t]
 180   \centering
 181     \includegraphics[width=8cm]{AIAC.pdf}
 182   \caption{The Asynchronous Iterations - Asynchronous Communications model }
 183   \label{fig:aiac}
 184 \end{figure}
 185
 186
 187 It is very challenging to develop efficient applications for large scale, heterogeneous and distributed platforms such
 188 as computing grids. Researchers and engineers have to develop techniques for maximizing application performance of these
 189 multi-cluster platforms, by redesigning the applications and/or by using novel algorithms that can account for the
 190 composite and heterogeneous nature of the platform. Unfortunately, the deployment of such applications on these very
 191 large scale systems is very costly, labor intensive and time consuming. In this context, it appears that the use of
 192 simulation tools to explore various platform scenarios at will and to run enormous numbers of experiments quickly can be
 193 very promising. Several works...
 194
 195 In the context of AIAC algorithms, the use of simulation tools is even more relevant. Indeed, this class of applications
 196 is very sensible to the execution environment context. For instance, variations in the network bandwith (intra and
 197 inter-clusters), in the number and the power of nodes, in the number of clusters... can lead to very different number of
 198 iterations and so to very different execution times.
 199
 200
 201
 202
 203 \section{SimGrid}
 204
 205 SimGrid~\cite{casanova+legrand+quinson.2008.simgrid,SimGrid} is a simulation
 206 framework to sudy the behavior of large-scale distributed systems.  As its name
 207 says, it emanates from the grid computing community, but is nowadays used to
 208 study grids, clouds, HPC or peer-to-peer systems.  The early versions of SimGrid
 209 date from 1999, but it's still actively developped and distributed as an open
 210 source software.  Today, it's one of the major generic tools in the field of
 211 simulation for large-scale distributed systems.
 212
 213 SimGrid provides several programming interfaces: MSG to simulate Concurrent
 214 Sequential Processes, SimDAG to simulate DAGs of (parallel) tasks, and SMPI to
 215 run real applications written in MPI~\cite{MPI}.  Apart from the native C
 216 interface, SimGrid provides bindings for the C++, Java, Lua and Ruby programming
 217 languages.  The SMPI interface supports applications written in C or Fortran,
 218 with little or no modifications.  SMPI implements about \np[\%]{80} of the MPI
 219 2.0 standard~\cite{bedaride:hal-00919507}.
 220
 221 %%% explain simulation
 222 %- simulated processes folded in one real process
 223 %- simulates interactions on the network, fluid model
 224 %- able to skip long-lasting computations
 225 %- traces + visu?
 226
 227 %%% platforms
 228 %- describe resources and their interconnection, with their properties
 229 %- XML files
 230
 231 %%% validation + refs
 232
 233 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 234 \section{Simulation of the multisplitting method}
 235 %Décrire le problème (algo) traité ainsi que le processus d'adaptation à SimGrid.
 236 Let $Ax=b$ be a large sparse system of $n$ linear equations in $\mathbb{R}$, where $A$ is a sparse square and nonsingular matrix, $x$ is the solution vector and $b$ is the right-hand side vector. We use a multisplitting method based on the block Jacobi splitting to solve this linear system on a large scale platform composed of $L$ clusters of processors~\cite{o1985multi}. In this case, we apply a row-by-row splitting without overlapping
 237 \[
 238 \left(\begin{array}{ccc}
 239 A_{11} & \cdots & A_{1L} \\
 240 \vdots & \ddots & \vdots\\
 241 A_{L1} & \cdots & A_{LL}
 242 \end{array} \right)
 243 \times
 244 \left(\begin{array}{c}
 245 X_1 \\
 246 \vdots\\
 247 X_L
 248 \end{array} \right)
 249 =
 250 \left(\begin{array}{c}
 251 B_1 \\
 252 \vdots\\
 253 B_L
 254 \end{array} \right)\]
 255 in such a way that successive rows of matrix $A$ and both vectors $x$ and $b$ are assigned to one cluster, where for all $l,m\in\{1,\ldots,L\}$ $A_{lm}$ is a rectangular block of $A$ of size $n_l\times n_m$, $X_l$ and $B_l$ are sub-vectors of $x$ and $b$, respectively, of size $n_l$ each and $\sum_{l} n_l=\sum_{m} n_m=n$.
 256
 257 The multisplitting method proceeds by iteration to solve in parallel the linear system on $L$ clusters of processors, in such a way each sub-system
 258 \begin{equation}
 259 \left\{
 260 \begin{array}{l}
 261 A_{ll}X_l = Y_l \mbox{,~such that}\\
 262 Y_l = B_l - \displaystyle\sum_{\substack{m=1\\ m\neq l}}^{L}A_{lm}X_m
 263 \end{array}
 264 \right.
 265 \label{eq:4.1}
 266 \end{equation}
 267 is solved independently by a cluster and communications are required to update the right-hand side sub-vector $Y_l$, such that the sub-vectors $X_m$ represent the data dependencies between the clusters. As each sub-system (\ref{eq:4.1}) is solved in parallel by a cluster of processors, our multisplitting method uses an iterative method as an inner solver which is easier to parallelize and more scalable than a direct method. In this work, we use the parallel algorithm of GMRES method~\cite{ref1} which is one of the most used iterative method by many researchers.
 268
 269 \begin{figure}[!t]
 270   %%% IEEE instructions forbid to use an algorithm environment here, use figure
 271   %%% instead
 272 \begin{algorithmic}[1]
 273 \Input $A_l$ (sparse sub-matrix), $B_l$ (right-hand side sub-vector)
 274 \Output $X_l$ (solution sub-vector)\vspace{0.2cm}
 275 \State Load $A_l$, $B_l$
 276 \State Set the initial guess $x^0$
 277 \For {$k=0,1,2,\ldots$ until the global convergence}
 278 \State Restart outer iteration with $x^0=x^k$
 279 \State Inner iteration: \Call{InnerSolver}{$x^0$, $k+1$}
 280 \State Send shared elements of $X_l^{k+1}$ to neighboring clusters
 281 \State Receive shared elements in $\{X_m^{k+1}\}_{m\neq l}$
 282 \EndFor
 283
 284 \Statex
 285
 286 \Function {InnerSolver}{$x^0$, $k$}
 287 \State Compute local right-hand side $Y_l$: \[Y_l = B_l - \sum\nolimits^L_{\substack{m=1 \\m\neq l}}A_{lm}X_m^0\]
 288 \State Solving sub-system $A_{ll}X_l^k=Y_l$ with the parallel GMRES method
 289 \State \Return $X_l^k$
 290 \EndFunction
 291 \end{algorithmic}
 292 \caption{A multisplitting solver with GMRES method}
 293 \label{algo:01}
 294 \end{figure}
 295
 296 Algorithm on Figure~\ref{algo:01} shows the main key points of the
 297 multisplitting method to solve a large sparse linear system. This algorithm is
 298 based on an outer-inner iteration method where the parallel synchronous GMRES
 299 method is used to solve the inner iteration. It is executed in parallel by each
 300 cluster of processors. For all $l,m\in\{1,\ldots,L\}$, the matrices and vectors
 301 with the subscript $l$ represent the local data for cluster $l$, while
 302 $\{A_{lm}\}_{m\neq l}$ are off-diagonal matrices of sparse matrix $A$ and
 303 $\{X_m\}_{m\neq l}$ contain vector elements of solution $x$ shared with
 304 neighboring clusters. At every outer iteration $k$, asynchronous communications
 305 are performed between processors of the local cluster and those of distant
 306 clusters (lines $6$ and $7$ in Figure~\ref{algo:01}). The shared vector
 307 elements of the solution $x$ are exchanged by message passing using MPI
 308 non-blocking communication routines.
 309
 310 \begin{figure}[!t]
 311 \centering
 312   \includegraphics[width=60mm,keepaspectratio]{clustering}
 313 \caption{Example of three clusters of processors interconnected by a virtual unidirectional ring network.}
 314 \label{fig:4.1}
 315 \end{figure}
 316
 317 The global convergence of the asynchronous multisplitting solver is detected when the clusters of processors have all converged locally. We implemented the global convergence detection process as follows. On each cluster a master processor is designated (for example the processor with rank $1$) and masters of all clusters are interconnected by a virtual unidirectional ring network (see Figure~\ref{fig:4.1}). During the resolution, a Boolean token circulates around the virtual ring from a master processor to another until the global convergence is achieved. So starting from the cluster with rank $1$, each master processor $i$ sets the token to {\it True} if the local convergence is achieved or to {\it False} otherwise, and sends it to master processor $i+1$. Finally, the global convergence is detected when the master of cluster $1$ receives from the master of cluster $L$ a token set to {\it True}. In this case, the master of cluster $1$ broadcasts a stop message to masters of other clusters. In this work, the local convergence on each cluster $l$ is detected when the following condition is satisfied
 318 \[(k\leq \MI) \mbox{~or~} (\|X_l^k - X_l^{k+1}\|_{\infty}\leq\epsilon)\]
 319 where $\MI$ is the maximum number of outer iterations and $\epsilon$ is the tolerance threshold of the error computed between two successive local solution $X_l^k$ and $X_l^{k+1}$.
 320
 321 \LZK{Description du processus d'adaptation de l'algo multisplitting à SimGrid}
 322 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 323
 324
 325
 326
 327
 328
 329
 330
 331 \section{Experimental results}
 332
 333 When the \emph{real} application runs in the simulation environment and produces the expected results, varying the input
 334 parameters and the program arguments allows us to compare outputs from the code execution. We have noticed from this
 335 study that the results depend on the following parameters:
 336 \begin{itemize}
 337 \item At the network level, we found that
 338 the most critical values are the bandwidth (bw) and the network latency (lat).
 339 \item Hosts power (GFlops) can also
 340 influence on the results.
 341 \item Finally, when submitting job batches for execution, the arguments values passed to the
 342 program like the maximum number of iterations or the \emph{external} precision are critical. They allow to ensure not
 343 only the convergence of the algorithm but also to get the main objective of the experimentation of the simulation in
 344 having an execution time in asynchronous less than in synchronous mode (i.e. speed-up less than $1$).
 345 \end{itemize}
 346
 347 A priori, obtaining a speedup less than $1$ would be difficult in a local area
 348 network configuration where the synchronous mode will take advantage on the rapid
 349 exchange of information on such high-speed links. Thus, the methodology adopted
 350 was to launch the application on clustered network. In this last configuration,
 351 degrading the inter-cluster network performance will \emph{penalize} the synchronous
 352 mode allowing to get a speedup lower than $1$. This action simulates the case of
 353 clusters linked with long distance network like Internet.
 354
 355 As a first step, the algorithm was run on a network consisting of two clusters
 356 containing $50$ hosts each, totaling $100$ hosts. Various combinations of
 357 the above factors have providing the results shown in
 358 Table~\ref{tab.cluster.2x50} with a matrix size ranging from $N_x = N_y = N_z =
 359 62 \text{ to } 171$ elements or from $62^{3} = \np{238328}$ to $171^{3} =
 360 \np{5211000}$ entries.
 361
 362 \begin{table}[!t]
 363   \centering
 364   \caption{$2$ clusters, each with $50$ nodes}
 365   \label{tab.cluster.2x50}
 366   \renewcommand{\arraystretch}{1.3}
 367
 368   \begin{tabular}{|>{\bfseries}r|*{12}{c|}}
 369     \hline
 370     bw
 371     & 5         & 5         & 5         & 5         & 5         & 50 \\
 372     \hline
 373     lat
 374     & 0.02      & 0.02      & 0.02      & 0.02      & 0.02      & 0.02 \\
 375     \hline
 376     power
 377     & 1         & 1         & 1         & 1.5       & 1.5       & 1.5 \\
 378     \hline
 379     size
 380     & 62        & 62        & 62        & 100       & 100       & 110 \\
 381     \hline
 382     Prec/Eprec
 383     & \np{E-5}  & \np{E-8}  & \np{E-9}  & \np{E-11} & \np{E-11} & \np{E-11} \\
 384     \hline
 385     speedup
 386     & 0.396     & 0.392     & 0.396     & 0.391     & 0.393     & 0.395 \\
 387     \hline
 388   \end{tabular}
 389
 390   \smallskip
 391
 392   \begin{tabular}{|>{\bfseries}r|*{12}{c|}}
 393     \hline
 394     bw
 395     & 50        & 50        & 50        & 50        & 10        & 10 \\
 396     \hline
 397     lat
 398     & 0.02      & 0.02      & 0.02      & 0.02      & 0.03      & 0.01 \\
 399     \hline
 400     power
 401     & 1.5       & 1.5       & 1.5       & 1.5       & 1         & 1.5 \\
 402     \hline
 403     size
 404     & 120       & 130       & 140       & 150       & 171       & 171 \\
 405     \hline
 406     Prec/Eprec
 407     & \np{E-11} & \np{E-11} & \np{E-11} & \np{E-11} & \np{E-5}  & \np{E-5} \\
 408     \hline
 409     speedup
 410     & 0.398     & 0.388     & 0.393     & 0.394     & 0.63      & 0.778 \\
 411     \hline
 412   \end{tabular}
 413 \end{table}
 414
 415 Then we have changed the network configuration using three clusters containing
 416 respectively $33$, $33$ and $34$ hosts, or again by on hundred hosts for all the
 417 clusters. In the same way as above, a judicious choice of key parameters has
 418 permitted to get the results in Table~\ref{tab.cluster.3x33} which shows the
 419 speedups less than $1$ with a matrix size from $62$ to $100$ elements.
 420
 421 \begin{table}[!t]
 422   \centering
 423   \caption{$3$ clusters, each with $33$ nodes}
 424   \label{tab.cluster.3x33}
 425   \renewcommand{\arraystretch}{1.3}
 426
 427   \begin{tabular}{|>{\bfseries}r|*{6}{c|}}
 428     \hline
 429     bw
 430     & 10       & 5        & 4        & 3        & 2        & 6 \\
 431     \hline
 432     lat
 433     & 0.01     & 0.02     & 0.02     & 0.02     & 0.02     & 0.02 \\
 434     \hline
 435     power
 436     & 1        & 1        & 1        & 1        & 1        & 1 \\
 437     \hline
 438     size
 439     & 62       & 100      & 100      & 100      & 100      & 171 \\
 440     \hline
 441     Prec/Eprec
 442     & \np{E-5} & \np{E-5} & \np{E-5} & \np{E-5} & \np{E-5} & \np{E-5} \\
 443     \hline
 444     speedup
 445     & 0.997    & 0.99     & 0.93     & 0.84     & 0.78     & 0.99 \\
 446     \hline
 447   \end{tabular}
 448 \end{table}
 449
 450
 451 In a final step, results of an execution attempt to scale up the three clustered
 452 configuration but increasing by two hundreds hosts has been recorded in
 453 Table~\ref{tab.cluster.3x67}.
 454
 455 \begin{table}[!t]
 456   \centering
 457   \caption{3 clusters, each with 66 nodes}
 458   \label{tab.cluster.3x67}
 459   \renewcommand{\arraystretch}{1.3}
 460
 461   \begin{tabular}{|>{\bfseries}r|c|}
 462     \hline
 463     bw         & 1 \\
 464     \hline
 465     lat        & 0.02 \\
 466     \hline
 467     power      & 1 \\
 468     \hline
 469     size       & 62 \\
 470     \hline
 471     Prec/Eprec & \np{E-5} \\
 472     \hline
 473     speedup    & 0.9 \\
 474     \hline
 475  \end{tabular}
 476 \end{table}
 477
 478 Note that the program was run with the following parameters:
 479
 480 \paragraph*{SMPI parameters}
 481
 482 \begin{itemize}
 483         \item HOSTFILE: Hosts file description.
 484         \item PLATFORM: file description of the platform architecture : clusters (CPU power,
 485 \dots{}), intra cluster network description, inter cluster network (bandwidth bw,
 486 lat latency, \dots{}).
 487 \end{itemize}
 488
 489
 490 \paragraph*{Arguments of the program}
 491
 492 \begin{itemize}
 493         \item Description of the cluster architecture;
 494         \item Maximum number of internal and external iterations;
 495         \item Internal and external precisions;
 496         \item Matrix size $N_x$, $N_y$ and $N_z$;
 497         \item Matrix diagonal value: \np{6.0};
 498         \item Execution Mode: synchronous or asynchronous.
 499 \end{itemize}
 500
 501 \paragraph*{Interpretations and comments}
 502
 503 After analyzing the outputs, generally, for the configuration with two or three
 504 clusters including one hundred hosts (Tables~\ref{tab.cluster.2x50}
 505 and~\ref{tab.cluster.3x33}), some combinations of the used parameters affecting
 506 the results have given a speedup less than 1, showing the effectiveness of the
 507 asynchronous performance compared to the synchronous mode.
 508
 509 In the case of a two clusters configuration, Table~\ref{tab.cluster.2x50} shows
 510 that with a deterioration of inter cluster network set with \np[Mbits/s]{5} of
 511 bandwidth, a latency in order of a hundredth of a millisecond and a system power
 512 of one GFlops, an efficiency of about \np[\%]{40} in asynchronous mode is
 513 obtained for a matrix size of 62 elements. It is noticed that the result remains
 514 stable even if we vary the external precision from \np{E-5} to \np{E-9}. By
 515 increasing the problem size up to $100$ elements, it was necessary to increase the
 516 CPU power of \np[\%]{50} to \np[GFlops]{1.5} for a convergence of the algorithm
 517 with the same order of asynchronous mode efficiency.  Maintaining such a system
 518 power but this time, increasing network throughput inter cluster up to
 519 \np[Mbits/s]{50}, the result of efficiency of about \np[\%]{40} is obtained with
 520 high external precision of \np{E-11} for a matrix size from $110$ to $150$ side
 521 elements.
 522
 523 For the $3$ clusters architecture including a total of 100 hosts,
 524 Table~\ref{tab.cluster.3x33} shows that it was difficult to have a combination
 525 which gives an efficiency of asynchronous below \np[\%]{80}. Indeed, for a
 526 matrix size of $62$ elements, equality between the performance of the two modes
 527 (synchronous and asynchronous) is achieved with an inter cluster of
 528 \np[Mbits/s]{10} and a latency of \np[ms]{E-1}. To challenge an efficiency by
 529 \np[\%]{78} with a matrix size of $100$ points, it was necessary to degrade the
 530 inter cluster network bandwidth from 5 to 2 Mbit/s.
 531
 532 A last attempt was made for a configuration of three clusters but more powerful
 533 with 200 nodes in total. The convergence with a speedup of \np[\%]{90} was
 534 obtained with a bandwidth of \np[Mbits/s]{1} as shown in
 535 Table~\ref{tab.cluster.3x67}.
 536
 537 \section{Conclusion}
 538 The experimental results on executing a parallel iterative algorithm in
 539 asynchronous mode on an environment simulating a large scale of virtual
 540 computers organized with interconnected clusters have been presented.
 541 Our work has demonstrated that using such a simulation tool allow us to
 542 reach the following three objectives:
 543
 544 \newcounter{numberedCntD}
 545 \begin{enumerate}
 546 \item To have a flexible configurable execution platform resolving the
 547 hard exercise to access to very limited but so solicited physical
 548 resources;
 549 \item to ensure the algorithm convergence with a raisonnable time and
 550 iteration number ;
 551 \item and finally and more importantly, to find the correct combination
 552 of the cluster and network specifications permitting to save time in
 553 executing the algorithm in asynchronous mode.
 554 \setcounter{numberedCntD}{\theenumi}
 555 \end{enumerate}
 556 Our results have shown that in certain conditions, asynchronous mode is
 557 speeder up to \np[\%]{40} than executing the algorithm in synchronous mode
 558 which is not negligible for solving complex practical problems with more
 559 and more increasing size.
 560
 561  Several studies have already addressed the performance execution time of
 562 this class of algorithm. The work presented in this paper has
 563 demonstrated an original solution to optimize the use of a simulation
 564 tool to run efficiently an iterative parallel algorithm in asynchronous
 565 mode in a grid architecture.
 566
 567 \section*{Acknowledgment}
 568
 569 This work is partially funded by the Labex ACTION program (contract ANR-11-LABX-01-01).
 570 The authors would like to thank\dots{}
 571
 572
 573 % trigger a \newpage just before the given reference
 574 % number - used to balance the columns on the last page
 575 % adjust value as needed - may need to be readjusted if
 576 % the document is modified later
 577 \bibliographystyle{IEEEtran}
 578 \bibliography{IEEEabrv,hpccBib}
 579
 580 \end{document}
 581
 582 %%% Local Variables:
 583 %%% mode: latex
 584 %%% TeX-master: t
 585 %%% fill-column: 80
 586 %%% ispell-local-dictionary: "american"
 587 %%% End: