性能悖论:堆栈与堆分配(c++)

performance paradox: stack versus heap allocation (C++)

本文关键字：分配 c++ 堆栈 性能      更新时间：2023-10-16

我昨天进行了一些性能测试，看看堆栈和堆分配将在实践中。从这样的测试中可以期望的是，堆分配稍微慢一些，或者与堆栈分配相当。然而，我惊讶地发现事实恰恰相反。我无法解释为什么，以及它在逻辑上是如何可能的，但是堆分配总是稍微快一些(我在编译时关闭了优化)。

这是一个示例输出:

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");
}

分配

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

和

vector<JJ> vec;

与vector的回推和内部内存管理相比，没有。

很难说在这样一个人为的基准中是什么导致了如此微小的差异。但我猜这是一个结盟问题。如果从堆中进行分配，就会得到一块适合存储任何类型的内存。如果你从堆栈中分配内存，你得到的内存块只是最低限度地对齐，适合你存储的类型。

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

但是差别很小，可以是任何东西

相关文章：