我有以下问题:

int8、int16、int32 和 对 std::array 的写入次数int64 的大小每增加一倍。我可以理解 8 位 CPU 的这种行为，但不能理解 32/64 位。

为什么 32 位系统保存 32 位值比保存 8 位值需要多 4 倍的时间？

这是我的测试代码:

#include <iostream>
#include <array>
#include <chrono>

std::array<std::int8_t, 64 * 1024 * 1024> int8Array;
std::array<std::int16_t, 64 * 1024 * 1024> int16Array;
std::array<std::int32_t, 64 * 1024 * 1024> int32Array;
std::array<std::int64_t, 64 * 1024 * 1024> int64Array;

void PutZero()
{
    auto point1 = std::chrono::high_resolution_clock::now();
    for (auto &v : int8Array) v = 0;
    auto point2 = std::chrono::high_resolution_clock::now();
    for (auto &v : int16Array) v = 0;
    auto point3 = std::chrono::high_resolution_clock::now();
    for (auto &v : int32Array) v = 0;
    auto point4 = std::chrono::high_resolution_clock::now();
    for (auto &v : int64Array) v = 0;
    auto point5 = std::chrono::high_resolution_clock::now();
    std::cout << "Time of processing int8 array:\t" << (std::chrono::duration_cast<std::chrono::microseconds>(point2 - point1)).count() << "us." << std::endl;
    std::cout << "Time of processing int16 array:\t" << (std::chrono::duration_cast<std::chrono::microseconds>(point3 - point2)).count() << "us." << std::endl;
    std::cout << "Time of processing int32 array:\t" << (std::chrono::duration_cast<std::chrono::microseconds>(point4 - point3)).count() << "us." << std::endl;
    std::cout << "Time of processing int64 array:\t" << (std::chrono::duration_cast<std::chrono::microseconds>(point5 - point4)).count() << "us." << std::endl;
}

int main()
{
    PutZero();
    std::cout << std::endl << "Press enter to exit" << std::endl;
    std::cin.get();
    return 0;
}

我在linux下编译:g++ -o array_issue_1 main.cpp -O3 -std=c++14

我的结果如下:

Time of processing int8 array:  9922us.   
Time of processing int16 array: 37717us.   
Time of processing int32 array: 76064us.   
Time of processing int64 array: 146803us.   

如果我用 -O2 编译，那么 int8 的结果会差 5 倍!

您也可以在 Windows 中编译此源代码。你会得到类似的结果之间的关系。

更新 #1

当我使用 -O2 编译时，结果如下:

Time of processing int8 array:  60182us.  
Time of processing int16 array: 77807us.  
Time of processing int32 array: 114204us.  
Time of processing int64 array: 186664us.  

我没有分析汇编程序的输出。我的主要观点是，我想用 C++ 编写高效的代码，并且类似的东西表明，从性能角度来看，像 std::array 这样的东西可能具有挑战性，并且在某种程度上违反直觉。

最佳答案

Why does a 32-bit system need 4 times more time to save 32-bit values than to save 8-bit values?

它没有。但是您的基准测试中有 3 个不同的问题会为您提供这些结果。

1. 您没有预先损坏内存。因此，您在基准测试期间对数组进行了页面错误处理。这些页面错误以及操作系统内核交互是当时的主要因素。
2. 带有 -O3 的编译器通过将所有循环转换为 memset() 来完全击败您的基准测试。
3. 您的基准测试受内存限制。因此，您测量的是内存而不是内核的速度。

问题一:测试数据不是预设的

您的数组已声明，但在基准测试之前未使用。由于内核和内存分配的工作方式，它们还没有映射到内存中。只有当你第一次接触它们时才会发生这种情况。当它这样做时，它会从内核中招致非常大的惩罚来映射页面。

这可以通过在基准测试之前触摸所有数组来完成。

无预故障:http://coliru.stacked-crooked.com/a/1df1f3f9de420d18

g++ -O3 -Wall main.cpp && ./a.out
Time of processing int8 array:  28983us.
Time of processing int16 array: 57100us.
Time of processing int32 array: 113361us.
Time of processing int64 array: 224451us.

预故障:http://coliru.stacked-crooked.com/a/7e62b9c7ca19c128

g++ -O3 -Wall main.cpp && ./a.out
Time of processing int8 array:  6216us.
Time of processing int16 array: 12472us.
Time of processing int32 array: 24961us.
Time of processing int64 array: 49886us.

时间大约下降了 4 倍。换句话说，您最初的基准测试是测量内核而不是实际代码。

问题 2:编译器击败了基准测试

