CUDA kopieren Array von Gerät zu Host mit cudaMemcpy2D

Question

cudaMemcpy2D kopiert nicht, dass ich erwartet habe. Nachdem ich das Handbuch über cudaMallocPitch gelesen habe, versuche ich Code zu machen, um zu verstehen, was vor sich geht. Aber, ich habe ein Problem.

Ich habe einfaches Programm wie folgt aus:

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"); 
    } 
} 

und doStuff ist:

__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; 
} 

So doStuff ist die gleiche wie d_A[i][j] = (i+1)*(j+1). Wenn SIZE 5 ist das, was ich erwartet ist:

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 

in doppelter Genauigkeit. Allerdings, wenn ich kompilieren und ausführen, ich habe:

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 

es, dass für jede Zeile scheint, cudaMemcpy2D Überschreibungen vorherigen Daten. Ich versuche das Problem zu finden, Tonhöhe und Breite zu ändern, aber ich kann nicht.

Also, was ist los mit meinem Code?

Answer 1

Der Fehler ist in dieser Zeile:

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

Es sollte:

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

Sie wollen den Zeilenindex (i) von der Größe einer Zeile in den Elementen skalieren (nicht die Größe eines Elements in Bytes).

Das hat natürlich nichts mit CUDA zu tun.