C++ for 循环和基于范围的循环性能答案

【问题标题】：C++ for loop and range-based loop performanceC++ for 循环和基于范围的循环性能
【发布时间】：2018-05-06 20:40:08
【问题描述】：

我读到基于范围的循环在某些编程语言上具有更好的性能。在 C++ 中是这种情况吗？比如；

int main()
{
    vector<int> v = {1, 2, 3, 4, 5};

    auto size = v.size();
    // LOOP1
    for (int i = 0; i < size; i++) {
        // do something with v[i]
    }

    // LOOP2    
    for (int& val : v) {
        // do something with val 
    }

    return 0;
}

当vector 的大小很大时，LOOP2 的性能是否优于 LOOP1？如果有，为什么？

【问题讨论】：

不公平的比较。您正在复制第二个版本中的所有元素。如果这是固定的，那么差异应该可以忽略不计，如果存在的话。适当地测试它们会比我更能告诉你。
优化器必须做更多的工作来优化第一个循环，但这与您在此处使用的迭代类型有关。对于某些（较旧的）编译器，使用迭代器进行迭代可能更有效。我前段时间使用 VS2010 和矩阵容器对此进行了测试。
这似乎可以作为基准。我希望int& val 的循环至少与另一个循环一样优化。如果您发现不同，也许您可以展示一个工作示例和两个循环的运行时间，并询问为什么会这样。
我曾经听过 Andrei Alexandrescu 说，衡量让你比那些优秀到不需要衡量的人更有优势。 :)
range-for 是迭代器的语法糖。因此，您实际上是在比较使用索引与使用迭代器，而且我确信在 SO 上有较早的帖子就是这样做的。

标签： c++ c++11 for-loop

【解决方案1】：

这是一个粗略的测试。我并不是说这是关于哪个更快的明确答案，但在我看来，在这种特殊情况下，gcc 编译器能够将两个循环优化到大致相同的性能水平。如果您愿意，您绝对可以改进测试方法。

在我的系统上（Ubuntu 14.04，某种 i7，8 GB DDR3，gcc）：

没有优化（g++ main.cpp -std=c++11）：

老式循环：5.45131 秒。

基于范围的循环：9.90306 秒。

经过优化（g++ main.cpp -O3 -std=c++11）：

老式循环：0.469001 秒。

基于范围的循环：0.467045 秒。

#include <iostream>
#include <vector>
#include <time.h>
using namespace std;

double time_elapsed(timespec& start, timespec& end)
{
    return ((1e9 * end.tv_sec + end.tv_nsec) - 
            (1e9 * start.tv_sec + start.tv_nsec)) / 1.0e9;
}

int main()
{
    vector<int> v(1e9, 42);

    timespec start, end;

//  Old-fashioned loop.
    clock_gettime(CLOCK_MONOTONIC_RAW, &start);
    size_t size = v.size();
    for (size_t i = 0; i < size; i++)
    {
        v[i] *= v[i];
    }
    clock_gettime(CLOCK_MONOTONIC_RAW, &end);

    cout << "Old-fashioned loop: " << time_elapsed(start, end) << " seconds\n";

//  Range-based loop.
    clock_gettime(CLOCK_MONOTONIC_RAW, &start); 
    for (int& val : v)
    {
        val *= val;
    }
    clock_gettime(CLOCK_MONOTONIC_RAW, &end);

    cout << "Range-based loop: " << time_elapsed(start, end) << " seconds.\n";
}

【讨论】：

你用什么编译器设置来编译这个？
微基准测试真的很复杂。至少，您需要发布编译器版本和编译设置。然后，用反向循环重试程序，或者更好的是，只循环一次。或者使用适当的框架。此外，您必须确保产生可见副作用。还有很多问题。
@dyp 我并不是说这是关于哪种类型的循环更快的规范答案，但是 OP 可以在他们的特定场景上运行类似的测试。或者根据他们的需要进行更复杂的测试。当然，鉴于这些数字，我不会说一个比另一个快，如果我想说编译器似乎足够聪明，可以将它们都优化到大致相同的水平。在这种情况下，我会使用基于范围的循环，因为它更具可读性。
我仍然认为您不能从您显示的代码中真正得出结论。但我认为免责声明在某种程度上是可以接受的。删除了反对票。

【解决方案2】：

我使用以下代码对它们进行了测试：

#include <benchmark/benchmark.h>
#include <vector>

auto get_vector(int size) {
    return std::vector<int>(size, 2333);
}
template <class F>
void BM_for_range(benchmark::State &state)
{
    for(auto _: state) {
        state.PauseTiming();

        F{}(get_vector(state.range(0)), state);//Run the test
    }
}
struct v1 {
    template <class T>
    void operator () (std::vector<T> v, benchmark::State &state) {
        state.ResumeTiming();

        auto size = v.size();
        decltype(size) i = 0;
        for (; i != size; i++) {
            v[i] *= v[i];
        }
    }
};
struct v2 {
    template <class T>
    void operator () (std::vector<T> v, benchmark::State &state) {
        state.ResumeTiming();

        for (int& val : v) {
            val *= val;
        }
    }
};

BENCHMARK_TEMPLATE(BM_for_range, v1)->Range(64, (1 << 30));
BENCHMARK_TEMPLATE(BM_for_range, v2)->Range(64, (1 << 30));
BENCHMARK_MAIN();

所有性能测试都在：

Debian 9.4, Linux version 4.9.0-6-amd64 (debian-kernel@lists.debian.org)(gcc version 6.3.0 20170516 (Debian 6.3.0-18+deb9u1) ) #1 SMP Debian 4.9.82-1+deb9u3 (2018-03-02)

使用clang++-6.0 -std=c++17 -lbenchmark -lpthread -Ofast main.cc编译

并通过在 bash 中运行这些得到结果：

sudo cpupower frequency-set --governor performance
./a.out

结果：

Run on (8 X 1600 MHz CPU s)
CPU Caches:
  L1 Data 32K (x4)
  L1 Instruction 32K (x4)
  L2 Unified 256K (x4)
  L3 Unified 6144K (x1)
-------------------------------------------------------------------
Benchmark                            Time           CPU Iterations
-------------------------------------------------------------------
BM_for_range<v1>/64                929 ns        932 ns     763881
BM_for_range<v1>/512              1051 ns       1053 ns     662887
BM_for_range<v1>/4096             2195 ns       2199 ns     317788
BM_for_range<v1>/32768           12484 ns      12509 ns      57699
BM_for_range<v1>/262144         114788 ns     114784 ns       6277
BM_for_range<v1>/2097152       1270037 ns    1269506 ns        554
BM_for_range<v1>/16777216     16472508 ns   16468972 ns         43
BM_for_range<v1>/134217728   130165013 ns  130136049 ns          5
BM_for_range<v1>/1073741824  986169581 ns  986168129 ns          1
BM_for_range<v2>/64                925 ns        927 ns     730624
BM_for_range<v2>/512              1060 ns       1062 ns     654477
BM_for_range<v2>/4096             2197 ns       2201 ns     319264
BM_for_range<v2>/32768           12288 ns      12314 ns      53352
BM_for_range<v2>/262144         112196 ns     112191 ns       6220
BM_for_range<v2>/2097152       1268441 ns    1267732 ns        553
BM_for_range<v2>/16777216     16627461 ns   16623624 ns         42
BM_for_range<v2>/134217728   127552348 ns  127551465 ns          6
BM_for_range<v2>/1073741824  963751205 ns  963152928 ns          1

【讨论】：