编译器正在识别您写入零的模式，并通过调用 memset() 完全替换所有循环。因此，实际上，您正在测量对不同大小的 memset() 的调用。

  call std::chrono::_V2::system_clock::now()
  xor esi, esi
  mov edx, 67108864
  mov edi, OFFSET FLAT:int8Array
  mov r14, rax
  call memset
  call std::chrono::_V2::system_clock::now()
  xor esi, esi
  mov edx, 134217728
  mov edi, OFFSET FLAT:int16Array
  mov r13, rax
  call memset
  call std::chrono::_V2::system_clock::now()
  xor esi, esi
  mov edx, 268435456
  mov edi, OFFSET FLAT:int32Array
  mov r12, rax
  call memset
  call std::chrono::_V2::system_clock::now()
  xor esi, esi
  mov edx, 536870912
  mov edi, OFFSET FLAT:int64Array
  mov rbp, rax
  call memset
  call std::chrono::_V2::system_clock::now()

这样做的优化是 -ftree-loop-distribute-patterns。即使你关闭它，矢量化器也会给你类似的效果。

使用 -O2，矢量化和模式识别都被禁用。所以编译器会给你你写的东西。

.L4:
  mov BYTE PTR [rax], 0         ;; <<------ 1 byte at a time
  add rax, 1
  cmp rdx, rax
  jne .L4
  call std::chrono::_V2::system_clock::now()
  mov rbp, rax
  mov eax, OFFSET FLAT:int16Array
  lea rdx, [rax+134217728]
.L5:
  xor ecx, ecx
  add rax, 2
  mov WORD PTR [rax-2], cx      ;; <<------ 2 bytes at a time
  cmp rdx, rax
  jne .L5
  call std::chrono::_V2::system_clock::now()
  mov r12, rax
  mov eax, OFFSET FLAT:int32Array
  lea rdx, [rax+268435456]
.L6:
  mov DWORD PTR [rax], 0        ;; <<------ 4 bytes at a time
  add rax, 4
  cmp rax, rdx
  jne .L6
  call std::chrono::_V2::system_clock::now()
  mov r13, rax
  mov eax, OFFSET FLAT:int64Array
  lea rdx, [rax+536870912]
.L7:
  mov QWORD PTR [rax], 0        ;; <<------ 8 bytes at a time
  add rax, 8
  cmp rdx, rax
  jne .L7
  call std::chrono::_V2::system_clock::now()

使用-O2:http://coliru.stacked-crooked.com/a/edfdfaaf7ec2882e

g++ -O2 -Wall main.cpp && ./a.out
Time of processing int8 array:  28414us.
Time of processing int16 array: 22617us.
Time of processing int32 array: 32551us.
Time of processing int64 array: 56591us.

现在很明显，字数越小越慢。但是，如果所有字长的速度都相同，您会期望时间是平坦的。它们不是因为内存带宽。

问题 3:内存带宽

由于基准(如所写)仅写入零，因此很容易使内核/系统的内存带宽饱和。因此，基准测试会受到所触及内存量的影响。

要解决这个问题，我们需要缩小数据集以使其适合缓存。为了弥补这一点，我们多次循环遍历相同的数据。

std::array<std::int8_t, 512> int8Array;
std::array<std::int16_t, 512> int16Array;
std::array<std::int32_t, 512> int32Array;
std::array<std::int64_t, 512> int64Array;

...

auto point1 = std::chrono::high_resolution_clock::now();
for (int c = 0; c < 64 * 1024; c++) for (auto &v : int8Array) v = 0;
auto point2 = std::chrono::high_resolution_clock::now();
for (int c = 0; c < 64 * 1024; c++) for (auto &v : int16Array) v = 0;
auto point3 = std::chrono::high_resolution_clock::now();
for (int c = 0; c < 64 * 1024; c++) for (auto &v : int32Array) v = 0;
auto point4 = std::chrono::high_resolution_clock::now();
for (int c = 0; c < 64 * 1024; c++) for (auto &v : int64Array) v = 0;
auto point5 = std::chrono::high_resolution_clock::now();

现在我们看到不同字长的时间安排更加平坦:

http://coliru.stacked-crooked.com/a/f534f98f6d840c5c

g++ -O2 -Wall main.cpp && ./a.out
Time of processing int8 array:  20487us.
Time of processing int16 array: 21965us.
Time of processing int32 array: 32569us.
Time of processing int64 array: 26059us.

它不完全平坦的原因可能是因为编译器优化涉及许多其他因素。您可能需要诉诸循环展开才能更接近。

关于c++ - 为什么不同整数大小的数组有不同的性能？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/46816848/