X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/kahina_paper2.git/blobdiff_plain/d1d299f31705641d990ab7b8d31f40ae5299144d..67b37118a273b5e87b90da1ccce91d97a55e09e5:/paper.tex?ds=inline

diff --git a/paper.tex b/paper.tex
index 8d0dc13..414bd83 100644
--- a/paper.tex
+++ b/paper.tex
@@ -312,8 +312,10 @@
 % correct bad hyphenation here
 \hyphenation{op-tical net-works semi-conduc-tor}
 %\usepackage{graphicx}
-
-
+\bibliographystyle{IEEEtran}
+% argument is your BibTeX string definitions and bibliography database(s)
+%\bibliography{IEEEabrv,../bib/paper}
+\bibliographystyle{elsarticle-num}
 \begin{document}
 %
 % paper title
@@ -456,29 +458,29 @@ This paper is organized as follows, in section 2 we recall the Ehrlich-Aberth me
  
 \section{Parallel Programmings Model}
  
-\subsection{OpenMP}%L'article en anglais Multi-GPU and multi-CPU accelerated FDTD scheme for vibroacoustic applications 
-Open Multi-Processing (OpenMP) is a shared memory architecture API that provides multi thread capacity [22]. OpenMP is
+\subsection{OpenMP}
+Open Multi-Processing (OpenMP) is a shared memory architecture API that provides multi thread capacity~\cite{openmp13}. OpenMP is
 a portable approach for parallel programming on shared memory systems based on compiler directives, that can be included in order
 to parallelize a loop. In this way, a set of loops can be distributed along the different threads that will access to different data allo-
 cated in local shared memory. One of the advantages of OpenMP is its global view of application memory address space that allows relatively fast development of parallel applications with easier maintenance. However, it is often difficult to get high rates of
 performance in large scale applications. Although, in OpenMP a usage of threads ids and managing data explicitly as done in an MPI
 code can be considered, it defeats the advantages of OpenMP.
 
-\subsection{OpenMP} %L'article en FranÃ§ais Programmation multiGPU â OpenMP versus MPI
-OpenMP is a shared memory programming API based on threads from
-the same system process. Designed for multiprocessor shared memory UMA or
-NUMA [10], it relies on the execution model SPMD ( Single Program, Multiple Data Stream )
-where the thread "master" and threads "slaves" asynchronously execute their codes
-communicate / synchronize via shared memory [7]. It also helps to build
-the loop parallelism and is very suitable for an incremental code parallelization
-Sequential natively. Threads share some or all of the available memory and can
-have private memory areas [6].
-
-\subsection{MPI} %L'article en FranÃ§ais Programmation multiGPU â OpenMP versus MPI
- The library MPI allows to use a distributed memory architecture. The various processes have their own environment of execution and execute their codes in a asynchronous way, according to the model MIMD (Multiple Instruction streams, Multiple Dated streams); they communicate and synchronize by exchanges of messages [17]. MPI messages are explicitly sent, while the exchanges are implicit within the framework of a programming multi-thread (OpenMP/Pthreads).
+%\subsection{OpenMP} %L'article en FranÃ§ais Programmation multiGPU â OpenMP versus MPI
+%OpenMP is a shared memory programming API based on threads from
+%the same system process. Designed for multiprocessor shared memory UMA or
+%NUMA [10], it relies on the execution model SPMD ( Single Program, Multiple Data Stream )
+%where the thread "master" and threads "slaves" asynchronously execute their codes
+%communicate / synchronize via shared memory [7]. It also helps to build
+%the loop parallelism and is very suitable for an incremental code parallelization
+%Sequential natively. Threads share some or all of the available memory and can
+%have private memory areas [6].
+
+\subsection{MPI} 
+ The library MPI allows to use a distributed memory architecture. The various processes have their own environment of execution and execute their codes in a asynchronous way, according to the model MIMD (Multiple Instruction streams, Multiple Dated streams); they communicate and synchronize by exchanges of messages~\cite{Peter96}. MPI messages are explicitly sent, while the exchanges are implicit within the framework of a programming multi-thread (OpenMP/Pthreads).
  
 \subsection{CUDA}%L'article en anglais Multi-GPU and multi-CPU accelerated FDTD scheme for vibroacoustic applications
