Discussion :

[nekodd]

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.

[Matthieu76]

Salut, je ne m'y connait pas trop mais je crois que ton erreur viens de là :

Tu peux faire :
<<<1024, 1024>>> // 1 048 576 threads

Mais pas :
<<<2024, 2024>>> // 4 194 304 threads

Pour cela il faut faire :
<<<4, 1024, 1024>>> // 4 194 304 threads

maxThreadsDim signifie que tu peux normalement écrire:
<<<64, 1024, 1024>>> // 67 108 864 threads
(67 millions de threads ??? J'ai dû me trompé quelque part ...)

Après fait attention si tu utilises des floats car si tu fais beaucoup trop de calcul il se peux qu'à force d’arrondir, ton calcul de vienne faux.
Et sur des images de 64*64, tout fonctionne parfaitement ?

PS : Vérifie bien la synchronisation de tes threads.