Como posso adicionar dois arrays 2D (inclinados) usando loops nesteds?

Eu sou novo no cuda. Eu quero adicionar dois 2d array em um terceiro array. Eu uso o seguinte código:

cudaMallocPitch((void**)&device_a, &pitch, 2*sizeof(int),2); cudaMallocPitch((void**)&device_b, &pitch, 2*sizeof(int),2); cudaMallocPitch((void**)&device_c, &pitch, 2*sizeof(int),2); 

agora meu problema é que eu não quero usar esses array como array 2D achatado todos no meu código do kernel eu quero di é usar dois for loop e colocar o resultado na terceira matriz como

 __global__ void add(int *dev_a ,int *dev_b,int* dec_c) { for i=0;i<2;i++) { for j=0;j<2;j++) { dev_c[i][j]=dev_a[i][j]+dev_b[i][j]; } } } 

Como eu posso fazer isso no CUDA? por favor me diga como usar o array 2D desta maneira?

Qual deve ser a chamada do kernel para usar o 2d-array? Se possível, explique usando exemplos de código.

A resposta curta é que você não pode. A function cudaMallocPitch() faz exatamente o que seu nome implica, ele aloca a memory linear inclinada, onde o pitch é escolhido para ser o ideal para o controlador de memory da GPU e hardware de textura.

Se você quisesse usar matrizes de pointers no kernel, o código do kernel teria que ser assim:

 __global___ void add(int *dev_a[] ,int *dev_b[], int* dec_c[]) { for i=0;i<2;i++) { for j=0;j<2;j++) { dev_c[i][j]=dev_a[i][j]+dev_b[i][j]; } } } 

e, em seguida, você precisaria de aninhadas chamadas cudaMalloc no lado do host para construir a matriz de pointers e copiá-lo para a memory do dispositivo. Para o seu exemplo trivial 2x2, o código para alocar um único array seria assim:

 int ** h_a = (int **)malloc(2 * sizeof(int *)); cudaMalloc((void**)&h_a[0], 2*sizeof(int)); cudaMalloc((void**)&h_a[1], 2*sizeof(int)); int **d_a; cudaMalloc((void ***)&d_a, 2 * sizeof(int *)); cudaMemcpy(d_a, h_a, 2*sizeof(int *), cudaMemcpyHostToDevice); 

O que deixaria a matriz de dispositivos alocada dos pointers em d_a, e você passaria isso para o seu kernel.

Por razões de complexidade de código e desempenho, você realmente não quer fazer isso, usando matrizes de pointers no código CUDA é mais difícil e mais lento do que a alternativa usando memory linear.


Para mostrar que loucura usando matrizes de pointers está em CUDA, aqui está um exemplo completo de seu problema de amostra que combina as duas idéias acima:

 #include  __global__ void add(int * dev_a[], int * dev_b[], int * dev_c[]) { for(int i=0;i<2;i++) { for(int j=0;j<2;j++) { dev_c[i][j]=dev_a[i][j]+dev_b[i][j]; } } } inline void GPUassert(cudaError_t code, char * file, int line, bool Abort=true) { if (code != 0) { fprintf(stderr, "GPUassert: %s %s %d\n", cudaGetErrorString(code),file,line); if (Abort) exit(code); } } #define GPUerrchk(ans) { GPUassert((ans), __FILE__, __LINE__); } int main(void) { const int aa[2][2]={{1,2},{3,4}}; const int bb[2][2]={{5,6},{7,8}}; int cc[2][2]; int ** h_a = (int **)malloc(2 * sizeof(int *)); for(int i=0; i<2;i++){ GPUerrchk(cudaMalloc((void**)&h_a[i], 2*sizeof(int))); GPUerrchk(cudaMemcpy(h_a[i], &aa[i][0], 2*sizeof(int), cudaMemcpyHostToDevice)); } int **d_a; GPUerrchk(cudaMalloc((void ***)&d_a, 2 * sizeof(int *))); GPUerrchk(cudaMemcpy(d_a, h_a, 2*sizeof(int *), cudaMemcpyHostToDevice)); int ** h_b = (int **)malloc(2 * sizeof(int *)); for(int i=0; i<2;i++){ GPUerrchk(cudaMalloc((void**)&h_b[i], 2*sizeof(int))); GPUerrchk(cudaMemcpy(h_b[i], &bb[i][0], 2*sizeof(int), cudaMemcpyHostToDevice)); } int ** d_b; GPUerrchk(cudaMalloc((void ***)&d_b, 2 * sizeof(int *))); GPUerrchk(cudaMemcpy(d_b, h_b, 2*sizeof(int *), cudaMemcpyHostToDevice)); int ** h_c = (int **)malloc(2 * sizeof(int *)); for(int i=0; i<2;i++){ GPUerrchk(cudaMalloc((void**)&h_c[i], 2*sizeof(int))); } int ** d_c; GPUerrchk(cudaMalloc((void ***)&d_c, 2 * sizeof(int *))); GPUerrchk(cudaMemcpy(d_c, h_c, 2*sizeof(int *), cudaMemcpyHostToDevice)); add< <<1,1>>>(d_a,d_b,d_c); GPUerrchk(cudaPeekAtLastError()); for(int i=0; i<2;i++){ GPUerrchk(cudaMemcpy(&cc[i][0], h_c[i], 2*sizeof(int), cudaMemcpyDeviceToHost)); } for(int i=0;i<2;i++) { for(int j=0;j<2;j++) { printf("(%d,%d):%d\n",i,j,cc[i][j]); } } return cudaThreadExit(); } 

Eu recomendo que você o estude até que você entenda o que ele faz, e por que é uma idéia tão pobre comparada ao uso de memory linear.

Você não precisa usar loops dentro do dispositivo. Tente este código.

 #include  #include  #include  #include