- CUDA (an acronym for Compute Unified Device Architecture) is a parallel computing architecture developed by NVIDIA [28]. The
+ CUDA (an acronym for Compute Unified Device Architecture) is a parallel computing architecture developed by NVIDIA~\cite{NVIDIA12}. The
 unit of execution in CUDA is called a thread. Each thread executes the kernel by the streaming processors in parallel. In CUDA,
 a group of threads that are executed together is called thread blocks, and the computational grid consists of a grid of thread
 blocks. Additionally, a thread block can use the shared memory on a single multiprocessor as while as the grid executes a single
@@ -492,6 +494,91 @@ We introduced three paradigms of parallel programming. Our objective consist to
 
 \section{The EA algorithm on single GPU}
 \subsection{the EA method}
+
+A cubically convergent iteration method to find zeros of
+polynomials was proposed by O. Aberth~\cite{Aberth73}. The
+Ehrlich-Aberth method contains 4 main steps, presented in what
+follows.
+
+%The Aberth method is a purely algebraic derivation. 
+%To illustrate the derivation, we let $w_{i}(z)$ be the product of linear factors 
+
+%\begin{equation}
+%w_{i}(z)=\prod_{j=1,j \neq i}^{n} (z-x_{j})
+%\end{equation}
+
+%And let a rational function $R_{i}(z)$ be the correction term of the
+%Weistrass method~\cite{Weierstrass03}
+
+%\begin{equation}
+%R_{i}(z)=\frac{p(z)}{w_{i}(z)} , i=1,2,...,n.
+%\end{equation}
+
+%Differentiating the rational function $R_{i}(z)$ and applying the
+%Newton method, we have:
+
+%\begin{equation}
+%\frac{R_{i}(z)}{R_{i}^{'}(z)}= \frac{p(z)}{p^{'}(z)-p(z)\frac{w_{i}(z)}{w_{i}^{'}(z)}}= \frac{p(z)}{p^{'}(z)-p(z) \sum _{j=1,j \neq i}^{n}\frac{1}{z-x_{j}}}, i=1,2,...,n
+%\end{equation}
+%where R_{i}^{'}(z)is the rational function derivative of F evaluated in the point z 
+%Substituting $x_{j}$ for $z_{j}$ we obtain the Aberth iteration method.% 
+
+
+\subsubsection{Polynomials Initialization}
+The initialization of a polynomial $p(z)$ is done by setting each of the $n$ complex coefficients $a_{i}$:
+
+\begin{equation}
+\label{eq:SimplePolynome}
+  p(z)=\sum{a_{i}z^{n-i}} , a_{n} \neq 0,a_{0}=1, a_{i}\subset C
+\end{equation}
+
+
+\subsubsection{Vector $Z^{(0)}$ Initialization}
+\label{sec:vec_initialization}
+As for any iterative method, we need to choose $n$ initial guess points $z^{0}_{i}, i = 1, . . . , n.$
+The initial guess is very important since the number of steps needed by the iterative method to reach
+a given approximation strongly depends on it.
+In~\cite{Aberth73} the Ehrlich-Aberth iteration is started by selecting $n$
+equi-spaced points on a circle of center 0 and radius r, where r is
+an upper bound to the moduli of the zeros. Later, Bini and al.~\cite{Bini96}
+performed this choice by selecting complex numbers along different
+circles which relies on the result of~\cite{Ostrowski41}.
+
+\begin{equation}
+\label{eq:radiusR}
+%%\begin{align}
+\sigma_{0}=\frac{u+v}{2};u=\frac{\sum_{i=1}^{n}u_{i}}{n.max_{i=1}^{n}u_{i}};
+v=\frac{\sum_{i=0}^{n-1}v_{i}}{n.min_{i=0}^{n-1}v_{i}};\\
+%%\end{align}
+\end{equation}
+Where:
+\begin{equation}
+u_{i}=2.|a_{i}|^{\frac{1}{i}};
+v_{i}=\frac{|\frac{a_{n}}{a_{i}}|^{\frac{1}{n-i}}}{2}.
+\end{equation}
+
+\subsubsection{Iterative Function}
+The operator used by the Aberth method is corresponding to the
+following equation~\ref{Eq:EA} which will enable the convergence towards
+polynomial solutions, provided all the roots are distinct.
+
+%Here we give a second form of the iterative function used by the Ehrlich-Aberth method: 
+
+\begin{equation}
+\label{Eq:EA}
+EA: z^{k+1}_{i}=z_{i}^{k}-\frac{\frac{p(z_{i}^{k})}{p'(z_{i}^{k})}}
+{1-\frac{p(z_{i}^{k})}{p'(z_{i}^{k})}\sum_{j=1,j\neq i}^{j=n}{\frac{1}{(z_{i}^{k}-z_{j}^{k})}}}, i=1,. . . .,n
+\end{equation}
+
+\subsubsection{Convergence Condition}
+The convergence condition determines the termination of the algorithm. It consists in stopping the iterative function  when the roots are sufficiently stable. We consider that the method converges sufficiently when:
+
+\begin{equation}
+\label{eq:Aberth-Conv-Cond}
+\forall i \in [1,n];\vert\frac{z_{i}^{k}-z_{i}^{k-1}}{z_{i}^{k}}\vert<\xi
+\end{equation}
+
+
 %\begin{figure}[htbp]
 %\centering
  % \includegraphics[angle=-90,width=0.5\textwidth]{EA-Algorithm}
@@ -499,9 +586,11 @@ We introduced three paradigms of parallel programming. Our objective consist to
 %\label{fig:03}
 %\end{figure}
 
-the Ehrlich-Aberth method is an iterative  method, contain 4 steps, start from the initial approximations of all the
-roots of the polynomial,the second step initialize the solution vector $Z$ using the Guggenheimer method to assure the distinction of the initial vector roots, than in step 3 we apply the the iterative function based on the Newton's method and Weiestrass operator[...,...], wich will make it possible to converge to the roots solution, provided that all the root are different. At the end of each application of the iterative function, a stop condition is verified consists in stopping the iterative process when the whole of the modules of the roots
-are lower than a fixed value $Îµ$ 
+%the Ehrlich-Aberth method is an iterative  method, contain 4 steps, start from the initial approximations of all the
+%roots of the polynomial,the second step initialize the solution vector $Z$ using the Guggenheimer method to assure the distinction of the initial vector roots, than in step 3 we apply the the iterative function based on the Newton's method and Weiestrass operator[...,...], wich will make it possible to converge to the roots solution, provided that all the root are different. At the end of each application of the iterative function, a stop condition is verified consists in stopping the iterative process when the whole of the modules of the roots
+%are lower than a fixed value $Îµ$ 
+
+
 \subsection{EA parallel implementation on CUDA}
 Like any parallel code, a GPU parallel implementation first
 requires to determine the sequential tasks and the
@@ -538,7 +627,7 @@ Algorithm~\ref{alg2-cuda} shows a sketch of the Ehrlich-Aberth method using CUDA
 
 \begin{enumerate}
 \begin{algorithm}[htpb]
-\label{alg2-cuda}
+\label{alg1-cuda}
 %\LinesNumbered
 \caption{CUDA Algorithm to find roots with the Ehrlich-Aberth method}
 
@@ -547,7 +636,7 @@ Algorithm~\ref{alg2-cuda} shows a sketch of the Ehrlich-Aberth method using CUDA
 
 \KwOut {$Z$ (Solution root's vector), $ZPrec$ (Previous solution root's vector)}
 
-\BlankLine
+%\BlankLine
 
 \item Initialization of the of P\;
 \item Initialization of the of Pu\;
@@ -571,8 +660,10 @@ Algorithm~\ref{alg2-cuda} shows a sketch of the Ehrlich-Aberth method using CUDA
  
 \section{The EA algorithm on Multi-GPU}
 
-\subsection{MGPU (OpenMP-CUDA)approach}
-Before starting computations, our parallel implementation shared input data of the root finding polynomial between OpenMP threads. From Algorithm 1, the input data are the solution vector $Z$, the polynomial to solve $P$. Let number of OpenMP threads is equal to the number of GPUs, each threads OpenMP ( T-omp) checks one GPU,  and control a part of the shared memory, that is a part of the vector Z  like: $(n/Nbr_gpu)$ roots, n: the polynomial's degrees, $Nbr_gpu$ the number of GPUs. Then every GPU will have a grid of computation organized with its performances and the size of data of which it checks. In principle a grid is set by two parameter DimGrid, the number of block per grid, DimBloc: the number of threads per block. The following schema  shows the architecture of (CUDA,OpenMP).
+\subsection{MGPU (OpenMP-CUDA) approach}
+Our OpenMP-CUDA implementation of EA algorithm is based on the hybrid OpenMP and CUDA programming model. It works
+as follows.
+Based on the metadata, a shared memory is used to make data evenly shared among OpenMP threads. The shared data are the solution vector $Z$, the polynomial to solve $P$. vector of error of stop condition $\Delta z$. Let(T\_omp) number of OpenMP threads is equal to the number of GPUs, each threads OpenMP checks one GPU,  and control a part of the shared memory, that is a part of the vector Z  like: $(n/num\_gpu)$ roots, n: the polynomial's degrees, $num\_gpu$ the number of GPUs. Each OpenMP thread copies its data from host memory to GPUâs device memory.Than every GPU will have a grid of computation organized with its performances and the size of data of which it checks and compute kernels. %In principle a grid is set by two parameter DimGrid, the number of block per grid, DimBloc: the number of threads per block. The following schema  shows the architecture of (CUDA,OpenMP).
 
 %\begin{figure}[htbp]
 %\centering
@@ -580,17 +671,17 @@ Before starting computations, our parallel implementation shared input data of t
 %\caption{The OpenMP-CUDA architecture}
 %\label{fig:03}
 %\end{figure}
+%Each thread OpenMP compute the kernels on GPUs,than after each iteration they copy out the data from GPU memory to CPU shared memory. The kernels are re-runs is up to the roots converge sufficiently. Here are below the corresponding algorithm:
 
-
-Each thread OpenMP compute the kernels on GPUs,than after each iteration they copy out the data from GPU memory to CPU shared memory. The kernels are re-runs is up to the roots converge sufficiently. Here are below the corresponding algorithm:
+$num\_gpus$ thread OpenMP are created using \verb=omp_set_num_threads();=function (line,Algorithm \ref{alg2-cuda-openmp}), the shared memory is created using \verb=#pragma omp parallel shared()= OpenMP function (line 5,Algorithm\ref{alg2-cuda-openmp}), than each OpenMP threads allocate and copy initial data from CPU memory to the GPU global memories, execute the kernels on GPU, and compute only his portion of roots indicated with variable \textit{index} initialized in (line 5, Algorithm \ref{alg2-cuda-openmp}), used as input data in the $kernel\_update$ (line 10, Algorithm \ref{alg2-cuda-openmp}). After each iteration, OpenMP threads synchronize using \verb=#pragma omp barrier;= to recuperate all values of vector $\Delta z$, to compute the maximum stop condition in vector $\Delta z$(line 12, Algorithm \ref{alg2-cuda-openmp}).Finally,they copy the results from GPU memories to CPU memory. The OpenMP threads execute kernels until the roots converge sufficiently.  
 \begin{enumerate}
 \begin{algorithm}[htpb]
-\label{alg2-cuda}
+\label{alg2-cuda-openmp}
 %\LinesNumbered
 \caption{CUDA-OpenMP Algorithm to find roots with the Ehrlich-Aberth method}
 
 \KwIn{$Z^{0}$ (Initial root's vector), $\varepsilon$ (Error tolerance
-  threshold), P (Polynomial to solve), Pu (Derivative of P), $n$ (Polynomial degrees), $\Delta z$ ( Vector of errors of stop condition), $num_gpus$ (number of OpenMP threads/ number of GPUs), Size (number of roots)}
+  threshold), P (Polynomial to solve), Pu (Derivative of P), $n$ (Polynomial degrees), $\Delta z$ ( Vector of errors of stop condition), $num_gpus$ (number of OpenMP threads/ number of GPUs), $Size$ (number of roots)}
 
 \KwOut {$Z$ (Solution root's vector), $ZPrec$ (Previous solution root's vector)}
 
@@ -600,8 +691,8 @@ Each thread OpenMP compute the kernels on GPUs,than after each iteration they co
 \item Initialization of the of Pu\;
 \item Initialization of the solution vector $Z^{0}$\;
 \verb=omp_set_num_threads(num_gpus);=
-\verb=cudaGetDevice(gpu_id);=
 \verb=#pragma omp parallel shared(Z,$\Delta$ z,P);=
+\verb=cudaGetDevice(gpu_id);=
 \item Allocate and copy initial data from CPU memory to the GPU global memories\;
 \item index= $Size/num\_gpus$\;
 \item k=0\;
@@ -622,18 +713,20 @@ Each thread OpenMP compute the kernels on GPUs,than after each iteration they co
 
 
 
-\subsection{Multi-GPU (MPI-CUDA)approach}
+\subsection{Multi-GPU (MPI-CUDA) approach}
 %\begin{figure}[htbp]
 %\centering
  % \includegraphics[angle=-90,width=0.2\textwidth]{MPI-CUDA}
 %\caption{The MPI-CUDA architecture }
 %\label{fig:03}
 %\end{figure}
+Our parallel implementation of the Ehrlich-Aberth method to find root polynomial using (CUDA-MPI) approach, splits input data of the polynomial to solve between MPI processes. From Algorithm 3, the input data are the polynomial to solve $P$, the solution vector $Z$, the previous solution vector $zPrev$, and the Value of errors of stop condition $\Delta z$. Let $p$ denote the number of MPI processes on and $n$ the size of the polynomial to be solved. The algorithm performs a simple data partitioning by creating $p$ portions, of at most $ân/pâ$ roots to find per MPI process, for each element mentioned above. Consequently, each MPI process $k$ will have its own solution vector $Z_{k}$,polynomial to be solved $p_{k}$, the error of stop condition $\Delta z_{k}$, Than each MPI processes compute only $ân/pâ$ roots.
 
+Since a GPU works only on data of its memory, all local input data, $Z_{k}, p_{k}$ and $\Delta z_{k}$, must be transferred from CPU memories to the corresponding GPU memories. Afterward, the same EA algorithm (Algorithm 1) is run by all processes but on different sub-polynomial root $ p(x)_{k}=\sum_{i=k(\frac{n}{p})}^{k+1(\frac{n}{p})} a_{i}x^{i}, k=1,...,p$.  Each processes MPI execute the  loop \verb=(While(...)...do)= contain the kernels. Than each process MPI  compute only his portion of roots indicated with variable \textit{index} initialized in (line 5, Algorithm \ref{alg2-cuda-mpi}), used as input data in the $kernel\_update$ (line 10, Algorithm \ref{alg2-cuda-mpi}). After each iteration, MPI processes synchronize using \verb=MPI_Allreduce= function, in order to compute the maximum error stops condition $\Delta z_{k}$ computed by each process MPI line (line, Algorithm\ref{alg2-cuda-mpi}), and  copy the values of new roots computed from GPU memories to CPU memories, than communicate  her results to the neighboring processes,using \verb=MPI_Alltoallv=. If maximum stop condition $error > \epsilon$ the processes stay to execute the loop \verb= while(...)...do= until all the roots converge sufficiently.
 
 \begin{enumerate}
 \begin{algorithm}[htpb]
-\label{alg2-cuda}
+\label{alg2-cuda-mpi}
 %\LinesNumbered
 \caption{CUDA-MPI Algorithm to find roots with the Ehrlich-Aberth method}
 
@@ -655,10 +748,11 @@ Each thread OpenMP compute the kernels on GPUs,than after each iteration they co
 \item  k=k+1\;
 \item $ kernel\_update(Z,P,Pu,index)$\;
 \item $kernel\_testConverge(\Delta z,Z,ZPrec)$\;
+\item ComputeMaxError($\Delta z$,error)\;
 \item Copy results from GPU memories to CPU memories\;
 \item Send $Z[id]$ to all neighboring processes\;
 \item Receive $Z[j]$ from neighboring process j\;
-\item ComputeMaxError($\Delta z$,error)\;
+
 
 }
 \end{algorithm}
@@ -666,28 +760,68 @@ Each thread OpenMP compute the kernels on GPUs,than after each iteration they co
 ~\\ 
 
 \section{experiments}
+We study two categories of polynomials: sparse polynomials and full polynomials.\\
+{\it A sparse polynomial} is a polynomial for which only some coefficients are not null. In this paper, we consider sparse polynomials for which the roots are distributed on 2 distinct circles:
+\begin{equation}
+	\forall \alpha_{1} \alpha_{2} \in C,\forall n_{1},n_{2} \in N^{*}; P(z)= (z^{n_{1}}-\alpha_{1})(z^{n_{2}}-\alpha_{2})
+\end{equation}\noindent
+{\it A full polynomial} is, in contrast, a polynomial for which all the coefficients are not null. A full polynomial is defined by:
+%%\begin{equation}
+	%%\forall \alpha_{i} \in C,\forall n_{i}\in N^{*}; P(z)= \sum^{n}_{i=1}(z^{n^{i}}.a_{i})
+%%\end{equation}
+
+\begin{equation}
+     {\Large \forall a_{i} \in C, i\in N;  p(x)=\sum^{n}_{i=0} a_{i}.x^{i}} 
+\end{equation}
+For our tests, a CPU Intel(R) Xeon(R) CPU E5620@2.40GHz and a GPU K40 (with 6 Go of ram) are used. 
+
+We performed a set of experiments on single GPU and Multi-GPU using (OpenMP/MPI) to find roots polynomials with EA algorithm, for both sparse and full polynomials of different sizes. We took into account the execution times and the  polynomial size performed by sum or each experiment.
+All experimental results obtained from the simulations are made in
+double precision data, the convergence threshold of the methods is set
+to $10^{-7}$.
+%Since we were more interested in the comparison of the
+%performance behaviors of Ehrlich-Aberth and Durand-Kerner methods on
+%CPUs versus on GPUs.
+The initialization values of the vector solution
+of the methods are given in %Section~\ref{sec:vec_initialization}.
+
+\subsection{Test with Multi-GPU (CUDA OpenMP) approach}
+
+In this part we performed  a set of experiments on Multi-GPU (CUDA OpenMP) approach for full and sparse polynomials of different degrees, compare it with Single GPU (CUDA).
+ \subsubsection{Execution times in seconds of the Ehrlich-Aberth method for solving sparse polynomials on GPUs using shared memory paradigm with OpenMP}
+ 
+ In this experiments we report the execution time of the EA algorithm, on single GPU and Multi-GPU with (2,3,4) GPUs, for different sparse polynomial degrees ranging from 100,000 to 1,400,000
 
 \begin{figure}[htbp]
 \centering
-  \includegraphics[angle=-90,width=0.5\textwidth]{Sparse_openmp}
+  \includegraphics[angle=-90,width=0.5\textwidth]{Sparse_omp}
 \caption{Execution times in seconds of the Ehrlich-Aberth method for solving sparse polynomials on GPUs using shared memory paradigm with OpenMP}
 \label{fig:01}
 \end{figure}
 
+This figure~\ref{fig:01} shows that (CUDA OpenMP) Multi-GPU approach reduce the execution time up to the scale 100 whereas single GPU is of scale 1000 for polynomial who exceed 1,000,000. It shows the advantage to use OpenMP parallel paradigm  to connect the performances of several GPUs and solve a  polynomial of high degrees.   
+
+\subsubsection{Execution times in seconds of the Ehrlich-Aberth method for solving full polynomials on GPUs using shared memory paradigm with OpenMP}
+
+This experiments shows the execution time of the EA algorithm, on single GPU (CUDA) and Multi-GPU (CUDA OpenMP)approach for full polynomials of degrees ranging from 100,000 to 1,400,000
+
 \begin{figure}[htbp]
 \centering
-  \includegraphics[angle=-90,width=0.5\textwidth]{Sparse_mpi}
-\caption{Execution times in seconds of the Ehrlich-Aberth method for solving sparse polynomials on GPUs using distributed memory paradigm with MPI}
-\label{fig:02}
+  \includegraphics[angle=-90,width=0.5\textwidth]{Full_omp}
+\caption{Execution times in seconds of the Ehrlich-Aberth method for solving full polynomials on GPUs using shared memory paradigm with OpenMP}
+\label{fig:03}
 \end{figure}
 
+The second test with full polynomial shows a very important saving of time, for a polynomial of degrees 1,4M (CUDA OpenMP) approach with 4 GPUs compute and solve it 4 times as fast as single GPU. We notice that curves are positioned one below the other one, more the number of used GPUs increases more the execution time decreases.
+
 \begin{figure}[htbp]
 \centering
-  \includegraphics[angle=-90,width=0.5\textwidth]{Full_openmp}
-\caption{Execution times in seconds of the Ehrlich-Aberth method for solving full polynomials on GPUs using shared memory paradigm with OpenMP}
-\label{fig:03}
+  \includegraphics[angle=-90,width=0.5\textwidth]{Sparse_mpi}
+\caption{Execution times in seconds of the Ehrlich-Aberth method for solving sparse polynomials on GPUs using distributed memory paradigm with MPI}
+\label{fig:02}
 \end{figure}
 
+
 \begin{figure}[htbp]
 \centering
   \includegraphics[angle=-90,width=0.5\textwidth]{Full_mpi}
@@ -697,28 +831,28 @@ Each thread OpenMP compute the kernels on GPUs,than after each iteration they co
 
 \begin{figure}[htbp]
 \centering
-  \includegraphics[angle=-90,width=0.5\textwidth]{Sparse_mpivsomp}
+  \includegraphics[angle=-90,width=0.5\textwidth]{Sparse}
 \caption{Comparaison between MPI and OpenMP versions of the Ehrlich-Aberth method for solving sparse plynomials on GPUs}
 \label{fig:05}
 \end{figure}
 
 \begin{figure}[htbp]
 \centering
-  \includegraphics[angle=-90,width=0.5\textwidth]{Full_mpivsomp}
+  \includegraphics[angle=-90,width=0.5\textwidth]{Full}
 \caption{Comparaison between MPI and OpenMP versions of the Ehrlich-Aberth method for solving full polynomials on GPUs}
 \label{fig:06}
 \end{figure}
 
 \begin{figure}[htbp]
 \centering
-  \includegraphics[angle=-90,width=0.5\textwidth]{MPI_mpivsomp}
+  \includegraphics[angle=-90,width=0.5\textwidth]{MPI}
 \caption{Comparaison of execution times of the Ehrlich-Aberth method for solving sparse and full polynomials on GPUs with distributed memory paradigm using MPI}
 \label{fig:07}
 \end{figure}
 
 \begin{figure}[htbp]
 \centering
-  \includegraphics[angle=-90,width=0.5\textwidth]{OMP_mpivsomp}
+  \includegraphics[angle=-90,width=0.5\textwidth]{OMP}
 \caption{Comparaison of execution times of the Ehrlich-Aberth method for solving sparse and full polynomials on GPUs with shared memory paradigm using OpenMP}
 \label{fig:08}
 \end{figure}
@@ -821,7 +955,7 @@ Each thread OpenMP compute the kernels on GPUs,than after each iteration they co
 
 
 \section{Conclusion}
-The conclusion goes here.
+The conclusion goes here~\cite{IEEEexample:bibtexdesign}.
 
 
 
@@ -857,17 +991,24 @@ The authors would like to thank...
 %\bibliographystyle{IEEEtran}
 % argument is your BibTeX string definitions and bibliography database(s)
 %\bibliography{IEEEabrv,../bib/paper}
+%\bibliographystyle{./IEEEtran}
+\bibliography{mybibfile}
+
 %
 % <OR> manually copy in the resultant .bbl file
 % set second argument of \begin to the number of references
 % (used to reserve space for the reference number labels box)
-\begin{thebibliography}{1}
+%\begin{thebibliography}{1}
 
-\bibitem{IEEEhowto:kopka}
-H.~Kopka and P.~W. Daly, \emph{A Guide to \LaTeX}, 3rd~ed.\hskip 1em plus
-  0.5em minus 0.4em\relax Harlow, England: Addison-Wesley, 1999.
+%\bibitem{IEEEhowto:kopka}
+%H.~Kopka and P.~W. Daly, \emph{A Guide to \LaTeX}, 3rd~ed.\hskip 1em plus
+ % 0.5em minus 0.4em\relax Harlow, England: Addison-Wesley, 1999.
+  
+%\bibitem{IEEEhowto:NVIDIA12} 
+ %NVIDIA Corporation, \textit{Whitepaper NVIDAâs Next Generation CUDATM Compute
+%Architecture: KeplerTM }, 1st ed., 2012.
 
-\end{thebibliography}
+%\end{thebibliography}
 
 
 
