我在分配 float 组时对 malloc 与 new 进行了基准测试。我的理解是 malloc 执行的操作是 new 执行的操作的子集—— malloc 只是分配，但 new 分配和构造，尽管我不确定这对于原语是否有意义。

使用 gcc 的基准测试结果给出了预期的行为。 malloc() 更快。甚至有一些问题与这个问题相反。

使用 icc malloc 可以比 new 慢 7 倍。怎么可能？!

接下来的一切只是基准测试过程的细节。

对于基准测试，我使用了最近描述的协议(protocol) by Intel .这是我的结果。

使用 GNU 的 gcc 分配 4000 个 float 的数组时经过的时钟周期:

new memory allocation, cycles            12168
malloc allocation, cycles                 5144

还有英特尔的 icc:

new    memory allocation clock cycles     7251
malloc memory allocation clock cycles    52372

我是如何使用 malloc 的:

volatile float* numbers = (float*)malloc(sizeof(float)*size);

我是如何使用新的:

volatile float* numbers = new float[size];

volatile 之所以存在，是因为在之前的基准测试尝试中，我遇到了狡猾的编译器优化掉整个函数调用并生成只存储常量的程序的问题。 (编译器选择以这种方式优化的函数实现确实比没有优化的更快!)我尝试删除 volatile 以确保结果是相同的。

我将要进行基准测试的代码部分夹在两个宏之间。

出现在函数之前的宏:

#define CYCLE_COUNT_START \
asm volatile ("CPUID\n\t" \
"RDTSC\n\t" \
"mov %%edx, %0\n\t" \
"mov %%eax, %1\n\t": "=r" (cycles_high), "=r" (cycles_low):: \
"%rax", "%rbx", "%rcx", "%rdx");

函数后面的宏:

#define CYCLE_COUNT_END \
asm volatile("RDTSCP\n\t" \
"mov %%edx, %0\n\t" \
"mov %%eax, %1\n\t" \
"CPUID\n\t": "=r" (cycles_high1), "=r" (cycles_low1):: \
"%rax", "%rbx", "%rcx", "%rdx"); \
start = ( ((uint64_t)cycles_high << 32) | cycles_low ); \
end = ( ((uint64_t)cycles_high1 << 32) | cycles_low1 ); \
ellapsed_cycles = end - start;

因此，带有夹在 new 中的宏的分配调用是这样的:

CYCLE_COUNT_START
volatile float* numbers = new float[size];
CYCLE_COUNT_END

之后，我检查了 ellapsed_cycles 的值，看看一切进展如何。

为了确保我没有做傻事，下面是我使用 icc 编译的方式:

icc -O3 -ipo -no-prec-div -std=c++11 heap_version3.cpp           -o heap_version3
icc -O3 -ipo -no-prec-div -std=c++11 malloc_heap_version3.cpp    -o malloc_heap_version3

使用 gcc:

g++-4.8 -Ofast -march=native -std=c++11 heap_version3.cpp        -o heap_version3
g++-4.8 -Ofast -march=native -std=c++11 malloc_heap_version3.cpp -o malloc_heap_version3

这是在 2012 款 MacBook Pro 上，带有 corei7-avx 指令。我将 'as' 二进制文件与匹配 here 的脚本交换以便 gcc 可以使用 AVX 指令。

编辑 1

要回答那些希望看到更多循环迭代的人，请浏览英特尔链接，然后发布。另一方面，我可能会有同样的 react ，所以这里是那些循环迭代。

数组大小仍然是 4000，并且程序的每次运行仍然会分配一次内存。我不想通过分配一个不适合 L1 的更大数组或重复分配和释放内存以及提出其他有关内存的问题来更改基准测试的内容。该程序由 bash 循环运行。我为基准测试运行了 4 个单独的程序，每个循环迭代中都有 4 个程序，以努力减少由于其他运行进程造成的异质性。

for i in $(seq 1 10000); do
    echo gcc malloc $(./gcc_malloc_heap_version3 | head -n 1 | cut -d" " -f 4-)
    echo icc malloc $(./icc_malloc_heap_version3 | head -n 1 | cut -d" " -f 4-)
    echo gcc new $(./gcc_heap_version3 | head -n 1 | cut -d" " -f 4-)
    echo icc new $(./icc_heap_version3 | head -n 1 | cut -d" " -f 4-)
done

icc 内存分配时序:

       malloc       new
Min.   : 3093      1150
1st Qu.: 3729      1367
Median : 3891      1496
Mean   : 4015      1571
3rd Qu.: 4099      1636
Max.   :33231    183377

    Welch Two Sample t-test
    p-value < 2.2e-16

观察到的差异不太可能是偶然发生的。

编译器和分配方法的密度估计:

现在差异不那么明显了，但 icc 的顺序仍然与预期相反。

编辑 2

char 数组的结果几乎相同。因为 sizeof(int) 给我 4 而 sizeof(char) 给我 1 我将数组长度增加到 16,000。

编辑 3

source code and scripts

编辑 4

相同的数据重新绘制为前 100 个分配的时间过程。

最佳答案

它不是那样工作的。处理器和操作系统很复杂。您不能只用几微秒的时间调用一个电话就期望获得有意义的计时信息。对于初学者，另一个应用程序可能会使用您的 CPU 一段时间，RDTSC 将继续计数。

关于c++ - 为什么英特尔的 icc 的 malloc 比 new 慢 7 倍？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/22684123/