好的，正确的答案肯定是要对CPU缓存进行一些处理。但是使用缓存参数可能非常困难，尤其是在没有数据的情况下。

有很多答案，引发了很多讨论，但让我们面对现实：缓存问题可能非常复杂，而且不是一维的。它们在很大程度上取决于数据的大小，所以我的问题是不公平的：结果是在缓存图中的一个非常有趣的点。

@Mysticial的回答说服了很多人（包括我），可能是因为它是唯一一个似乎依赖事实的答案，但它只是真相的一个“数据点”。

这就是为什么我结合了他的测试（使用连续分配和单独分配）和@James’Answer的建议。

下面的图表显示，根据所使用的确切场景和参数，大多数答案，尤其是对问题和答案的大多数评论都可以被视为完全错误或正确。

注意，我最初的问题是n=100.000。这一点（偶然）表现出特殊的行为：

它在单圈和双圈版本之间具有最大的差异（几乎是三分之一）这是唯一一点，其中一个循环（即连续分配）胜过两个循环版本。（这使得Mysticial的答案成为可能。）

使用初始化数据的结果：

使用未初始化数据的结果（这是Mysticial测试的结果）：

这是一个很难解释的问题：初始化的数据，分配一次，并重复用于以下不同向量大小的测试用例：

提议

堆栈溢出上的每一个低级性能相关问题都应该被要求为整个缓存相关数据大小范围提供MFLOPS信息！在没有这些信息的情况下，思考答案，特别是与其他人讨论答案，是浪费每个人的时间。

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

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

这意味着每个循环中的所有访问都将落在相同的缓存路径上。然而，英特尔处理器已经有一段时间具有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：

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

---

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

我不知道是不是糟糕的基准测试代码造成了问题，或者是什么，但在我的机器上，使用以下代码，这两个方法的速度相差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秒。

这是因为CPU没有太多缓存未命中（它必须等待来自RAM芯片的阵列数据）。您可以不断调整数组的大小，使其超过CPU的一级缓存（L1）和二级缓存（L2）的大小，并根据数组的大小绘制代码执行所需的时间。图表不应该像你期望的那样是一条直线。

假设您正在一台机器上工作，其中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

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

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

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

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