Cuda 模板\主机\设备\调用主机定义函数

在CUDA代码的实现过程中，我经常需要一些实用程序函数，这些函数将从设备和主机代码中调用。因此，我将这些函数声明为\uuuuuuu主机\uuuuuuu设备\uuuuuuu。这是正常的，并且可能的设备/主机不兼容可以由#ifdef CUDA_ARCH处理

当效用函数被模板化时会出现问题，例如，通过某些函子类型。如果模板实例调用一个\uuuuuuuuuuuuuuu函数，我会得到以下警告：

calling a __host__ function from a __host__ __device__ function is not allowed
      detected during instantiation of "int foo(const T &) [with T=HostObject]" 

我知道的唯一解决方案是定义函数两次——一次用于设备，一次用于具有不同名称的主机代码（我不能在

\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu。但这意味着存在代码复制，所有其他调用它的
\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu

简化示例：

#include <cuda.h>
#include <iostream>

struct HostObject {
    __host__ 
    int value() const { return 42; }
};

struct DeviceObject {
    __device__ 
    int value() const { return 3; }
};

template <typename T> 
__host__ __device__ 
int foo(const T &obj) {
    return obj.value();
}

/*
template <typename T> 
__host__ 
int foo_host(const T &obj) {
    return obj.value();
}

template <typename T> 
__device__ 
int foo_device(const T &obj) {
    return obj.value();
}
*/

__global__ void kernel(int *data) {
    data[threadIdx.x] = foo(DeviceObject());
}

int main() {
    foo(HostObject());

    int *data;
    cudaMalloc((void**)&data, sizeof(int) * 64);
    kernel<<<1, 64>>>(data);
    cudaThreadSynchronize();
    cudaFree(data);
}

#包括
#包括
结构主机对象{
__主持人
int value（）常量{return 42；}
};
结构设备对象{
__设备
int value（）常量{return 3；}
};
模板
__主机设备
int foo（施工T&obj）{
返回obj.value（）；
}
/*
模板
__主持人
int foo_主机（常数T&obj）{
返回obj.value（）；
}
模板
__设备
int foo_装置（常数T&obj）{
返回obj.value（）；
}
*/
__全局无效内核（int*数据）{
data[threadIdx.x]=foo（DeviceObject（））；
}
int main（）{
foo（HostObject（））；
int*数据；
cudamaloc（（void**）和数据，大小（int）*64）；
内核（数据）；
cudaThreadSynchronize（）；
cudaFree（数据）；
}

警告是由
foo（HostObject（））引起的在
main（）函数中调用

foo\u主机
和
foo\u设备
是有问题的
foo
的可能替代品

有更好的解决办法吗？我可以阻止在设备端实例化
foo（）
吗？
您不能阻止实例化
\uuuuuuuu主机\uuuuuuuuuu设备\uuuuu
函数模板的任何一半。如果通过在主机（设备）上调用函数来实例化该函数，编译器还将实例化该设备（主机）的一半

从CUDA 7.0开始，对于您的用例，您所能做的最好的事情就是使用
#pragma hd_warning_disable
来抑制警告，如下例所示，并确保没有错误调用该函数

#include <iostream>
#include <cstdio>

#pragma hd_warning_disable
template<class Function>
__host__ __device__
void invoke(Function f)
{
  f();
}

struct host_only
{
  __host__
  void operator()()
  {
    std::cout << "host_only()" << std::endl;
  }
};

struct device_only
{
  __device__
  void operator()()
  {
    printf("device_only(): thread %d\n", threadIdx.x);
  }
};

__global__
void kernel()
{
  // use from device with device functor
  invoke(device_only());

  // XXX error
  // invoke(host_only());
}

int main()
{
  // use from host with host functor
  invoke(host_only());

  kernel<<<1,1>>>();
  cudaDeviceSynchronize();

  // XXX error
  // invoke(device_only());

  return 0;
}

#包括
#包括
#pragma hd\u警告\u禁用
模板
__主机设备__
无效调用（函数f）
{
f（）；
}
仅结构主机
{
__主人__
void运算符（）（）
{
std:：cout在
foo（）
中没有调用构造函数。问题正是警告所说的。我在问我是否可以在不定义两次泛型函数的情况下以某种方式修复它。警告是由
foo（HostObject（））引起的
在主函数中。构造函数没有问题，因为在我自己声明一个之前，将自动生成构造函数（由主机和设备编译器生成）抱歉，现在我明白你的意思了-在没有编译器的情况下，不太容易看到错误显示的位置。因此，我相信在你的问题中提及它会很有用。我猜这只是一个编译器问题。推力过度使用模板，并使用
#pragma hd#u warning_disable
禁用此类警告，请参见想象HostObject I它不在您的控制之下-它可能来自不同的库或模块，因此您无法启用CUDA。这也意味着CUDA编译器将处理该函数，如果CUDA编译器无法编译该函数体，则会生成错误消息。您知道是
\pragma hd\u warning\u disable
还是
\pragma nv\u exec\u check\u disable
是否记录在任何地方？