X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/kahina_paper2.git/blobdiff_plain/b89095f023b142fe1421d966acc4382cb936360a..1e78a287ea3a106288ac212436e538862b5d0604:/paper.tex diff --git a/paper.tex b/paper.tex index 7819f18..0c1a417 100644 --- a/paper.tex +++ b/paper.tex @@ -90,7 +90,7 @@ convergence. Many authors have proposed parallel simultaneous methods~\cite{Freeman89,Loizou83,Freemanall90,bini96,cs01:nj,Couturier02}, using several paradigms of parallelization (synchronous or asynchronous computations, mechanism of shared or distributed memory, -etc). However, so fat until now, only polynomials not exceeding +etc). However, so far until now, only polynomials not exceeding degrees of less than 100,000 have been solved. %The main problem of the simultaneous methods is that the necessary @@ -121,7 +121,7 @@ model invented by NVIDIA had revived parallel programming interest for this problem. Indeed, the computing power of GPUs (Graphics Processing Units) has exceeded that of traditional CPUs processors, which makes it very appealing to the research community to investigate new parallel implementations for a whole set of scientific problems in the reasonable hope to solve bigger instances of well known computationally demanding issues such as the one beforehand. However, CUDA adopts a totally new computing architecture to use the hardware resources provided by the GPU in order to offer a stronger computing ability to the massive data computing. Ghidouche et al.~\cite{Kahinall14} proposed an implementation of the Durand-Kerner method on a single GPU. Their main results showed that a parallel CUDA implementation is about 10 times faster than the sequential implementation on a single CPU for sparse polynomials of degree 48,000. -In this paper we propose the parallelization of the Ehrlich-Aberth (EA) method which has a cubic convergence rate which is much better than the quadratic rate of the Durand-Kerner method which has already been investigated in \cite{Kahinall14}. In the other hand, EA is suitable to be implemented in parallel computers according to the data-parallel paradigm. In this model, computing elements carry computations on the data they are assigned and communicate with other computing elements in order to get fresh data or to synchronise. Classically, two parallel programming paradigms OpenMP and MPI are used to code such solutions. But in our case, computing elements are CUDA multi-GPU platforms. This architectural setting poses new programming challenges but offers also new opportunities to efficiently solve huge problems, otherwise considered intractable until recently. To the best of our knowledge, our CUDA-MPI and CUDA-OpenMP codes are the first implementations of EA method with multiple GPUs for finding roots of polynomials. Our major contributions include: +In this paper we propose the parallelization of the Ehrlich-Aberth (EA) method which has a cubic convergence rate which is much better than the quadratic rate of the Durand-Kerner method which has already been investigated in \cite{Kahinall14}. In the other hand, EA is suitable to be implemented in parallel computers according to the data-parallel paradigm. In this model, computing elements carry computations on the data they are assigned and communicate with other computing elements in order to get fresh data or to synchronize. Classically, two parallel programming paradigms OpenMP and MPI are used to code such solutions. But in our case, computing elements are CUDA multi-GPU platforms. This architectural setting poses new programming challenges but offers also new opportunities to efficiently solve huge problems, otherwise considered intractable until recently. To the best of our knowledge, our CUDA-MPI and CUDA-OpenMP codes are the first implementations of EA method with multiple GPUs for finding roots of polynomials. Our major contributions include: \begin{itemize} \item The parallel implementation of EA algorithm on a multi-GPU platform with a shared memory using OpenMP API. It is based on threads created from the same system process, such that each thread is attached to one GPU. In this case the communications between GPUs are done by OpenMP threads through shared memory. @@ -222,7 +222,7 @@ initial roots are all distinct from each other. In step 3, the iterative function based on the Newton's method~\cite{newt70} and Weiestrass operator~\cite{Weierstrass03} is applied. In our case, the Ehrlich-Aberth is applied as in~(\ref{Eq:EA1}). Iterations of the -Ehrlich-Aberth method will converge to the roots of the considered +EA method will converge to the roots of the considered polynomial. In order to stop the iterative function, a stop condition is applied, this is the 4th step. This condition checks that all the root modules are lower than a fixed value $\epsilon$. @@ -233,13 +233,13 @@ root modules are lower than a fixed value $\epsilon$. \end{equation} \subsection{Improving Ehrlich-Aberth method} -With high degree polynomials, the Ehrlich-Aberth method suffers from floating point overflows due to the mantissa of floating points representations. This induces errors in the computation of $p(z)$ when $z$ is large. +With high degree polynomials, the EA method suffers from floating point overflows due to the mantissa of floating points representations. This induces errors in the computation of $p(z)$ when $z$ is large. In order to solve this problem, we propose to modify the iterative function by using the logarithm and the exponential of a complex and -we propose a new version of the Ehrlich-Aberth method. This method +we propose a new version of the EA method. This method allows us to exceed the computation of the polynomials of degree -100,000 and to reach a degree up to more than 1,000,000. The reformulation of the iteration~(\ref{Eq:EA1}) of the Ehrlich-Aberth method with exponential and logarithm operators is defined as follows, for $i=1,\dots,n$: +100,000 and to reach a degree up to more than 1,000,000. The reformulation of the iteration~(\ref{Eq:EA1}) of the EA method with exponential and logarithm operators is defined as follows, for $i=1,\dots,n$: \begin{equation} \label{Log_H2} @@ -257,13 +257,13 @@ Using the logarithm and the exponential operators, we can replace any multiplications and divisions with additions and subtractions. Consequently, computations manipulate lower values in absolute values~\cite{Karimall98}. In practice, the exponential and -logarithm mode is used when a root is outisde the circle unit represented by the radius $R$ evaluated in C language with: +logarithm mode is used when a root is outside the circle unit represented by the radius $R$ evaluated in C language with: \begin{equation} \label{R.EL} R = exp(log(DBL\_MAX)/(2*n) ); \end{equation} where \verb=DBL_MAX= stands for the maximum representable -\verb=double= value and $n$ is the degree of the polynimal. +\verb=double= value and $n$ is the degree of the polynomial. \subsection{The Ehrlich-Aberth parallel implementation on CUDA} @@ -395,7 +395,7 @@ its own roots (line 9) with the EA method. The local error is computed the local roots are transferred from the GPU memory to the CPU memory (line 12) before being exchanged between all processors (line 13) in order to give to all processors the last version of the roots (with -the MPI\_AlltoAll routine). If the convergence is not satisfied, a +the $MPI\_AlltoAll$ routine). If the convergence is not satisfied, a new iteration is executed. \begin{algorithm}[htpb] @@ -443,7 +443,7 @@ For our tests, 4 GPU cards Tesla Kepler K40 are used. In order to evaluate both the GPU and Multi-GPU approaches, we performed a set of experiments on a single GPU and multiple GPUs using OpenMP or MPI with the EA algorithm, for both sparse and full polynomials of different -sizes. All experimental results obtained are performed with double +degrees. All experimental results obtained are performed with double precision float data and the convergence threshold of the EA method is set to $10^{-7}$. The initialization values of the vector solution of the methods are given by the Guggenheimer method~\cite{Gugg86}. @@ -502,7 +502,7 @@ In the previous section we saw that both approaches are very efficient to reduce \label{fig:06} \end{figure} -In Figure~\ref{fig:05} there is one curve for CUDA-OpenMP and another one for CUDA-MPI. We can see that the results are quite similar between OpenMP and MPI for the polynomial degree of 200K. For the degree of 800K, the MPI version is a little bit slower than the OpenMP version but for the degree of 1,4 million, there is a slight advantage for the MPI version. In Figure~\ref{fig:06}, we can see that when it comes to full polynomials, both approaches are almost equivalent. +In Figure~\ref{fig:05} there is one curve for CUDA-OpenMP and another one for CUDA-MPI for each polynomial investigated. We can see that the results are quite similar between OpenMP and MPI for the polynomial degree of 200K. For the degree of 800K, the MPI version is a little bit slower than the OpenMP version but for the degree of 1,4 million, there is a slight advantage for the MPI version. In Figure~\ref{fig:06}, we can see that when it comes to full polynomials, both approaches are almost equivalent. \subsection{Solving sparse and full polynomials of the same degree on multiple GPUs} @@ -544,9 +544,9 @@ These experiments report the execution times of the EA method for sparse and ful \section{Conclusion} \label{sec6} -In this paper, we have presented parallel implementations of the Ehrlich-Aberth algorithm to solve full and sparse polynomials, on a single GPU with CUDA and on multiple GPUs using two parallel paradigms: shared memory with OpenMP and distributed memory with MPI. These architectures were addressed by a CUDA-OpenMP approach and CUDA-MPI approach, respectively. Experiments show that, using parallel programming model like (OpenMP or MPI), we can efficiently manage multiple graphics cards to solve the same problem and accelerate the parallel execution with 4 GPUs and solve a polynomial of degree up-to 5,000,000 four times faster than on a single GPU. +In this paper, we have presented parallel implementations of the Ehrlich-Aberth algorithm to solve full and sparse polynomials, on a single GPU with CUDA and on multiple GPUs using two parallel paradigms: shared memory with OpenMP and distributed memory with MPI. These architectures were addressed by a CUDA-OpenMP approach and CUDA-MPI approach, respectively. Experiments show that, using parallel programming model like OpenMP or MPI, we can efficiently manage multiple graphics cards to solve the same problem and accelerate the parallel execution with 4 GPUs and solve a polynomial of degree up-to 5,000,000 four times faster than on a single GPU. -Our next objective is to extend the model presented here to clusters of GPU nodes, with a three-level scheme: inter-node communications via MPI processes (distributed memory), management of multi-GPU nodes by OpenMP threads (shared memory). Actual platforms may probably also contain purely multi-core nodes without any GPU. This heterogeneous setting may lead to the integration of load balancing algorithms so as to allow an optimal use of hardware ressources. +Our next objective is to extend the model presented here to clusters of GPU nodes, with a three-level scheme: inter-node communications via MPI processes (distributed memory), management of multi-GPU nodes by OpenMP threads (shared memory). Actual platforms may probably also contain purely multi-core nodes without any GPU. This heterogeneous setting may lead to the integration of load balancing algorithms so as to allow an optimal use of hardware resource's. \section*{Acknowledgment}