clang：强制特定循环展开

Question

clang：强制特定循环展开

c++cclang

10

有没有办法告诉clang展开特定的循环？

搜索答案会给出影响整个编译器而不是单个循环的命令行选项。

对于GCC有一个类似的问题---告诉gcc特别展开一个循环---

那里提供的第一种方法：

#pragma GCC optimize ("unroll-loops")

看起来被悄悄忽略了。事实上

#pragma GCC akjhdfkjahsdkjfhskdfhd

也会被默默地忽略。

选项2：

__attribute__((optimize("unroll-loops")))

结果会提示一个警告：

warning: unknown attribute 'optimize' ignored [-Wattributes]

更新

joshuanapoli提供了一个不需要创建循环即可通过模板元编程和C++11进行迭代的好方法。该结构将在编译时解析，从而产生一个重复内联的主体。虽然它并不完全是问题的答案，但它基本上实现了相同的功能。

这就是为什么我接受这个答案。不过，如果您知道如何使用标准的C循环(for, while)并强制展开它，请与我们分享！

- CygnusX1

1

通常，编译器非常清楚何时适合展开循环以及不适合展开循环。您试图解决的特殊情况是什么，使得这个规则不适用？ - Mats Petersson

它可能不会强制展开，但是尝试使用__attribute__ ((hot))可能值得一试。 - Brett Hale

1

@MatsPetersson 我想明确地衡量循环展开的好处。手写展开实际上可以将代码加速3倍，但编译器无法自动优化。 - CygnusX1

4个回答

3

Clang最近增加了循环展开指令（如#pragma unroll），可用于指定完全/部分展开。有关更多详细信息，请参见http://clang.llvm.org/docs/AttributeReference.html#pragma-unroll-pragma-nounroll。

- Jingyue Wu

3

在C++17及更高版本中，您可以使用if constexpr编写一个更加简单明了（对我来说）的joshuanapoli模板方法的版本：

template<std::size_t N, class F, std::size_t START = 0>
inline void repeat(const F &f) {
  if constexpr (N == 0) {
    return;
  } else {
    f(START);
    repeat<N - 1, F, START + 1>(f);
  }
}

这个版本在调用时不需要额外的 ():

  int accumulator = 3;
  repeat<4>([&](std::size_t x) {
    accumulator += x;
  });

- Tom 7

2

虽然这可能有些恶心，但你可以将该for循环分离到自己的文件中，并单独编译它（使用其自己的命令行标志）。

相关的、但目前未被回答的Clang开发者问题

- EHuhtala

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- joshuanapoli · Accepted Answer

对于一个C++程序，你可以在语言内部展开循环。你不需要找出编译器特定的选项。例如，

#include <cstddef>
#include <iostream>

template<std::size_t N, typename FunctionType, std::size_t I>
class repeat_t
{
public:
  repeat_t(FunctionType function) : function_(function) {}
  FunctionType operator()()
  {
    function_(I);
    return repeat_t<N,FunctionType,I+1>(function_)();
  }
private:
  FunctionType function_;
};

template<std::size_t N, typename FunctionType>
class repeat_t<N,FunctionType,N>
{
public:
  repeat_t(FunctionType function) : function_(function) {}
  FunctionType operator()() { return function_; }
private:
  FunctionType function_;
};

template<std::size_t N, typename FunctionType>
repeat_t<N,FunctionType,0> repeat(FunctionType function)
{
  return repeat_t<N,FunctionType,0>(function);
}

void loop_function(std::size_t index)
{
  std::cout << index << std::endl;
}

int main(int argc, char** argv)
{
  repeat<10>(loop_function)();
  return 0;
}

使用复杂的循环函数的示例

template<typename T, T V1>
struct sum_t
{
  sum_t(T v2) : v2_(v2) {}
  void operator()(std::size_t) { v2_ += V1; }
  T result() const { return v2_; }
private:
  T v2_;
};

int main(int argc, char* argv[])
{
  typedef sum_t<int,2> add_two;
  std::cout << repeat<4>(add_two(3))().result() << std::endl;
  return 0;
}
// output is 11 (3+2+2+2+2)

使用闭包代替显式函数对象

int main(int argc, char* argv[])
{
  int accumulator{3};
  repeat<4>( [&](std::size_t)
  {
    accumulator += 2;
  })();
  std::cout << accumulator << std::endl;
}