Cuda C ++设计：具有未知编译时大小的可重用类

Question

我正在寻找一种方便的设计，以便能够在编译时大小未知的设备上使用类。 此类的一个实例仅需要发送到设备，为此，应该对cudaMalloc和cudaMemcpy进行一次调用（理想情况下）。

该类的主机版本如下所示：

Class A {
public:
A(int size) : table(size) {
 // some useful initialization of table
}
double get(int i) const {
  // return some processed element from table 
}
private:
std::vector<int> table;
};

内核：

__global__ void kernel(const A *a){
  int idx = threadIdx.x + blockDim.x * blockIdx.x;
  a->get(idx);  // do something useful with it
}

到目前为止，我设计类的设备版本的方式是这样的：

const int sizeMax = 1000;
Class A {
public:
A(int size) {
 // size checking + some useful initialization of table
}
__host__ __device__
double get(int i) const {
  // 
}
private:
int table[sizeMax];
};

和客户端代码：

A a(128);
A* da;
cudaMalloc((void**)&da, sizeof(A));
cudaMemcpy(da, &a, sizeof(A), cudaMemcpyHostToDevice);
kernel<<<1, 32>>>(da);
cudaDeviceSynchronize();
cudaFree(da);

这很丑陋，因为：

• 为了安全起见，必须使用太大的sizeMax来浪费带宽
• 该类未关闭以进行修改，因此不可避免地需要提高sizeMax的值

还有其他方法可以以更清洁的方式实现相同目标而不会对性能造成负面影响吗？ 明确地说，我只需要该类的设备版本，第一个版本就是等效的非CUDA代码，以说明表大小应该是动态的这一事实。

Answer 1

在我的评论中，我说：

1. 包含在类中的表的单独主机和设备存储，两者都是动态分配的。 2.在构造函数中动态分配表的存储大小，而不是在客户端代码中。 如果需要，这还可以包括调整大小。 3.区分类方法以使用数据的主机副本还是数据的设备副本（即指针），具体取决于该方法是在主机中执行还是在设备代码中执行。4.一种将数据从主机复制到主机的方法设备，反之亦然，因为类上下文从主机移到设备，反之亦然。

这是我所想到的一个例子：

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


template <typename T>
class gpuvec{
  private:
    T *h_vec = NULL;
    T *d_vec = NULL;
    size_t vsize = 0;
    bool iscopy;
  public:
    __host__ __device__
    T * data(){
      #ifndef __CUDA_ARCH__
        return h_vec;
      #else
        return d_vec;
      #endif
      }
    __host__ __device__
    T& operator[](size_t i) {
      assert(i < vsize);
        return data()[i];}
    void to_device(){
      assert(cudaMemcpy(d_vec, h_vec, vsize*sizeof(T), cudaMemcpyHostToDevice) == cudaSuccess);}
    void to_host(){
      assert(cudaMemcpy(h_vec, d_vec, vsize*sizeof(T), cudaMemcpyDeviceToHost) == cudaSuccess);}
    gpuvec(gpuvec &o){
      h_vec = o.h_vec;
      d_vec = o.d_vec;
      vsize = o.vsize;
      iscopy = true;}
    void copy(gpuvec &o){
      free();
      iscopy = false;
      vsize = o.vsize;
      h_vec = (T *)malloc(vsize*sizeof(T));
      assert(h_vec != NULL);
      assert(cudaMalloc(&d_vec, vsize*sizeof(T)) == cudaSuccess);
      memcpy(h_vec, o.h_vec, vsize*sizeof(T));
      assert(cudaMemcpy(d_vec, o.d_vec, vsize*sizeof(T), cudaMemcpyDeviceToDevice) == cudaSuccess);}
    gpuvec(size_t ds) {
      assert(ds > 0);
      iscopy = false;
      vsize = ds;
      h_vec = (T *)malloc(vsize*sizeof(T));
      assert(h_vec != NULL);
      assert(cudaMalloc(&d_vec, vsize*sizeof(T)) == cudaSuccess);}
    gpuvec(){
      iscopy = false;
    }
    ~gpuvec(){
      if (!iscopy) free();}
    void free(){
      if (d_vec != NULL) cudaFree(d_vec); 
      d_vec = NULL;
      if (h_vec != NULL) ::free(h_vec);
      h_vec = NULL;}
    __host__ __device__
    size_t size() {
      return vsize;}
};

template <typename T>
__global__ void test(gpuvec<T> d){
  for (int i = 0; i < d.size(); i++){
    d[i] += 1;
    }
}


int main(){
  size_t ds = 10;
  gpuvec<int>  A(ds);
  A.to_device();
  test<<<1,1>>>(A);
  A.to_host();
  for (size_t i = 0; i < ds; i++)
    std::cout << A[i];
  std::cout << std::endl;
  gpuvec<int> B;
  B.copy(A);
  A.free();
  B.to_device();
  test<<<1,1>>>(B);
  B.to_host();
  for (size_t i = 0; i < ds; i++)
    std::cout << B[i];
  std::cout << std::endl;
  B.free();
}

我敢肯定会提出很多批评。 对于“矢量语法”应该是什么，这可能并不遵循任何特定意见。 此外，我确定有一些用例无法涵盖，并且可能包含完全的缺陷。 为了创建鲁棒的主机/设备矢量，实现可能需要与推力主机和设备矢量一样多的工作和复杂性。 但是，我并不是说推力矢量是问题似乎要问的直接答案。

Answer 2

根据罗伯特·克罗维拉（Robert Crovella）的回答，这是一个简化的（仅设备，因此忽略第3和4点）工作解决方案：

Class A {
public:
A(int size) : table(size) {
 // some useful initialization of table
 cudaMalloc((void**)&dTable, sizeof(int) * size);
 cudaMemcpy(dTable, &table[0], sizeof(int) * size, cudaMemcpyHostToDevice);
}
~A() {
cudaFree(dTable);
}
__device__
double get(int i) const {
  // return some processed element of dTable 
}
private:
std::vector<int> table;
int *dTable; 
};

内核代码和客户端代码保持完全相同。