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的值将为不可避免地需要在某个时候提出

有没有其他方法以更清洁的方式实现同样的事情而不会对性能产生负面影响？要明确的是，我只需要该类的设备版本，第一个版本只是等效的非CUDA代码来说明表格大小应该是动态的。

Answer 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();
}

我肯定会有很多批评。这可能不符合“矢量语法”应该是什么的任何特定意见。此外，我确信它没有覆盖的用例，它可能包含彻头彻尾的缺陷。要创建健壮的主机/设备向量实现，可能需要与thrust主机和设备向量一样多的工作和复杂性。然而，我并不是说推力向量是问题似乎要问的答案。

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

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

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

2 个答案: