correct

[kahina_paper1.git] / paper.tex

diff --git a/paper.tex b/paper.tex
index 30fe88003a8910f177d456d718ec7aa8da30208e..0d2bbd66ebdcd1789ca243c573d5e955b9d4f39c 100644 (file)
--- a/paper.tex
+++ b/paper.tex
@@ -391,7 +391,7 @@ in~\cite{Benall68,Jana06,Janall99,Riceall06}.
 
 There are many schemes for the simultaneous approximation of all roots of a given
 polynomial. Several works on different methods and issues of root
 
 There are many schemes for the simultaneous approximation of all roots of a given
 polynomial. Several works on different methods and issues of root

-finding have been reported in~\cite{Azad07, Gemignani07, Kalantari08, Skachek08, Zhancall08, Zhuall08}. However, Durand-Kerner and Ehrlich-Aberth methods are the most practical choices among
+finding have been reported in~\cite{Azad07, Gemignani07, Kalantari08, Zhancall08, Zhuall08}. However, Durand-Kerner and Ehrlich-Aberth methods are the most practical choices among

 them~\cite{Bini04}. These two methods have been extensively
 studied for parallelization due to their intrinsics parallelism, i.e. the
 computations involved in both methods has some inherent
 them~\cite{Bini04}. These two methods have been extensively
 studied for parallelization due to their intrinsics parallelism, i.e. the
 computations involved in both methods has some inherent


@@ -489,14 +489,14 @@ provides two read-only memory spaces, the constant space and the
 texture space, which reside in external DRAM, and are accessed via
 read-only caches.
 
 texture space, which reside in external DRAM, and are accessed via
 read-only caches.
 

