Question

这是一个经验假设（分配比解除分配更快）。

这也是一个的原因，我想，为什么基于堆的存储（如 STL 容器或其他）选择不将当前未使用的内存返回给系统（这就是缩小适合成语出生的原因。

当然，我们不应该混淆＆＃39; 堆＆＃39;具有＆＃39; 堆类似数据结构的内存。

所以为什么取消分配较慢？

Windows - 特定（我在 Win 8.1 上看到它）或 OS 是独立的吗？

是否有一些C ++特定的内存管理器自动参与使用＆＃39; new ＆＃39; /＆＃39; 删除＆＃39;或整个记忆。管理完全依赖于操作系统？（我知道 C ++ 11 引入了一些垃圾收集支持，我从未真正使用过，更好地依赖于旧的堆栈和静态持续时间或自我管理的容器和 RAII ）。

另外，在 FOLLY string 的代码中，我看到使用旧的C堆分配/解除分配，它比C ++＆＃39; new ＆＃39;更快。 /＆＃39; 删除＆＃39;？

P上。 S。请注意，关于虚拟内存机制的问题不，我知道用户空间程序没有＆＃39;使用真实存储器。 addresation。

Answer 1

我不确定你的观察。我编写了以下程序（在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的调用可以忽略不计（我不知道是否是）w.r.t. malloc＆amp; free时间，我倾向于不同意你的观察。 free似乎是malloc的两倍。我的gcc是6.1，我的libc是Glibc 2.22。

请花些时间在您的系统上编译上述基准并报告时间。

FWIW，我拿了Jerry's code和

 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

Answer 2

分配内存比释放内存更快的断言对我来说似乎有点奇怪，所以我测试了它。我运行了一个测试，我在32字节块中分配了64MB内存（所以2M调用new），我尝试按照分配的顺序删除该内存，并以随机顺序删除。我发现线性顺序释放比分配大约3％，并且随机释放比线性分配大约10％更慢。

然后我运行了一个测试，我开始使用64MB的已分配内存，然后2M次分配新内存或删除现有内存（随机）。在这里，我发现释放比分配慢约4.3％。

所以，事实证明你是正确的 - 释放比分配慢（虽然我不会称之为＃34;很多＆＃34;慢）。我怀疑这只是与更多的随机访问有关，但除了线性重新分配更快之外，我没有其他证据。

回答你的一些问题：

是否有一些C ++特定的内存管理器自动参与使用＆＃39; new＆＃39; /＆＃39;删除＆＃39;？

是。操作系统具有系统调用，可为进程分配内存页（通常为4KB块）。这是一个过程＆＃39;将这些页面划分为对象的工作。尝试查找＆＃34; GNU内存分配器。＆＃34;

我看到使用旧的C堆分配/解除分配，它比C ++＆＃39; new＆＃39;更快。 /＆＃39;删除＆＃39;？

大多数C ++ new / delete实现只需调用malloc和free。但是，标准并不要求这样做，因此总是在任何特定对象上使用相同的分配和释放功能是一个好主意。

我使用Visual Studio 2015中提供的本机测试框架在Windows 10 64位计算机上运行测试（测试也是64位）。这是代码：

#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];
                }
            }
        }
    };
}

以下是几次运行的原始结果。所有数字都以毫秒为单位。

Answer 3

我和@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

我警告说，分配和释放是由标准库（主要）处理的，因此在一个标准库和另一个标准库之间可能会有所不同（即使使用相同的编译器）。我还要注意，如果在多线程代码中有所改变，我不会感到惊讶。虽然它实际上并不正确，但似乎有一些作者误以为在多线程环境中释放需要锁定堆以进行独占访问。这是可以避免的，但这样做的方法并不一定是显而易见的。

Answer 4

当您分配小内存块时，您指定的块大小直接映射到该大小的子分配器，通常表示为＆＃34; slab＆＃34;内存包含相同大小的记录，以避免内存碎片。这可以非常快，类似于阵列访问。但释放这些块并不是那么简单，因为你传递一个指向未知大小的内存的指针，需要额外的工作来确定它所属的slab，然后才能将块返回到正确的位置。

当您分配大块虚拟内存时，会在您的进程空间中设置内存页面范围，而不会将任何物理内存实际映射到它，这需要很少的工作才能完成。但释放这么大的块可能需要更多的工作，因为释放的指针必须首先匹配该范围的页表，然后遍历它跨越的所有页面条目，并释放所有物理由中间页面错误分配给该范围的内存页面。

当然，具体细节取决于所使用的实现，但原理基本保持不变：已知块大小的内存分配比释放指向未知大小的内存块的指针需要更少的工作量。我对此的了解直接来自我开发高性能商业级RAII内存分配器的经验。

我还应该指出，由于每个堆分配都有匹配和相应的释放，这对操作代表一个分配周期，即作为一个硬币的两面。它们的执行时间可以一起准确地测量，但是单独这样的测量很难确定，因为它根据块大小，相似大小的先前活动，高速缓存和其他操作考虑而变化很大。但最终，分配/免费差异可能并不重要，因为你不能做另一个。

Answer 5

这里的问题是堆碎片。使用显式指针算法用语言编写的程序没有实际的堆碎片整理方法。

如果您的堆碎片化，则无法将内存返回给操作系统。禁止虚拟内存的操作系统取决于brk(2) - 类似机制 - 即您为所有要引用的内存地址设置上限。但是，当您在现有边界附近分配了一个缓冲区并仍在使用时，您无法明确地将内存返回给OS。如果程序中99％的内存都被释放，那不重要。

交易不必比分配慢。但是，使用堆分段进行手动释放的事实会使分配变得更慢，更复杂。

GCs通过压缩堆来对抗这种情况。这样，分配只是递增它们的指针，并且大量对象不需要重新分配。

为什么解除分配堆内存要比分配它慢得多？

5 个答案: