Salut, depuis peu je m'essaye à cuda et j'ai quelques petites incompréhensions
Tous d'abord j'ai une carte graphique assez vieille (Geforce 610m), et n'étant pas supporté par cuda 9. J'ai donc cuda 8 avec sa maj.
Pour comparé avec mon cpu, j'ai fais un ptit programme qui génère l'ensemble de Mandelbrot
Il marche correctement, seulement lorsqu'il y a trop de calcul, l'image est soit rendu seulement en partie (le reste est noir), soit complétement noir.
Si je veux rendre une image trop grande (ex : 2048x2048 avec 1000 itérations max) ça bug, mais ça bug aussi si je fais une image de taille raisonnable mais avec trop d'itération (ex : 1024x1024 avec 10000 itermax)
J'ai essayé de faire que chaque thread calcule un pixel et chaque thread calcule une ligne (au debut je pensais que ma grille ou mes blocs étaient trop gros) mais les deux donnent le même résultats
quelques morceaux de mon code :
Code c : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44 // taille bloc et grille (et image et itermax) int itermax = 5000; int sizepic = 128*5; int sizebloc = 128; // nbr de thread par blocs, max 1024 int sizegrid = (sizepic*sizepic)/sizebloc; // sur le site nvidia j'ai pas super compris ils mettent // (sizepic*sizepic+sizebloc-1)/sizebloc; mais ça ne marche pas mieux // je stock 3 tab sur la carte c'est trop ? avec un calcul rapide je trouve ~16Mb pour 2048x2048 cudaMalloc( (void**)& dev_x, n*sizeof(double)); cudaMalloc( (void**)& dev_y, n*sizeof(double)); cudaMalloc( (void**)& dev_sol, n*n*sizeof(int)); // appel du kernel mandeliter<<<sgrid, sbloc>>>(dev_x, dev_y, dev_sol, n, itermax); // kernel __global__ void mandeliter(double * dev_x, double * dev_y, int *dev_sol, int n, int itermax) { int t = blockIdx.x*blockDim.x + threadIdx.x; int tx = t%n; int ty = t/n; if(tx >= n || ty >= n) return; int i = 0; double x, y, x0, y0; x = dev_x[ty]; y = dev_y[tx]; x0 = x; y0 = y; while(x*x + y*y < 4.0f && i < itermax ){ double old_x = x; x = x*x - y*y + x0; y = 2*old_x*y + y0; i++; } dev_sol[t] = i; }
code complet : https://paste.ofcode.org/kqppz7xRytPQDyHfk2kvmv
Pourquoi je ne peux pas générer d'image trop grande ou avec trop d'itération ??
Est ce que je m'y prend mal pour faire mes calculs, j'ai fais un erreur dans mon code ou c'est ma carte graphique qui est au bout de sa vie ?
Au final comparer à mon cpu (3610qm) qui est de bien meilleur facture que ma carte graphique (610m), (sur des images pas trop grande et pas trop d’itération) c'est la carte graphique qui est légèrement plus rapide que mon processeur (multithreadé) mais bon c'est calculé sur 4 secondes...
J'aurais une dernière question, je ne comprend pas trop à quoi correspond "maxThreadsDim" qui est égale à 1024 x 1024 x 64 pour moi. Le maximum de thread par blocs que je peux faire c'est 1024, je ne peux pas faire de blocs plus grand que 32 x 32 x 1.
Edit :
Bref j'ai augmenté tdrDelay dans le registre, redémarrer et ça marche.
Partager