假设您正在一台机器上工作，其中n正好是一个正确的值，它只可能同时在内存中存储两个阵列，但通过磁盘缓存，可用的总内存仍然足以存储所有四个阵列。

假设一个简单的LIFO缓存策略，下面的代码：

for(int j=0;j<n;j++){
    a[j] += b[j];
}
for(int j=0;j<n;j++){
    c[j] += d[j];
}

首先将a和b加载到RAM中，然后完全在RAM中工作。当第二个循环开始时，c和d将从磁盘加载到RAM并在其上运行。

另一个回路

for(int j=0;j<n;j++){
    a[j] += b[j];
    c[j] += d[j];
}

每次循环时，都会调出两个数组并调入另两个数组。这显然要慢得多。

您可能在测试中没有看到磁盘缓存，但可能看到了其他形式缓存的副作用。

---

这里似乎有一点困惑/误解，所以我将尝试用一个例子来阐述一点。

假设n=2，我们正在处理字节。在我的场景中，我们只有4个字节的RAM，而我们的内存的其余部分则要慢得多（比如100倍的访问时间）。

假设一个相当愚蠢的缓存策略，即如果字节不在缓存中，那么将其放在那里，并在我们进行时获得以下字节，您将得到类似这样的场景：

具有对于（int j=0；j<n；j++）{a[j]+=b[j]；}对于（int j=0；j<n；j++）{c[j]+=d[j]；}缓存a[0]和a[1]，然后是b[0]和b[1]，并在缓存中设置a[0]=a[0]+b[0]-缓存中现在有四个字节，a[0]、a[1]和b[0]、b[1]。成本=100+100。在缓存中设置a[1]=a[1]+b[1]。成本=1+1。对c和d重复上述步骤。总成本=（100+100+1+1）*2=404具有对于（int j=0；j<n；j++）{a[j]+=b[j]；c[j]+=d[j]；}缓存a[0]和a[1]，然后是b[0]和b[1]，并在缓存中设置a[0]=a[0]+b[0]-缓存中现在有四个字节，a[0]、a[1]和b[0]、b[1]。成本=100+100。从缓存和缓存c[0]和c[1]中弹出a[0]、a[1]、b[0]和b[1]，然后是d[0]和d[1]，并在缓存中设置c[0]=c[0]+d[0]。成本=100+100。我怀疑你开始明白我要去哪里了。总成本=（100+100+100+100）*2=800

这是一个经典的缓存抖动场景。

第一个循环交替写入每个变量。第二个和第三个仅对元素大小进行小的跳跃。

试着用20厘米的纸和笔写两条平行的20个十字线。试着先完成一行，然后再完成另一行，试着在每一行中交替写一个十字。

它可能是旧的C++和优化。在我的电脑上，我获得了几乎相同的速度：

单回路：1.577 ms

两个回路：1.507 ms

我在E5-1620 3.5 GHz处理器和16 GB RAM上运行Visual Studio 2015。

我无法复制这里讨论的结果。

我不知道是不是糟糕的基准测试代码造成了问题，或者是什么，但在我的机器上，使用以下代码，这两个方法的速度相差10%以内，而且一个循环通常比两个循环稍快-正如您所预期的那样。

数组大小从2^16到2^24不等，使用八个循环。我小心地初始化了源数组，因此+=赋值不会要求FPU添加解释为双精度的内存垃圾。

我尝试了各种方案，例如将b[j]、d[j]赋值给InitToZero[j]到循环中，以及使用+=b[j]=1和+=d[j]=1，我得到了相当一致的结果。

正如您可能预期的那样，使用InitToZero[j]在循环内初始化b和d使组合方法具有优势，因为它们在分配给a和c之前是背靠背完成的，但仍在10%以内。想想看吧

硬件为Dell XPS 8500，具有第3代Core i7@3.4 GHz和8 GB内存。对于2^16到2^24，使用八个循环，累积时间分别为44.987和40.965。Visual C++2010，完全优化。

PS：我将循环改为倒数为零，组合方法稍微快一些。挠我的头。注意新的数组大小和循环计数。

// MemBufferMystery.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <iostream>
#include <cmath>
#include <string>
#include <time.h>

#define  dbl    double
#define  MAX_ARRAY_SZ    262145    //16777216    // AKA (2^24)
#define  STEP_SZ           1024    //   65536    // AKA (2^16)

