X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/rce2015.git/blobdiff_plain/5933ab9497ff790a931894f60fa16b9949111ff9..3ee7d87ebec391c81668db97e0b7aba41c597e56:/paper.tex?ds=inline

diff --git a/paper.tex b/paper.tex
index 4309369..bc1b1b4 100644
--- a/paper.tex
+++ b/paper.tex
@@ -659,16 +659,16 @@ Table~\ref{tab:01}). Figure~\ref{fig:01} shows, for all grid configurations and
 a given matrix size of 170$^3$ elements, a  non-variation in the number of
 iterations for the classical GMRES algorithm, which is not the case of the
 Krylov two-stage algorithm. In fact, with multisplitting  algorithms, the number
-of splitting (in our case, it is equal to the number of clusters) influences on the
-convergence speed. The higher the number  of splitting is, the slower the
+of splittings (in our case, it is equal to the number of clusters) influences on the
+convergence speed. The higher the number  of splittings is, the slower the
 convergence of the algorithm is (see the output results obtained from
 configurations 2$\times$16 vs. 4$\times$8 and configurations 4$\times$16 vs.
 8$\times$8).
 
-The execution times between both algorithms is significant with different grid
+The execution times between both algorithms are significant with different grid
 architectures. The synchronous Krylov two-stage algorithm presents better
-performances than the GMRES algorithm, even for a high number of clusters (about
-$32\%$ more efficient on a grid of 8$\times$8 than GMRES). In addition, we can
+performances than the GMRES algorithm, even for a high number of clusters (it is about
+$32\%$ more efficient on a grid of 8$\times$8 than the GMRES). In addition, we can
 observe a better sensitivity of the Krylov two-stage algorithm (compared to the
 GMRES one) when scaling up the number of the processors in the computational
 grid: the Krylov two-stage algorithm is about $48\%$ and the GMRES algorithm is
@@ -717,9 +717,8 @@ Figure~\ref{fig:03} shows the impact of the network latency on the performances
 
 Figure~\ref{fig:04} reports the results obtained for the simulation of a grid of
 $2\times16$ processors interconnected by a network of latency $lat=50\mu$s to
-solve a 3D Poisson problem of size $150^3$. The results of increasing the
-network bandwidth from $1$Gbit/s to $10$Gbit/s show the performances improvement for
-both algorithms by reducing the execution times. However, the Krylov two-stage
+solve a 3D Poisson problem of size $150^3$. Increasing the
+network bandwidth from $1$Gbit/s to $10$Gbit/s results in improving the performances of both algorithms by reducing the execution times. However, the Krylov two-stage
 algorithm presents a better performance gain in the considered bandwidth
 interval with a gain of $40\%$ compared to only about $24\%$ for the classical
 GMRES algorithm.
@@ -733,7 +732,7 @@ GMRES algorithm.
 
 \subsubsection{Matrix size impacts on performances\\}
 
-In these experiments, the matrix size of the 3D Poisson problem is varied from
+In these experiments, the matrix size of the 3D Poisson problem varies from
 $50^3$ to $190^3$ elements. The simulated computational grid is composed of $4$
 clusters of $8$ processors each interconnected by the network $N2$ (see
 Table~\ref{tab:01}). As shown in Figure~\ref{fig:05}, the execution
@@ -744,7 +743,7 @@ bigger the ratio between execution times of both algorithms is. We can also
 observe that for some problem sizes, the convergence (and thus the execution
 time) of the Krylov two-stage algorithm varies quite a lot.
 %This is due to the 3D partitioning of the 3D matrix of the Poisson problem.
-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.
+These findings may greatly 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.
 
 \begin{figure}[ht]
 \centering
@@ -774,14 +773,14 @@ processors.
 
 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 or very costly. Moreover
+with a real platform is most of the time impossible or very costly. Moreover
 the behavior of both GMRES and  Krylov two-stage algorithms is in accordance
 with larger real executions on large scale supercomputers~\cite{couturier15}.
 
 
 \subsection{Comparison between synchronous GMRES and asynchronous two-stage multisplitting algorithms}
 
-The previous paragraphs  put in evidence the interests to  simulate the behavior
+The previous paragraphs  put in evidence the interest to  simulate the behavior
 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
@@ -790,8 +789,8 @@ classical GMRES in \textit{synchronous mode}.
 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  iterations  freely without  any
-synchronization  with   the  other   processors.  Thus,  the   asynchronous  may
-theoretically reduce  the overall execution  time and can improve  the algorithm
+synchronization  with   the  other   processors.  Thus,  an   asynchronous algorithm  may
+theoretically reduce  the overall execution  time and can also improve  the algorithm
 performance.
 
 In this section,  the SimGrid simulator is  used to compare the  behavior of the
@@ -866,8 +865,8 @@ summarized in Table~\ref{tab:02}.
 Table~\ref{tab:03} reports  the relative gains  between both algorithms.   It is
 defined by the ratio between the execution  time of GMRES and the execution time
 of the  multisplitting. The ratio is  greater than one because  the asynchronous
-multisplitting  version  is  faster  than   GMRES.  In  average,  the  two-stage
-multisplitting algorithm to  be more than $2.5$ times faster  than the classical
+multisplitting  version  is  faster  than   GMRES.  On  average,  the  two-stage
+multisplitting algorithm is 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.
@@ -886,19 +885,19 @@ geographically distant clusters.
 
 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
+multi-core  architecture. Finding   good  resource allocation 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.
+convergeence and consequently 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
+large scale  applications. For  example, if  we are  interested in  simulating the
 execution of the solvers of this paper with thousand or even dozens of thousands
 of cores,  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.
+make the real computation. That is why, we plan to focus our research on that problematic.
 
 
 
