From: asider <ar.sider@univ-bejaia.dz>
Date: Wed, 21 Oct 2015 07:36:50 +0000 (+0100)
Subject: Merge branch 'master' of ssh://info.iut-bm.univ-fcomte.fr/kahina_paper1
X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/kahina_paper1.git/commitdiff_plain/e48d60147ff49ec4df9948967e6f8ef7c85202e9?ds=inline;hp=-c

Merge branch 'master' of ssh://info.iut-bm.univ-fcomte.fr/kahina_paper1
---

e48d60147ff49ec4df9948967e6f8ef7c85202e9
diff --combined paper.tex
index 7da8ca6,5920cad..24a86ca
--- a/paper.tex
+++ b/paper.tex
@@@ -510,7 -510,7 +510,7 @@@ T=\left[n\left(T_{i}(n)+T_{j}\right)+O(
  \end{equation}
  The execution time increases with the increasing of the polynomial degree, which justifies to parallelise these steps  in order to reduce the global execution time. In the following,  we explain how we did parrallelize these steps on a GPU architecture using the CUDA platform.
  
 -\subsubsection{A Parallel implementation on a GPU }
 +\subsubsection{A 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.
  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.
  
@@@ -530,7 -530,7 +530,7 @@@ Algorithm~\ref{alg2-cuda} shows a sketc
  \begin{algorithm}[H]
  \label{alg2-cuda}
  %\LinesNumbered
 -\caption{CUDA Algorithm to find roots of polynomial with Aberth method}
 +\caption{CUDA Algorithm to find roots with the Aberth method}
  
  \KwIn{$Z^{0}$(Initial root's vector),$\varepsilon$ (error
  tolerance threshold),P(Polynomial to solve)}
@@@ -545,19 -545,18 +545,19 @@@ Allocate and copy initial data to the G
  
  \While {$\Delta z_{max}\succ \epsilon$}{
   Let $\Delta z_{max}=0$\;
 -$ kernel\_save(d\_Z^{k-1})$\;
 +$ kernel\_save(d\_z^{k-1})$\;
  $ kernel\_update(d\_z^{k})$\;
 -$kernel\_testConverge (d_?z_{max},d_Z^{k},d_Z^{k-1})$\;
 +$kernel\_testConverge(\Delta z_{max},d_z^{k},d_z^{k-1})$\;
  }
  \end{algorithm}
  ~\\ 
  
 -After the initialization 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 work on the data filled 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 \textit{save} in line( 6, Algorithm 2) consist to save the vector of polynomial's root found at the previous time step on GPU memory, in order to test the convergence of the root at each iteration in line (8, Algorithm 2).
 +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 \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 and update Z(k),as formula (), we notice that the kernel update are called in two forms,  separated with  the value of \emph{R} which determines the radius beyond which we apply the logarithm formula like this: 
 +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 thevalue of \emph{R} which determines the radius beyond which we apply the logarithm computation of the power of a complex. 
  
  \begin{algorithm}[H]
 +\label{alg3-update}
  %\LinesNumbered
  \caption{A global Algorithm for the iterative function}
  
@@@ -568,9 -567,9 +568,9 @@@ $kernel\_update\_Log(d\_z^{k})$\
  }
  \end{algorithm}
  
 -The first form execute the formula(8) if all the module's $( |Z(k)|<= R)$, else the kernel execute the formulas(13,14).the radius R was computed like:
 +The first form execute the formula (8) if the modulus is of the current complex is less than the radius i.e. ($ |z^{k}_{i}|<= R$), else the kernel executes the formulas (13,14).the radius R was computed like:
  
 -$$R = \exp( \log(DBL\_MAX) / (2*(double)P.degrePolynome) )$$
 +$$R = \exp( \log(DBL\_MAX) / (2*n) )$$
  
  The last kernel verify the convergence of the root after each update of $Z^{(k)}$, as formula(), we used the function of the CUBLAS Library (CUDA Basic Linear Algebra Subroutines) to implement this kernel. 
  
@@@ -655,6 -654,16 +655,16 @@@ We initially carried out the convergenc
  		
  \end{table}
  
+ 
+ \begin{figure}[htbp]
+ \centering
+   \includegraphics[width=0.8\textwidth]{figures/influence_nb_threads}
+ \caption{Influence of the number of threads on the execution times of different polynomials (sparse and full)}
+ \label{fig:01}
+ \end{figure}
+ 
+ 
+ 
  \paragraph{A comparative study between Aberth and Durand-kerner algorithm}
  \begin{table}[htbp]
  	\centering
@@@ -670,6 -679,7 +680,6 @@@
  \end{table}
  
  
 -
  \bibliography{mybibfile}
  
  \end{document}