【问题标题】：Increase of access time with large array indexes使用大数组索引增加访问时间
【发布时间】：2015-02-24 19:23:47
【问题描述】：

问题

我目前正在编写一个包含大型数组的程序，但我对不同数组的处理时间感到非常困惑。一方面我有 7 个“较小”的数组（

#include <iostream>
#include <time.h>

using namespace std;

int main(int argc,char* argv[])
{
    int i;

    int* ExampleArray1 = new int [16384];       // 3 "small" arrays (2^14)
    int* ExampleArray2 = new int [32768];       //                  (2^15)
    int* ExampleArray3 = new int [65536];       //                  (2^16)
    for(i=0 ; i<16384 ; i++) {ExampleArray1[i] = 0;}
    for(i=0 ; i<32768 ; i++) {ExampleArray2[i] = 0;}
    for(i=0 ; i<65536 ; i++) {ExampleArray3[i] = 0;}

    int* ExampleArray4 = new int [16777216];    // 3 large arrays   (2^24)
    int* ExampleArray5 = new int [33554432];    //                  (2^25)
    int* ExampleArray6 = new int [67108864];    //                  (2^26)
    for(i=0 ; i<16777216 ; i++) {ExampleArray4[i] = 0;}
    for(i=0 ; i<33554432 ; i++) {ExampleArray5[i] = 0;}
    for(i=0 ; i<67108864 ; i++) {ExampleArray6[i] = 0;}

    int until;

    clock_t start,stop;
    cout << "Until: "; cin >> until;

    start = clock();
    for(i=0 ; i<until; i++)
    {
        ExampleArray1[1]++;
        ExampleArray2[1]++;
        ExampleArray3[1]++;
    }
    stop = clock();
    cout << "Time: " << static_cast<float>(stop-start)/CLOCKS_PER_SEC << " sec.\n";

    start = clock();
    for(i=0 ; i<until; i++)
    {
        ExampleArray4[1]++;
        ExampleArray5[1]++;
        ExampleArray6[1]++;
    }
    stop = clock();
    cout << "Time: " << static_cast<float>(stop-start)/CLOCKS_PER_SEC << " sec.\n";

    delete[] ExampleArray1; ExampleArray1 = NULL;
    delete[] ExampleArray2; ExampleArray2 = NULL;
    delete[] ExampleArray3; ExampleArray3 = NULL;
    delete[] ExampleArray4; ExampleArray4 = NULL;
    delete[] ExampleArray5; ExampleArray5 = NULL;
    delete[] ExampleArray6; ExampleArray6 = NULL;

    getchar();
    return 0;
}

另一个令人困惑的地方是编译模式之间的时间差异。作为“直到”我进入了 10 亿。

输出 -> 调试模式（标准）：

Time: 6 sec.
Time: 26 sec.

输出 -> 发布模式（启用完全优化[/Ox]（我相信这是标准的））：

Time: 34 sec.
Time: 47 sec.

输出 -> 释放模式（禁用属性表中的优化[/Od]）：

Time: 25 sec.
Time: 25 sec.

但如果我稍微更改代码并用赋值替换增量，输出会有点不同：

[...]
int until;
int value;

clock_t start,stop;
cout << "Until: "; cin >> until;
cout << "Value: "; cin >> value;

start = clock();
for(i=0 ; i<until; i++)
{
    ExampleArray1[1]=value;
    ExampleArray2[1]=value;
    ExampleArray3[1]=value;
}
stop = clock();
cout << "Time: " << static_cast<float>(stop-start)/CLOCKS_PER_SEC << " sec.\n";

start = clock();
for(i=0 ; i<until; i++)
{
    ExampleArray4[1]=value;
    ExampleArray5[1]=value;
    ExampleArray6[1]=value;
}
stop = clock();
cout << "Time: " << static_cast<float>(stop-start)/CLOCKS_PER_SEC << " sec.\n";
[...]

输出 -> 调试模式（标准）：

Time: 4 sec.
Time: 28 sec.

输出 -> 释放模式（启用完全优化[/Ox]）：

Time: 38 sec.
Time: 38 sec.

输出 -> 发布模式（优化禁用[/Od]）：

Time: 24 sec.
Time: 28 sec.

