Question

我正在编写一个代码来使用幂系列近似函数，并希望利用#pragma unroll和FMA指令，如下所示：

__constant__ double coeff[5] = {1.0,2.0,3.0,4.0,5.0}; /* constant is fake here */

__device__ double some_function(double x) {
  double y;
  int i;
  y = coeff[0];
#pragma unroll
  for(i=1;i<5;i++) y = y*x + coeff[i];
  return y;
}

代码将编译成这样的程序集：

ld.const.f64    %fd33, [coeff];
ld.const.f64    %fd34, [coeff+8];
fma.rn.f64      %fd35, %fd33, %fd32, %fd34;
ld.const.f64    %fd36, [coeff+16];
fma.rn.f64      %fd37, %fd35, %fd32, %fd36;
ld.const.f64    %fd38, [coeff+24];
fma.rn.f64      %fd39, %fd37, %fd32, %fd38;
ld.const.f64    %fd40, [coeff+32];
fma.rn.f64      %fd41, %fd39, %fd32, %fd40;

我想避免使用常量内存并使用这样的立即值：

mov.f64         %fd248, 0d3ED0EE258B7A8B04;
mov.f64         %fd249, 0d3EB1380B3AE80F1E;
fma.rn.f64      %fd250, %fd249, %fd247, %fd248;
mov.f64         %fd251, 0d3EF3B2669F02676F;
fma.rn.f64      %fd252, %fd250, %fd247, %fd251;
mov.f64         %fd253, 0d3F1745CBA9AB0956;
fma.rn.f64      %fd254, %fd252, %fd247, %fd253;
mov.f64         %fd255, 0d3F3C71C72D1B5154;
fma.rn.f64      %fd256, %fd254, %fd247, %fd255;
mov.f64         %fd257, 0d3F624924923BE72D;
fma.rn.f64      %fd258, %fd256, %fd247, %fd257;
mov.f64         %fd259, 0d3F8999999999A3C4;
fma.rn.f64      %fd260, %fd258, %fd247, %fd259;
mov.f64         %fd261, 0d3FB5555555555554;
fma.rn.f64      %fd262, %fd260, %fd247, %fd261;

我知道我可以使用#define宏来实现这一点，但是当有很多系数时它会非常不方便。

是否有任何C数据类型修饰符（或编译器选项）可以将我的系数数组转换为立即数而不是使用常量内存？

我尝试过，它不适用于static double，static __constant__ double和static __device__ double。

我的最后一个问题是：我猜使用立即值应该比使用常量内存更快？

Answer 1

好的，你尝试做的事情是不可能的（至少不是用CUDA），这是因为CUDA禁止在全局范围内声明static const数组。 CUDA要求将每个全局数组分配给特定的地址空间（__device__，__contant__等）。

但是有一些不便之处是可能的。

我收集了一些SO答案：

C++11: Compile Time Calculation of Array

Is it possible to develop static for loop in c++?

，请尊重那里的工作，并添加了一些CUDA。

你在这里：

你想要的是编译器为你做脏工作，因此你必须在编译时进行所有和所有的评估：

首先我们需要一个静态数组，我们可以存储系数：

template <unsigned int index, long long... remPack> struct getValue;

template <unsigned int index, long long In, long long... remPack>
struct getValue<index, In, remPack...> {
  static const long long value = getValue<index - 1, remPack...>::value;
};

template <long long In, long long... remPack>
struct getValue<1, In, remPack...> {
  static const long long value = In;
};

template <long long... T> struct static_array {
  template <int idx> static __device__ int get() { return getValue<idx, T...>::value; }
};

此static_array将C ++类型系统中的值存储为long long。我将在答案的后面再回过头来看。

接下来是必须展开的for循环。再次使用模板元编程：

template <int First, int Last, template <int> class Fn> struct static_for {
  __device__ double operator()(double x, double y) const {
      return static_for<First + 1, Last, Fn>()(x, Fn<First + 1>()(x, y));
  }
};

template <int N, template <int> class Fn> struct static_for<N, N, Fn> {
  __device__ double operator()(double x, double y) const { return y; }
};

由于我们在编译时完成所有静态操作，因此需要通过参数和operator()的返回表达式来移动每个“循环行程”的输入和输出。

此解决方案非常静态，您可以使用更多模板元编程来改进它。

好了，现在有趣的部分。计算：

template <int i> struct Function {
  __device__ double operator()(double x, double y) {
    double c = __longlong_as_double(static_array<12, 34, 22, 55, 24>::get<i>());
    return y * x + c;
  }
};

__device__ double some_function(double x) {
  return static_for<0, 5, Function>()(x, 0.0);
}

C ++类型系统仅允许整数类型作为非类型模板参数，因此我们必须将doubles存储在long long中，然后使用CUDA的__longlong_as_double()函数将其转换回来。这是我们在这一点上必须接受的东西，对你来说可能是一个交易破坏者，因为它不再“简单”了。但是，double到long long转换器不应该那么难写。

整个计算都包含在一个functor对象中，该对象从我们的static_loop作为模板参数获取行程计数器。使用此编译时间“行程计数器”，我们可以访问static_array转换双后的long long版本并计算FMA。

感谢CUDA编译器（这里做得非常好），这是我使用7.0 RC1版本的PTX代码（nvcc -ptx -arch=sm_35 test.cu）：

.visible .func  (.param .b64 func_retval0) _Z13some_functiond(
        .param .b64 _Z13some_functiond_param_0
)
{
        .reg .f64       %fd<7>;

        ld.param.f64    %fd1, [_Z13some_functiond_param_0];
        fma.rn.f64      %fd2, %fd1, 0d0000000000000000, 0d000000000000000C;
        fma.rn.f64      %fd3, %fd2, %fd1, 0d0000000000000022;
        fma.rn.f64      %fd4, %fd3, %fd1, 0d0000000000000016;
        fma.rn.f64      %fd5, %fd4, %fd1, 0d0000000000000037;
        fma.rn.f64      %fd6, %fd5, %fd1, 0d0000000000000018;
        st.param.f64    [func_retval0+0], %fd6;
        ret;
}

Answer 2

至少在Cuda 8中，本地constexpr数组工作正常，即对于展开的循环，* .ptx包含立即值，而不是内存引用。示例（未经测试）：

#define COEFF_VALUES { 1.0, 2.0, 3.0, 4.0, 5.0 }

__device__ double some_function( double x )
{
    constexpr double coeff[ 5 ] = COEFF_VALUES;
    double y;
    int i;
    y = coeff[ 0 ];
#pragma unroll
    for( i = 1; i < 5; i++ ) y = y*x + coeff[ i ];
    return y;
}

编译成这样的代码：

add.f64     %fd2, %fd1, 0d4000000000000000;
fma.rn.f64  %fd3, %fd1, %fd2, 0d4008000000000000;
fma.rn.f64  %fd4, %fd1, %fd3, 0d4010000000000000;
fma.rn.f64  %fd5, %fd1, %fd4, 0d4014000000000000;

在CUDA中将常量内存数组编译为立即值

2 个答案: