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{}.
 112
 113 Parallelization of such algorithms generally involved the division of the problem into several \emph{pieces} that will
 114 be solved in parallel on multiple processing units. The latter will communicate each intermediate results before a new
 115 iteration starts  until the approximate solution is reached. These parallel  computations can be performed either in
 116 \emph{synchronous} communication 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{bcvc06:ij} for more details).
 123
 124 Parallel numerical applications (synchronous or asynchronous) may have different configuration and deployment
 125 requirements.  Quantifying their performance of resource allocation policies and application scheduling algorithms in
 126 grid computing environments under varying load, CPU power and network speeds is very costly, labor intensive and time
 127 consuming \cite{BuRaCa}. 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. In this context, it appears that the use of simulation tools to explore various platform
 131 scenarios and to run enormous 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 to give a first approach of the simulation of AIAC algorithms using the SimGrid toolkit \cite{SimGrid}. We had
 141 in the scope of this work implemented a  program for solving large non-symmetric linear system of equations by numerical
 142 method GMRES (Generalized Minimal Residual). SimGrid had allowed us to launch the application from a modest computing
 143 infrastructure by simulating  different distributed architectures composed by clusters nodes interconnected by variable
 144 speed networks. The simulated results we obtained are in line with real results exposed in ?? In addition, it has been
 145 permitted to show the effectiveness of asynchronous mode algorithm by comparing its performance with the synchronous
 146 mode time. With selected parameters on the network platforms (bandwidth, latency of inter  cluster  network) and on the
 147 clusters architecture (number, capacity calculation power) in the simulated environment, the experimental results have
 148 demonstrated not only the algorithm convergence within a reasonable time compared with the physical environment
 149 performance, but also a time saving of up to \np[\%]{40} in asynchronous mode.
 150
 151 This article is structured as follows: after this introduction, the next  section will give a brief description of
 152 iterative asynchronous model.  Then, the simulation framework SimGrid is presented with the settings to create various
 153 distributed architectures. The algorithm of  the multi-splitting method used by GMRES written with MPI primitives and
 154 its adaptation to SimGrid with SMPI (Simulated MPI) is detailed in the next section. At last, the experiments results
 155 carried out will be presented before some concluding remarks and future works.
 156
 157 \section{Motivations and scientific context}
 158
 159 As exposed in the introduction, parallel iterative methods are now widely used in many scientific domains. They can be
 160 classified in three main classes depending on how iterations and communications are managed (for more details readers
 161 can refer to \cite{bcvc02:ip}). In the \textit{Synchronous Iterations - Synchronous Communications (SISC)} model data
 162 are exchanged at the end of each iteration. All the processors must begin the same iteration at the same time and
 163 important idle times on processors are generated. The \textit{Synchronous Iterations - Asynchronous Communications
 164 (SIAC)} model can be compared to the previous one except that data required on another processor are sent asynchronously
 165 i.e.  without stopping current computations. This technique allows to partially overlap communications by computations
 166 but unfortunately, the overlapping is only partial and important idle times remain.  It is clear that, in a grid
 167 computing context, where the number of computational nodes is large, heterogeneous and widely distributed, the idle
 168 times generated by synchronizations are very penalizing. One way to overcome this problem is to use the
 169 \textit{Asynchronous Iterations - Asynchronous   Communications (AIAC)} model. Here, local computations do not need to
 170 wait for required data. Processors can then perform their iterations with the data present at that time. Figure
 171 \ref{fig:aiac} illustrates this model where the grey blocks represent the computation phases, the white spaces the idle
 172 times and the arrows the communications. With this algorithmic model, the number of iterations required before the
 173 convergence is generally greater than for the two former classes. But, and as detailed in \cite{bcvc06:ij}, AIAC
 174 algorithms can significantly reduce overall execution times by suppressing idle times due to synchronizations especially
 175 in a grid computing context.
 176
 177 \begin{figure}[!t]
 178   \centering
 179     \includegraphics[width=8cm]{AIAC.pdf}
 180   \caption{The Asynchronous Iterations - Asynchronous Communications model }
 181   \label{fig:aiac}
 182 \end{figure}
 183
 184
 185 It is very challenging to develop efficient applications for large scale, heterogeneous and distributed platforms such
 186 as computing grids. Researchers and engineers have to develop techniques for maximizing application performance of these
 187 multi-cluster platforms, by redesigning the applications and/or by using novel algorithms that can account for the
 188 composite and heterogeneous nature of the platform. Unfortunately, the deployment of such applications on these very
 189 large scale systems is very costly, labor intensive and time consuming. In this context, it appears that the use of
 190 simulation tools to explore various platform scenarios at will and to run enormous numbers of experiments quickly can be
 191 very promising. Several works...
 192
 193 In the context of AIAC algorithms, the use of simulation tools is even more relevant. Indeed, this class of applications
 194 is very sensible to the execution environment context. For instance, variations in the network bandwith (intra and
 195 inter-clusters), in the number and the power of nodes, in the number of clusters... can lead to very different number of
 196 iterations and so to very different execution times.
 197
 198
 199
 200
 201 \section{SimGrid}
 202
 203 SimGrid~\cite{casanova+legrand+quinson.2008.simgrid,SimGrid} is a simulation
 204 framework to sudy the behavior of large-scale distributed systems.  As its name
 205 says, it emanates from the grid computing community, but is nowadays used to
 206 study grids, clouds, HPC or peer-to-peer systems.
 207 %- open source, developped since 1999, one of the major solution in the field
 208 %
 209 SimGrid provides several programming interfaces: MSG to simulate Concurrent
 210 Sequential Processes, SimDAG to simulate DAGs of (parallel) tasks, and SMPI to
 211 run real applications written in MPI~\cite{MPI}.  Apart from the native C
 212 interface, SimGrid provides bindings for the C++, Java, Lua and Ruby programming
 213 languages.  The SMPI interface supports applications written in C or Fortran,
 214 with little or no modifications.
 215 %- implements most of MPI-2 \cite{ref} standard [CHECK]
 216
 217 %%% explain simulation
 218 %- simulated processes folded in one real process
 219 %- simulates interactions on the network, fluid model
 220 %- able to skip long-lasting computations
 221 %- traces + visu?
 222
 223 %%% platforms
 224 %- describe resources and their interconnection, with their properties
 225 %- XML files
 226
 227 %%% validation + refs
 228
 229 \AG{Décrire SimGrid~\cite{casanova+legrand+quinson.2008.simgrid,SimGrid} (Arnaud)}
 230
 231 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 232 \section{Simulation of the multisplitting method}
 233 %Décrire le problème (algo) traité ainsi que le processus d'adaptation à SimGrid.
 234 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. In this case, we apply a row-by-row splitting without overlapping
 235 \[
 236 \left(\begin{array}{ccc}
 237 A_{11} & \cdots & A_{1L} \\
 238 \vdots & \ddots & \vdots\\
 239 A_{L1} & \cdots & A_{LL}
 240 \end{array} \right)
 241 \times
 242 \left(\begin{array}{c}
 243 X_1 \\
 244 \vdots\\
 245 X_L
 246 \end{array} \right)
 247 =
 248 \left(\begin{array}{c}
 249 B_1 \\
 250 \vdots\\
 251 B_L
 252 \end{array} \right)\]
 253 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$.
 254
 255 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
 256 \begin{equation}
 257 \left\{
 258 \begin{array}{l}
 259 A_{ll}X_l = Y_l \mbox{,~such that}\\
 260 Y_l = B_l - \displaystyle\sum_{\substack{m=1\\ m\neq l}}^{L}A_{lm}X_m
 261 \end{array}
 262 \right.
 263 \label{eq:4.1}
 264 \end{equation}
 265 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.
 266
 267 \begin{figure}[!t]
 268   %%% IEEE instructions forbid to use an algorithm environment here, use figure
 269   %%% instead
 270 \begin{algorithmic}[1]
 271 \Input $A_l$ (sparse sub-matrix), $B_l$ (right-hand side sub-vector)
 272 \Output $X_l$ (solution sub-vector)\vspace{0.2cm}
 273 \State Load $A_l$, $B_l$
 274 \State Set the initial guess $x^0$
 275 \For {$k=0,1,2,\ldots$ until the global convergence}
 276 \State Restart outer iteration with $x^0=x^k$
 277 \State Inner iteration: \Call{InnerSolver}{$x^0$, $k+1$}
 278 \State Send shared elements of $X_l^{k+1}$ to neighboring clusters
 279 \State Receive shared elements in $\{X_m^{k+1}\}_{m\neq l}$
 280 \EndFor
 281
 282 \Statex
 283
 284 \Function {InnerSolver}{$x^0$, $k$}
 285 \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\]
 286 \State Solving sub-system $A_{ll}X_l^k=Y_l$ with the parallel GMRES method
 287 \State \Return $X_l^k$
 288 \EndFunction
 289 \end{algorithmic}
 290 \caption{A multisplitting solver with GMRES method}
 291 \label{algo:01}
 292 \end{figure}
 293
 294 Algorithm on Figure~\ref{algo:01} shows the main key points of the
 295 multisplitting method to solve a large sparse linear system. This algorithm is
 296 based on an outer-inner iteration method where the parallel synchronous GMRES
 297 method is used to solve the inner iteration. It is executed in parallel by each
 298 cluster of processors. For all $l,m\in\{1,\ldots,L\}$, the matrices and vectors
 299 with the subscript $l$ represent the local data for cluster $l$, while
 300 $\{A_{lm}\}_{m\neq l}$ are off-diagonal matrices of sparse matrix $A$ and
 301 $\{X_m\}_{m\neq l}$ contain vector elements of solution $x$ shared with
 302 neighboring clusters. At every outer iteration $k$, asynchronous communications
 303 are performed between processors of the local cluster and those of distant
 304 clusters (lines $6$ and $7$ in Figure~\ref{algo:01}). The shared vector
 305 elements of the solution $x$ are exchanged by message passing using MPI
 306 non-blocking communication routines.
 307
 308 \begin{figure}[!t]
 309 \centering
 310   \includegraphics[width=60mm,keepaspectratio]{clustering}
 311 \caption{Example of three clusters of processors interconnected by a virtual unidirectional ring network.}
 312 \label{fig:4.1}
 313 \end{figure}
 314
 315 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
 316 \[(k\leq \MI) \mbox{~or~} (\|X_l^k - X_l^{k+1}\|_{\infty}\leq\epsilon)\]
 317 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}$.
 318
 319 \LZK{Description du processus d'adaptation de l'algo multisplitting à SimGrid}
 320 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 321
 322
 323
 324
 325
 326
 327
 328
 329 \section{Experimental results}
 330
 331 When the \emph{real} application runs in the simulation environment and produces
 332 the expected results, varying the input parameters and the program arguments
 333 allows us to compare outputs from the code execution. We have noticed from this
 334 study that the results depend on the following parameters: (1) at the network
 335 level, we found that the most critical values are the bandwidth (bw) and the
 336 network latency (lat). (2) Hosts power (GFlops) can also influence on the
 337 results. And finally, (3) when submitting job batches for execution, the
 338 arguments values passed to the program like the maximum number of iterations or
 339 the \emph{external} precision are critical to ensure not only the convergence of the
 340 algorithm but also to get the main objective of the experimentation of the
 341 simulation in having an execution time in asynchronous less than in synchronous
 342 mode, in others words, in having a \emph{speedup} less than 1
 343 ({speedup}${}={}${execution time in synchronous mode}${}/{}${execution time in
 344 asynchronous mode}).
 345
 346 A priori, obtaining a speedup less than 1 would be difficult in a local area
 347 network configuration where the synchronous mode will take advantage on the rapid
 348 exchange of information on such high-speed links. Thus, the methodology adopted
 349 was to launch the application on clustered network. In this last configuration,
 350 degrading the inter-cluster network performance will \emph{penalize} the synchronous
 351 mode allowing to get a speedup lower than 1. This action simulates the case of
 352 clusters linked with long distance network like Internet.
 353
 354 As a first step, the algorithm was run on a network consisting of two clusters
 355 containing fifty hosts each, totaling one hundred hosts. Various combinations of
 356 the above factors have providing the results shown in
 357 Table~\ref{tab.cluster.2x50} with a matrix size ranging from $N_x = N_y = N_z =
 358 62 \text{ to } 171$ elements or from $62^{3} = \np{238328}$ to $171^{3} =
 359 \np{5211000}$ entries.
 360
 361 \begin{table}[!t]
 362   \centering
 363   \caption{2 clusters, each with 50 nodes}
 364   \label{tab.cluster.2x50}
 365   \renewcommand{\arraystretch}{1.3}
 366
 367   \begin{tabular}{|>{\bfseries}r|*{12}{c|}}
 368     \hline
 369     bw
 370     & 5         & 5         & 5         & 5         & 5         & 50 \\
 371     \hline
 372     lat
 373     & 0.02      & 0.02      & 0.02      & 0.02      & 0.02      & 0.02 \\
 374     \hline
 375     power
 376     & 1         & 1         & 1         & 1.5       & 1.5       & 1.5 \\
 377     \hline
 378     size
 379     & 62        & 62        & 62        & 100       & 100       & 110 \\
 380     \hline
 381     Prec/Eprec
 382     & \np{E-5}  & \np{E-8}  & \np{E-9}  & \np{E-11} & \np{E-11} & \np{E-11} \\
 383     \hline
 384     speedup
 385     & 0.396     & 0.392     & 0.396     & 0.391     & 0.393     & 0.395 \\
 386     \hline
 387   \end{tabular}
 388
 389   \smallskip
 390
 391   \begin{tabular}{|>{\bfseries}r|*{12}{c|}}
 392     \hline
 393     bw
 394     & 50        & 50        & 50        & 50        & 10        & 10 \\
 395     \hline
 396     lat
 397     & 0.02      & 0.02      & 0.02      & 0.02      & 0.03      & 0.01 \\
 398     \hline
 399     power
 400     & 1.5       & 1.5       & 1.5       & 1.5       & 1         & 1.5 \\
 401     \hline
 402     size
 403     & 120       & 130       & 140       & 150       & 171       & 171 \\
 404     \hline
 405     Prec/Eprec
 406     & \np{E-11} & \np{E-11} & \np{E-11} & \np{E-11} & \np{E-5}  & \np{E-5} \\
 407     \hline
 408     speedup
 409     & 0.398     & 0.388     & 0.393     & 0.394     & 0.63      & 0.778 \\
 410     \hline
 411   \end{tabular}
 412 \end{table}
 413
 414 Then we have changed the network configuration using three clusters containing
 415 respectively 33, 33 and 34 hosts, or again by on hundred hosts for all the
 416 clusters. In the same way as above, a judicious choice of key parameters has
 417 permitted to get the results in Table~\ref{tab.cluster.3x33} which shows the
 418 speedups less than 1 with a matrix size from 62 to 100 elements.
 419
 420 \begin{table}[!t]
 421   \centering
 422   \caption{3 clusters, each with 33 nodes}
 423   \label{tab.cluster.3x33}
 424   \renewcommand{\arraystretch}{1.3}
 425
 426   \begin{tabular}{|>{\bfseries}r|*{6}{c|}}
 427     \hline
 428     bw
 429     & 10       & 5        & 4        & 3        & 2        & 6 \\
 430     \hline
 431     lat
 432     & 0.01     & 0.02     & 0.02     & 0.02     & 0.02     & 0.02 \\
 433     \hline
 434     power
 435     & 1        & 1        & 1        & 1        & 1        & 1 \\
 436     \hline
 437     size
 438     & 62       & 100      & 100      & 100      & 100      & 171 \\
 439     \hline
 440     Prec/Eprec
 441     & \np{E-5} & \np{E-5} & \np{E-5} & \np{E-5} & \np{E-5} & \np{E-5} \\
 442     \hline
 443     speedup
 444     & 0.997    & 0.99     & 0.93     & 0.84     & 0.78     & 0.99 \\
 445     \hline
 446   \end{tabular}
 447 \end{table}
 448
 449
 450 In a final step, results of an execution attempt to scale up the three clustered
 451 configuration but increasing by two hundreds hosts has been recorded in
 452 Table~\ref{tab.cluster.3x67}.
 453
 454 \begin{table}[!t]
 455   \centering
 456   \caption{3 clusters, each with 66 nodes}
 457   \label{tab.cluster.3x67}
 458   \renewcommand{\arraystretch}{1.3}
 459
 460   \begin{tabular}{|>{\bfseries}r|c|}
 461     \hline
 462     bw         & 1 \\
 463     \hline
 464     lat        & 0.02 \\
 465     \hline
 466     power      & 1 \\
 467     \hline
 468     size       & 62 \\
 469     \hline
 470     Prec/Eprec & \np{E-5} \\
 471     \hline
 472     speedup    & 0.9 \\
 473     \hline
 474  \end{tabular}
 475 \end{table}
 476
 477 Note that the program was run with the following parameters:
 478
 479 \paragraph*{SMPI parameters}
 480
 481 \begin{itemize}
 482         \item HOSTFILE: Hosts file description.
 483         \item PLATFORM: file description of the platform architecture : clusters (CPU power,
 484 \dots{}), intra cluster network description, inter cluster network (bandwidth bw,
 485 lat latency, \dots{}).
 486 \end{itemize}
 487
 488
 489 \paragraph*{Arguments of the program}
 490
 491 \begin{itemize}
 492         \item Description of the cluster architecture;
 493         \item Maximum number of internal and external iterations;
 494         \item Internal and external precisions;
 495         \item Matrix size $N_x$, $N_y$ and $N_z$;
 496         \item Matrix diagonal value: \np{6.0};
 497         \item Execution Mode: synchronous or asynchronous.
 498 \end{itemize}
 499
 500 \paragraph*{Interpretations and comments}
 501
 502 After analyzing the outputs, generally, for the configuration with two or three
 503 clusters including one hundred hosts (Tables~\ref{tab.cluster.2x50}
 504 and~\ref{tab.cluster.3x33}), some combinations of the used parameters affecting
 505 the results have given a speedup less than 1, showing the effectiveness of the
 506 asynchronous performance compared to the synchronous mode.
 507
 508 In the case of a two clusters configuration, Table~\ref{tab.cluster.2x50} shows
 509 that with a deterioration of inter cluster network set with \np[Mbits/s]{5} of
 510 bandwidth, a latency in order of a hundredth of a millisecond and a system power
 511 of one GFlops, an efficiency of about \np[\%]{40} in asynchronous mode is
 512 obtained for a matrix size of 62 elements. It is noticed that the result remains
 513 stable even if we vary the external precision from \np{E-5} to \np{E-9}. By
 514 increasing the problem size up to 100 elements, it was necessary to increase the
 515 CPU power of \np[\%]{50} to \np[GFlops]{1.5} for a convergence of the algorithm
 516 with the same order of asynchronous mode efficiency.  Maintaining such a system
 517 power but this time, increasing network throughput inter cluster up to
 518 \np[Mbits/s]{50}, the result of efficiency of about \np[\%]{40} is obtained with
 519 high external precision of \np{E-11} for a matrix size from 110 to 150 side
 520 elements.
 521
 522 For the 3 clusters architecture including a total of 100 hosts,
 523 Table~\ref{tab.cluster.3x33} shows that it was difficult to have a combination
 524 which gives an efficiency of asynchronous below \np[\%]{80}. Indeed, for a
 525 matrix size of 62 elements, equality between the performance of the two modes
 526 (synchronous and asynchronous) is achieved with an inter cluster of
 527 \np[Mbits/s]{10} and a latency of \np[ms]{E-1}. To challenge an efficiency by
 528 \np[\%]{78} with a matrix size of 100 points, it was necessary to degrade the
 529 inter cluster network bandwidth from 5 to 2 Mbit/s.
 530
 531 A last attempt was made for a configuration of three clusters but more powerful
 532 with 200 nodes in total. The convergence with a speedup of \np[\%]{90} was
 533 obtained with a bandwidth of \np[Mbits/s]{1} as shown in
 534 Table~\ref{tab.cluster.3x67}.
 535
 536 \section{Conclusion}
 537 The experimental results on executing a parallel iterative algorithm in
 538 asynchronous mode on an environment simulating a large scale of virtual
 539 computers organized with interconnected clusters have been presented.
 540 Our work has demonstrated that using such a simulation tool allow us to
 541 reach the following three objectives:
 542
 543 \newcounter{numberedCntD}
 544 \begin{enumerate}
 545 \item To have a flexible configurable execution platform resolving the
 546 hard exercise to access to very limited but so solicited physical
 547 resources;
 548 \item to ensure the algorithm convergence with a raisonnable time and
 549 iteration number ;
 550 \item and finally and more importantly, to find the correct combination
 551 of the cluster and network specifications permitting to save time in
 552 executing the algorithm in asynchronous mode.
 553 \setcounter{numberedCntD}{\theenumi}
 554 \end{enumerate}
 555 Our results have shown that in certain conditions, asynchronous mode is
 556 speeder up to \np[\%]{40} than executing the algorithm in synchronous mode
 557 which is not negligible for solving complex practical problems with more
 558 and more increasing size.
 559
 560  Several studies have already addressed the performance execution time of
 561 this class of algorithm. The work presented in this paper has
 562 demonstrated an original solution to optimize the use of a simulation
 563 tool to run efficiently an iterative parallel algorithm in asynchronous
 564 mode in a grid architecture.
 565
 566 \section*{Acknowledgment}
 567
 568
 569 The authors would like to thank\dots{}
 570
 571
 572 % trigger a \newpage just before the given reference
 573 % number - used to balance the columns on the last page
 574 % adjust value as needed - may need to be readjusted if
 575 % the document is modified later
 576 \bibliographystyle{IEEEtran}
 577 \bibliography{IEEEabrv,hpccBib}
 578
 579 \end{document}
 580
 581 %%% Local Variables:
 582 %%% mode: latex
 583 %%% TeX-master: t
 584 %%% fill-column: 80
 585 %%% ispell-local-dictionary: "american"
 586 %%% End: