Unterscheidet sich die dynamische Speicherzuordnung in gängigen Implementierungen in C und C++?

Was die jeweiligen Sprachstandards betrifft, bietet C dynamische Speicherallokation nur über die an malloc() Familie, während in C++ die häufigste Form der Zuordnung von durchgeführt wird ::operator new(). Der malloc im C-Stil ist auch in C++ verfügbar, und viele Beispiele für “Babys erste Zuweisung” verwenden ihn als Kernzuweisungsfunktion, aber ich bin gespannt, wie zeitgenössische Compiler die eigentliche Produktion von operator-new implementieren.

Ist es nur eine dünne Hülle herum malloc()oder ist es aufgrund des etwas anderen Speicherallokationsverhaltens eines typischen C++-Programms im Vergleich zu einem typischen C-Programm grundlegend anders implementiert?

[Edit: I believe the main difference is usually described as follows: A C program has fewer, larger, long-lived allocations, while a C++ program has many, small, short-lived allocations. Feel free to chime in if that’s mistaken, but it sounds like one would benefit from taking this into account.]

Für einen Compiler wie GCC wäre es einfach, nur eine einzige Kernzuweisungsimplementierung zu haben und diese für alle relevanten Sprachen zu verwenden, daher frage ich mich, ob es Unterschiede in den Details gibt, die versuchen, die resultierende Zuweisungsleistung in jeder Sprache zu optimieren.

Aktualisieren: Danke für all die tollen Antworten! Es sieht so aus, als ob dies in GCC vollständig gelöst ist ptmallocund die MSVC auch verwendet malloc im Kern. Weiß jemand, wie das MSVC-malloc implementiert wird?

Hier ist die Implementierung, die von verwendet wird g++ 4.6.1:

_GLIBCXX_WEAK_DEFINITION void *
operator new (std::size_t sz) throw (std::bad_alloc)
{
  void *p;

  /* malloc (0) is unpredictable; avoid it.  */
  if (sz == 0)
    sz = 1;
  p = (void *) malloc (sz);
  while (p == 0)
    {
      new_handler handler = __new_handler;
      if (! handler)
#ifdef __EXCEPTIONS
        throw bad_alloc();
#else
        std::abort();
#endif
      handler ();
      p = (void *) malloc (sz);
    }

  return p;
}

Das findet sich in libstdc++-v3/libsupc++/new_op.cc innerhalb der g++ Quelldistribution.

Wie Sie sehen können, ist es eine ziemlich dünne Hülle malloc.

bearbeiten Auf vielen Systemen ist es möglich, das Verhalten von zu optimieren mallocin der Regel per Anruf mallopt oder Umgebungsvariablen setzen. Hier ist eine Artikel Erörterung einiger Funktionen, die unter Linux verfügbar sind.

Laut Wikipedia, glibc Die Versionen 2.3+ verwenden eine modifizierte Version des aufgerufenen Zuordners ptmallocdie selbst eine Ableitung von ist dlmalloc entworfen von DougLea. Interessanterweise in einem Artikel über dlmalloc Doug Lea gibt die folgende Perspektive (Hervorhebung von mir):

Ich habe die erste Version des Zuordners geschrieben, nachdem ich einige C++-Programme geschrieben hatte, die sich fast ausschließlich auf die Zuweisung von dynamischem Speicher stützten. Ich stellte fest, dass sie viel langsamer und/oder mit viel mehr Gesamtspeicherverbrauch liefen, als ich erwartet hatte. Dies lag an Eigenschaften der Speicherzuweisungen auf den Systemen, auf denen ich lief (hauptsächlich die damals aktuellen Versionen von SunOs und BSD). Um dem entgegenzuwirken, habe ich zunächst eine Reihe von Allokatoren für spezielle Zwecke in C++ geschrieben, normalerweise durch Überladen von operator new für verschiedene Klassen. Einige davon werden in einem Artikel über C++-Zuweisungstechniken beschrieben, der in den C++-Berichtsartikel von 1989 Einige Speicherzuweisungstechniken für Containerklassen übernommen wurde.

Ich erkannte jedoch bald, dass das Erstellen eines speziellen Allokators für jede neue Klasse, die dazu neigte, dynamisch zugewiesen und stark genutzt zu werden, keine gute Strategie war, wenn ich eine Art Allzweck-Programmierungsunterstützungsklassen erstellte, die ich damals schrieb. (Von 1986 bis 1991 war ich der Hauptautor von libg++ , der GNU-C++-Bibliothek.) Eine umfassendere Lösung wurde benötigt – um zu schreiben eine Zuweisung, die unter normalen C++- und C-Lasten gut genug war so dass Programmierer nicht in Versuchung geraten, Zuweisungen für spezielle Zwecke zu schreiben, außer unter ganz besonderen Bedingungen.

Dieser Artikel enthält eine Beschreibung einiger der wichtigsten Entwurfsziele, Algorithmen und Implementierungsüberlegungen für diese Zuweisung.

In den meisten Implementierungen operator new() ruft nur an malloc(). Tatsächlich schlägt sogar The Standard dies als Standardstrategie vor. Natürlich können Sie Ihre eigenen implementieren operator newnormalerweise für eine Klasse, wenn Sie eine bessere Leistung wünschen, aber der Standardwert ist normalerweise nur ein Anruf malloc().

glibc new operator ist ein dünner Wrapper um malloc. Und glibc malloc verwendet unterschiedliche Strategien für unterschiedliche Größenzuordnungsanforderungen. Sie können die Implementierung oder zumindest die Kommentare sehen hier.

Hier ein Auszug aus den Kommentaren in malloc.c:

/*
47   This is not the fastest, most space-conserving, most portable, or
48   most tunable malloc ever written. However it is among the fastest
49   while also being among the most space-conserving, portable and tunable.
50   Consistent balance across these factors results in a good general-purpose
51   allocator for malloc-intensive programs.
52 
53   The main properties of the algorithms are:
54   * For large (>= 512 bytes) requests, it is a pure best-fit allocator,
55     with ties normally decided via FIFO (i.e. least recently used).
56   * For small (<= 64 bytes by default) requests, it is a caching
57     allocator, that maintains pools of quickly recycled chunks.
58   * In between, and for combinations of large and small requests, it does
59     the best it can trying to meet both goals at once.
60   * For very large requests (>= 128KB by default), it relies on system
61     memory mapping facilities, if supported.
*/

Wenn Sie in Visual C++ in a new Ausdruck führt mich zu diesem Snippet in new.cpp:

#include <cstdlib>
#include <new>

_C_LIB_DECL
int __cdecl _callnewh(size_t size) _THROW1(_STD bad_alloc);
_END_C_LIB_DECL

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
        {       // try to allocate size bytes
        void *p;
        while ((p = malloc(size)) == 0)
                if (_callnewh(size) == 0)
                {       // report no memory
                static const std::bad_alloc nomem;
                _RAISE(nomem);
                }

        return (p);
        }

Also VC++ new wickelt auch die malloc() Anruf.

Es geht nicht um die Leistung:
pA = new A hat eine andere Nebenwirkung als pA = (A*)malloc(sizeof(A));

Im zweiten wird der Konstruktor von A nicht aufgerufen. Um zu demselben Effekt zu kommen, sollten Sie dies tun

pA = (A*)malloc(sizeof(A));
new(pA)A();

wo neu ist die “platzierung neu”…

void* operator new(size_t sz, void* place) 
{ return place; }