如何在Cuda的设备内存中分配和传输(进出主机)2D阵列？
我是CUDA的新手.如何分配大小为MXN的2D数组？如何在CUDA中遍历该数组？给我一个示例代码................................................... ..........................................
嗨..谢谢你的回复.我在下面的程序中使用了你的代码.但我没有得到正确的结果.
__global__ void test(int A[BLOCK_SIZE][BLOCK_SIZE], int B[BLOCK_SIZE][BLOCK_SIZE],int C[BLOCK_SIZE][BLOCK_SIZE])
{
int i = blockIdx.y * blockDim.y + threadIdx.y;
int j = blockIdx.x * blockDim.x + threadIdx.x;
if (i < BLOCK_SIZE && j < BLOCK_SIZE)
C[i][j] = A[i][j] + B[i][j];
}
int main()
{
int d_A[BLOCK_SIZE][BLOCK_SIZE];
int d_B[BLOCK_SIZE][BLOCK_SIZE];
int d_C[BLOCK_SIZE][BLOCK_SIZE];
int C[BLOCK_SIZE][BLOCK_SIZE];
for(int i=0;i<BLOCK_SIZE;i++)
for(int j=0;j<BLOCK_SIZE;j++)
{
d_A[i][j]=i+j;
d_B[i][j]=i+j;
}
dim3 dimBlock(BLOCK_SIZE, BLOCK_SIZE);
dim3 dimGrid(GRID_SIZE, GRID_SIZE);
test<<<dimGrid, dimBlock>>>(d_A,d_B,d_C);
cudaMemcpy(C,d_C,BLOCK_SIZE*BLOCK_SIZE , cudaMemcpyDeviceToHost);
for(int i=0;i<BLOCK_SIZE;i++)
for(int j=0;j<BLOCK_SIZE;j++)
{
printf("%d\n",C[i][j]);
}
}
请帮我.
我可以将C++对象复制到设备吗？
说我有:
class CudaClass
{
public:
int* data;
CudaClass(int x) {
data = new int[1]; data[0] = x;
}
};
__global__ void useClass(CudaClass cudaClass)
{
printf("%d" cudaClass.data[0]);
};
int main()
{
CudaClass c(1);
}
现在如何将"c"复制到设备内存并启动内核"useClass"？
我是cuda的新手.我想将两个2d数组加到第三个数组中.我使用以下代码:
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);
现在我的问题是我不想在我的内核代码中使用这些数组作为扁平的二维数组我希望di使用两个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的内核调用应该是什么？如果可能,请使用代码示例进行说明.
我已经被这个错误困扰了很长一段时间所以我决定在这里发布它.
调用cudaMemcpy时发生此分段错误:
CurrentGrid->cdata[i] = new float[size];
cudaMemcpy(CurrentGrid->cdata[i], Grid_dev->cdata[i], size*sizeof(float),\
cudaMemcpyDeviceToHost);
CurrentGrid并且Grid_dev分别指向grid主机和设备上的类对象,在此上下文中i = 0.类成员cdata是一个浮点类型指针数组.为了调试,这cudaMemcpy调用之前对的,我打印出来的每个元素的值Grid_Dev->cdata[i],地址CurrentGrid->cdata[i]和Grid_dev->cdata[i]和的价值size,这一切看起来不错.但它仍然以"分段故障(核心转储)"结束,这是唯一的错误消息.cuda-memcheck只给出了"进程没有成功终止".我目前无法使用cuda-gdb.关于去哪儿的任何建议？
更新:现在看来我已经通过cudaMalloc解决了这个问题,设备上的另一个浮点指针A和cudaMemcpy的Grid_dev-> cdata [i]的值为A,然后是cudaMemcpy A来主机.所以上面写的代码段变成:
float * A;
cudaMalloc((void**)&A, sizeof(float));
...
...
cudaMemcpy(&A, &(Grid_dev->cdata[i]), sizeof(float *), cudaMemcpyDeviceToHost);
CurrentGrid->cdata[i] = new float[size];
cudaMemcpy(CurrentGrid->cdata[i], A, size*sizeof(float), cudaMemcpyDeviceToHost);
我之所以这样做是因为valgrind突然出现了"8号无效读取",我认为这是指的Grid_dev->cdata[i].我用gdb再次检查它,打印出Grid_dev->cdata[i]NULL值.所以我想即使在这个cudaMemcpy调用中也无法直接取消引用设备指针.但为什么 ？根据这个帖子底部的评论,我们应该能够在cudaMemcpy函数中取消引用设备指针.
另外,我不知道cudaMalloc和cudaMemcpy如何工作的基本机制,但我认为cudaMalloc是一个指针,比如A,我们实际上指定这个指针指向设备上的某个地址.并且通过cudaMemcpy Grid_dev->cdata[i]到A,如上面的修改代码,我们重新分配指针A指向数组.那么,当它是cudaMalloced时,我们不会失去A指向的先前地址的轨道吗？这会导致内存泄漏吗？如果是的话,我应该如何妥善解决这种情况？谢谢!
作为参考,我将完整函数的代码放在下面发生此错误的代码中.
非常感谢!
__global__ void Print(grid *, int);
__global__ void Printcell(grid *, int);
void CopyDataToHost(param_t p, grid …我把代码作为答案给出了如何使用嵌套for循环添加两个2d(音调)数组？并尝试将其用于3D而不是2D,并稍微更改了其他部分,现在看起来如下:
__global__ void doSmth(int*** a) {
for(int i=0; i<2; i++)
for(int j=0; j<2; j++)
for(int k=0; k<2; k++)
a[i][j][k]=i+j+k;
}
int main() {
int*** h_c = (int***) malloc(2*sizeof(int**));
for(int i=0; i<2; i++) {
h_c[i] = (int**) malloc(2*sizeof(int*));
for(int j=0; j<2; j++)
GPUerrchk(cudaMalloc((void**)&h_c[i][j],2*sizeof(int)));
}
int*** d_c;
GPUerrchk(cudaMalloc((void****)&d_c,2*sizeof(int**)));
GPUerrchk(cudaMemcpy(d_c,h_c,2*sizeof(int**),cudaMemcpyHostToDevice));
doSmth<<<1,1>>>(d_c);
GPUerrchk(cudaPeekAtLastError());
int res[2][2][2];
for(int i=0; i<2; i++)
for(int j=0; j<2; j++)
GPUerrchk(cudaMemcpy(&res[i][j][0],
h_c[i][j],2*sizeof(int),cudaMemcpyDeviceToHost));
for(int i=0; i<2; i++)
for(int j=0; j<2; j++)
for(int k=0; k<2; k++)
printf("[%d][%d][%d]=%d\n",i,j,k,res[i][j][k]);
}
在上面的代码中,我使用2作为h_c的每个维度的大小,在实际实现中,我将具有非常大的这些大小,并且对于"int***"或更多维度的子阵列的每个部分具有不同的大小.我在内核调用之后遇到问题,我尝试将结果复制回res数组.你能帮我解决这个问题吗？Plz你能以我上面写的方式展示解决方案.谢谢!
在这种情况下，cudaMemcpy 函数将如何工作？
我已经声明了一个这样的矩阵
float imagen[par->N][par->M];
我想将其复制到 cuda 设备，所以我这样做了
float *imagen_cuda;
int tam_cuda=par->M*par->N*sizeof(float);
cudaMalloc((void**) &imagen_cuda,tam_cuda);
cudaMemcpy(imagen_cuda,imagen,tam_cuda,cudaMemcpyHostToDevice);
这可以将二维数组复制到一维数组中吗？
如何复制到另一个二维数组？我可以改变这个吗？它会起作用吗？
float **imagen_cuda;
将struct数组传递给gpu内核时遇到问题.我基于这个主题 - cudaMemcpy分段错误,我写了这样的:
#include <stdio.h>
#include <stdlib.h>
struct Test {
char *array;
};
__global__ void kernel(Test *dev_test) {
for(int i=0; i < 5; i++) {
printf("Kernel[0][i]: %c \n", dev_test[0].array[i]);
}
}
int main(void) {
int n = 4, size = 5;
Test *dev_test, *test;
test = (Test*)malloc(sizeof(Test)*n);
for(int i = 0; i < n; i++)
test[i].array = (char*)malloc(size * sizeof(char));
for(int i=0; i < n; i++) {
char temp[] = { 'a', 'b', 'c', 'd' , 'e' };
memcpy(test[i].array, …所以我想在CUDA中分配2D数组并在CPU和GPU之间复制它们，但我是一个完全的初学者，其他在线材料对我来说很难理解或不完整。重要的是我能够在内核代码中将它们作为二维数组进行访问，如下所示。
请注意，数组的高度！=宽度，如果可能的话，这会让我更加困惑，因为我总是在选择网格大小方面遇到困难。
我考虑过将它们压平，但我真的想让它以这种方式工作。
这就是我自己的研究所取得的进展。
__global__ void myKernel(int *firstArray, int *secondArray, int rows, int columns) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int column = blockIdx.y * blockDim.y + threadIdx.y;
if (row >= rows || column >= columns)
return;
// Do something with the arrays like you would on a CPU, like:
firstArray[row][column] = row * 2;
secondArray[row[column] = row * 3;
}
int main() {
int rows = 300, columns = 200;
int h_firstArray[rows][columns], h_secondArray[rows][columns];
int *d_firstArray[rows][columns], *d_secondArray[rows][columns]; …