From: couturie <couturie@extinction>
Date: Sun, 17 Jan 2016 08:45:34 +0000 (+0100)
Subject: explication mpi
X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/kahina_paper2.git/commitdiff_plain/a055895aab68dd582363f108223327a760bea1ff?ds=inline;hp=--cc

explication mpi
---

a055895aab68dd582363f108223327a760bea1ff
diff --git a/paper.tex b/paper.tex
index 6a75cf9..2ee181a 100644
--- a/paper.tex
+++ b/paper.tex
@@ -329,37 +329,58 @@ Copy $P$, $P'$ from CPU to GPU\;
 
 
 
-\subsection{an MPI-CUDA approach}
+\subsection{a MPI-CUDA approach}
+
+Our parallel implementation of EA to find root of polynomials using a
+CUDA-MPI approach follows a similar computing approach to the one used
+in CUDA-OpenMP. Each process is responsible to compute its own part of
+roots using all the roots computed by other processors at the previous
+iteration. The difference between both approaches lies in the way
+processes communicate and exchange data. With MPI processors need to
+send and receive data explicitely. So in
+Algorithm~\ref{alg2-cuda-mpi}, after the initialization all the
+processors have the same $Z$ vector. Then they need to compute the
+parameters used by the $MPI\_AlltoAll$ routines (line 4). In practise,
+each processor needs to compute its offset and its local size. Then
+processors need to allocate memory on their GPU (line 5). At the
+beginning of each iteration, a processor starts by transfering the
+whole vector Z from the CPU to the GPU (line 7). Then only the local
+part of $Z^{prev}$ is saved (line 8). After that, a processor is able
+to compute its own roots (line 9). Next, the local error can be
+computed (ligne 10) and the global error (line 11). Then the local
+roots are transfered from the GPU memory to the CPU memory (line 12)
+before being exchanged between all processors (linge 13) in order to
+give to all processors the last version of the roots. If the
+convergence is not statisfied, an new iteration is executed.
 
-Our parallel implementation of EA to find root of polynomials using a CUDA-MPI approach is a data parallel approach. It splits input data of the polynomial to solve among MPI processes. In Algorithm \ref{alg2-cuda-mpi}, 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 degree of the polynomial to be solved. The algorithm performs a simple data partitioning by creating $p$ portions, of at most $\lceil n/p \rceil$ roots to find per MPI process, for each $Z$ and $ZPrec$. Consequently, each MPI process of rank $k$ will have its own solution vector $Z_{k}$ and $ZPrec$, the error related to the stop condition $\Delta z_{k}$, enabling each MPI process to compute $\lceil n/p \rceil$ roots.
 
-Since a GPU works only on data already allocated in its memory, all local input data, $Z_{k}$, $ZPrec$ and $\Delta z_{k}$, must be transferred from CPU memories to the corresponding GPU memories. Afterwards, the same EA algorithm (Algorithm \ref{alg1-cuda}) is run by all processes but on different polynomial subset of roots $ p(x)_{k}=\sum_{i=1}^{n} a_{i}x^{i}, k=1,...,p$.  Each MPI process executes the  loop \verb=(While(...)...do)= containing the CUDA kernels but each MPI process  computes only its own portion of the roots according to the rule ``''owner computes``''. The local range of roots is indicated with the \textit{index} variable initialized at (line 5, Algorithm \ref{alg2-cuda-mpi}), and passed as an input variable to $kernel\_update$ (line 10, Algorithm \ref{alg2-cuda-mpi}). After each iteration, MPI processes synchronize  (\verb=MPI_Allreduce= function) by a reduction on $\Delta z_{k}$ in order to compute the maximum error related to the stop condition.   Finally, processes copy the values of new computed roots  from GPU memories to CPU memories, then communicate their results to other processes with \verb=MPI_Alltoall= broadcast. If the stop condition is not verified ($error > \epsilon$) then processes stay withing the loop \verb= while(...)...do= until all the roots sufficiently converge.
 
 \begin{algorithm}[htpb]
 \label{alg2-cuda-mpi}
-%\LinesNumbered
+\LinesNumbered
 \caption{CUDA-MPI 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$ ( error of stop condition), $num_gpus$ (number of MPI processes/ number of GPUs), Size (number of roots)}
+  threshold), P (Polynomial to solve), P' (Derivative of P), $n$ (Polynomial degrees), $\Delta z$ ( error of stop condition)}
 
-\KwOut {$Z$ (Solution root's vector), $ZPrec$ (Previous solution root's vector)}
+\KwOut {$Z$ (Solution root's vector)}
 
 \BlankLine
 Initialization of P\;
 Initialization of Pu\;
 Initialization of the solution vector $Z^{0}$\;
-Distribution of Z\;
+Computation of the parameters for the $MPI\_AlltoAll$\;
 Allocate memory to GPU\;
 \While {$error > \epsilon$}{
 copy Z from CPU to GPU\;
-$ZPrec_{loc}=kernel\_save(Z_{loc})$\;
-$Z_{loc}=kernel\_update(Z,P,Pu)$\;
-$\Delta z=kernel\_testConv(Z_{loc},ZPrec_{loc})$\;
+$Z^{Prev}_{loc}=kernel\_save(Z_{loc})$\;
+$Z_{loc}=kernel\_update(Z,P,P')$\;
+$\Delta z=kernel\_testConv(Z_{loc},Z^{prev}_{loc})$\;
 $error=MPI\_Reduce(\Delta z)$\;
 Copy $Z_{loc}$ from GPU to CPU\;
 $Z=MPI\_AlltoAll(Z_{loc})$\;
 }
+\RC{A uniformiser avec les autres algos, mais les grandes lignes sont là}
 \end{algorithm}