如何使用嵌套的for循环添加两个2d间距数组？

如何解决如何使用嵌套的for循环添加两个2d间距数组？

| 我是cuda的新手。我想将两个2d数组加到第三个数组中。 我使用以下代码：

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

现在我的问题是我不想将这些数组用作扁平化的二维数组 我想要的所有在内核代码中的代码都是使用两个for循环并将结果放入第三个数组中，例如

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

我如何在CUDA中做到这一点？ 请告诉我如何以这种方式使用二维数组？ 使用2d-array的内核调用应该是什么？ 如果可能，请解释使用代码示例。     

解决方法

简短的答案是，您不能。 “ 2”函数完全按照其名称的含义工作，它分配了倾斜的线性内存，在此处选择的倾斜度对于GPU内存控制器和纹理硬件而言是最佳的。 如果要在内核中使用指针数组，则内核代码必须如下所示：

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

然后在主机端需要嵌套的“ 4”调用来构造指针数组并将其复制到设备内存中。对于您相当琐碎的2x2示例，分配单个数组的代码如下所示：

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

这样会将分配的设备指针数组保留在d_a中，然后将其传递给内核。 出于代码复杂性和性能的原因，您真的不想这样做，因为与使用线性内存的替代方法相比，在CUDA代码中使用指针数组既困难又慢。 为了说明在CUDA中使用指针数组是多么愚蠢，这是您的示例问题的完整工作示例，其中结合了以上两个想法：

#include <cstdio>
__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,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],cudaMemcpyHostToDevice));
    }

    int ** d_b;
    GPUerrchk(cudaMalloc((void ***)&d_b,2 * sizeof(int *)));
    GPUerrchk(cudaMemcpy(d_b,h_b,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,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],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();
}

我建议您研究它，直到您了解它的作用，以及为什么与使用线性内存相比这是一个糟糕的主意。     ,您无需在设备内部使用for循环。试试这个代码。

#include <stdio.h>
#include <cuda.h>
#include <stdlib.h>
#include <time.h>

#define N 800
__global__ void  matrixAdd(float* A,float* B,float* C){

int i = threadIdx.x;
int j = blockIdx.x;
C[N*j+i] = A[N*j+i] + B[N*j+i];
}

int main (void) {
clock_t start = clock();
float a[N][N],b[N][N],c[N][N];
float *dev_a,*dev_b,*dev_c;

cudaMalloc((void **)&dev_a,N * N * sizeof(float));
cudaMalloc((void **)&dev_b,N * N * sizeof(float));
cudaMalloc((void **)&dev_c,N * N * sizeof(float));

for (int i = 0; i < N; i++){
    for (int j = 0; j < N; j++){    
        a[i][j] = rand() % 10;
        b[i][j] = rand() % 10;
    }
}

cudaMemcpy(dev_a,a,N * N * sizeof(float),cudaMemcpyHostToDevice);
cudaMemcpy(dev_b,b,cudaMemcpyHostToDevice);

matrixAdd <<<N,N>>> (dev_a,dev_b,dev_c);
cudaMemcpy(c,dev_c,cudaMemcpyDeviceToHost);

for (int i = 0; i < N; i++){
    for (int j = 0; j < N; j++){
    printf(\"[%d,%d ]= %f + %f = %f\\n\",a[i][j],b[i][j],c[i][j]);
    }
}
printf(\"Time elapsed: %f\\n\",((double)clock() - start) / CLOCKS_PER_SEC);

cudaFree(dev_a);
cudaFree(dev_b);
cudaFree(dev_c);

return 0; 
}