这是一种经验性的假设（分配比释放更快）。
这也是我猜测堆存储（如STL容器或其他存储）选择不将当前未使用的内存返回给系统的原因之一（这就是为什么“shrink-to-fit”习语诞生的原因）。
当然，我们不应混淆“堆”内存和类似“堆”的数据结构。
那么“为什么释放比分配慢”？
它是特定于Windows（我在Win 8.1上看到它）还是与操作系统无关的？
在使用“new”/“delete”时是否有某些C++特定的内存管理器自动参与，还是整个内存管理完全依赖于操作系统？（我知道C++11引入了一些垃圾收集支持，但我从来没有真正使用过，更好地依靠旧的堆栈和静态持续时间或自管理的容器和RAII）。
此外，在“FOLLY string”的代码中，我看到使用旧的C堆分配/释放，它比C++的“new”/“delete”更快吗？
P.S.请注意，问题不涉及虚拟内存机制，我理解用户空间程序不使用实际的内存寻址。
new），并尝试按照分配顺序和随机顺序删除该内存。我发现线性顺序释放比分配要快大约3％，而随机顺序释放比线性顺序分配要慢约10％。new/delete实现只是在幕后调用malloc和free。虽然这不是标准所要求的，但在任何特定对象上始终使用相同的分配和释放函数是一个好主意。#include "stdafx.h"
#include "CppUnitTest.h"
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
namespace AllocationSpeedTest
{
class Obj32 {
uint64_t a;
uint64_t b;
uint64_t c;
uint64_t d;
};
constexpr int len = 1024 * 1024 * 2;
Obj32* ptrs[len];
TEST_CLASS(UnitTest1)
{
public:
TEST_METHOD(Linear32Alloc)
{
for (int i = 0; i < len; ++i) {
ptrs[i] = new Obj32();
}
}
TEST_METHOD(Linear32AllocDealloc)
{
for (int i = 0; i < len; ++i) {
ptrs[i] = new Obj32();
}
for (int i = 0; i < len; ++i) {
delete ptrs[i];
}
}
TEST_METHOD(Random32AllocShuffle)
{
for (int i = 0; i < len; ++i) {
ptrs[i] = new Obj32();
}
srand(0);
for (int i = 0; i < len; ++i) {
int pos = (rand() % (len - i)) + i;
Obj32* temp = ptrs[i];
ptrs[i] = ptrs[pos];
ptrs[pos] = temp;
}
}
TEST_METHOD(Random32AllocShuffleDealloc)
{
for (int i = 0; i < len; ++i) {
ptrs[i] = new Obj32();
}
srand(0);
for (int i = 0; i < len; ++i) {
int pos = (rand() % (len - i)) + i;
Obj32* temp = ptrs[i];
ptrs[i] = ptrs[pos];
ptrs[pos] = temp;
}
for (int i = 0; i < len; ++i) {
delete ptrs[i];
}
}
TEST_METHOD(Mixed32Both)
{
for (int i = 0; i < len; ++i) {
ptrs[i] = new Obj32();
}
srand(0);
for (int i = 0; i < len; ++i) {
if (rand() % 2) {
ptrs[i] = new Obj32();
}
else {
delete ptrs[i];
}
}
}
TEST_METHOD(Mixed32Alloc)
{
for (int i = 0; i < len; ++i) {
ptrs[i] = new Obj32();
}
srand(0);
for (int i = 0; i < len; ++i) {
if (rand() % 2) {
ptrs[i] = new Obj32();
}
else {
//delete ptrs[i];
}
}
}
TEST_METHOD(Mixed32Dealloc)
{
for (int i = 0; i < len; ++i) {
ptrs[i] = new Obj32();
}
srand(0);
for (int i = 0; i < len; ++i) {
if (rand() % 2) {
//ptrs[i] = new Obj32();
}
else {
delete ptrs[i];
}
}
}
TEST_METHOD(Mixed32Neither)
{
for (int i = 0; i < len; ++i) {
ptrs[i] = new Obj32();
}
srand(0);
for (int i = 0; i < len; ++i) {
if (rand() % 2) {
//ptrs[i] = new Obj32();
}
else {
//delete ptrs[i];
}
}
}
};
}
以下是多次运行的原始结果，所有数字以毫秒为单位。
我不确定你的观察是否正确。我写了以下程序（在Linux上，希望你能将其移植到你的系统上）。
// public domain code
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <errno.h>
#include <string.h>
#include <assert.h>
const unsigned possible_word_sizes[] = {
1, 2, 3, 4, 5,
8, 12, 16, 24,
32, 48, 64, 128,
256, 384, 2048
};
long long totalsize;
// return a calloc-ed array of nbchunks malloced zones of
// somehow random size
void **
malloc_chunks (int nbchunks)
{
const int nbsizes =
(int) (sizeof (possible_word_sizes)
/ sizeof (possible_word_sizes[0]));
void **ad = calloc (nbchunks, sizeof (void *));
if (!ad)
{
perror ("calloc chunks");
exit (EXIT_FAILURE);
};
for (int ix = 0; ix < nbchunks; ix++)
{
unsigned sizindex = random () % nbsizes;
unsigned size = possible_word_sizes[sizindex];
void *zon = malloc (size * sizeof (void *));
if (!zon)
{
fprintf (stderr,
"malloc#%d (%d words) failed (total %lld) %s\n",
ix, size, totalsize, strerror (errno));
exit (EXIT_FAILURE);
}
((int *) zon)[0] = ix;
totalsize += size;
ad[ix] = zon;
}
return ad;
}
void
free_chunks (void **chks, int nbchunks)
{
// first, free the two thirds of chunks in random order
for (int i = 0; 3 * i < 2 * nbchunks; i++)
{
int pix = random () % nbchunks;
if (chks[pix])
{
free (chks[pix]);
chks[pix] = NULL;
}
}
// then, free the rest in reverse order
for (int i = nbchunks - 1; i >= 0; i--)
if (chks[i])
{
free (chks[i]);
chks[i] = NULL;
}
}
int
main (int argc, char **argv)
{
assert (sizeof (int) <= sizeof (void *));
int nbchunks = (argc > 1) ? atoi (argv[1]) : 32768;
if (nbchunks < 128)
nbchunks = 128;
srandom (time (NULL));
printf ("nbchunks=%d\n", nbchunks);
void **chks = malloc_chunks (nbchunks);
clock_t clomall = clock ();
printf ("clomall=%ld totalsize=%lld words\n",
(long) clomall, totalsize);
free_chunks (chks, nbchunks);
clock_t clofree = clock ();
printf ("clofree=%ld\n", (long) clofree);
return 0;
}
我在我的Debian/Sid/x86-64 (i3770k, 16Gb)上使用gcc -O2 -Wall mf.c -o mf进行编译。我运行time ./mf 100000，并获得以下结果：
nbchunks=100000
clomall=54162 totalsize=19115681 words
clofree=83895
./mf 100000 0.02s user 0.06s system 95% cpu 0.089 total
clock 返回 CPU 微秒。如果对 random 的调用可以忽略不计（我不确定是否可以），相对于 malloc 和 free 的时间，我倾向于不同意你的观察结果。 free 似乎比 malloc 快两倍。我的 gcc 版本是 6.1，我的 libc 版本是 Glibc 2.22。
请花些时间在您的系统上编译上述基准测试，并报告时间。
顺便说一句，我使用了Jerry的代码
g++ -O3 -march=native jerry.cc -o jerry
time ./jerry; time ./jerry; time ./jerry
提供
alloc time: 1940516
del time: 602203
./jerry 0.00s user 0.01s system 68% cpu 0.016 total
alloc time: 1893057
del time: 558399
./jerry 0.00s user 0.01s system 68% cpu 0.014 total
alloc time: 1818884
del time: 527618
./jerry 0.00s user 0.01s system 70% cpu 0.014 total
我和 @Basile 的想法差不多：我想知道你的基本假设是否真的（甚至接近）正确。因为你的问题标记了 C++，所以我写了一个快速的 C++ 基准测试。
#include <vector>
#include <iostream>
#include <numeric>
#include <chrono>
#include <iomanip>
#include <locale>
int main() {
std::cout.imbue(std::locale(""));
using namespace std::chrono;
using factor = microseconds;
auto const size = 2000;
std::vector<int *> allocs(size);
auto start = high_resolution_clock::now();
for (int i = 0; i < size; i++)
allocs[i] = new int[size];
auto stop = high_resolution_clock::now();
auto alloc_time = duration_cast<factor>(stop - start).count();
start = high_resolution_clock::now();
for (int i = 0; i < size; i++)
delete[] allocs[i];
stop = high_resolution_clock::now();
auto del_time = duration_cast<factor>(stop - start).count();
std::cout << std::left << std::setw(20) << "alloc time: " << alloc_time << " uS\n";
std::cout << std::left << std::setw(20) << "del time: " << del_time << " uS\n";
}
我也在Windows上使用了VC++而不是Linux上的gcc。结果并没有太大的区别：释放内存所需的时间比分配内存所需的时间要少得多。以下是连续三次运行的结果。
alloc time: 2,381 uS
del time: 1,429 uS
alloc time: 2,764 uS
del time: 1,592 uS
alloc time: 2,492 uS
del time: 1,442 uS
然而，需要注意的是，分配和释放主要由标准库处理，因此在使用相同编译器时，不同的标准库可能会有所不同。我还想指出，在多线程代码中，这种情况可能会有所改变。虽然这并不完全正确，但似乎有一些作者误认为在多线程环境中释放内存需要锁定堆以获得独占访问权。虽然可以避免这种情况，但如何做到并不一定立即显而易见。
high_resolution_clock的实现非常糟糕。如果你真的关心这个编译器的结果，你可能需要重写测试，使用另一个计时器（例如GetPerformanceCounter）来代替。 - Jerry Coffin/O2b2 /GL作为编译器选项。我尝试了各种其他选项，但没有找到任何能够产生像你引用的结果的选项。我很难相信这会有太大的区别 - 我们计时的大部分是标准库中的代码，所以唯一重要的是链接哪个库。 - Jerry Coffinmmap()иҖҢдёҚжҳҜbrk()пјҢиҝҷж ·жӣҙеҘҪең°и§ЈеҶідәҶзўҺзүҮй—®йўҳгҖӮ - gudokmmap()会有所帮助。 - alamar
syscall()进行调用。所有在库中声明的分配/释放函数，例如C++的new/delete或C++的malloc，都可以扩展系统调用或直接调用它。这取决于操作系统的性能，因为您无法在其根本上重写分配的内核实现。 - Pierre Emmanuel Lallemantmalloc和new）和释放（free和delete）不是系统调用（在Linux上，列在syscalls(2)中...）。C运行时（例如malloc）有时可能会调用mmap或sbrk，但不总是（它尝试重用先前的free区域）。请参阅这里。 - Basile Starynkevitchmalloc分配许多随机大小的区域，并以某种随机顺序释放它们吗？ - Basile Starynkevitch