使用开关展开循环的 C++ 模板？

Question

我的问题类似于Can one unroll a loop when working with an integer template parameter?，但我想混合编译时间和运行时。具体来说，我在编译时知道一个常量NBLOCK，我想在变量start_block 上编写一个开关，该变量仅在运行时知道，其中NBLOCK 是开关中的条目数。这是我使用宏得到的结果：

#define CASE_UNROLL(i_loop)         \
  case i_loop : \
    dst.blocks[i_loop+1] -= (load_unaligned_epi8(srcblock) != zero) & block1; \
    srcblock += sizeof(*srcblock);

  switch(start_block)
    {
      CASE_UNROLL(0);
#if NBLOCKS > 2
      CASE_UNROLL(1);
#endif
#if NBLOCKS > 3
      CASE_UNROLL(2);
#endif
#if NBLOCKS > 4
      CASE_UNROLL(3);
#endif
...
...
#if NBLOCKS > 15
      CASE_UNROLL(14);
#endif
#if NBLOCKS > 16
#error "Too many blocks"
#endif
    }

我觉得它很丑。特别是如果我想将界限从 16 提高到 32。

我想知道是否可以使用一些模板元编程来编写它。困难的部分是，出于性能原因，使用跳转表而不是嵌套条件序列来编译开关至关重要。

请注意，这个问题与C++/C++11 - Switch statement for variadic templates? 非常相似，但据我了解，这里提出的解决方案是通过使用混合编译/调谐时间初始化函数指针数组来删除开关。我不能付钱给王子在这里调用一个函数。

如果需要一些讨厌的扩展，我正在使用 GCC。

Answer 1

您可以简单地将 Boost.Preprocessor 与 BOOST_PP_REPEAT(COUNT, MACRO, DATA) 一起使用：

#define APPLY_FUNC(INDEX, FUNC) FUNC(INDEX);

// ...

switch(start_block)
{
    BOOST_PP_REPEAT(NBLOCK, APPLY_FUNC, CASE_UNROLL);
}

应该扩展为：

switch(start_block)
{
    CASE_UNROLL(0);
    CASE_UNROLL(1);
    CASE_UNROLL(2);
    // ...
    CASE_UNROLL(NBLOCK-1);
}

Answer 2

基于模板的展开：

template<int N>
struct loopUnroller
{
  template<typename Operation>
  inline void operator(Operation& op) { op(); loopUnroller<N-1>(op); }
};

template<>
struct loopUnroller<0>
{
  template<typename Operation>
  inline void operator(Operation& op) { op(); }
};

对loopUnroller<6>(Foo) 的调用可能是内联的，但也包含对内联loopUnroller<5>(Foo) 的调用等。每个级别都会对Foo() 增加一个额外的调用。

如果您的编译器拒绝内联 16 层深度，有一个简单的解决方法：

template<>
struct loopUnroller<16>
{
  template<typename Operation>
  inline void operator(Operation& op) { 
        op(); op(); op(); op();
        op(); op(); op(); op();
        op(); op(); op(); op();
        op(); op(); op(); op();
  }
};

具有对数复杂度：

template<int N>
struct loopUnroller
{
  template<typename Operation>
  inline void operator(Operation& op) { 
       loopUnroller<N/2>(op);
       loopUnroller<N/2>(op);
       if (N%1) { op(); } // Will be optimized out if N is even.
  }
};

具有动态复杂性：

template<int L>
struct loopUnroller
{
  template<typename Operation>
  inline void operator(Operation& op, int i) {
     if (i & (1<<L)) {
       for(int j = 0; j != 1<<L; ++j)
       {
         op();
       }
     }
     loopUnroller<L-1>(op, i);
  }
};

for 循环现在有一个固定的运行时长度，使其很可能被展开。 因此，您有一个长度为 32、16、8、4、2 和 1 的展开循环（假设没有专门化），并且在运行时您可以根据 i 的位选择循环。