跟我学C++中级篇——循环展开的分析

原创已于 2025-12-14 12:10:14 修改 · 318 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #优化

于 2025-12-14 09:53:05 首次发布

C++ 同时被 2 个专栏收录

474 篇文章

订阅专栏

C++11

354 篇文章

订阅专栏

一、循环展开

什么是循环展开？为什么要循环展开？可能对不少的程序员来说，循环展开,loop unrolling。它是一种编译器优化的技术，它的本质是通过减少条件分支和运行时的pipeline停顿来提升性能，并有可能提高缓存的命中率。
C++中的循环展开，相对于其它语言来说可能操作更具有灵活性。这种优化一般应用于循环的迭代次数相对较少，而且每次迭代计算量较大的情况。网上有些资料把其称为短循环。

二、循环展开的方式和分析

一般来说，循环展开的方式主要有两个方向即手动展开和自动展开。手动展开依赖开发者自己把循环按实际的场景进行展开而自动展开依赖于编译器及其它辅助的技术。

手动循环展开
手动循环展开非常好理解，就是将循环体的操作的代码人工操作多次，这样就会减少循环执行的次数。当然这需要开发者自己仔细衡量并平衡相关的代价。如下面的例子：

for (int i = 0; i < 16; i++) {
    arr[i] = i * 2;
}

// 展开5次
for (int i = 0; i < 4; i += 4) {
    arr[i] = i * 2;
    arr[i+1] = (i+1) * 2;
    arr[i+2] = (i+2) * 2;
    arr[i+3] = (i+3) * 2;
    arr[i+4] = (i+4) * 2;
}

说简单些就是ctrl+c,ctrl+v大法。强调一下，之所以称之为短循环，一般是循环次数不太大（16次以下）时才有优势。其实就是分支预测耗时大于循环消耗时才有优势。
也可以使用switch中的fallthrough方法：

void working(int n,int *a,int *b){
  if(n<0||n >16){return;}
  switch(n){
   case n: a[n] = b[n] * 2;
   ...
   case 2: a[1] = b[1] * 2;
   case 1: a[0] = b[0] * 2;
   case 0: break;
  }
}

自动循环展开
自动循环展开一般有两种情况：
1）使用编译优化选项
如在编译时增加-O2 或-O3（注意O大写，小写表示输出选项）
2）使用预编译展开选项
即在代码中使用"#pragma GCC unroll N"或“#pragma unroll”,但需要注意，这个N是一个具体数值。另外，循环中判断退出的大小值，建议是一个常量，否则可能无法进行完全展开而只进行部分展开。

#pragma GCC unroll 4
for (int i = 0; i <4 * n; i++) {
    arr[i] = i * 2;
}

部分展开的意思是上面的4*n如果换成任意数，可能不是5的倍数，那么编译器就会展开5的倍数部分，而余下则不展开直接循环。其实就是能快一点是一点。这叫做循环剥离+部分展开（loop peeling+Partial Unrolling）。

循环展开之所以能提升性能，主要就在于通过展开，减少了循环控制中的条件判断和指令跳转（减少流水线的扰动），提高了CPU指令执行的并行机会。减少了变量迭代更新的次数（包括加减等操作）。而循环内大的数据计算，又可能导致内存缓存的命中率有可能提升（只是有可能，毕竟相邻数据多了），这样就有了提高性能的前提和基础。
循环展开需要实际情况进行恰当的应用，因为循环展开的结果未必能完全保证提升性能或者说达不到优化的目的。主要原因在于面对过长的循环且内部复杂时，过度的展开可能引起严重的代码膨胀（有点类似于内联和模板啊）。而如果代码的大小超过了缓存的容量，就需要不断的去内存取指。这样，反而可能导致性能的下降。其次，过多的展开，导致寄存器的大占用，会导致CPU的寄存器耗尽，不断的将相关的数据转移到内存，降低性能。当然，还有些循环是不适合循环展开的，比如循环过少或循环内存在在很复杂的分支条件等，此时的循环展开其实是没有什么优化的余地的。
综合上述，在进行循环优化时，一定要仔细考虑，不要为了展开而展开。一定要从最终的性能测试结果出发，有根据的进行循环展开的优化。

三、循环展开的缺点

循环展开时，编译器无法对过长的循环进行完全的展开，但可以进行部分展开或开发者自行利用手动再加一些编译期优化代码技术进行运行时的动态处理。这就增加了对开发者的要求。其主要的缺点有：

最直观就是代码变得不易理解和维护
过多的展开有可能导致性能降低的情况，如内存数据的读写和数据的溢出到内存（包括代码膨胀导致的溢出）
循环展开的优化的兼容性低。不同的硬件平台、编译平台和系统可能导致不同的结果

在现代的CPU中，使用SIMD反而可能会有更好的效果，所以在编译时提供能够自动向量化的标记（-O3 -march=native）反而可能会有更好的效果。

四、循环展开的高级用法

循环展开除了前面提到的方法，还可以使用模板技术和c++17以后的新的方式来进行：

模板或元编程方式
看代码：

template<int N>
struct uLoop {
    template<typename F>
    static void invoke(F func) {
        uLoop<N-1>::invoke(func);
        func(N-1);
    }
};

// 终止递归的特化条件
template<>
struct uLoop<0> {
    template<typename F>
    static void invoke(F func) {}
};

int arr[10];
uLoop<16>::invoke(arr);

使用常量表达式或索引展开
使用新标准的代码：

template<int N>
void unrollTest(int n, float* a, const float* b) {
    if (N <= n){
      a[N-1] = b[N-1] * 2;
    }
    if constexpr (N > 1) {
      unrollTest<N-1>(n, a, b);
    }
}

void working(int n, float* a, const float* b) {
    if (n <= 8) {
      unrollTest<8>(n, a, b);
    }
}
//std::make_index_sequence
#include <utility>
#include <array>

template<typename T, std::size_t... id>
void unrollInvoke(T* arr, std::index_sequence<id...>) {
    ((arr[id] = id * 2), ...); // 折叠表达式
}

template<std::size_t N>
void unrollDemo(std::array<int, N>& arr) {
    unrollInvoke(arr.data(), std::make_index_sequence<N>{});
}

std::array<int, 16> arr;
unrollDemo(arr);