-\section{ The implementation of Ehrlich-Aberth method on GPU}
+\section{ Implementation of Ehrlich-Aberth method on GPU}

 \label{sec5}
 %%\subsection{A CUDA implementation of the Aberth's method }
 %%\subsection{A GPU implementation of the Aberth's method }
 
 
 
 \label{sec5}
 %%\subsection{A CUDA implementation of the Aberth's method }
 %%\subsection{A GPU implementation of the Aberth's method }
 
 
 

-\subsection{A sequential Ehrlich-Aberth algorithm}
+\subsection{Sequential Ehrlich-Aberth algorithm}

 The main steps of Ehrlich-Aberth method are shown in Algorithm.~\ref{alg1-seq} :
 %\LinesNumbered  
 \begin{algorithm}[H]
 The main steps of Ehrlich-Aberth method are shown in Algorithm.~\ref{alg1-seq} :
 %\LinesNumbered  
 \begin{algorithm}[H]


@@ -504,8 +504,10 @@ The main steps of Ehrlich-Aberth method are shown in Algorithm.~\ref{alg1-seq} :
 
 \caption{A sequential algorithm to find roots with the Ehrlich-Aberth method}
 
 
 \caption{A sequential algorithm to find roots with the Ehrlich-Aberth method}
 

-\KwIn{$Z^{0}$(Initial root's vector),$\varepsilon$ (error tolerance threshold), P(Polynomial to solve),$\Delta z_{max}$ (maximum value of stop condition),k (number of iteration),n(Polynomial's degrees)}
-\KwOut {Z (The solution root's vector),ZPrec (the previous solution root's vector)}
+\KwIn{$Z^{0}$ (Initial root's vector), $\varepsilon$ (error tolerance
+  threshold), P (Polynomial to solve), $\Delta z_{max}$ (maximum value
+  of stop condition), k (number of iteration), n (Polynomial's degrees)}
+\KwOut {Z (The solution root's vector), ZPrec (the previous solution root's vector)}

 
 \BlankLine
 
 
 \BlankLine
 


@@ -546,17 +548,24 @@ With the Gauss-Seidel iteration, we have:
 EAGS: z^{k+1}_{i}=\frac{p(z^{k}_{i})}{p'(z^{k}_{i})-p(z^{k}_{i})(\sum^{i-1}_{j=1}\frac{1}{z^{k}_{i}-z^{k+1}_{j}}+\sum^{n}_{j=i+1}\frac{1}{z^{k}_{i}-z^{k}_{j}})}, i=1,...,n.
 \end{equation}
 %%Here a finiched my revision %%
 EAGS: z^{k+1}_{i}=\frac{p(z^{k}_{i})}{p'(z^{k}_{i})-p(z^{k}_{i})(\sum^{i-1}_{j=1}\frac{1}{z^{k}_{i}-z^{k+1}_{j}}+\sum^{n}_{j=i+1}\frac{1}{z^{k}_{i}-z^{k}_{j}})}, i=1,...,n.
 \end{equation}
 %%Here a finiched my revision %%

-Using Equation.~\ref{eq:Aberth-H-GS} to update the vector solution \textit{Z}, we expect the Gauss-Seidel iteration to converge more quickly because, just as its ancestor (for solving linear systems of equations), it uses the most fresh computed roots $z^{k+1}_{i}$.
+Using Equation.~\ref{eq:Aberth-H-GS} to update the vector solution
+\textit{Z}, we expect the Gauss-Seidel iteration to converge more
+quickly because, just as any Jacobi algorithm (for solving linear systems of equations), it uses the most fresh computed roots $z^{k+1}_{i}$.

 
 The $4^{th}$ step of the algorithm checks the convergence condition using Equation.~\ref{eq:Aberth-Conv-Cond}.
 Both steps 3 and 4 use 1 thread to compute all the $n$ roots on CPU, which is very harmful for performance in case of the large degree polynomials.
 
 
 
 The $4^{th}$ step of the algorithm checks the convergence condition using Equation.~\ref{eq:Aberth-Conv-Cond}.
 Both steps 3 and 4 use 1 thread to compute all the $n$ roots on CPU, which is very harmful for performance in case of the large degree polynomials.
 
 

-\subsection{A Parallel implementation with CUDA }
+\subsection{Parallel implementation with CUDA }

 On the CPU,  both steps 3 and 4 contain the loop \verb=for= and a single thread executes all the instructions in the loop $n$ times. In this subsection, we explain how the GPU architecture can compute this loop and reduce the execution time.
 On the CPU,  both steps 3 and 4 contain the loop \verb=for= and a single thread executes all the instructions in the loop $n$ times. In this subsection, we explain how the GPU architecture can compute this loop and reduce the execution time.

-In the GPU, the schduler assigns the execution of this loop to a group of threads organised as a grid of blocks with block containing a number of threads. All threads within a block are executed concurrently in parallel. The instructions run on the GPU are grouped in special function called kernels. It's up to the programmer, to describe the execution context, that is the size of the Grid, the number of blocks and the number of threads per block upon the call of a given kernel, according to a special syntax defined by CUDA.
+In the GPU, the scheduler assigns the execution of this loop to a
+group of threads organised as a grid of blocks with block containing a
+number of threads. All threads within a block are executed
+concurrently in parallel. The instructions run on the GPU are grouped
+in special function called kernels. With CUDA, a programmer must
+describe the kernel execution context:  the size of the Grid, the number of blocks and the number of threads per block.

 
 

-In CUDA programming, all the instructions of the  \verb=for= loop are executed by the GPU as a kernel. A kernel is a function written in CUDA and defined by the  \verb=__global__= qualifier added before a usual \verb=C= function, which instructs the compiler to generate appropriate code to pass it to the CUDA runtime in order to be executed on the GPU. 
+%In CUDA programming, all the instructions of the  \verb=for= loop are executed by the GPU as a kernel. A kernel is a function written in CUDA and defined by the  \verb=__global__= qualifier added before a usual \verb=C= function, which instructs the compiler to generate appropriate code to pass it to the CUDA runtime in order to be executed on the GPU. 

 
 Algorithm~\ref{alg2-cuda} shows a sketch of the Ehrlich-Aberth algorithm using CUDA.
 
 
 Algorithm~\ref{alg2-cuda} shows a sketch of the Ehrlich-Aberth algorithm using CUDA.
 


@@ -565,13 +574,13 @@ Algorithm~\ref{alg2-cuda} shows a sketch of the Ehrlich-Aberth algorithm using C
 %\LinesNumbered
 \caption{CUDA Algorithm to find roots with the Ehrlich-Aberth method}
 
 %\LinesNumbered
 \caption{CUDA Algorithm to find roots with the Ehrlich-Aberth method}
 

-\KwIn{$Z^{0}$(Initial root's vector),$\varepsilon$ (error tolerance threshold), P(Polynomial to solve), $\Delta z_{max}$ (maximum value of stop condition)}
+\KwIn{$Z^{0}$ (Initial root's vector), $\varepsilon$ (error tolerance threshold), P(Polynomial to solve), $\Delta z_{max}$ (maximum value of stop condition)}

 
 

-\KwOut {Z(The solution root's vector)}
+\KwOut {Z (The solution root's vector)}

 
 \BlankLine
 
 
 \BlankLine
 

-Initialization of the coeffcients of the polynomial to solve\;
+Initialization of the coefficients of the polynomial to solve\;

 Initialization of the solution vector $Z^{0}$\;
 Allocate and copy initial data to the GPU global memory\;
 k=0\;
 Initialization of the solution vector $Z^{0}$\;
 Allocate and copy initial data to the GPU global memory\;
 k=0\;


@@ -588,7 +597,11 @@ $kernel\_testConverge(\Delta z_{max},d\_Z^{k},d\_Z^{k-1})$\;
 
 After the initialisation step, all data of the root finding problem to be solved must be copied from the CPU memory to the GPU global memory, because the GPUs only access data already present in their memories. Next, all the data-parallel arithmetic operations inside the main loop \verb=(do ... while(...))= are executed as kernels by the GPU. The first kernel named \textit{save} in line 6 of Algorithm~\ref{alg2-cuda} consists in saving the vector of polynomial's root found at the previous time-step in GPU memory, in order to check the convergence of the roots after each iteration (line 8, Algorithm~\ref{alg2-cuda}).
 
 
 After the initialisation step, all data of the root finding problem to be solved must be copied from the CPU memory to the GPU global memory, because the GPUs only access data already present in their memories. Next, all the data-parallel arithmetic operations inside the main loop \verb=(do ... while(...))= are executed as kernels by the GPU. The first kernel named \textit{save} in line 6 of Algorithm~\ref{alg2-cuda} consists in saving the vector of polynomial's root found at the previous time-step in GPU memory, in order to check the convergence of the roots after each iteration (line 8, Algorithm~\ref{alg2-cuda}).
 

-The second kernel executes the iterative function $H$ and updates $z^{k}$, according to Algorithm~\ref{alg3-update}. We notice that the update kernel is called in two forms, separated with the value of \emph{R} which determines the radius beyond which we apply the logarithm computation of the power of a complex. 
+The second kernel executes the iterative function $H$ and updates
+$z^{k}$, according to Algorithm~\ref{alg3-update}. We notice that the
+update kernel is called in two forms, separated with the value of
+\emph{R} which determines the radius beyond which we apply the
+exponential logarithm algorithm. 

 
 \begin{algorithm}[H]
 \label{alg3-update}
 
 \begin{algorithm}[H]
 \label{alg3-update}


@@ -598,11 +611,15 @@ The second kernel executes the iterative function $H$ and updates $z^{k}$, accor
 \eIf{$(\left|Z^{(k)}\right|<= R)$}{
 $kernel\_update(d\_z^{k})$\;}
 {
 \eIf{$(\left|Z^{(k)}\right|<= R)$}{
 $kernel\_update(d\_z^{k})$\;}
 {

-$kernel\_update\_Log(d\_z^{k})$\;
+$kernel\_update\_ExpoLog(d\_z^{k})$\;

 }
 \end{algorithm}
 
 }
 \end{algorithm}
 

-The first form executes formula \ref{eq:SimplePolynome} if the modulus of the current complex is less than the a certain value called the radius i.e. ($ |z^{k}_{i}|<= R$), else the kernel executes formulas (Eq.~\ref{deflncomplex},Eq.~\ref{defexpcomplex}). The radius $R$ is evaluated as :
+The first form executes formula \ref{eq:SimplePolynome} if the modulus
+of the current complex is less than the a certain value called the
+radius i.e. ($ |z^{k}_{i}|<= R$), else the kernel executes the EA.EL
+function Eq.~\ref{Log_H2}
+( with Eq.~\ref{deflncomplex}, Eq.~\ref{defexpcomplex}). The radius $R$ is evaluated as :

 
 $$R = \exp( \log(DBL\_MAX) / (2*n) )$$ where $DBL\_MAX$ stands for the maximum representable double value.
 
 
 $$R = \exp( \log(DBL\_MAX) / (2*n) )$$ where $DBL\_MAX$ stands for the maximum representable double value.