Question

我正在寻找一个重新分配CUDA（设备）数组的函数，如果数据超出它的容器。背景是稀疏数据，我保留在数组中，我从0开始并慢慢开始填充。

我开始分配一个给定的数字来开始：

在main（）中：

int number_of_blocks = 30;
int dyn_cells = number_of_blocks * (BLOCK_WIDTH-4) * (BLOCK_HEIGHT-4);
HANDLE_ERROR(cudaMalloc(&h_dev, dyn_cells * sizeof(float)));

然后我做了一些计算，h_dev中越来越多的块被用完了。如果使用了超过一半，我想让阵列更大。我用这个函数来做到这一点：

void grow_array(float **ptr, int length, int length_new)
{
    float *ptr_new;
    int width = length_new * (BLOCK_WIDTH - 4);
    int height= (BLOCK_HEIGHT- 4);
    HANDLE_ERROR(cudaMalloc(&ptr_new    , width * height * sizeof(float)));
    //this is the copy kernel
    dim3 threads(BLOCK_WIDTH-4,BLOCK_HEIGHT-4);
    dim3 blocks(length_new);
    copy_kernel<<<blocks,threads>>>(*ptr,ptr_new, length, length_new);

    float *old_ptr;
    old_ptr = *ptr;
    HANDLE_ERROR( cudaFree( old_ptr ) );
    *ptr = ptr_new;
}

我称之为：

void memory_manager(int &blocks_available, int blocks_used, float** h_dev)
{
    double ratio = (double)blocks_used/(double)blocks_available;
    if (ratio > 0.5)
    {
        int new_length = 1.5 * blocks_available;
        grow_array(h_dev , blocks_available, new_length);
        (...)
    {
{

copy-kernel看起来如下：

__global__ void copy_kernel(float* old_vector, float* new_vector, int old_size, int new_size)
{
    int x = blockIdx.x * blockDim.x + threadIdx.x;
    int y = threadIdx.y;
    int offset_new = x + y * new_size * (BLOCK_WIDTH-4);
    int offset_old = x + y * old_size * (BLOCK_WIDTH-4);
    if (blockIdx.x < old_size)
    {
        new_vector[offset_new] = old_vector[offset_old];
    }
    else
    {
        new_vector[offset_new] = 42.0f;
    }
}

我最初在使用malloc和free（非CUDA）的原型之后写了这个，这似乎有效。然而，这使我的程序崩溃，提示超出内存访问。我很确定我错过了一些参考/去参考问题，但无法找到问题的确切位置。任何指向这为什么失败的指针？

Answer 1

代码用新的更大的指针替换指针显然不是越界错误的原因，尽管它触发了它。在不相关的内核中找到错误并修复它。谢谢大家。

在库达重新分配日益增长的记忆的功能

1 个答案: