为什么 std::vector 的速度是原始数组的两倍？包含完整代码

Question

结果：

向量时间：7051

阵列时间：18944

我为此使用了 MSVC 发布模式，编译为 32 位。

在此测试之前，我查看了向量的 GCC 源代码并感到惊讶，因为我认为 operator[] 检查了数组越界，但事实并非如此。不过，没想到向量这么快？！

完整代码：

#include <iostream>
#include <vector>

int main(){
    const int size = 10000;
    unsigned long long my_array[size];
    std::vector<unsigned long long> my_vec;
    
    my_vec.resize(size);

    //Populate containers
    for(int i=0; i<size; i++){
        my_vec[i] = i;
        my_array[i] = i;
    }

    //Initialise test variables
    unsigned long long sum = 0;
    unsigned long long time = 0;
    unsigned long long start = 0;
    unsigned long long finish = 0;

    //Time the vector
    start = __rdtsc();
    for(int i=0; i<size; i++){
        sum += my_vec[i];
    }
    finish = __rdtsc();


    time = finish - start;
    std::cout << "Vector time: " << time << "     " << sum << std::endl;


    sum = 0;

    //Time the array
    start = __rdtsc();
    for(int i=0; i<size; i++){
        sum += my_array[i];
    }
    finish = __rdtsc();

    time = finish - start;
    std::cout << "Array time: " << time << "     " << sum << std::endl;

    int t = 8;
    std::cin >> t;
    return 0;
}

Answer 1

以下使用的是 MSVC 2013。

对于向量：

0019138E  mov         edi,edi  
  for (int i = 0; i<size; i++){
00191390  lea         ecx,[ecx+20h]  
    sum += my_vec[i];
00191393  movdqu      xmm0,xmmword ptr [ecx-20h]  
00191398  paddq       xmm1,xmm0  
0019139C  movdqu      xmm0,xmmword ptr [ecx-10h]  
001913A1  paddq       xmm2,xmm0  
001913A5  dec         esi  
001913A6  jne         main+0F0h (0191390h)  
  }

对于数组：

0019142D  lea         ecx,[ecx]  
  for (int i = 0; i<size; i++){
00191430  lea         ecx,[ecx+20h]  
    sum += my_array[i];
00191433  movdqu      xmm0,xmmword ptr [ecx-30h]  
00191438  paddq       xmm1,xmm0  
0019143C  movdqu      xmm0,xmmword ptr [ecx-20h]  
00191441  paddq       xmm2,xmm0  
00191445  dec         esi  
00191446  jne         main+190h (0191430h)  
  }

如您所见，内部循环是相同的。实际上，我怀疑这是一个硬件问题，我交换了两个循环，并且数组的输出速度更快到相同的幅度（所以实际上，在现实世界中，两者都没有比另一个更快或更慢）。

我预测这是某种 CPU 缓存行为： https://en.wikipedia.org/wiki/CPU_cache

Answer 2

我们有两个数组，每个数组 80,000 字节。首先，160,000 字节并行填充数据。然后读取其中的 80,000 个，然后读取其他 80,000 个。假设缓存为 128,000 字节：

在读取向量的前 32,000 个字节时，数据不会被缓存。接下来的 48,000 个字节被缓存。现在缓存包含所有向量和数组的最后 48,000 字节。但是数组中的字节是最旧的，所以当数组从头开始读取时，它末尾的数据会被丢弃。所以从数组中读取的所有内容都是未缓存的。

因此，对于向量，我们有 32,000 字节的未缓存读取和 48,000 字节的缓存读取，而数组有 80,000 字节的未缓存读取。

这是针对 128,000 字节的缓存大小。其他尺寸会有所不同。 但随后可能会发生完全不同的事情。您的代码可以在运行时切换到不同的处理器，此时一个处理器可能必须将数据写入主存储器，而另一个处理器读取它。在另一个方向上，操作系统可能刚刚意识到正在进行一些操作，并将处理器从省电模式切换到某种加速模式。

进行一次测量并从中得出结论，这些都没有考虑在内。