CUDA copie tableau de périphérique à l'hôte en utilisant cudaMemcpy2D

Question

cudaMemcpy2D ne copie pas que je m'attendais. Après avoir lu le manuel sur cudaMallocPitch, j'essaie de faire du code pour comprendre ce qui se passe. Mais, eh bien, j'ai un problème.

J'ai fait simple programme comme celui-ci:

int main() 
{ 
    double *d_A; 
    size_t d_pitch; 

    cudaMallocPitch((void**)&d_A, &d_pitch, sizeof(double) * SIZE, SIZE); 

    dim3 blocks(4, 4); 
    dim3 threads(16, 16); 

    doStuff<<<blocks, threads>>>(d_A, d_pitch); 

    double *A; 
    size_t pitch = sizeof(double) * SIZE; 

    A = (double*)malloc(sizeof(double) * SIZE * SIZE); 

    cudaMemcpy2D(A, pitch, d_A, d_pitch, sizeof(double) * SIZE, SIZE, cudaMemcpyDeviceToHost); 

    for (int i = 0; i < SIZE; i++) { 
     for (int j = 0; j < SIZE; j++) printf("%f ", A[sizeof(double) * i + j]); 
     printf("\n"); 
    } 
} 

et doStuff est:

__global__ void doStuff(double *d_A, size_t d_pitch) 
{ 
    unsigned int i = blockIdx.x * blockDim.x + threadIdx.x; 
    unsigned int j = blockIdx.y * blockDim.y + threadIdx.y; 
    double *target = ((double*)(((char*)d_A) + (d_pitch * i))) + j; 

    if (i < SIZE && j < SIZE) 
     *target = (i + 1) * (j + 1) + 0.0; 
} 

Alors doStuff est la même que d_A[i][j] = (i+1)*(j+1). Si SIZE est 5, ce que je pensais est:

1 2 3 4 5 
2 4 6 8 10 
3 6 9 12 15 
4 8 12 16 20 
5 10 15 20 25 

en double précision. Cependant, quand je compiler et exécuter, je suis arrivé:

1 2 3 4 5 
8 10 3 6 9 
8 12 16 20 5 
25 0 0 0 0 
0 0 0 0 0 

Il semble que pour chaque ligne, les données précédentes cudaMemcpy2D overrides. J'essaie de trouver le problème en changeant la hauteur et la largeur, mais je ne peux pas.

Alors, que se passe-t-il avec mon code?

Answer 1

L'erreur est dans cette ligne:

for (int j = 0; j < SIZE; j++) printf("%f ", A[sizeof(double) * i + j]); 

Il devrait être:

for (int j = 0; j < SIZE; j++) printf("%f ", A[SIZE * i + j]); 

Vous voulez à l'échelle de l'indice de ligne (i) par la taille d'une ligne dans les éléments (et non la taille d'un élément en octets).

Cela n'a rien à voir avec CUDA bien sûr.