我以为数组的访问时间总是一样的。我正在使用 Visual Studio 2012 32 位 Express 和 Windows 7 64 位。我已经测试了几次。时间大致相同（但最多 +/- 6 秒），我取了一个四舍五入的平均值。我的问题是：

问题

为什么不同数组大小的时间差异如此之大？ -> 如果不拆分大数组，这是否可以避免？
为什么调试模式比发布模式需要更少的时间？
没有优化的发布模式比有优化的发布模式快的原因是什么？

提前致谢。

编辑：

系统数据：

处理器：AMD Phenom II X6 1045T (6 x 2.7GHz)
L1 缓存：768 KB (2x6x64 KB) 2 路 | L2 缓存：3072 KB (6x512 KB) 16 路 | L3 缓存：6 MB 48 路关联
内存：2x 4GB DDR3
SSD 硬盘

反汇编（第一个带有增量的代码）

反汇编 - VS 2012 (Express)

调试模式下的反汇编在每种情况下（大数组和小数组）都是相同的。例如Array1和第一个循环的头部：

    for (i = 0; i<until; i++)
01275FEA  mov         dword ptr [i],0  
01275FF1  jmp         main+21Ch (01275FFCh)  
01275FF3  mov         eax,dword ptr [i]  
01275FF6  add         eax,1  
01275FF9  mov         dword ptr [i],eax  
01275FFC  mov         eax,dword ptr [i]  
01275FFF  cmp         eax,dword ptr [until]  
01276002  jge         main+283h (01276063h)  
    {
        ExampleArray1[1]++;
01276004  mov         eax,4  
01276009  shl         eax,0  
0127600C  mov         ecx,dword ptr [ExampleArray1]  
0127600F  mov         edx,dword ptr [ecx+eax]  
01276012  add         edx,1  
01276015  mov         eax,4  
0127601A  shl         eax,0  
0127601D  mov         ecx,dword ptr [ExampleArray1]  
01276020  mov         dword ptr [ecx+eax],edx

在发布模式下（经过优化），第一个循环的代码比第二个循环的代码短，而第二个标头在反汇编中是两倍（这可能是罪魁祸首吗？）。第一个循环：

    for(i=0 ; i<until; i++)
00AD10D9  xor         ecx,ecx  
00AD10DB  mov         dword ptr [esp+24h],eax  
00AD10DF  cmp         dword ptr [esp+10h],ecx  
00AD10E3  jle         main+0F5h (0AD10F5h)  
    {
        ExampleArray1[1]++;
00AD10E5  inc         dword ptr [esi+4]  
        ExampleArray2[1]++;
00AD10E8  inc         dword ptr [ebx+4]  
        ExampleArray3[1]++;
00AD10EB  inc         dword ptr [edi+4]  
00AD10EE  inc         ecx  
00AD10EF  cmp         ecx,dword ptr [esp+10h]  
00AD10F3  jl          main+0E5h (0AD10E5h)

第二次循环：

        for(i=0 ; i<until; i++)
003B13B4  xor         ecx,ecx  
003B13B6  mov         dword ptr [esp+24h],eax  
003B13BA  cmp         dword ptr [esp+10h],ecx  
003B13BE  jle         main+174h (03B13E4h)  
        for(i=0 ; i<until; i++)
003B13C0  mov         eax,dword ptr [esp+1Ch]  
003B13C4  mov         edx,dword ptr [esp+18h]  
003B13C8  mov         edi,dword ptr [esp+20h]  
003B13CC  lea         esp,[esp]  
    {
        ExampleArray4[1]++;
003B13D0  inc         dword ptr [eax+4]  
        ExampleArray5[1]++;
003B13D3  inc         dword ptr [edx+4]  
        ExampleArray6[1]++;
003B13D6  inc         dword ptr [edi+4]  
003B13D9  inc         ecx  
003B13DA  cmp         ecx,dword ptr [esp+10h]  
003B13DE  jl          main+160h (03B13D0h)  
003B13E0  mov         edi,dword ptr [esp+14h]  
    }

这是没有优化的release的反汇编->第一个循环：

    for(i=0 ; i<until; i++)
001A17A2  mov         dword ptr [i],0  
001A17A9  jmp         main+1C4h (01A17B4h)  
001A17AB  mov         edx,dword ptr [i]  
001A17AE  add         edx,1  
001A17B1  mov         dword ptr [i],edx  
001A17B4  mov         eax,dword ptr [i]  
001A17B7  cmp         eax,dword ptr [until]  
001A17BA  jge         main+22Bh (01A181Bh)  
    {
        ExampleArray1[1]++;
001A17BC  mov         ecx,4  
001A17C1  shl         ecx,0  
001A17C4  mov         edx,dword ptr [ExampleArray1]  
001A17C7  mov         eax,dword ptr [edx+ecx]  
001A17CA  add         eax,1  
001A17CD  mov         ecx,4  
001A17D2  shl         ecx,0  
001A17D5  mov         edx,dword ptr [ExampleArray1]  
001A17D8  mov         dword ptr [edx+ecx],eax  
        ExampleArray2[1]++;
001A17DB  mov         eax,4  
001A17E0  shl         eax,0  
001A17E3  mov         ecx,dword ptr [ExampleArray2]  
001A17E6  mov         edx,dword ptr [ecx+eax]  
001A17E9  add         edx,1  
001A17EC  mov         eax,4  
001A17F1  shl         eax,0  
001A17F4  mov         ecx,dword ptr [ExampleArray2]  
001A17F7  mov         dword ptr [ecx+eax],edx  
        ExampleArray3[1]++;
001A17FA  mov         edx,4  
001A17FF  shl         edx,0  
001A1802  mov         eax,dword ptr [ExampleArray3]  
001A1805  mov         ecx,dword ptr [eax+edx]  
001A1808  add         ecx,1  
001A180B  mov         edx,4  
001A1810  shl         edx,0  
001A1813  mov         eax,dword ptr [ExampleArray3]  
001A1816  mov         dword ptr [eax+edx],ecx

第二次循环：

    for(i=0 ; i<until; i++)
001A186F  mov         dword ptr [i],0  
001A1876  jmp         main+291h (01A1881h)  
001A1878  mov         eax,dword ptr [i]  
001A187B  add         eax,1  
001A187E  mov         dword ptr [i],eax  
001A1881  mov         ecx,dword ptr [i]  
001A1884  cmp         ecx,dword ptr [until]  
001A1887  jge         main+2F8h (01A18E8h)  
    {
        ExampleArray4[1]++;
001A1889  mov         edx,4  
001A188E  shl         edx,0  
001A1891  mov         eax,dword ptr [ExampleArray4]  
001A1894  mov         ecx,dword ptr [eax+edx]  
001A1897  add         ecx,1  
001A189A  mov         edx,4  
001A189F  shl         edx,0  
001A18A2  mov         eax,dword ptr [ExampleArray4]  
    {
        ExampleArray4[1]++;
001A18A5  mov         dword ptr [eax+edx],ecx  
        ExampleArray5[1]++;
001A18A8  mov         ecx,4  
001A18AD  shl         ecx,0  
001A18B0  mov         edx,dword ptr [ExampleArray5]  
001A18B3  mov         eax,dword ptr [edx+ecx]  
001A18B6  add         eax,1  
001A18B9  mov         ecx,4  
001A18BE  shl         ecx,0  
001A18C1  mov         edx,dword ptr [ExampleArray5]  
001A18C4  mov         dword ptr [edx+ecx],eax  
        ExampleArray6[1]++;
001A18C7  mov         eax,4  
001A18CC  shl         eax,0  
001A18CF  mov         ecx,dword ptr [ExampleArray6]  
001A18D2  mov         edx,dword ptr [ecx+eax]  
001A18D5  add         edx,1  
001A18D8  mov         eax,4  
001A18DD  shl         eax,0  
001A18E0  mov         ecx,dword ptr [ExampleArray6]  
001A18E3  mov         dword ptr [ecx+eax],edx  
    }

反汇编 - VS 2013 (Express)

调试模式：-与VS 2012相同-

在发布模式下（经过优化），它看起来有点不同 -> 第一个循环：

    for (i = 0; i<until; i++)
01391384  xor         ecx,ecx  
01391386  mov         dword ptr [esp+10h],eax  
0139138A  cmp         dword ptr [esp+20h],ecx  
0139138E  jle         main+100h (013913A0h)  
    {
        ExampleArray1[1]++;
01391390  inc         dword ptr [esi+4]  
01391393  inc         ecx  
        ExampleArray2[1]++;
01391394  inc         dword ptr [ebx+4]  
        ExampleArray3[1]++;
01391397  inc         dword ptr [edi+4]  
0139139A  cmp         ecx,dword ptr [esp+20h]  
0139139E  jl          main+0F0h (01391390h)  
    }

第二个循环（循环头更大？）：

    for (i = 0; i<until; i++)
013913EF  xor         ecx,ecx  
013913F1  mov         dword ptr [esp+10h],eax  
013913F5  cmp         dword ptr [esp+20h],ecx  
013913F9  jle         main+17Bh (0139141Bh)  
013913FB  mov         eax,dword ptr [esp+18h]  
013913FF  mov         edx,dword ptr [esp+0Ch]  
01391403  mov         edi,dword ptr [esp+1Ch]  
    {
        ExampleArray4[1]++;
01391407  inc         dword ptr [eax+4]  
0139140A  inc         ecx  
        ExampleArray5[1]++;
0139140B  inc         dword ptr [edx+4]  
        ExampleArray6[1]++;
0139140E  inc         dword ptr [edi+4]  
01391411  cmp         ecx,dword ptr [esp+20h]  
01391415  jl          main+167h (01391407h)  
01391417  mov         edi,dword ptr [esp+14h]  
    }

发布模式（无优化）-> 第一个循环：

    for (i = 0; i<until; i++)
00DC182C  mov         dword ptr [i],0  
00DC1833  jmp         main+1CEh (0DC183Eh)  
00DC1835  mov         edx,dword ptr [i]  
00DC1838  add         edx,1  
00DC183B  mov         dword ptr [i],edx  
00DC183E  mov         eax,dword ptr [i]  
00DC1841  cmp         eax,dword ptr [until]  
00DC1844  jge         main+235h (0DC18A5h)  
    {
        ExampleArray1[1]++;
00DC1846  mov         ecx,4  
00DC184B  shl         ecx,0  
00DC184E  mov         edx,dword ptr [ExampleArray1]  
00DC1851  mov         eax,dword ptr [edx+ecx]  
00DC1854  add         eax,1  
00DC1857  mov         ecx,4  
00DC185C  shl         ecx,0  
00DC185F  mov         edx,dword ptr [ExampleArray1]  
00DC1862  mov         dword ptr [edx+ecx],eax  
        ExampleArray2[1]++;
00DC1865  mov         eax,4  
00DC186A  shl         eax,0  
00DC186D  mov         ecx,dword ptr [ExampleArray2]  
00DC1870  mov         edx,dword ptr [ecx+eax]  
00DC1873  add         edx,1  
00DC1876  mov         eax,4  
00DC187B  shl         eax,0  
00DC187E  mov         ecx,dword ptr [ExampleArray2]  
00DC1881  mov         dword ptr [ecx+eax],edx  
        ExampleArray3[1]++;
00DC1884  mov         edx,4  
00DC1889  shl         edx,0  
00DC188C  mov         eax,dword ptr [ExampleArray3]  
00DC188F  mov         ecx,dword ptr [eax+edx]  
00DC1892  add         ecx,1  
00DC1895  mov         edx,4  
00DC189A  shl         edx,0  
00DC189D  mov         eax,dword ptr [ExampleArray3]  
00DC18A0  mov         dword ptr [eax+edx],ecx  
        }

第二次循环：

    for (i = 0; i<until; i++)
00DC18F9  mov         dword ptr [i],0  
00DC1900  jmp         main+29Bh (0DC190Bh)  
00DC1902  mov         eax,dword ptr [i]  
00DC1905  add         eax,1  
00DC1908  mov         dword ptr [i],eax  
00DC190B  mov         ecx,dword ptr [i]  
00DC190E  cmp         ecx,dword ptr [until]  
00DC1911  jge         main+302h (0DC1972h)  
    {
        ExampleArray4[1]++;
 00DC1913  mov         edx,4  
    {
        ExampleArray4[1]++;
00DC1918  shl         edx,0  
00DC191B  mov         eax,dword ptr [ExampleArray4]  
00DC191E  mov         ecx,dword ptr [eax+edx]  
00DC1921  add         ecx,1  
00DC1924  mov         edx,4  
00DC1929  shl         edx,0  
00DC192C  mov         eax,dword ptr [ExampleArray4]  
00DC192F  mov         dword ptr [eax+edx],ecx  
        ExampleArray5[1]++;
00DC1932  mov         ecx,4  
00DC1937  shl         ecx,0  
00DC193A  mov         edx,dword ptr [ExampleArray5]  
00DC193D  mov         eax,dword ptr [edx+ecx]  
00DC1940  add         eax,1  
00DC1943  mov         ecx,4  
00DC1948  shl         ecx,0  
00DC194B  mov         edx,dword ptr [ExampleArray5]  
00DC194E  mov         dword ptr [edx+ecx],eax  
        ExampleArray6[1]++;
00DC1951  mov         eax,4  
00DC1956  shl         eax,0  
00DC1959  mov         ecx,dword ptr [ExampleArray6]  
00DC195C  mov         edx,dword ptr [ecx+eax]  
00DC195F  add         edx,1  
00DC1962  mov         eax,4  
00DC1967  shl         eax,0  
00DC196A  mov         ecx,dword ptr [ExampleArray6]  
00DC196D  mov         dword ptr [ecx+eax],edx  
    }

编辑：好吧，我已经尽力了。我比以前更糊涂了。要查看反汇编，我在我的代码中设置了一个断点并按下鼠标右键->转到反汇编。然后我看到了拆解。在所有这些代码中，我都在“ExampleArray2[1]++”（第 34 行）处设置了断点。现在，我注意到如果我在另一个数组上设置断点，反汇编会发生变化。为什么...... Visual Studio 坏了或类似的东西还是正常的？ 这个问题已经很大了。我已经上传了时钟的反汇编和硬编码，直到在 pastebin：http://pastebin.com/pxgegzZ6

重要提示：我在发布模式下发现了一个很有帮助的发现。如果我在第二个循环中按鼠标右键并按“运行直到到达光标”或将光标设置在第二个循环中并按 Ctrl+F10，则第一个循环只需要 2.6 秒！如果我将光标设置在代码的末尾，第一个循环需要 2.5-2.7 秒，但第二个循环和以前一样慢。在调试模式下，时间不会改变。

【问题讨论】：

使用 Visual Studio 2013 并使用硬编码到 10 亿，调试需要 2.5/2.8 秒，发布需要 1.6/1.7 秒。您可能会遇到缓存大小问题，但不知道您的处理器、内存，以及机器上运行的其他任何东西，这只是一个猜测。也有可能在你的发布版本中事情的顺序不同，这样你就可以计算输入数字需要多长时间。看看拆解。
我看到的（近似但一致的）时间是（按照问题中提出的相同顺序，全部以秒为单位）：4.7,6.9; 1.7,3.3; 4.7,6.9。我正在 VS2013 (VC12) 上编译。这意味着我似乎无法重现您的“优化异常”。但是小数组和大数组的区别确实存在。
我认为这可能是一个“缓存 associativity”问题（但我不知道具体如何或为什么。）我将代码更改为 2 次更新而不是 3 次在内部循环（对于小型和大型阵列）中，我的时间现在是 2.1 和 2.2 秒，用于优化发布版本。（是的，小数组的更新变慢了！）
我无法使用 Visual Studio 2013 Pro 进行复制。我的时间是 2.5/3.5 用于调试和 2.1/2.17 用于发布模式。就像人们期望的那样。
缺少反汇编的重要部分，这是相对于其余代码分配开始/结束时钟值的地方。使用硬编码的 until 值而不是从 cin 获取它会得到什么结果？

标签： c++ arrays visual-studio-2012 assembly disassembly

【解决方案1】：

这在我看来像是缓存问题。

如果，而不是

for(i=0 ; i<until; i++)
{
    ExampleArray4[1]++;
    ExampleArray5[1]++;
    ExampleArray6[1]++;
}

你做到了

for(i=0 ; i<until; i++) ExampleArray4[1]++;
for(i=0 ; i<until; i++) ExampleArray5[1]++;
for(i=0 ; i<until; i++) ExampleArray6[1]++;

我预计它会快得多。

缓存成为问题的原因是，每次您从一个阵列切换到下一个阵列时，都必须从缓存中提取不同的位置。通过频繁切换阵列，您会遇到很多缓存未命中。如果您穿过二维数组的行而不是列，则会出现类似的问题。据推测，这不会影响您的较小数组，因为它们都可以放入缓存中。

【讨论】：