c++ - 如何使用 TBB parallel_for 并行可变参数函数？

Question

我有一个像这样的模板可变函数需要与 TBB 并行化 parallel_for功能

template<typename T1, typename T2, typename... T3>
void func(T1 t1, T2 t2, std::size_t n, T3... t3)

我首先尝试使用 lambda 函数，它能够捕获可变参数。它使用 C++11 功能通过 clang 编译。

template<typename T1, typename T2, typename... T3>
void parallel_func(T1 t1, T2 t2, std::size_t n, T3 t3...){
     range r(n);
     apply_func = [=](range r){  //clang 6.1 can catch t3... here, gcc 4.8.3 could not
         std::size_t offset = r.begin();
         std::size_t n = r.end() -r.begin();
         func(t1, t2, n, (t3+offset)...);
     };
     tbb::parallel_for(r, apply_func);
}

然而，我使用的集群没有编译器来支持这个特性。我不得不放弃 lambda 函数并编写一个类并将其传递给 parallel_for功能。我试过:

template<typename T1, typename T2, typename... T3>
class ApplyFunc{
     ApplyFunc(T1 t1, T2 t2, T3... t3){
         t1_ = t1;
         t2_ = t2;
         t3_ = t3...;

     }
      void operator(range r){
         std::size_t offset = r.begin();
         std::size_t n = r.end() -r.begin();
         func(T1, T2, n, (T3+offset)...);
      }
      private:
         T1 t1_;
         T2 t2_;
         T3... t3_;
}

显然，不支持可变变量。我试过 std::元组 t3_；但是，我无法转换 std::tuple<T3...>回到可变参数。

Answer 1

您可以使用 std::tuple<Ts...>保存可变值，并用 the indices trick 扩展它以进行函数调用. C++14 标准库提供 std::index_sequence 为此目的。

#include <tuple>

// forward compatibility for C++14 Standard Library
namespace cxx14 {
template<std::size_t...> struct index_sequence{};

template<std::size_t N, std::size_t... Is>
struct make_index_sequence : make_index_sequence<N-1, N-1, Is...>{};

template<std::size_t... Is>
struct make_index_sequence<0, Is...> : index_sequence<Is...>{};
}

template<typename T1, typename T2, typename... Ts>
class ApplyFunc{
public:
  ApplyFunc(T1 t1, T2 t2, Ts... ts)
    : t1_(t1), t2_(t2), pack_(ts...) {}

  template<std::size_t... Is>
  void call(range r, cxx14::index_sequence<Is...>){
    std::size_t offset = r.begin();
    std::size_t n = r.end() - r.begin();
    func(t1_, t2_, n, (std::get<Is>(pack_)+offset)...);
  }

  void operator()(range r){
    call(r, cxx14::make_index_sequence<sizeof...(Ts)>());
  }
private:
  T1 t1_;
  T2 t2_;
  std::tuple<Ts...> pack_;
};