两个几乎相同的调用，一个有效，一个失败

Question

我有这些模板函数，可以在带有 cuda 的设备上内联使用，

template <class T> __device__ inline T& cmin(T&a,T&b){return (a<b)?(a):(b);};
template <class T> __device__ inline T& cmax(T&a,T&b){return (a>b)?(a):(b);};

代码中

cmin(z[i],y[j])-cmax(x[i],z[j])

在我的int 数组 x、y 和 z 的 。我收到错误：

错误：没有函数模板“cmax”的实例与参数列表匹配

 参数类型为：(int, int)

我得到了 cmax 的错误，但没有得到 cmin 的错误。如果我用它替换 cmax 行

#define cmax(a,b) ((a)>(b))?(a):(b)

就可以了，但我不想要#defines，它们是有问题的。这到底是怎么回事？

编辑： 这是完整的调用函数。 times 是 typedef int。

__global__ void compute_integral_y_isums(times * admit, times * discharge, times * Mx, times * isums, ar_size N){
    // computes the sums for each j
    // blocks on j,
    // threads on i since we will be summing over i.
    // sumation over J should be handled by either a different kernel or on the cpu.
    ar_index tid = threadIdx.x;
    ar_index i = blockIdx.x;                       // summing for patient i 
    ar_index j = threadIdx.x; // across other patients j
    __shared__ times cache[threadsPerBlock];

  times Iy = 0;
    while(j<N){
        // R code:  max(0,min(Mx[i],d3[j,'Discharge.time'])-max(d3[i,'Admission.time'],Mx[j]))
        times imin = cmin(Mx[i],discharge[j]);
        times imax = cmax(admit[i],Mx[j]);
        Iy += cmax(0,imin-imax);
        j += blockDim.x;
    }
    cache[tid] = Iy;

    __syncthreads(); 
    // reduce 
    /***REMOVED***/
}

Answer 1

Iy += cmax(0,imin-imax);

不合法。您无法将文字 0 绑定到 int& 引用（但可以绑定到 const int& 引用）。

Answer 2

如果x或z是一个const数组，它们的元素类型将为const int，这是不可转换的到int&。

尝试使用：

template<class T> __device__ inline T cmin(const T& a, const T& b)
{
    return (a < b ? a : b);
}

template<class T> __device__ inline T cmax(const T& a, const T& b)
{
    return (a > b ? a : b);
}

如果 T 始终是像 int 这样的原始类型，您甚至可以按值传递参数：

template<class T> __device__ inline T cmin(T a, T b)
{
    return (a < b ? a : b);
}

template<class T> __device__ inline T cmax(T a, T b)
{
    return (a > b ? a : b);
}

编辑： @aschepler 有权回答。

Answer 3

如果您的函数也采用引用作为参数，则在返回引用时应小心。您可能会返回对临时对象的引用！就像这样：

cmin(0,imin-imax);

这对于 int 和 float 来说可能没问题，但对于非 POD 来说是危险的。

Answer 4

请尝试颠倒定义顺序。

template <class T> __device__ inline T& cmax(T&a,T&b){return (a>b)?(a):(b);};
template <class T> __device__ inline T& cmin(T&a,T&b){return (a<b)?(a):(b);};

cmax 然后 cmmin。那么输出是什么？

Answer 5

您的 cmax 和 cmin 对元素进行非常量引用。也许你的数组被声明为 const ？

很难说，因为示例不完整。

Answer 6

也许您已经有一些活动的定义，它们会污染您的命名空间？尝试重命名cmin和cmax，或#undef cmin和#undef cmax。或者运行g++ -E来查看去宏化的代码。

或者添加::命名空间说明符：

::cmin(z[i],y[j])-::cmax(x[i],z[j])

无论如何，你只需要define中的所有()即可。更好：

template  __device__ T& cmin(const T&a,const T&b){return a<b?a:b;};

而且您可能也不需要模板函数的内联。

Answer 7

为了澄清我对第一个问题的评论：是的，如果 ona 只是传递来自参数的引用，那么应该小心。这是一个完整的说明：

#include <iostream>

struct Thing {
    int data;
    Thing() { data = 42; }
    Thing(int val) { data = val; }
    Thing(const Thing& oth) { data = oth.data; }
    Thing& operator=(const Thing& oth)
      { if(this!=&oth) this->data = oth.data; return *this; }
    ~Thing() { data = 0; } // clear, destroy, release...
};

bool operator<(const Thing &a, const  Thing &b) { return a.data 
const T& refmin(const T &a, const T &b) // return a ref
{
    return a < b ? a : b;
}


template
const T copymin(const T &a, const T &b) // return a copy
{
    return a < b ? a : b;
}

后面是

int main(int argc, const char* [])
{
    Thing a(11);
    Thing b(88);

    std::cerr << "Simple operation:" << std::endl;
    const Thing c = a + b;
    std::cerr << "  c:" << c.data << "  should be 99" << std::endl;

    std::cerr << "Working on temp expression (BAD):" << std::endl;
    const Thing &x = refmin(c, b-a); // '&x' will be gone after ';' 
    // the next line might crash:
    std::cerr << "  x:" << x.data << "  should be 77" << std::endl;

    std::cerr << "Working explicit side variable (OK):" << std::endl;
    const Thing &d = b-a;
    const Thing &y = refmin(c, d);  // '&y' is now same as '&d'
    std::cerr << "  d:" << d.data << "  should be 77" << std::endl;
    std::cerr << "  y:" << y.data << "  should be 77" << std::endl;

    std::cerr << "Working on a copy (OK):" << std::endl;
    const Thing &z = copymin(c, b-a);
    std::cerr <<  z:" << z.data << "  should be 77" << std::endl;

    return 0;
}

输出是：

$ ./minreftest
Simple operation:
  c:99  should be 99
Working on temp expression (BAD):
  x:0  should be 77
Working explicit side variable (OK):
  d:77  should be 77
  y:77  should be 77
Working on a copy (OK):
  z:77  should be 77

在某些机器上，我猜它甚至可能段错误。在 Thing 的析构函数中，我将 data 重置为 0，但人们很容易想象更多。

因此，当我们执行 BAD refmin 调用时，我们返回对临时对象的引用。它在 ; 之后被销毁。因此，当我们尝试输出 &x 时，它已经消失了。