CUDA : [cours]    [mise en pratique]

4. Courbe de Julia

L'objectif du TD est de comparer les temps de calcul entre CPU et GPU pour calculer une courbe ou ensemble de Julia. On se réfère ici au chapitre 4 de CUDA par L'exemple.

4.1. Contexte

Etant donnés deux nombres complexes, $c$ et $z_0$, on définit la suite $z_n$ par la relation de récurrence :

$z_{n+1} = z_n^2 + c$

Pour une valeur donnée de $c$, l'ensemble de Julia correspondant est la frontière de l'ensemble des valeurs initiales $z_0$ pour lesquelles la suite est bornée (l’ensemble de ces valeurs étant lui désigné comme l'ensemble de Julia rempli).

Voici une listes de valeurs à tester pour $c$:

• 0.3 + 0.5i
• 0.285 + 0.01i
• -0.8 + 0.156i

4.2. Implantation sur le CPU

Récupérer l'archive et étudier le code.

4.2.1. fonction principale (kernel)

Le kernel qui est exécuté sur le CPU consiste à déterminer, pour chaque point de l'image de coordonnées complexes $(x + yi)$, s'il appartient à l'ensemble de Julia.

4.2.2. la fonction julia

Elle détermine si un point de l'écran est dans l'ensemble en retournant la norme de $z$ sauf si celle-ci dépasse la valeur limite (NORM_THRESOLD = 4.0), on considère alors que la suite $z_n$ ne converge pas.

On centre les pixels sur le milieu de l'image et on les place dans l'intervalle $x=[-2.4 , +2.4]$ et $y=[-1.5 , +1.5]$.

on calcule 200 itérations de la fonction (soit 200 $z_i$), tout en vérifiant si l'équation diverge à chaque itération.

4.3. Implantation sur le GPU (version 1)

Réaliser une première implantation sur le GPU. On fera en sorte de créer une grille 2D de de la taille de l'image. Chaque bloc contient donc 1 seul thread qui se charge de calculer si le point de coordonnées $(threadIdx.x, threadIdx.y)$ appartient ou non à l'ensemble de Julia.

4.3.1. Comparaison CPU vs GPU

Modifier le fichier initial pour qu'on puisse réaliser l'exécution sur le GPU, puis comparer en terme de temps, les deux versions. On donnera un tableau comparatif des temps pour les valeurs suivantes de l'image :

• 10000 itérations
• image : 256 x 256 pixels
• image : 512 x 512 pixels
• image : 1024 x 1024 pixels

4.4. Amélioration GPU

On s'arrange pour que la grille soit composée de moins de blocs qui contiennent plus de thread (grille 2D de blocs 2D). Notez l'amélioration obtenue par rapport à la première version GPU et donner les temps comparatifs pour les tailles d'images de l'exercice précédent ainsi que pour :

• 2048 x 2048 pixels
• 4096 x 4096 pixels

4.5. Meilleure configuration

Déterminer la meilleure configuration possible pour votre GPU. Pour cela faire un test de peformance avec différentes tailles de blocs et comparer les temps GPU.

On fixera les variables suivantes pour récupérer le résultat dans le fichier julia.log

export CUDA_PROFILE=1
export CUDA_PROFILE_LOG=julia.log
export CUDA_PROFILE_CSV=1

ou alors on utilisera nvprof.

4.6. Quelques résultats

Voici à présent plusieurs résultats comparatifs entre CPU et carte graphique pour une représentation en simple précision et double précision.

Ces tableaux appellent quelques commentaires :

• en simple précision la Geforce GTX 970 (204 ms) surpasse la Tesla K20m (591 ms), le meilleur des CPU avec 8 threads met 10,484s
• en double précision la Tesla K20m donne le meilleur résultat (700 ms pour 4096x4096) alors que la plus performantes des cartes GeForce se révèle être la GTX 770

Recherche du bloc de taille optimale

Exemple avec Tesla K20m : meilleur temps 608 ms avec un bloc de 16 x 16