1 \documentclass[conference]{IEEEtran}
3 \usepackage[T1]{fontenc}
4 \usepackage[utf8]{inputenc}
5 \usepackage{amsfonts,amssymb}
7 %\usepackage{algorithm}
8 \usepackage{algpseudocode}
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}
17 \DeclareUrlCommand\email{\urlstyle{same}}
19 \usepackage[autolanguage,np]{numprint}
21 \renewcommand*\npunitcommand[1]{\text{#1}}
22 \npthousandthpartsep{}}
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}
35 \algnewcommand\algorithmicinput{\textbf{Input:}}
36 \algnewcommand\Input{\item[\algorithmicinput]}
38 \algnewcommand\algorithmicoutput{\textbf{Output:}}
39 \algnewcommand\Output{\item[\algorithmicoutput]}
41 \newcommand{\MI}{\mathit{MaxIter}}
45 \title{Simulation of Asynchronous Iterative Numerical Algorithms Using SimGrid}
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}
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}
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}
71 \RC{Ordre des autheurs pas définitif.}
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.
97 % no keywords for IEEE conferences
98 % Keywords: Algorithm distributed iterative asynchronous simulation SimGrid
101 \section{Introduction}
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}.
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).
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.
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.
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.
159 \section{Motivations and scientific context}
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.
181 \includegraphics[width=8cm]{AIAC.pdf}
182 \caption{The Asynchronous Iterations - Asynchronous Communications model }
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...
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.
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.
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}.
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
228 %- describe resources and their interconnection, with their properties
231 %%% validation + refs
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
238 \left(\begin{array}{ccc}
239 A_{11} & \cdots & A_{1L} \\
240 \vdots & \ddots & \vdots\\
241 A_{L1} & \cdots & A_{LL}
244 \left(\begin{array}{c}
250 \left(\begin{array}{c}
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$.
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
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
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.
270 %%% IEEE instructions forbid to use an algorithm environment here, use figure
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}$
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$
292 \caption{A multisplitting solver with GMRES method}
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.
312 \includegraphics[width=60mm,keepaspectratio]{clustering}
313 \caption{Example of three clusters of processors interconnected by a virtual unidirectional ring network.}
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}$.
321 \LZK{Description du processus d'adaptation de l'algo multisplitting à SimGrid}
322 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
323 We did not encounter major blocking problems when adapting the multisplitting algorithm previously described to a simulation environment like SIMGRID unless some code
324 debugging. Indeed, apart from the review of the program sequence for asynchronous exchanges between the six neighbors of each point in a submatrix within a cluster or
325 between clusters, the algorithm was executed successfully with SMPI and provided identical outputs as those obtained with direct execution under MPI. In synchronous
326 mode, the execution of the program raised no particular issue but in asynchronous mode, the review of the sequence of MPI\_Isend, MPI\_Irecv and MPI\_waitall instructions
327 and with the addition of the primitive MPI\_Test was needed to avoid a memory fault due to an infinite loop resulting from the non- convergence of the algorithm. Note here that the use of SMPI
328 functions optimizer for memory footprint and CPU usage is not recommended knowing that one wants to get real results by simulation.
329 As mentioned, upon this adaptation, the algorithm is executed as in the real life in the simulated environment after the following minor changes. First, all declared
330 global variables have been moved to local variables for each subroutine. In fact, global variables generate side effects arising from the concurrent access of
331 shared memory used by threads simulating each computing units in the Simgrid architecture. Second, the alignment of certain types of variables such as "long int" had
332 also to be reviewed. Finally, some compilation errors on MPI\_waitall and MPI\_Finalise primitives have been fixed with the latest version of Simgrid.
333 In total, the initial MPI program running on the simulation environment SMPI gave after a very simple adaptation the same results as those obtained in a real
334 environment. We have tested in synchronous mode with a simulated platform starting from a modest 2 or 3 clusters grid to a larger configuration like simulating
335 Grid5000 with more than 1500 hosts with 5000 cores [?]. Once the code debugging and adaptation were complete, the next section shows our methodology and experimental
344 \section{Experimental results}
346 When the \emph{real} application runs in the simulation environment and produces the expected results, varying the input
347 parameters and the program arguments allows us to compare outputs from the code execution. We have noticed from this
348 study that the results depend on the following parameters:
350 \item At the network level, we found that
351 the most critical values are the bandwidth (bw) and the network latency (lat).
352 \item Hosts power (GFlops) can also
353 influence on the results.
354 \item Finally, when submitting job batches for execution, the arguments values passed to the
355 program like the maximum number of iterations or the \emph{external} precision are critical. They allow to ensure not
356 only the convergence of the algorithm but also to get the main objective of the experimentation of the simulation in
357 having an execution time in asynchronous less than in synchronous mode (i.e. speed-up less than $1$).
360 A priori, obtaining a speedup less than $1$ would be difficult in a local area
361 network configuration where the synchronous mode will take advantage on the rapid
362 exchange of information on such high-speed links. Thus, the methodology adopted
363 was to launch the application on clustered network. In this last configuration,
364 degrading the inter-cluster network performance will \emph{penalize} the synchronous
365 mode allowing to get a speedup lower than $1$. This action simulates the case of
366 clusters linked with long distance network like Internet.
368 As a first step, the algorithm was run on a network consisting of two clusters
369 containing $50$ hosts each, totaling $100$ hosts. Various combinations of
370 the above factors have providing the results shown in
371 Table~\ref{tab.cluster.2x50} with a matrix size ranging from $N_x = N_y = N_z =
372 62 \text{ to } 171$ elements or from $62^{3} = \np{238328}$ to $171^{3} =
373 \np{5211000}$ entries.
377 \caption{$2$ clusters, each with $50$ nodes}
378 \label{tab.cluster.2x50}
379 \renewcommand{\arraystretch}{1.3}
381 \begin{tabular}{|>{\bfseries}r|*{12}{c|}}
384 & 5 & 5 & 5 & 5 & 5 & 50 \\
387 & 0.02 & 0.02 & 0.02 & 0.02 & 0.02 & 0.02 \\
390 & 1 & 1 & 1 & 1.5 & 1.5 & 1.5 \\
393 & 62 & 62 & 62 & 100 & 100 & 110 \\
396 & \np{E-5} & \np{E-8} & \np{E-9} & \np{E-11} & \np{E-11} & \np{E-11} \\
399 & 0.396 & 0.392 & 0.396 & 0.391 & 0.393 & 0.395 \\
405 \begin{tabular}{|>{\bfseries}r|*{12}{c|}}
408 & 50 & 50 & 50 & 50 & 10 & 10 \\
411 & 0.02 & 0.02 & 0.02 & 0.02 & 0.03 & 0.01 \\
414 & 1.5 & 1.5 & 1.5 & 1.5 & 1 & 1.5 \\
417 & 120 & 130 & 140 & 150 & 171 & 171 \\
420 & \np{E-11} & \np{E-11} & \np{E-11} & \np{E-11} & \np{E-5} & \np{E-5} \\
423 & 0.398 & 0.388 & 0.393 & 0.394 & 0.63 & 0.778 \\
428 Then we have changed the network configuration using three clusters containing
429 respectively $33$, $33$ and $34$ hosts, or again by on hundred hosts for all the
430 clusters. In the same way as above, a judicious choice of key parameters has
431 permitted to get the results in Table~\ref{tab.cluster.3x33} which shows the
432 speedups less than $1$ with a matrix size from $62$ to $100$ elements.
436 \caption{$3$ clusters, each with $33$ nodes}
437 \label{tab.cluster.3x33}
438 \renewcommand{\arraystretch}{1.3}
440 \begin{tabular}{|>{\bfseries}r|*{6}{c|}}
443 & 10 & 5 & 4 & 3 & 2 & 6 \\
446 & 0.01 & 0.02 & 0.02 & 0.02 & 0.02 & 0.02 \\
449 & 1 & 1 & 1 & 1 & 1 & 1 \\
452 & 62 & 100 & 100 & 100 & 100 & 171 \\
455 & \np{E-5} & \np{E-5} & \np{E-5} & \np{E-5} & \np{E-5} & \np{E-5} \\
458 & 0.997 & 0.99 & 0.93 & 0.84 & 0.78 & 0.99 \\
464 In a final step, results of an execution attempt to scale up the three clustered
465 configuration but increasing by two hundreds hosts has been recorded in
466 Table~\ref{tab.cluster.3x67}.
470 \caption{3 clusters, each with 66 nodes}
471 \label{tab.cluster.3x67}
472 \renewcommand{\arraystretch}{1.3}
474 \begin{tabular}{|>{\bfseries}r|c|}
484 Prec/Eprec & \np{E-5} \\
491 Note that the program was run with the following parameters:
493 \paragraph*{SMPI parameters}
496 \item HOSTFILE: Hosts file description.
497 \item PLATFORM: file description of the platform architecture : clusters (CPU power,
498 \dots{}), intra cluster network description, inter cluster network (bandwidth bw,
499 lat latency, \dots{}).
503 \paragraph*{Arguments of the program}
506 \item Description of the cluster architecture;
507 \item Maximum number of internal and external iterations;
508 \item Internal and external precisions;
509 \item Matrix size $N_x$, $N_y$ and $N_z$;
510 \item Matrix diagonal value: \np{6.0};
511 \item Execution Mode: synchronous or asynchronous.
514 \paragraph*{Interpretations and comments}
516 After analyzing the outputs, generally, for the configuration with two or three
517 clusters including one hundred hosts (Tables~\ref{tab.cluster.2x50}
518 and~\ref{tab.cluster.3x33}), some combinations of the used parameters affecting
519 the results have given a speedup less than 1, showing the effectiveness of the
520 asynchronous performance compared to the synchronous mode.
522 In the case of a two clusters configuration, Table~\ref{tab.cluster.2x50} shows
523 that with a deterioration of inter cluster network set with \np[Mbits/s]{5} of
524 bandwidth, a latency in order of a hundredth of a millisecond and a system power
525 of one GFlops, an efficiency of about \np[\%]{40} in asynchronous mode is
526 obtained for a matrix size of 62 elements. It is noticed that the result remains
527 stable even if we vary the external precision from \np{E-5} to \np{E-9}. By
528 increasing the problem size up to $100$ elements, it was necessary to increase the
529 CPU power of \np[\%]{50} to \np[GFlops]{1.5} for a convergence of the algorithm
530 with the same order of asynchronous mode efficiency. Maintaining such a system
531 power but this time, increasing network throughput inter cluster up to
532 \np[Mbits/s]{50}, the result of efficiency of about \np[\%]{40} is obtained with
533 high external precision of \np{E-11} for a matrix size from $110$ to $150$ side
536 For the $3$ clusters architecture including a total of 100 hosts,
537 Table~\ref{tab.cluster.3x33} shows that it was difficult to have a combination
538 which gives an efficiency of asynchronous below \np[\%]{80}. Indeed, for a
539 matrix size of $62$ elements, equality between the performance of the two modes
540 (synchronous and asynchronous) is achieved with an inter cluster of
541 \np[Mbits/s]{10} and a latency of \np[ms]{E-1}. To challenge an efficiency by
542 \np[\%]{78} with a matrix size of $100$ points, it was necessary to degrade the
543 inter cluster network bandwidth from 5 to 2 Mbit/s.
545 A last attempt was made for a configuration of three clusters but more powerful
546 with 200 nodes in total. The convergence with a speedup of \np[\%]{90} was
547 obtained with a bandwidth of \np[Mbits/s]{1} as shown in
548 Table~\ref{tab.cluster.3x67}.
551 The experimental results on executing a parallel iterative algorithm in
552 asynchronous mode on an environment simulating a large scale of virtual
553 computers organized with interconnected clusters have been presented.
554 Our work has demonstrated that using such a simulation tool allow us to
555 reach the following three objectives:
557 \newcounter{numberedCntD}
559 \item To have a flexible configurable execution platform resolving the
560 hard exercise to access to very limited but so solicited physical
562 \item to ensure the algorithm convergence with a raisonnable time and
564 \item and finally and more importantly, to find the correct combination
565 of the cluster and network specifications permitting to save time in
566 executing the algorithm in asynchronous mode.
567 \setcounter{numberedCntD}{\theenumi}
569 Our results have shown that in certain conditions, asynchronous mode is
570 speeder up to \np[\%]{40} than executing the algorithm in synchronous mode
571 which is not negligible for solving complex practical problems with more
572 and more increasing size.
574 Several studies have already addressed the performance execution time of
575 this class of algorithm. The work presented in this paper has
576 demonstrated an original solution to optimize the use of a simulation
577 tool to run efficiently an iterative parallel algorithm in asynchronous
578 mode in a grid architecture.
580 \section*{Acknowledgment}
582 This work is partially funded by the Labex ACTION program (contract ANR-11-LABX-01-01).
583 The authors would like to thank\dots{}
586 % trigger a \newpage just before the given reference
587 % number - used to balance the columns on the last page
588 % adjust value as needed - may need to be readjusted if
589 % the document is modified later
590 \bibliographystyle{IEEEtran}
591 \bibliography{IEEEabrv,hpccBib}
599 %%% ispell-local-dictionary: "american"
