X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/prng_gpu.git/blobdiff_plain/a595bc795f31e05fc7fcc8415e1549bdda84b076..b64600704673c37dbb08701c0b811f65d159db34:/prng_gpu.tex?ds=inline

diff --git a/prng_gpu.tex b/prng_gpu.tex
index 730b620..00991e9 100644
--- a/prng_gpu.tex
+++ b/prng_gpu.tex
@@ -667,16 +667,30 @@ Indeed this result is weaker than the theorem establishing the chaos for the fin
 
 \section{Efficient prng based on chaotic iterations}
 
-On parle du sÃ©quentiel avec des nombres 64 bits\\
-
-
 In  order to  implement efficiently  a PRNG  based on  chaotic iterations  it is
 possible to improve  previous works [ref]. One solution  consists in considering
 that the  strategy used contains all the  bits for which the  negation is
-achieved out. Then instead of applying  the negation on these bits we can simply
+achieved out. Then in order to apply  the negation on these bits we can simply
 apply the  xor operator between  the current number  and the strategy. In
 order to obtain the strategy we also use a classical PRNG.
 
+Here  is an  example with  16-bits numbers  showing how  the bit  operations are
+applied.  Suppose  that $x$ and the  strategy $S^i$ are defined  in binary mode.
+Then the following table shows the result of $x$ xor $S^i$.
+$$
+\begin{array}{|cc|cccccccccccccccc|}
+\hline
+x      &=&1&0&1&1&1&0&1&0&1&0&0&1&0&0&1&0\\
+\hline
+S^i      &=&0&1&1&0&0&1&1&0&1&1&1&0&0&1&1&1\\
+\hline
+x \oplus S^i&=&1&1&0&1&1&1&0&0&0&1&1&1&0&1&0&1\\
+\hline
+
+\hline
+ \end{array}
+$$
+
 %% \begin{figure}[htbp]
 %% \begin{center}
 %% \fbox{
@@ -725,7 +739,7 @@ unsigned int CIprng() {
 
 
 In listing~\ref{algo:seqCIprng}  a sequential  version of our  chaotic iterations
-based PRNG  is presented.  This version  uses three classical  64-bits PRNG: the
+based PRNG  is presented. The xor operator is represented by \textasciicircum. This function  uses three classical  64-bits PRNG: the
 \texttt{xorshift},   the  \texttt{xor128}  and   the  \texttt{xorwow}.   In  the
 following,  we  call them  xor-like  PRNGSs.   These  three PRNGs  are  presented
 in~\cite{Marsaglia2003}.  As each xor-like  PRNG used works with 64-bits  and as our PRNG
@@ -748,8 +762,8 @@ on  GPU. The principe  consists in  assigning the  computation of  a PRNG  as in
 sequential to each thread of the GPU.  Of course, it is essential that the three
 xor-like PRNGs used  for our computation have different  parameters. So we chose
 them randomly with another PRNG. As  the initialisation is performed by the CPU,
-we have chosen to use the ISAAC PRNG to initalize all the parameters for the GPU
-version  of  our  PRNG.  The  implementation  of  the  three xor-like  PRNGs  is
+we have chosen to  use the ISAAC PRNG [ref] to initalize  all the parameters for
+the GPU version of our PRNG.   The implementation of the three xor-like PRNGs is
 straightforward  as soon  as their  parameters have  been allocated  in  the GPU
 memory. Each xor-like  PRNGs used works with an internal  number $x$ which keeps
 the last generated random numbers. Other internal variables are also used by the
@@ -785,11 +799,17 @@ PRNGs\footnote{we multiply this number by $2$ in order to count 32-bits numbers}
 and  random  number of  our  PRNG  is  equals to  $100,000\times  ((4+5+6)\times
 2+(1+100))=1,310,000$ 32-bits numbers, i.e. about $52$Mb.
 
+All the  tests performed  to pass the  BigCrush of TestU01  succeeded. Different
+number of threads have been tested upto $10$ millions.
+
 \section{Experiments}
 
-On passe le BigCrush\\
-On donne des temps de gÃ©nÃ©rations sur GPU/CPU\\
-On donne des temps de gÃ©nÃ©rations de nombre sur GPU puis on rappatrie sur CPU / CPU ? bof bof, on verra
+Differents experiments have been performed in order to measure the generation speed.
+
+
+First of all we have compared the time to generate X random numbers with both the CPU version and the GPU version. 
+
+Faire une courbe du nombre de random en fonction du nombre de threads, Ã©ventuellement en fonction du nombres de threads par bloc.
 
 
 \section{Conclusion}