int _tmain(int argc, _TCHAR* argv[]) {
    long i, j, ArraySz = 0,  LoopKnt = 1024;
    time_t start, Cumulative_Combined = 0, Cumulative_Separate = 0;
    dbl *a = NULL, *b = NULL, *c = NULL, *d = NULL, *InitToOnes = NULL;

    a = (dbl *)calloc( MAX_ARRAY_SZ, sizeof(dbl));
    b = (dbl *)calloc( MAX_ARRAY_SZ, sizeof(dbl));
    c = (dbl *)calloc( MAX_ARRAY_SZ, sizeof(dbl));
    d = (dbl *)calloc( MAX_ARRAY_SZ, sizeof(dbl));
    InitToOnes = (dbl *)calloc( MAX_ARRAY_SZ, sizeof(dbl));
    // Initialize array to 1.0 second.
    for(j = 0; j< MAX_ARRAY_SZ; j++) {
        InitToOnes[j] = 1.0;
    }

    // Increase size of arrays and time
    for(ArraySz = STEP_SZ; ArraySz<MAX_ARRAY_SZ; ArraySz += STEP_SZ) {
        a = (dbl *)realloc(a, ArraySz * sizeof(dbl));
        b = (dbl *)realloc(b, ArraySz * sizeof(dbl));
        c = (dbl *)realloc(c, ArraySz * sizeof(dbl));
        d = (dbl *)realloc(d, ArraySz * sizeof(dbl));
        // Outside the timing loop, initialize
        // b and d arrays to 1.0 sec for consistent += performance.
        memcpy((void *)b, (void *)InitToOnes, ArraySz * sizeof(dbl));
        memcpy((void *)d, (void *)InitToOnes, ArraySz * sizeof(dbl));

        start = clock();
        for(i = LoopKnt; i; i--) {
            for(j = ArraySz; j; j--) {
                a[j] += b[j];
                c[j] += d[j];
            }
        }
        Cumulative_Combined += (clock()-start);
        printf("\n %6i miliseconds for combined array sizes %i and %i loops",
                (int)(clock()-start), ArraySz, LoopKnt);
        start = clock();
        for(i = LoopKnt; i; i--) {
            for(j = ArraySz; j; j--) {
                a[j] += b[j];
            }
            for(j = ArraySz; j; j--) {
                c[j] += d[j];
            }
        }
        Cumulative_Separate += (clock()-start);
        printf("\n %6i miliseconds for separate array sizes %i and %i loops \n",
                (int)(clock()-start), ArraySz, LoopKnt);
    }
    printf("\n Cumulative combined array processing took %10.3f seconds",
            (dbl)(Cumulative_Combined/(dbl)CLOCKS_PER_SEC));
    printf("\n Cumulative seperate array processing took %10.3f seconds",
        (dbl)(Cumulative_Separate/(dbl)CLOCKS_PER_SEC));
    getchar();

    free(a); free(b); free(c); free(d); free(InitToOnes);
    return 0;
}

我不确定为什么决定MFLOPS是一个相关的指标。我认为我的想法是专注于内存访问，所以我尽量减少浮点计算时间。我离开了，但我不知道为什么。

没有计算的直接赋值将是对内存访问时间的更干净的测试，并将创建一个与循环计数无关的统一测试。也许我在谈话中漏掉了什么，但值得三思。如果赋值中省略了加号，则累积时间几乎相同，每个值为31秒。

进一步分析后，我认为这（至少部分）是由四个指针的数据对齐造成的。这将导致一定程度的缓存库/通道冲突。

如果我猜对了如何分配数组，那么它们很可能与页面行对齐。

这意味着每个循环中的所有访问都将落在相同的缓存路径上。然而，英特尔处理器已经有一段时间具有8路L1缓存关联性。但事实上，表现并不完全一致。访问4路仍然比访问2路慢。

编辑：事实上，它看起来像是在单独分配所有数组。通常，当请求如此大的分配时，分配器将从OS请求新的页面。因此，大的分配很有可能出现在距页面边界相同的偏移处。

以下是测试代码：

