Question

定义了如何处理错误：

static void HandleError( cudaError_t err,
                         const char *file,
                         int line ) {
    if (err != cudaSuccess) {
        printf( "%s in %s at line %d\n", cudaGetErrorString( err ),
                file, line );
        exit( EXIT_FAILURE );
    }
}
#define HANDLE_ERROR( err ) (HandleError( err, __FILE__, __LINE__ ))

通常，要将结果存储在类型为double的大小为n的数组d_results中，可以立即在GPU内存中分配，我们可以设法将数据从设备传输到主机，如下所示： / p>

    double *d_results;
    HANDLE_ERROR(cudaMalloc(&d_results,N*sizeof(double)));
//Launch our kernel to do some computations and store the results in d_results
.....
// and transfer our data from the device to the host
vector<double> results(N);
cudaMemcpy(results.data(),d_results,N*sizeof(double),cudaMemcpyDeviceToHost);

如果第二行失败，因为没有足够的内存来一次存储所有结果。如何设法进行计算并将结果正确传输到主机？是否必须按批次进行计算？我宁愿避免手动批处理。在CUDA中管理这种情况的标准方法是什么？

Answer 1

批处理是最好的方法。如果您执行以下操作，则可以自动执行大部分批处理过程：

#include <assert.h>
#include <iostream>

int main()
{
    // Allocate 4 Gb array on host
    const size_t N = 1 << 30;
    int * data = new int[N];

    // Allocate as much memory as will fit on GPU
    size_t total_mem, free_mem;
    cudaMemGetInfo(&free_mem, &total_mem);
    const size_t MB = 1 << 20;

    cudaError_t status;
    int *buffer;
    size_t buffer_size = free_mem;
    for(; buffer_size > MB; buffer_size -= MB) {
        status = cudaMalloc((void **)&buffer, buffer_size);
        if (status == cudaSuccess)
            break;
    }

    std::cout << "Allocated " << buffer_size << " bytes on GPU" << std::endl;

    // Loop through host source data in batches
    std::cout << N << " items require processing" << std::endl;
    size_t batchN = buffer_size / sizeof(int);
    size_t remainN = N;
    int * dp = data;
    std::cout << "Using batch size " << batchN << std::endl;

    for(; remainN > 0; remainN -= batchN) {
        batchN = (remainN < batchN) ? remainN : batchN;
        size_t worksize = batchN * sizeof(int);
        std::cout << "Processing batch of size " << batchN;
        std::cout << "," << remainN << " items remaining" << std::endl;
        cudaMemcpy(buffer, dp, worksize, cudaMemcpyHostToDevice);
        cudaMemset(buffer, 0xff, worksize);
        cudaMemcpy(dp, buffer, worksize, cudaMemcpyDeviceToHost);
        dp += batchN;
    }

    for(size_t i = 0; i < N; i++) {
        assert(data[i] == 0xffffffff);
    }

    cudaDeviceReset();

    return 0;
}

基本上是

分配与设备一样多的可用内存
以缓冲区大小块迭代处理输入数据到gpu，直到一切都完成

在上面的代码中，我使用cudaMemset作为真实内核的代理，但它可以让您了解所需内容。如果你想变得更加漂亮，可以使用两个缓冲区和流（带有注册/固定主机内存）并异步复制以获得计算/复制重叠，这将改善非平凡情况下的整体性能。

正确管理大于GPU可用内存的结果数组？

1 个答案: