-6

我昨天进行了一些性能测试，以了解堆栈和堆分配在实践中的差异有多大。从这样的测试中可以预期的是堆分配稍微慢一些或与堆栈分配相当。然而，我惊讶地发现相反的情况。我无法解释为什么，以及它在逻辑上是如何可能的，但堆分配总是稍微快一些（我在优化关闭的情况下进行编译）。

这是一个示例输出：

ticks (stack): 42698
ticks (stack): 43977
ticks (stack): 44024
ticks (stack): 44070
ticks (stack): 45038

ticks (heap): 42588
ticks (heap): 43525
ticks (heap): 43633
ticks (heap): 43681
ticks (heap): 43071

这是一个很小的差异，但它非常一致，它重现了 100% 的时间，有利于堆分配。

谁能解释为什么我会得到这些奇怪的结果？

这是我运行的代码：

#include <vector>
#include <iostream>
#include <string>
#include <windows.h>

using namespace std;

struct JJ
{
    int c[50];
    JJ(int i) { c[5] = 3; c[29] = 4; c[30] = i; c[49] = c[5]; }
};

void fill_direct_stack()
{
    vector<JJ> vec;
    for (int i=0; i<1000; ++i)
        vec.push_back(i);
}

void fill_direct_heap()
{
    vector<JJ>* pVec = new vector<JJ>();
    for (int i=0; i<1000; ++i)
        pVec->push_back(i);
    delete pVec;
}

CRITICAL_SECTION cs_print;

void print(string msg, DWORD val)
{
    EnterCriticalSection(&cs_print);
    cout << msg << val << endl;
    LeaveCriticalSection(&cs_print);
}

DWORD __stdcall threadEntry(void*)
{
    DWORD ticks1,ticks2;

    ticks1 = GetTickCount();
    for (int i=0; i<10000; ++i)
        fill_direct_stack();
    ticks2 = GetTickCount();
    print("ticks (stack): ", ticks2 - ticks1);

    ticks1 = GetTickCount();
    for (int i=0; i<10000; ++i)
        fill_direct_heap();
    ticks2 = GetTickCount();
    print("ticks (heap): ", ticks2 - ticks1);

    return 0;
}

int main()
{
    cout<<"hi"<<endl;

    InitializeCriticalSection(&cs_print);

#define N_THREADS 5

    HANDLE thr[N_THREADS];
    for (int i=0; i<N_THREADS; ++i)
        thr[i] = CreateThread(NULL, 0, &threadEntry, NULL, 0, NULL);

    for (int i=0; i<N_THREADS; ++i)
        WaitForSingleObject(thr[i], INFINITE);

    DeleteCriticalSection(&cs_print);

    system("pause");
}
4

2 回答 2

6

分配

vector<JJ>* pVec = new vector<JJ>();

和

vector<JJ> vec;

与推回和内部内存管理相比，这算不了什么vector。

于 2013-01-09T13:40:25.817 回答
1

很难说是什么导致了如此人为的基准测试中如此微小的差异。但我的猜测是这是一个对齐问题。如果你从堆中分配，你会得到一块适合存储任何类型的内存。如果您从堆栈中分配，您将获得一块仅最小对齐的内存，适合您存储的类型。

我的另一个理论是数据缓存命中率。考虑一个线程完成，然后另一个线程在同一内核上运行。使用堆栈分配，分配永远不会分配到同一块内存，因为每个线程都有自己的堆栈。数据缓存将是冷的。使用堆分配，分配可能会获得前一个线程刚刚释放的相同块。这块内存在 CPU 数据缓存中会很热。（不过，这个理论会预测数字的相当多的变化——我认为比你看到的要多。）

但差异是如此之小，它可能是任何东西。

于 2013-01-09T13:48:23.800 回答