int main(){
    const int n = 100000;

#ifdef ALLOCATE_SEPERATE
    double *a1 = (double*)malloc(n * sizeof(double));
    double *b1 = (double*)malloc(n * sizeof(double));
    double *c1 = (double*)malloc(n * sizeof(double));
    double *d1 = (double*)malloc(n * sizeof(double));
#else
    double *a1 = (double*)malloc(n * sizeof(double) * 4);
    double *b1 = a1 + n;
    double *c1 = b1 + n;
    double *d1 = c1 + n;
#endif

    //  Zero the data to prevent any chance of denormals.
    memset(a1,0,n * sizeof(double));
    memset(b1,0,n * sizeof(double));
    memset(c1,0,n * sizeof(double));
    memset(d1,0,n * sizeof(double));

    //  Print the addresses
    cout << a1 << endl;
    cout << b1 << endl;
    cout << c1 << endl;
    cout << d1 << endl;

    clock_t start = clock();

    int c = 0;
    while (c++ < 10000){

#if ONE_LOOP
        for(int j=0;j<n;j++){
            a1[j] += b1[j];
            c1[j] += d1[j];
        }
#else
        for(int j=0;j<n;j++){
            a1[j] += b1[j];
        }
        for(int j=0;j<n;j++){
            c1[j] += d1[j];
        }
#endif

    }

    clock_t end = clock();
    cout << "seconds = " << (double)(end - start) / CLOCKS_PER_SEC << endl;

    system("pause");
    return 0;
}

---

基准结果：

编辑：实际Core 2体系结构机器上的结果：

2 x Intel Xeon X5482 Harpertown@3.2 GHz：

#define ALLOCATE_SEPERATE
#define ONE_LOOP
00600020
006D0020
007A0020
00870020
seconds = 6.206

#define ALLOCATE_SEPERATE
//#define ONE_LOOP
005E0020
006B0020
00780020
00850020
seconds = 2.116

//#define ALLOCATE_SEPERATE
#define ONE_LOOP
00570020
00633520
006F6A20
007B9F20
seconds = 1.894

//#define ALLOCATE_SEPERATE
//#define ONE_LOOP
008C0020
00983520
00A46A20
00B09F20
seconds = 1.993

观察：

一圈6.206秒，两圈2.116秒。这准确地再现了OP的结果。在前两个测试中，阵列是单独分配的。您将注意到它们都具有与页面相同的对齐方式。在第二个测试中，阵列被打包在一起以打破这种对齐。在这里，您会注意到两个循环都更快。此外，第二个（双）循环现在是您通常预期的速度较慢的循环。

正如@Stephen Cannon在评论中指出的那样，这种对齐很可能会导致加载/存储单元或缓存中出现假别名。我在谷歌上搜索了一下，发现英特尔实际上有一个用于部分地址混淆暂停的硬件计数器：

http://software.intel.com/sites/products/documentation/doclib/stdxe/2013/~amplifierxe/pmw_dp/events/partial_address_alias.html

---

5个地区-解释

区域1：

这个很简单。数据集如此之小，以至于性能受到开销（如循环和分支）的控制。

区域2：

在这里，随着数据大小的增加，相对开销的数量下降，性能“饱和”。这里两个循环比较慢，因为它有两倍的循环和分支开销。

我不知道这里到底发生了什么。。。当Agner Fog提到缓存库冲突时，对齐仍可能发挥作用。（这个链接是关于Sandy Bridge的，但这个想法应该仍然适用于核心2。）

区域3：

此时，数据不再适合一级缓存。因此，性能受到L1<->L2缓存带宽的限制。

区域4：

我们观察到的是单循环中的性能下降。如上所述，这是由于对齐（最有可能）导致处理器加载/存储单元中的假混叠暂停。

然而，为了发生假混叠，数据集之间必须有足够大的步长。这就是为什么你在区域3中看不到这一点。

区域5：

此时，缓存中没有任何内容。所以你受到内存带宽的限制。

---

这不是因为不同的代码，而是因为缓存：RAM比CPU寄存器慢，并且CPU内部有一个缓存，以避免每次变量发生变化时都写入RAM。但是缓存并不像RAM那么大，因此它只映射了其中的一小部分。

第一个代码在每个循环中交替修改远程内存地址，因此需要不断地使缓存无效。

第二个代码不交替：它只在相邻地址上流动两次。这使得所有作业都在缓存中完成，只有在第二个循环开始后才使其无效。