1 \documentclass[times]{cpeauth}
5 %\usepackage[dvips,colorlinks,bookmarksopen,bookmarksnumbered,citecolor=red,urlcolor=red]{hyperref}
7 %\newcommand\BibTeX{{\rmfamily B\kern-.05em \textsc{i\kern-.025em b}\kern-.08em
8 %T\kern-.1667em\lower.7ex\hbox{E}\kern-.125emX}}
16 \usepackage[T1]{fontenc}
17 \usepackage[utf8]{inputenc}
18 \usepackage{amsfonts,amssymb}
20 \usepackage{algorithm}
21 \usepackage{algpseudocode}
24 \usepackage[american]{babel}
25 % Extension pour les liens intra-documents (tagged PDF)
26 % et l'affichage correct des URL (commande \url{http://example.com})
27 %\usepackage{hyperref}
30 \DeclareUrlCommand\email{\urlstyle{same}}
32 \usepackage[autolanguage,np]{numprint}
34 \renewcommand*\npunitcommand[1]{\text{#1}}
35 \npthousandthpartsep{}}
38 \usepackage[textsize=footnotesize]{todonotes}
40 \newcommand{\AG}[2][inline]{%
41 \todo[color=green!50,#1]{\sffamily\textbf{AG:} #2}\xspace}
42 \newcommand{\RC}[2][inline]{%
43 \todo[color=red!10,#1]{\sffamily\textbf{RC:} #2}\xspace}
44 \newcommand{\LZK}[2][inline]{%
45 \todo[color=blue!10,#1]{\sffamily\textbf{LZK:} #2}\xspace}
46 \newcommand{\RCE}[2][inline]{%
47 \todo[color=yellow!10,#1]{\sffamily\textbf{RCE:} #2}\xspace}
48 \newcommand{\DL}[2][inline]{%
49 \todo[color=pink!10,#1]{\sffamily\textbf{DL:} #2}\xspace}
51 \algnewcommand\algorithmicinput{\textbf{Input:}}
52 \algnewcommand\Input{\item[\algorithmicinput]}
54 \algnewcommand\algorithmicoutput{\textbf{Output:}}
55 \algnewcommand\Output{\item[\algorithmicoutput]}
57 \newcommand{\TOLG}{\mathit{tol_{gmres}}}
58 \newcommand{\MIG}{\mathit{maxit_{gmres}}}
59 \newcommand{\TOLM}{\mathit{tol_{multi}}}
60 \newcommand{\MIM}{\mathit{maxit_{multi}}}
61 \newcommand{\TOLC}{\mathit{tol_{cgls}}}
62 \newcommand{\MIC}{\mathit{maxit_{cgls}}}
65 \usepackage{color, colortbl}
66 \newcolumntype{M}[1]{>{\centering\arraybackslash}m{#1}}
67 \newcolumntype{Z}[1]{>{\raggedleft}m{#1}}
69 \newcolumntype{g}{>{\columncolor{Gray}}c}
70 \definecolor{Gray}{gray}{0.9}
74 \begin{document} \RCE{Titre a confirmer.} \title{Comparative performance
75 analysis of simulated grid-enabled numerical iterative algorithms}
76 %\itshape{\journalnamelc}\footnotemark[2]}
78 \author{ Charles Emile Ramamonjisoa and
81 Lilia Ziane Khodja and
87 Femto-ST Institute - DISC Department\\
88 Université de Franche-Comté\\
90 Email: \email{{raphael.couturier,arnaud.giersch,david.laiymani,charles.ramamonjisoa}@univ-fcomte.fr}
93 %% Lilia Ziane Khodja: Department of Aerospace \& Mechanical Engineering\\ Non Linear Computational Mechanics\\ University of Liege\\ Liege, Belgium. Email: l.zianekhodja@ulg.ac.be
95 \begin{abstract} The behavior of multi-core applications is always a challenge
96 to predict, especially with a new architecture for which no experiment has been
97 performed. With some applications, it is difficult, if not impossible, to build
98 accurate performance models. That is why another solution is to use a simulation
99 tool which allows us to change many parameters of the architecture (network
100 bandwidth, latency, number of processors) and to simulate the execution of such
101 applications. The main contribution of this paper is to show that the use of a
102 simulation tool (here we have decided to use the SimGrid toolkit) can really
103 help developpers to better tune their applications for a given multi-core
106 In particular we focus our attention on two parallel iterative algorithms based
107 on the Multisplitting algorithm and we compare them to the GMRES algorithm.
108 These algorithms are used to solve linear systems. Two different variants of
109 the Multisplitting are studied: one using synchronoous iterations and another
110 one with asynchronous iterations. For each algorithm we have simulated
111 different architecture parameters to evaluate their influence on the overall
112 execution time. The obtain simulated results confirm the real results
113 previously obtained on different real multi-core architectures and also confirm
114 the efficiency of the asynchronous multisplitting algorithm compared to the
115 synchronous GMRES method.
119 %\keywords{Algorithm; distributed; iterative; asynchronous; simulation; simgrid;
121 \keywords{ Performance evaluation, Simulation, SimGrid, Synchronous and asynchronous iterations, Multisplitting algorithms}
125 \section{Introduction} The use of multi-core architectures to solve large
126 scientific problems seems to become imperative in many situations.
127 Whatever the scale of these architectures (distributed clusters, computational
128 grids, embedded multi-core,~\ldots) they are generally well adapted to execute
129 complex parallel applications operating on a large amount of data.
130 Unfortunately, users (industrials or scientists), who need such computational
131 resources, may not have an easy access to such efficient architectures. The cost
132 of using the platform and/or the cost of testing and deploying an application
133 are often very important. So, in this context it is difficult to optimize a
134 given application for a given architecture. In this way and in order to reduce
135 the access cost to these computing resources it seems very interesting to use a
136 simulation environment. The advantages are numerous: development life cycle,
137 code debugging, ability to obtain results quickly~\ldots. In counterpart, the simulation results need to be consistent with the real ones.
139 In this paper we focus on a class of highly efficient parallel algorithms called
140 \emph{iterative algorithms}. The parallel scheme of iterative methods is quite
141 simple. It generally involves the division of the problem into several
142 \emph{blocks} that will be solved in parallel on multiple processing
143 units. Each processing unit has to compute an iteration to send/receive some
144 data dependencies to/from its neighbors and to iterate this process until the
145 convergence of the method. Several well-known studies demonstrate the
146 convergence of these algorithms~\cite{BT89,bahi07}. In this processing mode a
147 task cannot begin a new iteration while it has not received data dependencies
148 from its neighbors. We say that the iteration computation follows a
149 \textit{synchronous} scheme. In the asynchronous scheme a task can compute a new
150 iteration without having to wait for the data dependencies coming from its
151 neighbors. Both communication and computations are \textit{asynchronous}
152 inducing that there is no more idle time, due to synchronizations, between two
153 iterations~\cite{bcvc06:ij}. This model presents some advantages and drawbacks
154 that we detail in section~\ref{sec:asynchro} but even if the number of
155 iterations required to converge is generally greater than for the synchronous
156 case, it appears that the asynchronous iterative scheme can significantly
157 reduce overall execution times by suppressing idle times due to
158 synchronizations~(see~\cite{bahi07} for more details).
160 Nevertheless, in both cases (synchronous or asynchronous) it is very time
161 consuming to find optimal configuration and deployment requirements for a given
162 application on a given multi-core architecture. Finding good resource
163 allocations policies under varying CPU power, network speeds and loads is very
164 challenging and labor intensive~\cite{Calheiros:2011:CTM:1951445.1951450}. This
165 problematic is even more difficult for the asynchronous scheme where a small
166 parameter variation of the execution platform can lead to very different numbers
167 of iterations to reach the converge and so to very different execution times. In
168 this challenging context we think that the use of a simulation tool can greatly
169 leverage the possibility of testing various platform scenarios.
171 The main contribution of this paper is to show that the use of a simulation tool
172 (i.e. the SimGrid toolkit~\cite{SimGrid}) in the context of real parallel
173 applications (i.e. large linear system solvers) can help developers to better
174 tune their application for a given multi-core architecture. To show the validity
175 of this approach we first compare the simulated execution of the multisplitting
176 algorithm with the GMRES (Generalized Minimal Residual)
177 solver~\cite{saad86} in synchronous mode. The obtained results on different
178 simulated multi-core architectures confirm the real results previously obtained
179 on non simulated architectures. We also confirm the efficiency of the
180 asynchronous multisplitting algorithm compared to the synchronous GMRES. In
181 this way and with a simple computing architecture (a laptop) SimGrid allows us
182 to run a test campaign of a real parallel iterative applications on
183 different simulated multi-core architectures. To our knowledge, there is no
184 related work on the large-scale multi-core simulation of a real synchronous and
185 asynchronous iterative application.
187 This paper is organized as follows. Section~\ref{sec:asynchro} presents the
188 iteration model we use and more particularly the asynchronous scheme. In
189 section~\ref{sec:simgrid} the SimGrid simulation toolkit is presented.
190 Section~\ref{sec:04} details the different solvers that we use. Finally our
191 experimental results are presented in section~\ref{sec:expe} followed by some
192 concluding remarks and perspectives.
195 \section{The asynchronous iteration model}
198 Asynchronous iterative methods have been studied for many years theoritecally and
199 practically. Many methods have been considered and convergence results have been
200 proved. These methods can be used to solve, in parallel, fixed point problems
201 (i.e. problems for which the solution is $x^\star =f(x^\star)$. In practice,
202 asynchronous iterations methods can be used to solve, for example, linear and
203 non-linear systems of equations or optimization problems, interested readers are
204 invited to read~\cite{BT89,bahi07}.
206 Before using an asynchronous iterative method, the convergence must be
207 studied. Otherwise, the application is not ensure to reach the convergence. An
208 algorithm that supports both the synchronous or the asynchronous iteration model
209 requires very few modifications to be able to be executed in both variants. In
210 practice, only the communications and convergence detection are different. In
211 the synchronous mode, iterations are synchronized whereas in the asynchronous
212 one, they are not. It should be noticed that non blocking communications can be
213 used in both modes. Concerning the convergence detection, synchronous variants
214 can use a global convergence procedure which acts as a global synchronization
215 point. In the asynchronous model, the convergence detection is more tricky as
216 it must not synchronize all the processors. Interested readers can
217 consult~\cite{myBCCV05c,bahi07,ccl09:ij}.
222 %%%%%%%%%%%%%%%%%%%%%%%%%
223 %%%%%%%%%%%%%%%%%%%%%%%%%
225 \section{Two-stage multisplitting methods}
227 \subsection{Synchronous and asynchronous two-stage methods for sparse linear systems}
229 In this paper we focus on two-stage multisplitting methods in their both versions (synchronous and asynchronous)~\cite{Frommer92,Szyld92,Bru95}. These iterative methods are based on multisplitting methods~\cite{O'leary85,White86,Alefeld97} and use two nested iterations: the outer iteration and the inner iteration. Let us consider the following sparse linear system of $n$ equations in $\mathbb{R}$:
234 where $A$ is a sparse square and nonsingular matrix, $b$ is the right-hand side and $x$ is the solution of the system. Our work in this paper is restricted to the block Jacobi splitting method. This approach of multisplitting consists in partitioning the matrix $A$ into $L$ horizontal band matrices of order $\frac{n}{L}\times n$ without overlapping (i.e. sub-vectors $\{x_\ell\}_{1\leq\ell\leq L}$ are disjoint). Two-stage multisplitting methods solve the linear system~(\ref{eq:01}) iteratively as follows:
236 x_\ell^{k+1} = A_{\ell\ell}^{-1}(b_\ell - \displaystyle\sum^{L}_{\substack{m=1\\m\neq\ell}}{A_{\ell m}x^k_m}),\mbox{~for~}\ell=1,\ldots,L\mbox{~and~}k=1,2,3,\ldots
239 where $x_\ell$ are sub-vectors of the solution $x$, $b_\ell$ are the sub-vectors of the right-hand side $b$, and $A_{\ell\ell}$ and $A_{\ell m}$ are diagonal and off-diagonal blocks of matrix $A$ respectively. The iterations of these methods can naturally be computed in parallel such that each processor or cluster of processors is responsible for solving one splitting as a linear sub-system:
241 A_{\ell\ell} x_\ell = c_\ell,\mbox{~for~}\ell=1,\ldots,L,
244 where right-hand sides $c_\ell=b_\ell-\sum_{m\neq\ell}A_{\ell m}x_m$ are computed using the shared vectors $x_m$. In this paper, we use the well-known iterative method GMRES ({\it Generalized Minimal RESidual})~\cite{saad86} as an inner iteration to approximate the solutions of the different splittings arising from the block Jacobi multisplitting of matrix $A$. The algorithm in Figure~\ref{01} shows the main key points of our block Jacobi two-stage method executed by a cluster of processors. In line~\ref{solve}, the linear sub-system~(\ref{eq:03}) is solved in parallel using GMRES method where $\MIG$ and $\TOLG$ are the maximum number of inner iterations and the tolerance threshold for GMRES respectively. The convergence of the two-stage multisplitting methods, based on synchronous or asynchronous iterations, has been studied by many authors for example~\cite{Bru95,bahi07}.
247 %\begin{algorithm}[t]
248 %\caption{Block Jacobi two-stage multisplitting method}
249 \begin{algorithmic}[1]
250 \Input $A_\ell$ (sparse matrix), $b_\ell$ (right-hand side)
251 \Output $x_\ell$ (solution vector)\vspace{0.2cm}
252 \State Set the initial guess $x^0$
253 \For {$k=1,2,3,\ldots$ until convergence}
254 \State $c_\ell=b_\ell-\sum_{m\neq\ell}A_{\ell m}x_m^{k-1}$
255 \State $x^k_\ell=Solve_{gmres}(A_{\ell\ell},c_\ell,x^{k-1}_\ell,\MIG,\TOLG)$\label{solve}
256 \State Send $x_\ell^k$ to neighboring clusters\label{send}
257 \State Receive $\{x_m^k\}_{m\neq\ell}$ from neighboring clusters\label{recv}
260 \caption{Block Jacobi two-stage multisplitting method}
265 In this paper, we propose two algorithms of two-stage multisplitting methods. The first algorithm is based on the asynchronous model which allows communications to be overlapped by computations and reduces the idle times resulting from the synchronizations. So in the asynchronous mode, our two-stage algorithm uses asynchronous outer iterations and asynchronous communications between clusters. The communications (i.e. lines~\ref{send} and~\ref{recv} in Figure~\ref{alg:01}) are performed by message passing using MPI non-blocking communication routines. The convergence of the asynchronous iterations is detected when all clusters have locally converged:
267 k\geq\MIM\mbox{~or~}\|x_\ell^{k+1}-x_\ell^k\|_{\infty }\leq\TOLM,
270 where $\MIM$ is the maximum number of outer iterations and $\TOLM$ is the tolerance threshold for the two-stage algorithm.
272 The second two-stage algorithm is based on synchronous outer iterations. We propose to use the Krylov iteration based on residual minimization to improve the slow convergence of the multisplitting methods. In this case, a $n\times s$ matrix $S$ is set using solutions issued from the inner iteration:
274 S=[x^1,x^2,\ldots,x^s],~s\ll n.
277 At each $s$ outer iterations, the algorithm computes a new approximation $\tilde{x}=S\alpha$ which minimizes the residual:
279 \min_{\alpha\in\mathbb{R}^s}{\|b-AS\alpha\|_2}.
282 The algorithm in Figure~\ref{alg:02} includes the procedure of the residual minimization and the outer iteration is restarted with a new approximation $\tilde{x}$ at every $s$ iterations. The least-squares problem~(\ref{eq:06}) is solved in parallel by all clusters using CGLS method~\cite{Hestenes52} such that $\MIC$ is the maximum number of iterations and $\TOLC$ is the tolerance threshold for this method (line~\ref{cgls} in Figure~\ref{alg:02}).
285 %\begin{algorithm}[t]
286 %\caption{Krylov two-stage method using block Jacobi multisplitting}
287 \begin{algorithmic}[1]
288 \Input $A_\ell$ (sparse matrix), $b_\ell$ (right-hand side)
289 \Output $x_\ell$ (solution vector)\vspace{0.2cm}
290 \State Set the initial guess $x^0$
291 \For {$k=1,2,3,\ldots$ until convergence}
292 \State $c_\ell=b_\ell-\sum_{m\neq\ell}A_{\ell m}x_m^{k-1}$
293 \State $x^k_\ell=Solve_{gmres}(A_{\ell\ell},c_\ell,x^{k-1}_\ell,\MIG,\TOLG)$
294 \State $S_{\ell,k\mod s}=x_\ell^k$
296 \State $\alpha = Solve_{cgls}(AS,b,\MIC,\TOLC)$\label{cgls}
297 \State $\tilde{x_\ell}=S_\ell\alpha$
298 \State Send $\tilde{x_\ell}$ to neighboring clusters
300 \State Send $x_\ell^k$ to neighboring clusters
302 \State Receive $\{x_m^k\}_{m\neq\ell}$ from neighboring clusters
305 \caption{Krylov two-stage method using block Jacobi multisplitting}
310 \subsection{Simulation of the two-stage methods using SimGrid toolkit}
313 One of our objectives when simulating the application in Simgrid is, as in real
314 life, to get accurate results (solutions of the problem) but also to ensure the
315 test reproducibility under the same conditions. According to our experience,
316 very few modifications are required to adapt a MPI program for the Simgrid
317 simulator using SMPI (Simulator MPI). The first modification is to include SMPI
318 libraries and related header files (smpi.h). The second modification is to
319 suppress all global variables by replacing them with local variables or using a
320 Simgrid selector called "runtime automatic switching"
321 (smpi/privatize\_global\_variables). Indeed, global variables can generate side
322 effects on runtime between the threads running in the same process and generated by
323 Simgrid to simulate the grid environment.
325 %\RC{On vire cette phrase ?} \RCE {Si c'est la phrase d'avant sur les threads, je pense qu'on peut la retenir car c'est l'explication du pourquoi Simgrid n'aime pas les variables globales. Si c'est pas bien dit, on peut la reformuler. Si c'est la phrase ci-apres, effectivement, on peut la virer si elle preterais a discussion}The
326 %last modification on the MPI program pointed out for some cases, the review of
327 %the sequence of the MPI\_Isend, MPI\_Irecv and MPI\_Waitall instructions which
328 %might cause an infinite loop.
331 \paragraph{Simgrid Simulator parameters}
332 \ \\ \noindent Before running a Simgrid benchmark, many parameters for the
333 computation platform must be defined. For our experiments, we consider platforms
334 in which several clusters are geographically distant, so there are intra and
335 inter-cluster communications. In the following, these parameters are described:
338 \item hostfile: hosts description file.
339 \item platform: file describing the platform architecture: clusters (CPU power,
340 \dots{}), intra cluster network description, inter cluster network (bandwidth bw,
341 latency lat, \dots{}).
342 \item archi : grid computational description (number of clusters, number of
343 nodes/processors for each cluster).
346 In addition, the following arguments are given to the programs at runtime:
349 \item maximum number of inner iterations $\MIG$ and outer iterations $\MIM$,
350 \item inner precision $\TOLG$ and outer precision $\TOLM$,
351 \item matrix sizes of the 3D Poisson problem: N$_{x}$, N$_{y}$ and N$_{z}$ on axis $x$, $y$ and $z$ respectively,
352 \item matrix diagonal value is fixed to $6.0$ for synchronous Krylov multisplitting experiments and $6.2$ for asynchronous block Jacobi experiments,
353 \item matrix off-diagonal value is fixed to $-1.0$,
354 \item number of vectors in matrix $S$ (i.e. value of $s$),
355 \item maximum number of iterations $\MIC$ and precision $\TOLC$ for CGLS method,
356 \item maximum number of iterations and precision for the classical GMRES method,
357 \item maximum number of restarts for the Arnorldi process in GMRES method,
358 \item execution mode: synchronous or asynchronous.
360 \LZK{CE pourrais tu vérifier et confirmer les valeurs des éléments diag et off-diag de la matrice?}
361 \RCE{oui, les valeurs de diag et off-diag donnees sont ok}
363 It should also be noticed that both solvers have been executed with the Simgrid selector \texttt{-cfg=smpi/running\_power} which determines the computational power (here 19GFlops) of the simulator host machine.
365 %%%%%%%%%%%%%%%%%%%%%%%%%
366 %%%%%%%%%%%%%%%%%%%%%%%%%
368 \section{Experimental Results}
371 In this section, experiments for both Multisplitting algorithms are reported. First the 3D Poisson problem used in our experiments is described.
373 \subsection{The 3D Poisson problem}
376 We use our two-stage algorithms to solve the well-known Poisson problem $\nabla^2\phi=f$~\cite{Polyanin01}. In three-dimensional Cartesian coordinates in $\mathbb{R}^3$, the problem takes the following form:
378 \frac{\partial^2}{\partial x^2}\phi(x,y,z)+\frac{\partial^2}{\partial y^2}\phi(x,y,z)+\frac{\partial^2}{\partial z^2}\phi(x,y,z)=f(x,y,z)\mbox{~in the domain~}\Omega
383 \phi(x,y,z)=0\mbox{~on the boundary~}\partial\Omega
385 where the real-valued function $\phi(x,y,z)$ is the solution sought, $f(x,y,z)$ is a known function and $\Omega=[0,1]^3$. The 3D discretization of the Laplace operator $\nabla^2$ with the finite difference scheme includes 7 points stencil on the computational grid. The numerical approximation of the Poisson problem on three-dimensional grid is repeatedly computed as $\phi=\phi^\star$ such that:
388 \phi^\star(x,y,z)=&\frac{1}{6}(\phi(x-h,y,z)+\phi(x,y-h,z)+\phi(x,y,z-h)\\&+\phi(x+h,y,z)+\phi(x,y+h,z)+\phi(x,y,z+h)\\&-h^2f(x,y,z))
392 until convergence where $h$ is the grid spacing between two adjacent elements in the 3D computational grid.
394 In the parallel context, the 3D Poisson problem is partitioned into $L\times p$ sub-problems such that $L$ is the number of clusters and $p$ is the number of processors in each cluster. We apply the three-dimensional partitioning instead of the row-by-row one in order to reduce the size of the data shared at the sub-problems boundaries. In this case, each processor is in charge of parallelepipedic block of the problem and has at most six neighbors in the same cluster or in distant clusters with which it shares data at boundaries.
396 \subsection{Study setup and simulation methodology}
398 First, to conduct our study, we propose the following methodology
399 which can be reused for any grid-enabled applications.\\
401 \textbf{Step 1}: Choose with the end users the class of algorithms or
402 the application to be tested. Numerical parallel iterative algorithms
403 have been chosen for the study in this paper. \\
405 \textbf{Step 2}: Collect the software materials needed for the experimentation.
406 In our case, we have two variants algorithms for the resolution of the
407 3D-Poisson problem: (1) using the classical GMRES; (2) and the Multisplitting
408 method. In addition, the Simgrid simulator has been chosen to simulate the
409 behaviors of the distributed applications. Simgrid is running in a virtual
410 machine on a simple laptop. \\
412 \textbf{Step 3}: Fix the criteria which will be used for the future
413 results comparison and analysis. In the scope of this study, we retain
414 on the one hand the algorithm execution mode (synchronous and asynchronous)
415 and on the other hand the execution time and the number of iterations to reach the convergence. \\
417 \textbf{Step 4 }: Set up the different grid testbed environments that will be
418 simulated in the simulator tool to run the program. The following architecture
419 has been configured in Simgrid : 2x16, 4x8, 4x16, 8x8 and 2x50. The first number
420 represents the number of clusters in the grid and the second number represents
421 the number of hosts (processors/cores) in each cluster. The network has been
422 designed to operate with a bandwidth equals to 10Gbits (resp. 1Gbits/s) and a
423 latency of 8.10$^{-6}$ seconds (resp. 5.10$^{-5}$) for the intra-clusters links
424 (resp. inter-clusters backbone links). \\
426 \textbf{Step 5}: Conduct an extensive and comprehensive testings
427 within these configurations by varying the key parameters, especially
428 the CPU power capacity, the network parameters and also the size of the
431 \textbf{Step 6} : Collect and analyze the output results.
433 \subsection{Factors impacting distributed applications performance in
436 When running a distributed application in a computational grid, many factors may
437 have a strong impact on the performance. First of all, the architecture of the
438 grid itself can obviously influence the performance results of the program. The
439 performance gain might be important theoretically when the number of clusters
440 and/or the number of nodes (processors/cores) in each individual cluster
443 Another important factor impacting the overall performance of the application
444 is the network configuration. Two main network parameters can modify drastically
445 the program output results:
447 \item the network bandwidth (bw=bits/s) also known as "the data-carrying
448 capacity" of the network is defined as the maximum of data that can transit
449 from one point to another in a unit of time.
450 \item the network latency (lat : microsecond) defined as the delay from the
451 start time to send a simple data from a source to a destination.
453 Upon the network characteristics, another impacting factor is the volume of data exchanged between the nodes in the cluster
454 and between distant clusters. This parameter is application dependent.
456 In a grid environment, it is common to distinguish, on the one hand, the
457 "intra-network" which refers to the links between nodes within a cluster and
458 on the other hand, the "inter-network" which is the backbone link between
459 clusters. In practice, these two networks have different speeds.
460 The intra-network generally works like a high speed local network with a
461 high bandwith and very low latency. In opposite, the inter-network connects
462 clusters sometime via heterogeneous networks components throuth internet with
463 a lower speed. The network between distant clusters might be a bottleneck
464 for the global performance of the application.
466 \subsection{Comparison of GMRES and Krylov Multisplitting algorithms in synchronous mode}
468 In the scope of this paper, our first objective is to analyze when the Krylov
469 Multisplitting method has better performance than the classical GMRES
470 method. With a synchronous iterative method, better performance mean a
471 smaller number of iterations and execution time before reaching the convergence.
472 For a systematic study, the experiments should figure out that, for various
473 grid parameters values, the simulator will confirm the targeted outcomes,
474 particularly for poor and slow networks, focusing on the impact on the
475 communication performance on the chosen class of algorithm.
477 The following paragraphs present the test conditions, the output results
481 \subsubsection{Execution of the algorithms on various computational grid
482 architectures and scaling up the input matrix size}
488 \begin{tabular}{r c }
490 Grid Architecture & 2x16, 4x8, 4x16 and 8x8\\ %\hline
491 Network & N2 : bw=1Gbits/s - lat=5.10$^{-5}$ \\ %\hline
492 Input matrix size & N$_{x}$ x N$_{y}$ x N$_{z}$ =150 x 150 x 150\\ %\hline
493 - & N$_{x}$ x N$_{y}$ x N$_{z}$ =170 x 170 x 170 \\ \hline
495 \caption{Test conditions: Various grid configurations with the input matix size N$_{x}$=150 or N$_{x}$=170 \RC{je ne comprends pas la légende... Ca ne serait pas plutot Characteristics of cluster (mais il faudrait lui donner un nom)}}
503 %\RCE{J'ai voulu mettre les tableaux des données mais je pense que c'est inutile et ça va surcharger}
506 In this section, we analyze the performance of algorithms running on various
507 grid configurations (2x16, 4x8, 4x16 and 8x8). First, the results in Figure~\ref{fig:01}
508 show for all grid configurations the non-variation of the number of iterations of
509 classical GMRES for a given input matrix size; it is not the case for the
510 multisplitting method.
512 \RC{CE attention tu n'as pas mis de label dans tes figures, donc c'est le bordel, j'en mets mais vérifie...}
513 \RC{Les légendes ne sont pas explicites...}
518 \includegraphics[width=100mm]{cluster_x_nodes_nx_150_and_nx_170.pdf}
520 \caption{Various grid configurations with the input matrix size N$_{x}$=150 and N$_{x}$=170}
525 The execution times between the two algorithms is significant with different
526 grid architectures, even with the same number of processors (for example, 2x16
527 and 4x8). We can observ the low sensitivity of the Krylov multisplitting method
528 (compared with the classical GMRES) when scaling up the number of the processors
529 in the grid: in average, the GMRES (resp. Multisplitting) algorithm performs
530 $40\%$ better (resp. $48\%$) when running from 2x16=32 to 8x8=64 processors.
532 \subsubsection{Running on two different inter-clusters network speeds \\}
536 \begin{tabular}{r c }
538 Grid Architecture & 2x16, 4x8\\ %\hline
539 Network & N1 : bw=10Gbs-lat=8.10$^{-6}$ \\ %\hline
540 - & N2 : bw=1Gbs-lat=5.10$^{-5}$ \\
541 Input matrix size & N$_{x}$ x N$_{y}$ x N$_{z}$ =150 x 150 x 150\\ \hline
543 \caption{Test conditions: Grid 2x16 and 4x8 - Networks N1 vs N2}
548 These experiments compare the behavior of the algorithms running first on a
549 speed inter-cluster network (N1) and also on a less performant network (N2).
550 Figure~\ref{fig:02} shows that end users will gain to reduce the execution time
551 for both algorithms in using a grid architecture like 4x16 or 8x8: the
552 performance was increased by a factor of $2$. The results depict also that when
553 the network speed drops down (variation of 12.5\%), the difference between the two Multisplitting algorithms execution times can reach more than 25\%.
554 %\RC{c'est pas clair : la différence entre quoi et quoi?}
559 %\begin{wrapfigure}{l}{100mm}
562 \includegraphics[width=100mm]{cluster_x_nodes_n1_x_n2.pdf}
563 \caption{Grid 2x16 and 4x8 - Networks N1 vs N2}
569 \subsubsection{Network latency impacts on performance}
573 \begin{tabular}{r c }
575 Grid Architecture & 2x16\\ %\hline
576 Network & N1 : bw=1Gbs \\ %\hline
577 Input matrix size & N$_{x}$ x N$_{y}$ x N$_{z}$ =150 x 150 x 150\\ \hline
579 \caption{Test conditions: Network latency impacts}
587 \includegraphics[width=100mm]{network_latency_impact_on_execution_time.pdf}
588 \caption{Network latency impacts on execution time}
593 According to the results of Figure~\ref{fig:03}, a degradation of the network
594 latency from $8.10^{-6}$ to $6.10^{-5}$ implies an absolute time increase of more
595 than $75\%$ (resp. $82\%$) of the execution for the classical GMRES (resp. Krylov
596 multisplitting) algorithm. In addition, it appears that the Krylov
597 multisplitting method tolerates more the network latency variation with a less
598 rate increase of the execution time. Consequently, in the worst case
599 ($lat=6.10^{-5 }$), the execution time for GMRES is almost the double than the
600 time of the Krylov multisplitting, even though, the performance was on the same
601 order of magnitude with a latency of $8.10^{-6}$.
603 \subsubsection{Network bandwidth impacts on performance}
607 \begin{tabular}{r c }
609 Grid Architecture & 2x16\\ %\hline
610 Network & N1 : bw=1Gbs - lat=5.10$^{-5}$ \\ %\hline
611 Input matrix size & N$_{x}$ x N$_{y}$ x N$_{z}$ =150 x 150 x 150\\ \hline \\
613 \caption{Test conditions: Network bandwidth impacts}
620 \includegraphics[width=100mm]{network_bandwith_impact_on_execution_time.pdf}
621 \caption{Network bandwith impacts on execution time}
625 The results of increasing the network bandwidth show the improvement of the
626 performance for both algorithms by reducing the execution time (see
627 Figure~\ref{fig:04}). However, in this case, the Krylov multisplitting method
628 presents a better performance in the considered bandwidth interval with a gain
629 of $40\%$ which is only around $24\%$ for the classical GMRES.
631 \subsubsection{Input matrix size impacts on performance}
635 \begin{tabular}{r c }
637 Grid Architecture & 4x8\\ %\hline
638 Network & N2 : bw=1Gbs - lat=5.10$^{-5}$ \\
639 Input matrix size & N$_{x}$ = From 40 to 200\\ \hline
641 \caption{Test conditions: Input matrix size impacts}
648 \includegraphics[width=100mm]{pb_size_impact_on_execution_time.pdf}
649 \caption{Problem size impacts on execution time}
653 In these experiments, the input matrix size has been set from $N_{x} = N_{y}
654 = N_{z} = 40$ to $200$ side elements that is from $40^{3} = 64.000$ to $200^{3}
655 = 8,000,000$ points. Obviously, as shown in Figure~\ref{fig:05}, the execution
656 time for both algorithms increases when the input matrix size also increases.
657 But the interesting results are:
659 \item the drastic increase ($10$ times) \RC{Je ne vois pas cela sur la figure}
660 \RCE{Corrige} of the number of iterations needed to reach the convergence for the classical
661 GMRES algorithm when the matrix size go beyond $N_{x}=150$;
662 \item the classical GMRES execution time is almost the double for $N_{x}=140$
663 compared with the Krylov multisplitting method.
666 These findings may help a lot end users to setup the best and the optimal
667 targeted environment for the application deployment when focusing on the problem
668 size scale up. It should be noticed that the same test has been done with the
669 grid 2x16 leading to the same conclusion.
671 \subsubsection{CPU Power impacts on performance}
675 \begin{tabular}{r c }
677 Grid architecture & 2x16\\ %\hline
678 Network & N2 : bw=1Gbs - lat=5.10$^{-5}$ \\ %\hline
679 Input matrix size & N$_{x}$ = 150 x 150 x 150\\ \hline
681 \caption{Test conditions: CPU Power impacts}
687 \includegraphics[width=100mm]{cpu_power_impact_on_execution_time.pdf}
688 \caption{CPU Power impacts on execution time}
692 Using the Simgrid simulator flexibility, we have tried to determine the impact
693 on the algorithms performance in varying the CPU power of the clusters nodes
694 from $1$ to $19$ GFlops. The outputs depicted in Figure~\ref{fig:06} confirm the
695 performance gain, around $95\%$ for both of the two methods, after adding more
698 \DL{il faut une conclusion sur ces tests : ils confirment les résultats déjà
699 obtenus en grandeur réelle. Donc c'est une aide précieuse pour les dev. Pas
700 besoin de déployer sur une archi réelle}
703 \subsection{Comparing GMRES in native synchronous mode and the multisplitting algorithm in asynchronous mode}
705 The previous paragraphs put in evidence the interests to simulate the behavior
706 of the application before any deployment in a real environment. In this
707 section, following the same previous methodology, our goal is to compare the
708 efficiency of the multisplitting method in \textit{ asynchronous mode} compared with the
709 classical GMRES in \textit{synchronous mode}.
711 The interest of using an asynchronous algorithm is that there is no more
712 synchronization. With geographically distant clusters, this may be essential.
713 In this case, each processor can compute its iteration freely without any
714 synchronization with the other processors. Thus, the asynchronous may
715 theoretically reduce the overall execution time and can improve the algorithm
718 \RC{la phrase suivante est bizarre, je ne comprends pas pourquoi elle vient ici}
719 In this section, Simgrid simulator tool has been successfully used to show
720 the efficiency of the multisplitting in asynchronous mode and to find the best
721 combination of the grid resources (CPU, Network, input matrix size, \ldots ) to
722 get the highest \textit{"relative gain"} (exec\_time$_{GMRES}$ /
723 exec\_time$_{multisplitting}$) in comparison with the classical GMRES time.
726 The test conditions are summarized in the table~\ref{tab:07}: \\
730 \begin{tabular}{r c }
732 Grid Architecture & 2x50 totaling 100 processors\\ %\hline
733 Processors Power & 1 GFlops to 1.5 GFlops\\
734 Intra-Network & bw=1.25 Gbits - lat=5.10$^{-5}$ \\ %\hline
735 Inter-Network & bw=5 Mbits - lat=2.10$^{-2}$\\
736 Input matrix size & N$_{x}$ = From 62 to 150\\ %\hline
737 Residual error precision & 10$^{-5}$ to 10$^{-9}$\\ \hline \\
739 \caption{Test conditions: GMRES in synchronous mode vs Krylov Multisplitting in asynchronous mode}
743 Again, comprehensive and extensive tests have been conducted with different
744 parameters as the CPU power, the network parameters (bandwidth and latency)
745 and with different problem size. The relative gains greater than $1$ between the
746 two algorithms have been captured after each step of the test. In
747 Figure~\ref{fig:07} are reported the best grid configurations allowing
748 the multisplitting method to be more than $2.5$ times faster than the
749 classical GMRES. These experiments also show the relative tolerance of the
750 multisplitting algorithm when using a low speed network as usually observed with
751 geographically distant clusters through the internet.
753 % use the same column width for the following three tables
754 \newlength{\mytablew}\settowidth{\mytablew}{\footnotesize\np{E-11}}
755 \newenvironment{mytable}[1]{% #1: number of columns for data
756 \renewcommand{\arraystretch}{1.3}%
757 \begin{tabular}{|>{\bfseries}r%
758 |*{#1}{>{\centering\arraybackslash}p{\mytablew}|}}}{%
765 % \caption{Relative gain of the multisplitting algorithm compared with the classical GMRES}
770 & 5 & 5 & 5 & 5 & 5 & 50 & 50 & 50 & 50 & 50 \\
773 & 20 & 20 & 20 & 20 & 20 & 20 & 20 & 20 & 20 & 20 \\
776 & 1 & 1 & 1 & 1.5 & 1.5 & 1.5 & 1.5 & 1 & 1.5 & 1.5 \\
779 & 62 & 62 & 62 & 100 & 100 & 110 & 120 & 130 & 140 & 150 \\
782 & \np{E-5} & \np{E-8} & \np{E-9} & \np{E-11} & \np{E-11} & \np{E-11} & \np{E-11} & \np{E-11} & \np{E-11} & \np{E-11}\\
785 & 2.52 & 2.55 & 2.52 & 2.57 & 2.54 & 2.53 & 2.51 & 2.58 & 2.55 & 2.54 \\
789 \caption{Relative gain of the multisplitting algorithm compared with the classical GMRES}
798 \section*{Acknowledgment}
800 This work is partially funded by the Labex ACTION program (contract ANR-11-LABX-01-01).
803 \bibliographystyle{wileyj}
804 \bibliography{biblio}
812 %%% ispell-local-dictionary: "american"