为什么数组元素的打印平均比 C++ 中单个对象的打印慢？

Question

我做了一个测试，通过将它们的值打印到 CLI 中来查看访问数组元素和单个对象之间的区别：

#include <iostream>
#include <chrono>
#include <iomanip>

int main()
{
    int a[10] = {1,2,3,4,5,6,7,8,9,10};

    int v1 = 1;
    int v2 = 2;
    int v3 = 3;
    int v4 = 4;
    int v5 = 5;
    int v6 = 6;
    int v7 = 7;
    int v8 = 8;
    int v9 = 9;
    int v10 = 10;

    std::cout << "Array output:" << std::endl << std::endl;

    auto t_start1 = std::chrono::high_resolution_clock::now();

    std::cout << "1. value: " << a[0] << std::endl;
    std::cout << "2. value: " << a[1] << std::endl;
    std::cout << "3. value: " << a[2] << std::endl;
    std::cout << "4. value: " << a[3] << std::endl;
    std::cout << "5. value: " << a[4] << std::endl;
    std::cout << "6. value: " << a[5] << std::endl;
    std::cout << "7. value: " << a[6] << std::endl;
    std::cout << "8. value: " << a[7] << std::endl;
    std::cout << "9. value: " << a[8] << std::endl;
    std::cout << "10. value: " << a[9] << std::endl;

    auto t_end1 = std::chrono::high_resolution_clock::now();

    std::cout << std::endl;

    std::cout << "Variable output:" << std::endl << std::endl;

    auto t_start2 = std::chrono::high_resolution_clock::now();

    std::cout << "1. value: " << v1 << std::endl;
    std::cout << "2. value: " << v2 << std::endl;
    std::cout << "3. value: " << v3 << std::endl;
    std::cout << "4. value: " << v4 << std::endl;
    std::cout << "5. value: " << v5 << std::endl;
    std::cout << "6. value: " << v6 << std::endl;
    std::cout << "7. value: " << v7 << std::endl;
    std::cout << "8. value: " << v8 << std::endl;
    std::cout << "9. value: " << v9 << std::endl;
    std::cout << "10. value: " << v10 << std::endl;


    auto t_end2 = std::chrono::high_resolution_clock::now();

    std::cout<< std::endl << "Time passed with array: "
              << std::chrono::duration<double, std::milli>(t_end1-t_start1).count()
              << " ms\n" << std::endl;
    std::cout<< std::endl << "Time passed with variables: "
              << std::chrono::duration<double, std::milli>(t_end2-t_start2).count()
              << " ms\n" << std::endl;

    return 0;
}

在第一个实现中（MingW/g++ Windows 10，cmd.exe），数组元素内值的打印平均需要 3 毫秒比使用单个标量对象慢：

Table 对于 Windows，g++/MingW:

                Array Elements:            Single Objects:   

1. Run          13.9609 ms                 9.529 ms
2. Run          11.9031 ms                 8.0936 ms
3. Run          13.3706 ms                 9.5264 ms
4. Run          12.5302 ms                 8.4723 ms
5. Run          14.4679 ms                 9.9688 ms
6. Run          12.3989 ms                 8.4326 ms
7. Run          12.8719 ms                 10.1851 ms
8. Run          10.9138 ms                 7.4481 ms
9. Run          12.8971 ms                 9.4094 ms
10. Run         11.9045 ms                 7.9391 ms
11. Run          9.9192 ms                 8.4047 ms
12. Run         13.4106 ms                 10.0296 ms

在第二个实现中（g++ 在 Linux Ubuntu 下），数组元素内值的打印平均比使用单个慢 3 微秒标量对象：

Table 对于 Linux Ubuntu, g++:

                Array Elements:            Single Objects:   

1. Run          0.013 ms                   0.008 ms
2. Run          0.012 ms                   0.007 ms
3. Run          0.013 ms                   0.008 ms
4. Run          0.014 ms                   0.009 ms
5. Run          0.012 ms                   0.008 ms
6. Run          0.013 ms                   0.008 ms
7. Run          0.013 ms                   0.009 ms
8. Run          0.014 ms                   0.009 ms
9. Run          0.012 ms                   0.008 ms
10. Run         0.013 ms                   0.009 ms
11. Run         0.012 ms                   0.009 ms
12. Run         0.012 ms                   0.008 ms

我的问题：

为什么在 *C++ 中打印数组元素中的值平均比打印单个对象中的值慢？

*信息：我不知道数组元素的打印是否普遍较慢，与特定语言无关。

Answer 1

如果您看一下 generated assembly，您会注意到编译器将大量数组元素和标量替换为常量，因为它们的值在编译时已知。

您测量格式化和输出数组元素所需的时间，以及刷新每个元素的输出流（使用 std::endl），这涉及系统调用。

从数组中加载一个元素比这要短得多。从 L1 缓存加载 CPU 寄存器需要 4 CPU 个周期（在 5GHz CPU 上不到 1 纳秒），从内存（最后一级缓存未命中）在 i9-i9900KS ~215 CPU 周期，在 Ryzen 上约 280 CPU 周期。

从数组或（标量）变量加载元素之间应该没有明显的区别。从数组加载元素可能涉及生成的程序集中的一些索引算法，但这可能很难测量。

当我围绕你的时间安排循环让 CPU 将其频率增加到最大值时，页面错误页面进入并预热 CPU 缓存；并将 std::endl 替换为 '\n' 我得到以下时间：

Time passed with array:     0.029154 ms
Time passed with variables: 0.029286 ms

Time passed with array:     0.027148 ms
Time passed with variables: 0.027587 ms

这是为了表明访问数组元素和标量变量之间没有可测量的时间差异（但它仍然测量std::cout次）。

Answer 2

在您的测试中，将内容写入 cout 比仅访问内存中的内容花费更多的时间。

更糟糕的是，它可能甚至不从数组或变量中读取值，因为该值在编译时已经已知。它可能在这两种情况下都使用常量。

为了证明这一切，只需尝试与硬编码常量的输出时间进行比较。并尝试将其与计算和输出这些数字的总和所花费的时间进行比较。

我们无法确定第一个输出速度较慢的原因。这仅取决于 OS 如何处理这些输出流。

为什么数组元素的打印平均比 C++ 中单个对象的打印慢？

Why is the printing of array elements in average slower than the printing of single objects in C++?

c++

arrays

performance

benchmarking

microbenchmark