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 :

// 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/QHUJMN5ww2kVrmUFQhpmqd

 Pourquoi je ne peux pas généré d'image grande ou avec beaucoup 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...

Edit :

J'ai augmenté tdrDelay dans le registre, redémarrer et ça marche.

-
Edité par moc_oo 24 mars 2018 à 16:42:53