为什么释放堆内存比分配内存慢得多？

2018-06-10 23:48:45

这是一个经验假设（即分配速度快于解除分配）。

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

当然，我们不应该混淆'堆'内存和'堆'数据结构。

那么为什么解除分配速度较慢 ？

它是特定于Windows（我在Win 8.1上看到它）还是独立于操作系统？

是否有一些C ++特定的内存管理器会自动使用'new'/'delete'或整个mem。管理完全依赖于操作系统？（我知道C ++ 11引入了一些垃圾收集支持，我从来没有用过，更好的依靠旧的堆栈和静态持续时间或自我管理的容器和RAII）。

另外，在我看到使用旧C堆分配/释放的FOLLY字符串的代码中，C ++'new'/'delete'会更快吗？

PS请注意，这个问题不是关于虚拟内存机制，我了解用户空间程序不使用真正的内存。 addresation。

我和@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 << " uSn";
    std::cout << std::left << std::setw(20) << "del time: " << del_time << " uSn";
}

我也在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

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

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

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

所以，事实证明你是正确的 - 释放速度比分配速度慢（尽管我不会称之为“太慢”）。我怀疑这只是为了更随机的访问，但除此之外，我没有证据表明线性重新分配更快。

回答你的一些问题：

是否有一些C ++特定的内存管理器自动使用'new'/'delete'？

是。操作系统有系统调用，为进程分配内存页（通常为4KB块）。把这些页面分成对象是流程的工作。尝试查找“GNU内存分配器”。

我看到使用旧的C堆分配/释放，它比C ++'new'/'delete'更快吗？

大多数C ++ new / delete实现只是调用malloc并且在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];
                }
            }
        }
    };
}

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

我不确定你的观察。我编写了以下程序（在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) %sn",
           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=%dn", nbchunks);
  void **chks = malloc_chunks (nbchunks);
  clock_t clomall = clock ();
  printf ("clomall=%ld totalsize=%lld wordsn",
      (long) clomall, totalsize);
  free_chunks (chks, nbchunks);
  clock_t clofree = clock ();
  printf ("clofree=%ldn", (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是微不足道的（我不知道这是否是）WRT malloc和free的时候，我倾向于你的意见不同意。 free似乎是malloc两倍。我的gcc是6.1，我的libc是Glibc 2.22。

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

FWIW，我拿了杰里的代码和

 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

链接地址: http://www.djcxy.com/p/31611.html

上一篇: Why deallocating heap memory is much slower than allocating it?

下一篇: Can allocating memory from a private heap cause a deadlock?