c++ - 避免模​​板分支的最干净方法

Question

我有一个cuda内核，它带有一些bool模板参数，这些参数有助于显式优化内核的未使用部分。我想知道是否有比下面的解决方案更简洁的实例化内核调用的方法。
设备模板

template <bool pred1, bool pred2>
__global__ void foo(args)
{
  /* probably doesn't need to exist, but just to improve readability in the kernel */
  constexpr bool predAll = pred1 && pred2;

  if (predAll || pred1 || pred2 || someVariablePred) {
  /* working hard */
  } else {
  /* or hardly working */
  }
}

工作主机代码

const bool pred1 = variableCond1 == variableCond2, pred2 = variableCond3 == variableCond4;

/* working, compiles, but cumbersome */
for (int i = 0; i < bigNumber; ++i) {
  if (pred1) {
    if (pred2) {
      foo<true, true><<<dimGrid, dimBlock>>>(args...);
    }
    foo<true, false><<<dimGrid, dimBlock>>>(args...);
  } else if (pred2) {
    foo<false, true><<<dimGrid, dimBlock>>>(args...);
  } else {
    foo<false, false><<<dimGrid, dimBlock>>>(args...);
  }
}

想要像这样的干净东西

/* doesn't compile */
const bool pred1 = variableCond1 == variableCond2, pred2 = variableCond3 == variableCond4;

for (int i = 0; i < bigNumber; ++i) {
  foo<pred1, pred2><<<dimGrid, dimBlock>>>(args...);
}

我知道为什么谓词在编译时不会显式地写出/不知道，为什么第二次内核启动不会编译，但是由于模板参数组合的数量有限，因此技术上信息在编译时就全部存在了吗？

Answer 1

好吧，有很多方法，但是它们比当前的实现需要更多的行。而且我不确定以下实现是否会提高可读性，而不仅仅是将“不干净的”部分放在单独的函数中。
以下代码可能比为您准备的代码更长，因为我实现了两种方法(直接调用和获取函数指针)和两个示例来证明它确实有效。

#include <iostream>
#include <string>

template <bool pred0, bool pred1, bool pred2, bool pred3, bool pred4>
void Func1()
{
  std::cout << "func1: " << pred0 << pred1 << pred2 << pred3 << pred4 << std::endl;
}

template <bool pred0, bool pred1, bool pred2, bool pred3, bool pred4>
struct Func1Wrapper
{
  static constexpr auto Ptr = Func1<pred0, pred1, pred2, pred3, pred4>;
  static void Call()
  {
    Func1<pred0, pred1, pred2, pred3, pred4>();
  }
};

template <bool pred0, bool pred1, bool pred2>
void Func2()
{
  std::cout << "func2: " << pred0 << pred1 << pred2 << std::endl;
}

template <bool pred0, bool pred1, bool pred2>
struct Func2Wrapper
{
  static constexpr auto Ptr = Func2<pred0, pred1, pred2>;
  static void Call()
  {
    Func2<pred0, pred1, pred2>();
  }
};

template <template<bool...> class F, bool... preds>
struct Ct
{
  template <bool newPred>
  using Expanded = Ct<F, preds..., newPred>;

  static void CallFunc()
  {
    F<preds...>::Call();
  }

  static auto GetFunc()
  {
    return F<preds...>::Ptr;
  }
};

template <class DeducedPreds, typename BoolLast>
void Rt2Ct(BoolLast predLast)
{
  if (predLast)
    DeducedPreds::template Expanded<true>::CallFunc();
  else
    DeducedPreds::template Expanded<false>::CallFunc();
}

template <class DeducedPreds, typename BoolFirst, typename ...BoolRest>
void Rt2Ct(BoolFirst predFirst, BoolRest... predRest)
{
  if (predFirst)
    Rt2Ct<typename DeducedPreds::template Expanded<true>, BoolRest...>(predRest...);
  else
    Rt2Ct<typename DeducedPreds::template Expanded<false>, BoolRest...>(predRest...);
}

template <template<bool...> class F, typename ...Bools>
void FuncCaller(Bools... preds)
{
  Rt2Ct<Ct<F>, Bools...>(preds...);
}

template <class DeducedPreds, typename BoolLast>
auto Rt2CtGet(BoolLast predLast)
{
  if (predLast)
    return DeducedPreds::template Expanded<true>::GetFunc();
  else
    return DeducedPreds::template Expanded<false>::GetFunc();
}

template <class DeducedPreds, typename BoolFirst, typename ...BoolRest>
auto Rt2CtGet(BoolFirst predFirst, BoolRest... predRest)
{
  if (predFirst)
    return Rt2CtGet<typename DeducedPreds::template Expanded<true>, BoolRest...>(predRest...);
  else
    return Rt2CtGet<typename DeducedPreds::template Expanded<false>, BoolRest...>(predRest...);
}

template <template<bool...> class F, typename ...Bools>
auto FuncGetter(Bools... preds)
{
  return Rt2CtGet<Ct<F>, Bools...>(preds...);
}

int main(int argc, char* argv[])
{
  FuncCaller<Func1Wrapper>(std::stoi(argv[1]), std::stoi(argv[2]), std::stoi(argv[3]), std::stoi(argv[4]), std::stoi(argv[5]));
  auto f2 = FuncGetter<Func2Wrapper>(std::stoi(argv[1]), std::stoi(argv[3]), std::stoi(argv[5]));
  f2();
  return 0;
}

该代码要求使用C++ 14(只需稍加重写就可以实现C++ 11)，并且没有CUDA，因为我真的看不到调用内核而不是普通函数是如何解决此问题的。当然，您将必须添加一些参数来传递 dimGrid和 dimBlock以及所需的所有 args。
如前所述，您可能需要将 if-else内容放到 for循环之外。这就是为什么我还实现了 FuncGetter例程的原因。
还要注意，您可能要确保 Bools， BoolFirst等模板参数确实是 bool类型。
编译，函数调用和输出:

$ g++ -std=c++14 main.cpp && ./a.out 1 0 1 0 0
func1: 10100
func2: 110