Question

我正在尝试编写一个模板类来管理Host和Nvidia GPU上的指针，类似于boost::shared_ptr。为此，我需要定义2个指针，一个用于Host，另一个用于类中的GPU。

template<typename T>
class GPUSharedPtr
{
  protected:

  T *cpu_pointer;
  T *gpu_pointer;
}

CUDA的问题在于它为std::complex<double>和std::complex<float>定义了自己的类型，分别为cuDoubleComplex和cuComplex。

template<typename std::complex<double> >
class GPUSharedPtr
{
  protected:

  std::complex<double> *cpu_pointer;
  cuDoubleComplex *gpu_pointer;
}


template<typename std::complex<float> >
class GPUSharedPtr
{
  protected:

  std::complex<float> *cpu_pointer;
  cuComplex *gpu_pointer;
}

在这两种情况下，如何为GPU提供不同类型的指针？

谢谢！

Answer 1

为什么不将两者都添加为模板参数：

template<typename CPU_T, typename GPU_T>
class GPUSharedPtr
{
  protected:
      CPU_T *cpu_pointer;
      GPU_T *gpu_pointer;
};

int main()
{
    GPUSharedPtr<std::complex<double> , cuDoubleComplex> g1;
    GPUSharedPtr<std::complex<float> , cuComplex> g2;
    return 0;
}

或者（如果在你的情况下更有意义），你可以使用MooingDuck建议的标签调度来正确默认GPU指针类型的值：

template<class CPU_T> struct DefaultGPU_T { typedef CPU_T type;};
template<> struct DefaultGPU_T<std::complex<double>> { typedef cuDoubleComplex type;};
template<> struct DefaultGPU_T<std::complex<float>> { typedef cuComplex type;};

template<typename CPU_T, typename GPU_T=typename DefaultGPU_T<CPU_T>::type>

class GPUSharedPtr
{
protected:
    CPU_T *cpu_pointer;
    GPU_T *gpu_pointer;
};

int main()
{
    GPUSharedPtr<int> g0;
    GPUSharedPtr<std::complex<double>> g1;
    GPUSharedPtr<std::complex<float>> g2;
    return 0;
}

Live demo.

Answer 2

最简单，最合理的解决方案可能是采用两个模板参数，第二个参数默认为第一个参数：

template<typename T, typename GPUType = T>
class GPUSharedPtr
{
  protected:

  T *cpu_pointer;
  GPUType *gpu_pointer;
};

然后你可以输入def例如

typedef GPUSharedPtr<std:.complex<float>, cuComplex> ComplexPtr;

具有可变类型的类成员，具体取决于模板C ++的类型

2 个答案: