RCE : Correction parrtie expe

[rce2015.git] / paper.tex

diff --git a/paper.tex b/paper.tex
index 8fd9fb4de09be6ab67501ce7f591a104b91bdf3d..f9434f99f107282e52b57eb6e0187428cd870c73 100644 (file)
--- a/paper.tex
+++ b/paper.tex
@@ -21,7 +21,6 @@
 \usepackage{algpseudocode}
 %\usepackage{amsthm}
 \usepackage{graphicx}
 \usepackage{algpseudocode}
 %\usepackage{amsthm}
 \usepackage{graphicx}

-\usepackage[american]{babel}

 % Extension pour les liens intra-documents (tagged PDF)
 % et l'affichage correct des URL (commande \url{http://example.com})
 %\usepackage{hyperref}
 % Extension pour les liens intra-documents (tagged PDF)
 % et l'affichage correct des URL (commande \url{http://example.com})
 %\usepackage{hyperref}


@@ -45,6 +44,8 @@
   \todo[color=blue!10,#1]{\sffamily\textbf{LZK:} #2}\xspace}
 \newcommand{\RCE}[2][inline]{%
   \todo[color=yellow!10,#1]{\sffamily\textbf{RCE:} #2}\xspace}
   \todo[color=blue!10,#1]{\sffamily\textbf{LZK:} #2}\xspace}
 \newcommand{\RCE}[2][inline]{%
   \todo[color=yellow!10,#1]{\sffamily\textbf{RCE:} #2}\xspace}

+\newcommand{\DL}[2][inline]{%
+    \todo[color=pink!10,#1]{\sffamily\textbf{DL:} #2}\xspace}

 
 \algnewcommand\algorithmicinput{\textbf{Input:}}
 \algnewcommand\Input{\item[\algorithmicinput]}
 
 \algnewcommand\algorithmicinput{\textbf{Input:}}
 \algnewcommand\Input{\item[\algorithmicinput]}


@@ -69,47 +70,50 @@
 
 
 
 
 
 

-\begin{document} \RCE{Titre a confirmer.} \title{Comparative performance
-analysis of simulated grid-enabled numerical iterative algorithms}
+\begin{document}
+\title{Grid-enabled simulation of large-scale linear iterative solvers}

 %\itshape{\journalnamelc}\footnotemark[2]}
 
 %\itshape{\journalnamelc}\footnotemark[2]}
 

-\author{    Charles Emile Ramamonjisoa and
-    David Laiymani and
-    Arnaud Giersch and
-    Lilia Ziane Khodja and
-    Raphaël Couturier
+\author{Charles Emile Ramamonjisoa\affil{1},
+    David Laiymani\affil{1},
+    Arnaud Giersch\affil{1},
+    Lilia Ziane Khodja\affil{2} and
+    Raphaël Couturier\affil{1}

 }
 
 \address{
 }
 
 \address{

-       \centering
-    Femto-ST Institute - DISC Department\\
-    Université de Franche-Comté\\
-    Belfort\\
-    Email: \email{{raphael.couturier,arnaud.giersch,david.laiymani,charles.ramamonjisoa}@univ-fcomte.fr}
+  \affilnum{1}%
+  Femto-ST Institute, DISC Department,
+  University of Franche-Comté,
+  Belfort, France.
+  Email:~\email{{charles.ramamonjisoa,david.laiymani,arnaud.giersch,raphael.couturier}@univ-fcomte.fr}\break
+  \affilnum{2}
+  Department of Aerospace \& Mechanical Engineering,
+  Non Linear Computational Mechanics,
+  University of Liege, Liege, Belgium.
+  Email:~\email{l.zianekhodja@ulg.ac.be}

 }
 
 }
 

-%% Lilia Ziane Khodja: Department of Aerospace \& Mechanical Engineering\\ Non Linear Computational Mechanics\\ University of Liege\\ Liege, Belgium. Email: l.zianekhodja@ulg.ac.be
-
-\begin{abstract}   The behavior of multi-core applications is always a challenge
-to predict, especially with a new architecture for which no experiment has been
-performed. With some applications, it is difficult, if not impossible, to build
-accurate performance models. That is why another solution is to use a simulation
-tool which allows us to change many parameters of the architecture (network
-bandwidth, latency, number of processors) and to simulate the execution of such
-applications. We have decided to use SimGrid as it enables to benchmark MPI
-applications.
-
-In this paper, we focus our attention on two parallel iterative algorithms based
-on the  Multisplitting algorithm  and we  compare them  to the  GMRES algorithm.
-These algorithms  are used to  solve libear  systems. Two different  variants of
-the Multisplitting are studied: one  using synchronoous  iterations and  another
-one  with asynchronous iterations. For each algorithm we have  tested different
-parameters to see their influence.  We strongly  recommend people  interested
-by investing  into a  new expensive  hardware  architecture  to   benchmark
-their  applications  using  a simulation tool before.
+\begin{abstract} %% The behavior of multi-core applications is always a challenge
+%% to predict, especially with a new architecture for which no experiment has been
+%% performed. With some applications, it is difficult, if not impossible, to build
+%% accurate performance models. That is why another solution is to use a simulation
+%% tool which allows us to change many parameters of the architecture (network
+%% bandwidth, latency, number of processors) and to simulate the execution of such
+%% applications. The main contribution of this paper is to show that the use of a
+%% simulation tool (here we have decided to use the SimGrid toolkit) can really
+%% help developers to better tune their applications for a given multi-core
+%% architecture.

 
 

+%% In this paper we focus our attention on the simulation of iterative algorithms to solve sparse linear systems on large clusters. We study the behavior of the widely used GMRES algorithm and two different variants of the Multisplitting algorithms: one using synchronous iterations and another one with asynchronous iterations.  
+%% For each algorithm we have simulated
+%% different architecture parameters to evaluate their influence on the overall
+%% execution time. 
+%% The simulations confirm the real results previously obtained on different real multi-core architectures and also confirm the efficiency of the asynchronous Multisplitting algorithm on distant clusters compared to the synchronous GMRES algorithm.

 
 

+The behavior of multi-core applications is always a challenge to predict, especially with a new architecture for which no experiment has been performed. With some applications, it is difficult, if not impossible, to build accurate performance models. That is why another solution is to use a simulation tool which allows us to change many parameters of the architecture (network bandwidth, latency, number of processors) and to simulate the execution of such applications. 

 
 

+In this paper we focus on the simulation of iterative algorithms to solve sparse linear systems. We study the behavior of the GMRES algorithm and two different variants of the multisplitting algorithms: using synchronous or asynchronous iterations. For each algorithm we have simulated different architecture parameters to evaluate their influence on the overall execution time. The simulations confirm the real results previously obtained on different real multi-core architectures and also confirm the efficiency of the asynchronous multisplitting algorithm on distant clusters compared to the GMRES algorithm.

 
 \end{abstract}
 
 
 \end{abstract}
 


@@ -131,7 +135,7 @@ are often very important. So, in this context it is difficult to optimize a
 given application for a given  architecture. In this way and in order to reduce
 the access cost to these computing resources it seems very interesting to use a
 simulation environment.  The advantages are numerous: development life cycle,
 given application for a given  architecture. In this way and in order to reduce
 the access cost to these computing resources it seems very interesting to use a
 simulation environment.  The advantages are numerous: development life cycle,

-code debugging, ability to obtain results quickly~\ldots. In counterpart, the simulation results need to be consistent with the real ones.
+code debugging, ability to obtain results quickly\dots{} In counterpart, the simulation results need to be consistent with the real ones.

 
 In this paper we focus on a class of highly efficient parallel algorithms called
 \emph{iterative algorithms}. The parallel scheme of iterative methods is quite
 
 In this paper we focus on a class of highly efficient parallel algorithms called
 \emph{iterative algorithms}. The parallel scheme of iterative methods is quite


@@ -145,10 +149,10 @@ task cannot begin a new iteration while it has not received data dependencies
 from its neighbors. We say that the iteration computation follows a
 \textit{synchronous} scheme. In the asynchronous scheme a task can compute a new
 iteration without having to wait for the data dependencies coming from its
 from its neighbors. We say that the iteration computation follows a
 \textit{synchronous} scheme. In the asynchronous scheme a task can compute a new
 iteration without having to wait for the data dependencies coming from its

-neighbors. Both communication and computations are \textit{asynchronous}
+neighbors. Both communications and computations are \textit{asynchronous}

 inducing that there is no more idle time, due to synchronizations, between two
 iterations~\cite{bcvc06:ij}. This model presents some advantages and drawbacks
 inducing that there is no more idle time, due to synchronizations, between two
 iterations~\cite{bcvc06:ij}. This model presents some advantages and drawbacks

-that we detail in section~\ref{sec:asynchro} but even if the number of
+that we detail in Section~\ref{sec:asynchro} but even if the number of

 iterations required to converge is generally  greater  than for the synchronous
 case, it appears that the asynchronous  iterative scheme  can significantly
 reduce  overall execution times by  suppressing idle  times due to
 iterations required to converge is generally  greater  than for the synchronous
 case, it appears that the asynchronous  iterative scheme  can significantly
 reduce  overall execution times by  suppressing idle  times due to


@@ -160,22 +164,30 @@ application  on   a  given   multi-core  architecture.  Finding   good  resource
 allocations policies under  varying CPU power, network speeds and  loads is very
 challenging and  labor intensive~\cite{Calheiros:2011:CTM:1951445.1951450}. This
 problematic is  even more difficult  for the  asynchronous scheme where  a small
 allocations policies under  varying CPU power, network speeds and  loads is very
 challenging and  labor intensive~\cite{Calheiros:2011:CTM:1951445.1951450}. This
 problematic is  even more difficult  for the  asynchronous scheme where  a small

-parameter variation of the execution platform can lead to very different numbers
-of iterations to reach the converge and so to very different execution times. In
-this challenging context we think that the  use of a simulation tool can greatly
-leverage the possibility of testing various platform scenarios.
-
-The main contribution of this paper is to show that the use of a simulation tool
-(i.e. the SimGrid toolkit~\cite{SimGrid}) in the context of real  parallel
-applications (i.e. large linear system solvers) can help developers to better
-tune their application for a given multi-core architecture. To show the validity
-of this approach we first compare the simulated execution of the multisplitting
-algorithm  with  the  GMRES   (Generalized   Minimal  Residual)
-solver~\cite{saad86} in synchronous mode. The obtained results on different
-simulated multi-core architectures confirm the real results previously obtained
-on non simulated architectures.  We also confirm  the efficiency  of the
-asynchronous  multisplitting algorithm  compared to the synchronous  GMRES. In
-this way and with a simple computing architecture (a laptop) SimGrid allows us
+parameter variation of the execution platform and of the application data can
+lead to very different numbers of iterations to reach the convergence and so to
+very different execution times. In this challenging context we think that the
+use of a simulation tool can greatly leverage the possibility of testing various
+platform scenarios.
+
+The  {\bf main  contribution  of  this paper}  is  to show  that  the  use of  a
+simulation tool (i.e. the SimGrid toolkit~\cite{SimGrid}) in the context of real
+parallel applications (i.e. large linear  system solvers) can help developers to
+better tune their  applications for a given multi-core architecture.  To show the
+validity of this approach we first compare the simulated execution of the Krylov
+multisplitting  algorithm   with  the   GMRES  (Generalized   Minimal  RESidual)
+solver~\cite{saad86} in  synchronous mode.  The simulation  results allow  us to
+determine  which method  to choose  for a given multi-core  architecture.
+Moreover the  obtained results  on different simulated  multi-core architectures
+confirm the  real results  previously obtained  on non  simulated architectures.
+More precisely the simulated results are in accordance (i.e. with the same order
+of magnitude)  with the works  presented in~\cite{couturier15}, which  show that
+the synchronous  Krylov multisplitting method  is more efficient  than GMRES  for large
+scale  clusters.   Simulated   results  also  confirm  the   efficiency  of  the
+asynchronous  multisplitting   algorithm  compared  to  the   synchronous  GMRES
+especially in case of geographically distant clusters.
+
+In this way and with a simple computing architecture (a laptop) SimGrid allows us

 to run a test campaign  of  a  real parallel iterative  applications on
 different simulated multi-core architectures.  To our knowledge, there is no
 related work on the large-scale multi-core simulation of a real synchronous and
 to run a test campaign  of  a  real parallel iterative  applications on
 different simulated multi-core architectures.  To our knowledge, there is no
 related work on the large-scale multi-core simulation of a real synchronous and


@@ -183,20 +195,20 @@ asynchronous iterative application.
 
 This paper is organized as follows. Section~\ref{sec:asynchro} presents the
 iteration model we use and more particularly the asynchronous scheme.  In
 
 This paper is organized as follows. Section~\ref{sec:asynchro} presents the
 iteration model we use and more particularly the asynchronous scheme.  In

-section~\ref{sec:simgrid} the SimGrid simulation toolkit is presented.
+Section~\ref{sec:simgrid} the SimGrid simulation toolkit is presented.

 Section~\ref{sec:04} details the different solvers that we use.  Finally our
 Section~\ref{sec:04} details the different solvers that we use.  Finally our

-experimental results are presented in section~\ref{sec:expe} followed by some
+experimental results are presented in Section~\ref{sec:expe} followed by some

 concluding remarks and perspectives.
 
 
 concluding remarks and perspectives.
 
 

-\section{The asynchronous iteration model}
+\section{The asynchronous iteration model and the motivations of our work}

 \label{sec:asynchro}
 
 \label{sec:asynchro}
 

-Asynchronous iterative methods have been  studied for many years theoritecally and
+Asynchronous iterative methods have been  studied for many years theoretically and

 practically. Many methods have been considered and convergence results have been
 proved. These  methods can  be used  to solve, in  parallel, fixed  point problems
 (i.e. problems  for which  the solution is  $x^\star =f(x^\star)$.  In practice,
 practically. Many methods have been considered and convergence results have been
 proved. These  methods can  be used  to solve, in  parallel, fixed  point problems
 (i.e. problems  for which  the solution is  $x^\star =f(x^\star)$.  In practice,

-asynchronous iterations  methods can be used  to solve, for example,  linear and
+asynchronous iteration  methods can be used  to solve, for example,  linear and

 non-linear systems of equations or optimization problems, interested readers are
 invited to read~\cite{BT89,bahi07}.
 
 non-linear systems of equations or optimization problems, interested readers are
 invited to read~\cite{BT89,bahi07}.
 


@@ -206,17 +218,84 @@ algorithm that supports both the synchronous or the asynchronous iteration model
 requires very few modifications  to be able to be executed  in both variants. In
 practice, only  the communications and  convergence detection are  different. In
 the synchronous  mode, iterations are  synchronized whereas in  the asynchronous
 requires very few modifications  to be able to be executed  in both variants. In
 practice, only  the communications and  convergence detection are  different. In
 the synchronous  mode, iterations are  synchronized whereas in  the asynchronous

-one, they are not.  It should be noticed that non blocking communications can be
+one, they are not.  It should be noticed that non-blocking communications can be

 used in both  modes. Concerning the convergence  detection, synchronous variants
 can use  a global convergence procedure  which acts as a  global synchronization
 point. In the  asynchronous model, the convergence detection is  more tricky as
 it   must  not   synchronize  all   the  processors.   Interested  readers   can
 consult~\cite{myBCCV05c,bahi07,ccl09:ij}.
 
 used in both  modes. Concerning the convergence  detection, synchronous variants
 can use  a global convergence procedure  which acts as a  global synchronization
 point. In the  asynchronous model, the convergence detection is  more tricky as
 it   must  not   synchronize  all   the  processors.   Interested  readers   can
 consult~\cite{myBCCV05c,bahi07,ccl09:ij}.
 

+The number of iterations required to reach the convergence is generally greater
+for the asynchronous scheme (this number depends on  the delay of the
+messages). Note that, it is not the case in the synchronous mode where the
+number of iterations is the same than in the sequential mode. In this way, the
+set of the parameters  of the  platform (number  of nodes,  power of nodes,
+inter and  intra clusters  bandwidth  and  latency,~\ldots) and  of  the
+application can drastically change the number of iterations required to get the
+convergence. It follows that asynchronous iterative algorithms are difficult to
+optimize since the financial and deployment costs on large scale multi-core
+architectures are often very important. So, prior to deployment and tests it
+seems very promising to be able to simulate the behavior of asynchronous
+iterative algorithms. The problematic is then to show that the results produced
+by simulation are in accordance with reality i.e. of the same order of
+magnitude. To our knowledge, there is no study on this problematic.
+

 \section{SimGrid}
 \section{SimGrid}

- \label{sec:simgrid}
+\label{sec:simgrid}
+SimGrid~\cite{SimGrid,casanova+legrand+quinson.2008.simgrid,casanova+giersch+legrand+al.2014.versatile} is a discrete event simulation framework to study the behavior of large-scale distributed computing platforms as Grids, Peer-to-Peer systems, Clouds and High Performance Computation systems. It is widely used to simulate and evaluate heuristics, prototype applications or even assess legacy MPI applications. It is still actively developed by the scientific community and distributed as an open source software.

 
 %%%%%%%%%%%%%%%%%%%%%%%%%
 
 %%%%%%%%%%%%%%%%%%%%%%%%%

+% SimGrid~\cite{SimGrid,casanova+legrand+quinson.2008.simgrid,casanova+giersch+legrand+al.2014.versatile}
+% is a simulation framework to study the behavior of large-scale distributed
+% systems.  As its name suggests, it emanates from the grid computing community,
+% but is nowadays used to study grids, clouds, HPC or peer-to-peer systems.  The
+% early versions of SimGrid date back from 1999, but it is still actively
+% developed and distributed as an open source software.  Today, it is one of the
+% major generic tools in the field of simulation for large-scale distributed
+% systems.
+
+SimGrid provides several programming interfaces: MSG to simulate Concurrent
+Sequential Processes, SimDAG to simulate DAGs of (parallel) tasks, and SMPI to
+run real applications written in MPI~\cite{MPI}.  Apart from the native C
+interface, SimGrid provides bindings for the C++, Java, Lua and Ruby programming
+languages.  SMPI is the interface that has been used for the work described in
+this paper.  The SMPI interface implements about \np[\%]{80} of the MPI 2.0
+standard~\cite{bedaride+degomme+genaud+al.2013.toward}, and supports
+applications written in C or Fortran, with little or no modifications (cf Section IV - paragraph B).
+
+Within SimGrid, the execution of a distributed application is simulated by a
+single process.  The application code is really executed, but some operations,
+like communications, are intercepted, and their running time is computed
+according to the characteristics of the simulated execution platform.  The
+description of this target platform is given as an input for the execution, by
+means of an XML file.  It describes the properties of the platform, such as
+the computing nodes with their computing power, the interconnection links with
+their bandwidth and latency, and the routing strategy.  The scheduling of the
+simulated processes, as well as the simulated running time of the application
+are computed according to these properties.
+
+To compute the durations of the operations in the simulated world, and to take
+into account resource sharing (e.g. bandwidth sharing between competing
+communications), SimGrid uses a fluid model.  This allows users to run relatively fast
+simulations, while still keeping accurate
+results~\cite{bedaride+degomme+genaud+al.2013.toward,
+  velho+schnorr+casanova+al.2013.validity}.  Moreover, depending on the
+simulated application, SimGrid/SMPI allows to skip long lasting computations and
+to only take their duration into account.  When the real computations cannot be
+skipped, but the results are unimportant for the simulation results, it is
+also possible to share dynamically allocated data structures between
+several simulated processes, and thus to reduce the whole memory consumption.
+These two techniques can help to run simulations on a very large scale.
+
+The validity of simulations with SimGrid has been asserted by several studies.
+See, for example, \cite{velho+schnorr+casanova+al.2013.validity} and articles
+referenced therein for the validity of the network models.  Comparisons between
+real execution of MPI applications on the one hand, and their simulation with
+SMPI on the other hand, are presented in~\cite{guermouche+renard.2010.first,
+  clauss+stillwell+genaud+al.2011.single,
+  bedaride+degomme+genaud+al.2013.toward}.  All these works conclude that
+SimGrid is able to simulate pretty accurately the real behavior of the
+applications.

 %%%%%%%%%%%%%%%%%%%%%%%%%
 
 \section{Two-stage multisplitting methods}
 %%%%%%%%%%%%%%%%%%%%%%%%%
 
 \section{Two-stage multisplitting methods}


@@ -238,7 +317,7 @@ where $x_\ell$ are sub-vectors of the solution $x$, $b_\ell$ are the sub-vectors
 A_{\ell\ell} x_\ell = c_\ell,\mbox{~for~}\ell=1,\ldots,L,
 \label{eq:03}
 \end{equation}
 A_{\ell\ell} x_\ell = c_\ell,\mbox{~for~}\ell=1,\ldots,L,
 \label{eq:03}
 \end{equation}

-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{alg: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}.
+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~\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{alg: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}.

 
 \begin{figure}[t]
 %\begin{algorithm}[t]
 
 \begin{figure}[t]
 %\begin{algorithm}[t]


@@ -307,26 +386,20 @@ The algorithm in Figure~\ref{alg:02} includes the procedure of the residual mini
 \subsection{Simulation of the two-stage methods using SimGrid toolkit}
 \label{sec:04.02}
 
 \subsection{Simulation of the two-stage methods using SimGrid toolkit}
 \label{sec:04.02}
 

-One of our objectives when simulating the  application in Simgrid is, as in real
+One of our objectives when simulating the  application in SimGrid is, as in real

 life, to  get accurate results  (solutions of the  problem) but also to ensure the
 test reproducibility  under the same  conditions.  According to  our experience,
 life, to  get accurate results  (solutions of the  problem) but also to ensure the
 test reproducibility  under the same  conditions.  According to  our experience,

-very  few modifications  are required  to adapt  a MPI  program for  the Simgrid
+very  few modifications  are required  to adapt  a MPI  program for  the SimGrid

 simulator using SMPI (Simulator MPI). The  first modification is to include SMPI
 simulator using SMPI (Simulator MPI). The  first modification is to include SMPI

-libraries  and related  header files  (smpi.h).  The  second modification  is to
+libraries  and related  header files  (\verb+smpi.h+).  The  second modification  is to

 suppress all global variables by replacing  them with local variables or using a
 suppress all global variables by replacing  them with local variables or using a

-Simgrid      selector       called      "runtime       automatic      switching"
+SimGrid selector       called      "runtime       automatic      switching"

 (smpi/privatize\_global\_variables). Indeed, global  variables can generate side
 effects on runtime between the threads running in the same process and generated by
 (smpi/privatize\_global\_variables). Indeed, global  variables can generate side
 effects on runtime between the threads running in the same process and generated by

-Simgrid  to simulate the  grid environment.
-
-%\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
-%last modification on the  MPI program pointed out for some  cases, the review of
-%the sequence of  the MPI\_Isend, MPI\_Irecv and  MPI\_Waitall instructions which
-%might cause an infinite loop.
-
+SimGrid  to simulate the  grid environment.

 
 

-\paragraph{Simgrid Simulator parameters}
-\  \\ \noindent  Before running  a Simgrid  benchmark, many  parameters for  the
+\paragraph{Parameters of the simulation in SimGrid}
+\  \\ \noindent  Before running  a SimGrid  benchmark, many  parameters for  the

 computation platform must be defined. For our experiments, we consider platforms
 in which  several clusters are  geographically distant,  so there are  intra and
 inter-cluster communications. In the following, these parameters are described:
 computation platform must be defined. For our experiments, we consider platforms
 in which  several clusters are  geographically distant,  so there are  intra and
 inter-cluster communications. In the following, these parameters are described:


@@ -334,40 +407,39 @@ inter-cluster communications. In the following, these parameters are described:
 \begin{itemize}
        \item hostfile: hosts description file.
        \item platform: file describing the platform architecture: clusters (CPU power,
 \begin{itemize}
        \item hostfile: hosts description file.
        \item platform: file describing the platform architecture: clusters (CPU power,

-\dots{}), intra cluster network description, inter cluster network (bandwidth bw,
-latency lat, \dots{}).
+\dots{}), intra cluster network description, inter cluster network (bandwidth $bw$,
+latency $lat$, \dots{}).

        \item archi   : grid computational description (number of clusters, number of
        \item archi   : grid computational description (number of clusters, number of

-nodes/processors for each cluster).
+nodes/processors in each cluster).

 \end{itemize}
 \noindent
 In addition, the following arguments are given to the programs at runtime:
 
 \begin{itemize}
 \end{itemize}
 \noindent
 In addition, the following arguments are given to the programs at runtime:
 
 \begin{itemize}

-       \item maximum number of inner and outer iterations;
-       \item inner and outer precisions;
-       \item maximum number of the GMRES restarts in the Arnorldi process;
-       \item maximum number of iterations and the tolerance threshold in classical GMRES;
-       \item tolerance threshold for outer and inner-iterations;
-       \item matrix size (N$_{x}$, N$_{y}$ and N$_{z}$) respectively on $x, y, z$ axis;
-       \item matrix diagonal value is fixed to $6.0$ for synchronous Krylov multisplitting experiments and $6.2$ for asynchronous block Jacobi experiments; \RC{CE tu vérifies, je dis ca de tête}
-       \item matrix off-diagonal value;
-       \item execution mode: synchronous or asynchronous;
-       \RCE {C'est ok la liste des arguments du programme mais si Lilia ou toi pouvez preciser pour les  arguments pour CGLS ci dessous} \RC{Vu que tu n'as pas fait varier ce paramètre, on peut ne pas en parler}
-       \item Size of matrix S;
-       \item Maximum number of iterations and tolerance threshold for CGLS.
+       \item maximum number of inner iterations $\MIG$ and outer iterations $\MIM$,
+       \item inner precision $\TOLG$ and outer precision $\TOLM$,
+       \item matrix sizes of the problem: N$_{x}$, N$_{y}$ and N$_{z}$ on axis $x$, $y$ and $z$ respectively (in our experiments, we solve 3D problem, see Section~\ref{3dpoisson}),
+       \item matrix diagonal value is fixed to $6.0$ for synchronous experiments and $6.2$ for asynchronous ones,
+       \item matrix off-diagonal value is fixed to $-1.0$,
+       \item number of vectors in matrix $S$ (i.e. value of $s$),
+       \item maximum number of iterations $\MIC$ and precision $\TOLC$ for CGLS method,
+        \item maximum number of iterations and precision for the classical GMRES method,
+        \item maximum number of restarts for the Arnorldi process in GMRES method,
+       \item execution mode: synchronous or asynchronous.

 \end{itemize}
 
 \end{itemize}
 

-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.
+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.

 
 %%%%%%%%%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%%%%%%%%
 
 
 %%%%%%%%%%%%%%%%%%%%%%%%%
 %%%%%%%%%%%%%%%%%%%%%%%%%
 

-\section{Experimental Results}
+\section{Experimental results}

 \label{sec:expe}
 
 \label{sec:expe}
 

-In this section, experiments for both Multisplitting algorithms are reported. First the 3D Poisson problem used in our experiments is described.
+In this section, experiments for both multisplitting algorithms are reported. First the 3D Poisson problem used in our experiments is described.

 
 \subsection{The 3D Poisson problem}
 
 \subsection{The 3D Poisson problem}

+\label{3dpoisson}

 
 
 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:
 
 
 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:


@@ -401,9 +473,9 @@ have been chosen for the study in this paper. \\
 
 \textbf{Step 2}: Collect the software materials needed for the experimentation.
 In our case, we have two variants algorithms for the resolution of the
 
 \textbf{Step 2}: Collect the software materials needed for the experimentation.
 In our case, we have two variants algorithms for the resolution of the

-3D-Poisson problem: (1) using the classical GMRES; (2) and the Multisplitting
-method. In addition, the Simgrid simulator has been chosen to simulate the
-behaviors of the distributed applications. Simgrid is running in a virtual
+3D-Poisson problem: (1) using the classical GMRES; (2) and the multisplitting
+method. In addition, the SimGrid simulator has been chosen to simulate the
+behaviors of the distributed applications. SimGrid is running in a virtual

 machine on a simple laptop. \\
 
 \textbf{Step 3}: Fix the criteria which will be used for the future
 machine on a simple laptop. \\
 
 \textbf{Step 3}: Fix the criteria which will be used for the future


@@ -412,10 +484,10 @@ on the  one hand the algorithm execution mode (synchronous and asynchronous)
 and on the other hand the execution time and the number of iterations to reach the convergence. \\
 
 \textbf{Step 4  }: Set up the  different grid testbed environments  that will be
 and on the other hand the execution time and the number of iterations to reach the convergence. \\
 
 \textbf{Step 4  }: Set up the  different grid testbed environments  that will be

-simulated in the  simulator tool to run the program.  The following architecture
-has been configured in Simgrid : 2x16, 4x8, 4x16, 8x8 and 2x50. The first number
+simulated in the  simulator tool to run the program.  The following architectures
+have been configured in SimGrid : 2$\times$16, 4$\times$8, 4$\times$16, 8$\times$8 and 2$\times$50. The first number

 represents the number  of clusters in the grid and  the second number represents
 represents the number  of clusters in the grid and  the second number represents

-the number  of hosts (processors/cores)  in each  cluster. The network  has been
+the number  of hosts (processors/cores)  in each  cluster. The network has been

 designed to  operate with a bandwidth  equals to 10Gbits (resp.  1Gbits/s) and a
 latency of 8.10$^{-6}$ seconds (resp.  5.10$^{-5}$) for the intra-clusters links
 (resp.  inter-clusters backbone links). \\
 designed to  operate with a bandwidth  equals to 10Gbits (resp.  1Gbits/s) and a
 latency of 8.10$^{-6}$ seconds (resp.  5.10$^{-5}$) for the intra-clusters links
 (resp.  inter-clusters backbone links). \\


@@ -427,24 +499,23 @@ input data.  \\
 
 \textbf{Step 6} : Collect and analyze the output results.
 
 
 \textbf{Step 6} : Collect and analyze the output results.
 

-\subsection{Factors impacting distributed applications performance in
-a grid environment}
+\subsection{Factors impacting distributed applications performance in a grid environment}

 
 When running a distributed application in a computational grid, many factors may
 
 When running a distributed application in a computational grid, many factors may

-have a strong impact on the performances.  First of all, the architecture of the
+have a strong impact on the performance.  First of all, the architecture of the

 grid itself can obviously influence the  performance results of the program. The
 performance gain  might be important  theoretically when the number  of clusters
 and/or  the  number  of  nodes (processors/cores)  in  each  individual  cluster
 increase.
 
 grid itself can obviously influence the  performance results of the program. The
 performance gain  might be important  theoretically when the number  of clusters
 and/or  the  number  of  nodes (processors/cores)  in  each  individual  cluster
 increase.
 

-Another important factor  impacting the overall performances  of the application
+Another important factor  impacting the overall performance  of the application

 is the network configuration. Two main network parameters can modify drastically
 the program output results:
 \begin{enumerate}
 is the network configuration. Two main network parameters can modify drastically
 the program output results:
 \begin{enumerate}

-\item  the network  bandwidth  (bw=bits/s) also  known  as "the  data-carrying
+\item  the network  bandwidth  ($bw$ in bits/s) also  known  as "the  data-carrying

     capacity" of the network is defined as  the maximum of data that can transit
     from one point to another in a unit of time.
     capacity" of the network is defined as  the maximum of data that can transit
     from one point to another in a unit of time.

-\item the  network latency  (lat :  microsecond) defined as  the delay  from the
+\item the  network latency  ($lat$ in microseconds) defined as  the delay  from the

   start time to send  a simple data from a source to a destination.
 \end{enumerate}
 Upon  the   network  characteristics,  another  impacting   factor  is  the volume of data exchanged  between the nodes in the cluster
   start time to send  a simple data from a source to a destination.
 \end{enumerate}
 Upon  the   network  characteristics,  another  impacting   factor  is  the volume of data exchanged  between the nodes in the cluster


@@ -455,91 +526,97 @@ and  between distant  clusters.  This parameter is application dependent.
  on  the other  hand, the  "inter-network" which  is the  backbone link  between
  clusters.  In   practice,  these  two   networks  have  different   speeds.
  The intra-network  generally works  like a  high speed  local network  with a
  on  the other  hand, the  "inter-network" which  is the  backbone link  between
  clusters.  In   practice,  these  two   networks  have  different   speeds.
  The intra-network  generally works  like a  high speed  local network  with a

- high bandwith and very low latency. In opposite, the inter-network connects
- clusters sometime via  heterogeneous networks components  throuth internet with
+ high bandwidth and very low latency. In opposite, the inter-network connects
+ clusters sometime via  heterogeneous networks components  through internet with

  a lower speed.  The network  between distant  clusters might  be a  bottleneck
  for  the global performance of the application.
 
 \subsection{Comparison of GMRES and Krylov Multisplitting algorithms in synchronous mode}
 
 In the scope  of this paper, our  first objective is to analyze  when the Krylov
  a lower speed.  The network  between distant  clusters might  be a  bottleneck
  for  the global performance of the application.
 
 \subsection{Comparison of GMRES and Krylov Multisplitting algorithms in synchronous mode}
 
 In the scope  of this paper, our  first objective is to analyze  when the Krylov

-Multisplitting  method   has  better  performances  than   the  classical  GMRES
-method. With an  iterative method, better performances mean a  smaller number of
-iterations and execution time before reaching the convergence.  For a systematic
-study,  the experiments  should figure  out  that, for  various grid  parameters
-values, the simulator will confirm  the targeted outcomes, particularly for poor
-and slow  networks, focusing on the  impact on the communication  performance on
-the chosen class of algorithm.
+Multisplitting  method   has  better  performance  than   the  classical  GMRES
+method. With a synchronous  iterative method, better performance means a
+smaller number of iterations and execution time before reaching the convergence.
+For a systematic study,  the experiments  should figure  out  that, for  various
+grid  parameters values, the simulator will confirm  the targeted outcomes,
+particularly for poor and slow  networks, focusing on the  impact on the
+communication  performance on the chosen class of algorithm.

 
 The following paragraphs present the test conditions, the output results
 and our comments.\\
 
 
 
 The following paragraphs present the test conditions, the output results
 and our comments.\\
 
 

-\subsubsection{Execution of the the algorithms on various computational grid
-architecture and scaling up the input matrix size}
+\subsubsection{Execution of the algorithms on various computational grid
+architectures and scaling up the input matrix size}

 \ \\
 % environment
 
 \ \\
 % environment
 

-\begin{figure} [ht!]
+\begin{table} [ht!]

 \begin{center}
 \begin{tabular}{r c }
  \hline
 \begin{center}
 \begin{tabular}{r c }
  \hline

- Grid & 2x16, 4x8, 4x16 and 8x8\\ %\hline
- Network & N2 : bw=1Gbits/s - lat=5.10$^{-5}$ \\ %\hline
- Input matrix size & N$_{x}$ x N$_{y}$ x N$_{z}$ =150 x 150 x 150\\ %\hline
- - &  N$_{x}$ x N$_{y}$ x N$_{z}$  =170 x 170 x 170    \\ \hline
+ Grid Architecture & 2 $\times$ 16, 4 $\times$ 8, 4 $\times$ 16 and 8 $\times$ 8\\ %\hline
+ Inter Network N2 & bw=1Gbits/s - lat=5.10$^{-5}$ \\ %\hline
+ Input matrix size & N$_{x}$ $\times$ N$_{y}$ $\times$ N$_{z}$ =150 $\times$ 150 $\times$ 150\\ %\hline
+ - &  N$_{x}$ $\times$ N$_{y}$ $\times$ N$_{z}$  =170 $\times$ 170 $\times$ 170    \\ \hline

  \end{tabular}
  \end{tabular}

-\caption{Clusters x Nodes with 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)}}
+\caption{Test conditions: various grid configurations with the input matrix size N$_{x}$=N$_{y}$=N$_{z}$=150 or 170 \RC{N2 n'est pas défini..}\RC{Nx est défini, Ny? Nz?}
+\AG{La lettre 'x' n'est pas le symbole de la multiplication. Utiliser \texttt{\textbackslash times}.  Idem dans le texte, les figures, etc.}}
+\label{tab:01}

 \end{center}
 \end{center}

-\end{figure}
-
+\end{table}

 
 
 
 
 
 

-%\RCE{J'ai voulu mettre les tableaux des données mais je pense que c'est inutile et ça va surcharger}

 
 
 
 

-In this  section, we analyze the  performences of algorithms running  on various
-grid configuration  (2x16, 4x8, 4x16  and 8x8). First,  the results in  Figure~\ref{fig:01}
-show for all grid configuration the non-variation of the number of iterations of
-classical  GMRES for  a given  input matrix  size; it  is not  the case  for the
+In this  section, we analyze the  performance of algorithms running  on various
+grid configurations  (2 $\times$ 16, 4 $\times$ 8, 4 $\times$ 16  and 8 $\times$ 8) and using an inter-network N2 defined in the test conditions in Table~\ref{tab:01}. First,  the results in  Figure~\ref{fig:01}
+show for all grid configurations the non-variation of the number of iterations of
+classical  GMRES for  a given  input matrix  size; it is not  the case  for the

 multisplitting method.
 
 multisplitting method.
 

-\RC{CE attention tu n'as pas mis de label dans tes figures, donc c'est le bordel, j'en mets mais vérifie...}
-\RC{Les légendes ne sont pas explicites...}
+%\RC{CE attention tu n'as pas mis de label dans tes figures, donc c'est le bordel, j'en mets mais vérifie...}
+%\RC{Les légendes ne sont pas explicites...}

 
 
 \begin{figure} [ht!]
   \begin{center}
     \includegraphics[width=100mm]{cluster_x_nodes_nx_150_and_nx_170.pdf}
   \end{center}
 
 
 \begin{figure} [ht!]
   \begin{center}
     \includegraphics[width=100mm]{cluster_x_nodes_nx_150_and_nx_170.pdf}
   \end{center}

-  \caption{Cluster x Nodes N$_{x}$=150 and N$_{x}$=170}
+  \caption{Various grid configurations with the input matrix size $N_{x}=150$ and $N_{x}=170$\RC{idem}
+\AG{Utiliser le point comme séparateur décimal et non la virgule.  Idem dans les autres figures.}}

   \label{fig:01}
 \end{figure}
 
 
   \label{fig:01}
 \end{figure}
 
 

-The execution  times between  the two algorithms  is significant  with different
-grid architectures, even  with the same number of processors  (for example, 2x16
-and  4x8). We  can  observ  the low  sensitivity  of  the Krylov multisplitting  method
+Secondly, the execution  times between  the two algorithms  is significant  with different
+grid architectures, even  with the same number of processors  (for example, 2 $\times$ 16
+and  4 $\times$ 8). We  can  observ  the sensitivity  of  the Krylov multisplitting  method

 (compared with the classical GMRES) when scaling up the number of the processors
 (compared with the classical GMRES) when scaling up the number of the processors

-in the  grid: in  average, the GMRES  (resp. Multisplitting)  algorithm performs
-40\% better (resp. 48\%) less when running from 2x16=32 to 8x8=64 processors.
+in the  grid: in  average, the reduction of the execution time for GMRES  (resp. Multisplitting)  algorithm is around $40\%$ (resp. around $48\%$) when running from 32 (grid 2 $\times$ 16) to 64 processors (grid 8 $\times$ 8) processors. \RC{pas très clair, c'est pas précis de dire qu'un algo perform mieux qu'un autre, selon quel critère?}

 
 

-\subsubsection{Running on two different speed cluster inter-networks}
-\ \\
+\subsubsection{Running on two different inter-clusters network speeds \\}

 
 

-\begin{figure} [ht!]
+\begin{table} [ht!]

 \begin{center}
 \begin{tabular}{r c }
  \hline
 \begin{center}
 \begin{tabular}{r c }
  \hline

- Grid & 2x16, 4x8\\ %\hline
- Network & N1 : bw=10Gbs-lat=8.10$^{-6}$ \\ %\hline
+ Grid Architecture & 2 $\times$ 16, 4 $\times$ 8\\ %\hline
+ Inter Networks & N1 : bw=10Gbs-lat=8.10$^{-6}$ \\ %\hline

  - & N2 : bw=1Gbs-lat=5.10$^{-5}$ \\
  - & N2 : bw=1Gbs-lat=5.10$^{-5}$ \\

- Input matrix size & N$_{x}$ x N$_{y}$ x N$_{z}$ =150 x 150 x 150\\ \hline 
+ Input matrix size & $N_{x} \times N_{y} \times N_{z} =150 \times 150 \times 150$\\ \hline

  \end{tabular}
  \end{tabular}

-\caption{Clusters x Nodes - Networks N1 x N2}
+\caption{Test conditions: grid 2 $\times$ 16 and 4 $\times$ 8 with  networks N1 vs N2}
+\label{tab:02}

 \end{center}
 \end{center}

-\end{figure}
+\end{table}
+
+In this section, the experiments  compare the  behavior of  the algorithms  running on a
+speeder inter-cluster  network (N1) and  also on  a less performant  network (N2) respectively defined in the test conditions Table~\ref{tab:02}. \RC{Il faut définir cela avant...}
+Figure~\ref{fig:02} shows that end users will reduce the execution time
+for  both  algorithms when using  a  grid  architecture  like  4 $\times$ 16 or  8 $\times$ 8: the reduction is about $2$. The results depict  also that when
+the  network speed  drops down (variation of 12.5\%), the  difference between  the two Multisplitting algorithms execution times can reach more than 25\%.

 
 
 
 
 
 


@@ -547,193 +624,205 @@ in the  grid: in  average, the GMRES  (resp. Multisplitting)  algorithm performs
 \begin{figure} [ht!]
 \centering
 \includegraphics[width=100mm]{cluster_x_nodes_n1_x_n2.pdf}
 \begin{figure} [ht!]
 \centering
 \includegraphics[width=100mm]{cluster_x_nodes_n1_x_n2.pdf}

-\caption{Cluster x Nodes N1 x N2}
+\caption{Grid 2 $\times$ 16 and 4 $\times$ 8 with networks N1 vs N2
+\AG{\np{8E-6}, \np{5E-6} au lieu de 8E-6, 5E-6}}

 \label{fig:02}
 \end{figure}
 %\end{wrapfigure}
 
 \label{fig:02}
 \end{figure}
 %\end{wrapfigure}
 

-These experiments  compare the  behavior of  the algorithms  running first  on a
-speed inter-cluster  network (N1) and  also on  a less performant  network (N2).
-Figure~\ref{fig:02} shows that end users will  gain to reduce the execution time
-for  both  algorithms  in using  a  grid  architecture  like  4x16 or  8x8:  the
-performance was increased  in a factor of  2. The results depict  also that when
-the  network speed  drops down  (12.5\%), the  difference between  the execution
-times can reach more than 25\%. \RC{c'est pas clair : la différence entre quoi et quoi?}

 
 \subsubsection{Network latency impacts on performance}
 \ \\
 
 \subsubsection{Network latency impacts on performance}
 \ \\

-\begin{figure} [ht!]
+\begin{table} [ht!]

 \centering
 \begin{tabular}{r c }
  \hline
 \centering
 \begin{tabular}{r c }
  \hline

- Grid & 2x16\\ %\hline
+ Grid Architecture & 2 $\times$ 16\\ %\hline

  Network & N1 : bw=1Gbs \\ %\hline
  Network & N1 : bw=1Gbs \\ %\hline

- Input matrix size & N$_{x}$ x N$_{y}$ x N$_{z}$ =150 x 150 x 150\\ \hline
+ Input matrix size & $N_{x} \times N_{y} \times N_{z} = 150 \times 150 \times 150$\\ \hline

  \end{tabular}
  \end{tabular}

-\caption{Network latency impact}
-\end{figure}
+\caption{Test conditions: network latency impacts}
+\label{tab:03}
+\end{table}

 
 
 
 \begin{figure} [ht!]
 \centering
 \includegraphics[width=100mm]{network_latency_impact_on_execution_time.pdf}
 
 
 
 \begin{figure} [ht!]
 \centering
 \includegraphics[width=100mm]{network_latency_impact_on_execution_time.pdf}

-\caption{Network latency impact on execution time}
+\caption{Network latency impacts on execution time
+\AG{\np{E-6}}}

 \label{fig:03}
 \end{figure}
 
 
 \label{fig:03}
 \end{figure}
 
 

-According  the results  in  Figure~\ref{fig:03}, a  degradation  of the  network
-latency from 8.10$^{-6}$  to 6.10$^{-5}$ implies an absolute  time increase more
-than 75\%  (resp. 82\%) of the  execution for the classical  GMRES (resp. Krylov
-multisplitting)   algorithm.   In   addition,   it  appears   that  the   Krylov
-multisplitting method tolerates  more the network latency variation  with a less
-rate  increase  of  the  execution   time.   Consequently,  in  the  worst  case
-(lat=6.10$^{-5 }$), the  execution time for GMRES is almost  the double than the
-time of the Krylov multisplitting, even  though, the performance was on the same
-order of magnitude with a latency of 8.10$^{-6}$.
+According to  the results of  Figure~\ref{fig:03}, a degradation of  the network
+latency from  $8.10^{-6}$ to  $6.10^{-5}$ implies an  absolute time  increase of
+more  than $75\%$  (resp.  $82\%$)  of the  execution  for  the classical  GMRES
+(resp.  Krylov multisplitting)  algorithm.   In addition,  it  appears that  the
+Krylov multisplitting method tolerates more the network latency variation with a
+less  rate increase  of  the  execution time.\RC{Les  2  précédentes phrases  me
+  semblent en contradiction....}  Consequently, in the worst case ($lat=6.10^{-5
+}$), the  execution time for  GMRES is  almost the double  than the time  of the
+Krylov multisplitting,  even though, the  performance was  on the same  order of
+magnitude with a latency of $8.10^{-6}$.

 
 \subsubsection{Network bandwidth impacts on performance}
 \ \\
 
 \subsubsection{Network bandwidth impacts on performance}
 \ \\

-\begin{figure} [ht!]
+\begin{table} [ht!]

 \centering
 \begin{tabular}{r c }
  \hline
 \centering
 \begin{tabular}{r c }
  \hline

- Grid & 2x16\\ %\hline
+ Grid Architecture & 2 $\times$ 16\\ %\hline

  Network & N1 : bw=1Gbs - lat=5.10$^{-5}$ \\ %\hline
  Network & N1 : bw=1Gbs - lat=5.10$^{-5}$ \\ %\hline

- Input matrix size & N$_{x}$ x N$_{y}$ x N$_{z}$ =150 x 150 x 150\\ \hline \\
+ Input matrix size & $N_{x} \times N_{y} \times N_{z} =150 \times 150 \times 150$\\ \hline \\

  \end{tabular}
  \end{tabular}

-\caption{Network bandwidth impact}
-\end{figure}
+\caption{Test conditions: Network bandwidth impacts\RC{Qu'est ce qui varie ici? Il n'y a pas de variation dans le tableau}}
+\label{tab:04}
+\end{table}

 
 
 \begin{figure} [ht!]
 \centering
 \includegraphics[width=100mm]{network_bandwith_impact_on_execution_time.pdf}
 
 
 \begin{figure} [ht!]
 \centering
 \includegraphics[width=100mm]{network_bandwith_impact_on_execution_time.pdf}

-\caption{Network bandwith impact on execution time}
+\caption{Network bandwith impacts on execution time
+\AG{``Execution time'' avec un 't' minuscule}. Idem autres figures.}

 \label{fig:04}
 \end{figure}
 
 \label{fig:04}
 \end{figure}
 

-
-

 The results  of increasing  the network  bandwidth show  the improvement  of the
 performance  for   both  algorithms   by  reducing   the  execution   time  (see
 Figure~\ref{fig:04}). However,  in this  case, the Krylov  multisplitting method
 presents a better  performance in the considered bandwidth interval  with a gain
 The results  of increasing  the network  bandwidth show  the improvement  of the
 performance  for   both  algorithms   by  reducing   the  execution   time  (see
 Figure~\ref{fig:04}). However,  in this  case, the Krylov  multisplitting method
 presents a better  performance in the considered bandwidth interval  with a gain

-of 40\% which is only around 24\% for classical GMRES.
+of $40\%$ which is only around $24\%$ for the classical GMRES.

 
 \subsubsection{Input matrix size impacts on performance}
 \ \\
 
 \subsubsection{Input matrix size impacts on performance}
 \ \\

-\begin{figure} [ht!]
+\begin{table} [ht!]

 \centering
 \begin{tabular}{r c }
  \hline
 \centering
 \begin{tabular}{r c }
  \hline

- Grid & 4x8\\ %\hline
- Network & N2 : bw=1Gbs - lat=5.10$^{-5}$ \\ 
- Input matrix size & N$_{x}$ = From 40 to 200\\ \hline
+ Grid Architecture & 4 $\times$ 8\\ %\hline
+ Network & N2 : bw=1Gbs - lat=5.10$^{-5}$ \\
+ Input matrix size & $N_{x}$ = From 40 to 200\\ \hline

  \end{tabular}
  \end{tabular}

-\caption{Input matrix size impact}
-\end{figure}
+\caption{Test conditions: Input matrix size impacts}
+\label{tab:05}
+\end{table}

 
 
 \begin{figure} [ht!]
 \centering
 \includegraphics[width=100mm]{pb_size_impact_on_execution_time.pdf}
 
 
 \begin{figure} [ht!]
 \centering
 \includegraphics[width=100mm]{pb_size_impact_on_execution_time.pdf}

-\caption{Problem size impact on execution time}
+\caption{Problem size impacts on execution time}

 \label{fig:05}
 \end{figure}
 
 \label{fig:05}
 \end{figure}
 

-In these experiments, the input matrix size  has been set from N$_{x}$ = N$_{y}$
-= N$_{z}$ = 40 to 200 side elements  that is from 40$^{3}$ = 64.000 to 200$^{3}$
-= 8,000,000  points. Obviously, as  shown in Figure~\ref{fig:05},  the execution
+In these experiments, the input matrix size  has been set from $N_{x} = N_{y}
+= N_{z} = 40$ to $200$ side elements  that is from $40^{3} = 64.000$ to $200^{3}
+= 8,000,000$  points. Obviously, as  shown in Figure~\ref{fig:05},  the execution

 time for  both algorithms increases when  the input matrix size  also increases.
 But the interesting results are:
 \begin{enumerate}
 time for  both algorithms increases when  the input matrix size  also increases.
 But the interesting results are:
 \begin{enumerate}

-  \item the drastic increase (300 times) \RC{Je ne vois pas cela sur la figure}
-of the  number of  iterations needed  to reach the  convergence for  the classical
-GMRES algorithm when  the matrix size go beyond N$_{x}$=150;
-\item the  classical GMRES execution time  is almost the double  for N$_{x}$=140
+  \item the drastic increase ($10$ times)  of the number of iterations needed to
+    reach the convergence for the classical GMRES algorithm when the matrix size
+    go beyond $N_{x}=150$; \RC{C'est toujours pas clair... ok le nommbre d'itérations est 10 fois plus long mais la suite de la phrase ne veut rien dire}
+\item the  classical GMRES execution time  is almost the double  for $N_{x}=140$

   compared with the Krylov multisplitting method.
 \end{enumerate}
 
 These  findings may  help a  lot end  users to  setup the  best and  the optimal
 targeted environment for the application deployment when focusing on the problem
 size scale up.  It  should be noticed that the same test has  been done with the
   compared with the Krylov multisplitting method.
 \end{enumerate}
 
 These  findings may  help a  lot end  users to  setup the  best and  the optimal
 targeted environment for the application deployment when focusing on the problem
 size scale up.  It  should be noticed that the same test has  been done with the

-grid 2x16 leading to the same conclusion.
+grid 2 $\times$ 16 leading to the same conclusion.

 
 

-\subsubsection{CPU Power impact on performance}
+\subsubsection{CPU Power impacts on performance}

 
 

-\begin{figure} [ht!]
+\begin{table} [ht!]

 \centering
 \begin{tabular}{r c }
  \hline
 \centering
 \begin{tabular}{r c }
  \hline

- Grid & 2x16\\ %\hline
+ Grid architecture & 2 $\times$ 16\\ %\hline

  Network & N2 : bw=1Gbs - lat=5.10$^{-5}$ \\ %\hline
  Network & N2 : bw=1Gbs - lat=5.10$^{-5}$ \\ %\hline

- Input matrix size & N$_{x}$ = 150 x 150 x 150\\ \hline
+ Input matrix size & $N_{x} = 150 \times 150 \times 150$\\ \hline

  \end{tabular}
  \end{tabular}

-\caption{CPU Power impact}
-\end{figure}
+\caption{Test conditions: CPU Power impacts}
+\label{tab:06}
+\end{table}

 
 \begin{figure} [ht!]
 \centering
 \includegraphics[width=100mm]{cpu_power_impact_on_execution_time.pdf}
 
 \begin{figure} [ht!]
 \centering
 \includegraphics[width=100mm]{cpu_power_impact_on_execution_time.pdf}

-\caption{CPU Power impact on execution time}
+\caption{CPU Power impacts on execution time}

 \label{fig:06}
 \end{figure}
 
 Using the Simgrid  simulator flexibility, we have tried to  determine the impact
 on the  algorithms performance in  varying the CPU  power of the  clusters nodes
 \label{fig:06}
 \end{figure}
 
 Using the Simgrid  simulator flexibility, we have tried to  determine the impact
 on the  algorithms performance in  varying the CPU  power of the  clusters nodes

-from 1  to 19 GFlops.  The outputs  depicted in Figure~\ref{fig:06}  confirm the
-performance gain,  around 95\% for  both of the  two methods, after  adding more
+from $1$ to $19$ GFlops.  The outputs  depicted in Figure~\ref{fig:06}  confirm the
+performance gain,  around $95\%$ for  both of the  two methods, after  adding more

 powerful CPU.
 powerful CPU.

+\ \\
+%\DL{il faut une conclusion sur ces tests : ils confirment les résultats déjà
+%obtenus en grandeur réelle. Donc c'est une aide précieuse pour les dev. Pas
+%besoin de déployer sur une archi réelle}
+
+To conclude these series of experiments, with  SimGrid we have been able to make
+many simulations  with many parameters  variations. Doing all  these experiments
+with a real platform is most of  the time not possible. Moreover the behavior of
+both GMRES and  Krylov multisplitting methods is in accordance  with larger real
+executions on large scale supercomputer~\cite{couturier15}.
+

 
 \subsection{Comparing GMRES in native synchronous mode and the multisplitting algorithm in asynchronous mode}
 
 The previous paragraphs  put in evidence the interests to  simulate the behavior
 
 \subsection{Comparing GMRES in native synchronous mode and the multisplitting algorithm in asynchronous mode}
 
 The previous paragraphs  put in evidence the interests to  simulate the behavior

-of the application before any deployment in a real environment.  We have focused
-the study on analyzing the performance  in varying the key factors impacting the
-results. The study compares the performance  of the two proposed algorithms both
-in  \textit{synchronous mode  }. In  this section,  following the  same previous
-methodology, the  goal is  to demonstrate the  efficiency of  the multisplitting
-method in \textit{ asynchronous mode}  compared with the classical GMRES staying
-in \textit{synchronous mode}.
-
-Note that the interest of using the asynchronous mode for data exchange
-is mainly, in opposite of the synchronous mode, the non-wait aspects of
-the current computation after a communication operation like sending
-some data between nodes. Each processor can continue their local
-calculation without waiting for the end of the communication. Thus, the
-asynchronous may theoretically reduce the overall execution time and can
-improve the algorithm performance.
-
-As stated supra, Simgrid simulator tool has been used to prove the
-efficiency of the multisplitting in asynchronous mode and to find the
-best combination of the grid resources (CPU, Network, input matrix size,
-\ldots ) to get the highest \textit{"relative gain"} (exec\_time$_{GMRES}$ / exec\_time$_{multisplitting}$) in comparison with the classical GMRES time.
-
-
-The test conditions are summarized in the table below : \\
+of  the application  before  any  deployment in  a  real  environment.  In  this
+section, following  the same previous  methodology, our  goal is to  compare the
+efficiency of the multisplitting method  in \textit{ asynchronous mode} compared with the
+classical GMRES in \textit{synchronous mode}.

 
 

-% environment
-\begin{footnotesize}
+The  interest of  using  an asynchronous  algorithm  is that  there  is no  more
+synchronization. With  geographically distant  clusters, this may  be essential.
+In  this case,  each  processor can  compute its  iteration  freely without  any
+synchronization  with   the  other   processors.  Thus,  the   asynchronous  may
+theoretically reduce  the overall execution  time and can improve  the algorithm
+performance.
+
+\RC{la phrase suivante est bizarre, je ne comprends pas pourquoi elle vient ici}
+In this section, Simgrid simulator tool has been successfully used to show
+the efficiency of  the multisplitting in asynchronous mode and  to find the best
+combination of the grid resources (CPU,  Network, input matrix size, \ldots ) to
+get    the   highest    \textit{"relative    gain"}   (exec\_time$_{GMRES}$    /
+exec\_time$_{multisplitting}$) in comparison with the classical GMRES time.
+
+
+The test conditions are summarized in the table~\ref{tab:07}: \\
+
+\begin{table} [ht!]
+\centering

 \begin{tabular}{r c }
  \hline
 \begin{tabular}{r c }
  \hline

- Grid & 2x50 totaling 100 processors\\ %\hline
+ Grid Architecture & 2 $\times$ 50 totaling 100 processors\\ %\hline

  Processors Power & 1 GFlops to 1.5 GFlops\\
    Intra-Network & bw=1.25 Gbits - lat=5.10$^{-5}$ \\ %\hline
    Inter-Network & bw=5 Mbits - lat=2.10$^{-2}$\\
  Processors Power & 1 GFlops to 1.5 GFlops\\
    Intra-Network & bw=1.25 Gbits - lat=5.10$^{-5}$ \\ %\hline
    Inter-Network & bw=5 Mbits - lat=2.10$^{-2}$\\

- Input matrix size & N$_{x}$ = From 62 to 150\\ %\hline
+ Input matrix size & $N_{x}$ = From 62 to 150\\ %\hline

  Residual error precision & 10$^{-5}$ to 10$^{-9}$\\ \hline \\
  \end{tabular}
  Residual error precision & 10$^{-5}$ to 10$^{-9}$\\ \hline \\
  \end{tabular}

-\end{footnotesize}
+\caption{Test conditions: GMRES in synchronous mode vs Krylov Multisplitting in asynchronous mode}
+\label{tab:07}
+\end{table}

 
 

-Again, comprehensive and extensive tests have been conducted varying the
-CPU power and the network parameters (bandwidth and latency) in the
-simulator tool with different problem size. The relative gains greater
-than 1 between the two algorithms have been captured after each step of
-the test. Table 7 below has recorded the best grid configurations
-allowing the multisplitting method execution time more performant 2.5 times than
-the classical GMRES execution and convergence time. The experimentation has demonstrated the relative multisplitting algorithm tolerance when using a low speed network that we encounter usually with distant clusters thru the internet.
+Again,  comprehensive and  extensive tests  have been  conducted with  different
+parameters as  the CPU power, the  network parameters (bandwidth and  latency)
+and with different problem size. The  relative gains greater than $1$  between the
+two algorithms have  been captured after  each step  of the test.   In
+Table~\ref{tab:08}  are  reported the  best  grid  configurations allowing
+the  multisplitting method to  be more than  $2.5$ times faster  than the
+classical  GMRES.  These  experiments also  show the  relative tolerance  of the
+multisplitting algorithm when using a low speed network as usually observed with
+geographically distant clusters through the internet.

 
 % use the same column width for the following three tables
 \newlength{\mytablew}\settowidth{\mytablew}{\footnotesize\np{E-11}}
 
 % use the same column width for the following three tables
 \newlength{\mytablew}\settowidth{\mytablew}{\footnotesize\np{E-11}}


@@ -745,13 +834,11 @@ the classical GMRES execution and convergence time. The experimentation has demo
 
 
 \begin{table}[!t]
 
 
 \begin{table}[!t]

-  \centering
+\centering
+%\begin{table}

 %  \caption{Relative gain of the multisplitting algorithm compared with the classical GMRES}
 %  \label{"Table 7"}
 %  \caption{Relative gain of the multisplitting algorithm compared with the classical GMRES}
 %  \label{"Table 7"}

-Table 7. Relative gain of the multisplitting algorithm compared with
-the classical GMRES \\
-
-  \begin{mytable}{11}
+ \begin{mytable}{11}

     \hline
     bandwidth (Mbit/s)
     & 5     & 5     & 5         & 5         & 5  & 50        & 50        & 50        & 50        & 50 \\
     \hline
     bandwidth (Mbit/s)
     & 5     & 5     & 5         & 5         & 5  & 50        & 50        & 50        & 50        & 50 \\


@@ -772,20 +859,50 @@ the classical GMRES \\
     & 2.52     & 2.55     & 2.52     & 2.57     & 2.54 & 2.53     & 2.51     & 2.58     & 2.55     & 2.54 \\
     \hline
   \end{mytable}
     & 2.52     & 2.55     & 2.52     & 2.57     & 2.54 & 2.53     & 2.51     & 2.58     & 2.55     & 2.54 \\
     \hline
   \end{mytable}

+%\end{table}
+ \caption{Relative gain of the multisplitting algorithm compared with the classical GMRES}
+ \label{tab:08}

 \end{table}
 
 \end{table}
 

+

 \section{Conclusion}
 \section{Conclusion}

-CONCLUSION

 
 

+In this paper we have presented the simulation of the execution of three
+different parallel solvers on some multi-core architectures. We have show that
+the SimGrid toolkit is an interesting simulation tool that has allowed us to
+determine  which method  to choose  given a  specified multi-core  architecture.
+Moreover the simulated results are in accordance (i.e. with the same order of
+magnitude)  with the works  presented in~\cite{couturier15}. Simulated   results
+also  confirm  the   efficiency  of  the asynchronous  multisplitting
+algorithm  compared  to  the   synchronous  GMRES especially in case of
+geographically distant clusters.

 
 

-\section*{Acknowledgment}
+These results are important since it is very  time consuming to find optimal
+configuration  and deployment requirements for a given application  on   a given
+multi-core  architecture. Finding   good  resource allocations policies under
+varying CPU power, network speeds and  loads is very challenging and  labor
+intensive. This problematic is  even more difficult  for the  asynchronous
+scheme where  a small parameter variation of the execution platform and of the
+application data can lead to very different numbers of iterations to reach the
+converge and so to very different execution times.
+
+
+In future works, we  plan to investigate how to simulate  the behavior of really
+large scale  applications. For  example, if  we are  interested to  simulate the
+execution of the solvers of this paper with thousand or even dozens of thousands
+or core,  it is not possible  to do that with  SimGrid. In fact, this  tool will
+make the real computation. So we plan to focus our research on that problematic.

 
 

-This work is partially funded by the Labex ACTION program (contract ANR-11-LABX-01-01).

 
 
 
 

+%\section*{Acknowledgment}
+\ack
+This work is partially funded by the Labex ACTION program (contract ANR-11-LABX-01-01).
+

 \bibliographystyle{wileyj}
 \bibliography{biblio}
 
 \bibliographystyle{wileyj}
 \bibliography{biblio}
 

+

 \end{document}
 
 %%% Local Variables:
 \end{document}
 
 %%% Local Variables: