From 4de6573eeccc7dee05f3a8d6db29aa3cd97de386 Mon Sep 17 00:00:00 2001 From: Kahina Date: Wed, 4 Nov 2015 17:03:46 +0100 Subject: [PATCH] Quelque modif comme 1,024 au lieu de 1024 --- paper.tex | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/paper.tex b/paper.tex index e1dfd58..3498bc0 100644 --- a/paper.tex +++ b/paper.tex @@ -691,7 +691,7 @@ E5620@2.40GHz and a GPU K40 (with 6 Go of ram) is used. %First, performances of the Ehrlich-Aberth method of root finding polynomials %implemented on CPUs and on GPUs are studied. -We performed a set of experiments on the sequential and the parallel algorithms, for both sparse and full polynomials and different sizes. We took into account the execution times, the polynomial size and the number of threads per block performed by sum or each experiment on CPUs and on GPUs. +We performed a set of experiments on the sequential and the parallel algorithms, for both sparse and full polynomials and different sizes. We took into account the execution times, the polynomial size and the number of threads per block performed by sum or each experiment on CPU and on GPU. All experimental results obtained from the simulations are made in double precision data, the convergence threshold of the methods is set @@ -705,8 +705,6 @@ of the methods are given in Section~\ref{sec:vec_initialization}. \subsection{Comparison of execution times of the Ehrlich-Aberth method on a CPU with OpenMP (1 core and 4 cores) vs. on a Tesla GPU} - - \begin{figure}[htbp] \centering \includegraphics[width=0.8\textwidth]{figures/openMP-GPU} @@ -721,7 +719,7 @@ In Figure~\ref{fig:01}, we report respectively the execution time of the Ehrlich \subsection{Influence of the number of threads on the execution times of different polynomials (sparse and full)} To optimize the performances of an algorithm on a GPU, it is necessary to maximize the use of cores GPU (maximize the number of threads executed in parallel) and to optimize the use of the various memoirs GPU. In fact, it is interesting to see the influence of the number of threads per block on the execution time of Ehrlich-Aberth algorithm. -For that, we notice that the maximum number of threads per block for the Nvidia Tesla K40 GPU is 1024, so we varied the number of threads per block from 8 to 1024. We took into account the execution time for both sparse and full of 10 different polynomials of size 50,000 and 10 different polynomials of size 500,000 degrees. +For that, we notice that the maximum number of threads per block for the Nvidia Tesla K40 GPU is 1024, so we varied the number of threads per block from 8 to 1,024. We took into account the execution time for both sparse and full of 10 different polynomials of size 50,000 and 10 different polynomials of size 500,000 degrees. \begin{figure}[htbp] \centering @@ -748,11 +746,11 @@ the Ehrlich-Aberth algorithm using the exp.log solution and the execution time of the Ehrlich-Aberth algorithm without this solution, with full and sparse polynomials degrees. We can see that the execution times for both algorithms are the same with full polynomials -degrees less than 4000 and sparse polynomials less than 150,000. We +degrees less than 4,000 and sparse polynomials less than 150,000. We also clearly show that the classical version (without log.exp) of Ehrlich-Aberth algorithm do not converge after these degree with sparse and full polynomials. In counterpart, the new version of -Ehrlich-Aberth algorithm with the log.exp solution can solve very +Ehrlich-Aberth algorithm with the exp.log solution can solve very high degree polynomials. %in fact, when the modulus of the roots are up than \textit{R} given in ~\ref{R},this exceed the limited number in the mantissa of floating points representations and can not compute the iterative function given in ~\ref{eq:Aberth-H-GS} to obtain the root solution, who justify the divergence of the classical Ehrlich-Aberth algorithm. However, applying log.exp solution given in ~\ref{sec2} took into account the limit of floating using the iterative function in(Eq.~\ref{Log_H1},Eq.~\ref{Log_H2} and allows to solve a very large polynomials degrees . @@ -783,8 +781,8 @@ Figure~\ref{fig:04} shows the execution times of both methods with sparse polynomial degrees ranging from 1,000 to 1,000,000. We can see that the Ehrlich-Aberth algorithm is faster than Durand-Kerner algorithm, with an average of 25 times faster. Then, when degrees of -polynomial exceed 500000 the execution time with EA is of the order -100 whereas DK passes in the order 1000. +polynomial exceed 500,000 the execution time with EA is of the order +100 whereas DK passes in the order 1,000. %with double precision not exceed $10^{-5}$. -- 2.39.5