Überladen von Löschen und Abrufen der Größe?

Question

Ich schreibe derzeit einen kleinen benutzerdefinierten Speicher Allocator in C++, und möchte es zusammen mit Operator-Überladung von new / delete . Wie auch immer, mein Speicher Allocator im Grunde prüft, ob der angeforderte Speicher über einen bestimmten Schwellenwert ist, und wenn ja verwendet malloc, um den angeforderten Speicher-Chunk zuzuweisen. Andernfalls wird der Speicher von einem fixedPool Allokatoren. Das funktioniert im Allgemeinen, aber für meine Deallokationsfunktion sieht das so aus:

void MemoryManager::deallocate(void * _ptr, size_t _size){
    if(_size > heapThreshold)
        deallocHeap(_ptr);
    else 
        deallocFixedPool(_ptr, _size);
}

Ich muss also die Größe des Chunks angeben, auf den verwiesen wird, um die Zuordnung an der richtigen Stelle aufzuheben.

Das Problem ist nun, dass das Schlüsselwort delete keinen Hinweis auf die Größe des gelöschten Chunks gibt, also bräuchte ich so etwas wie das hier:

void operator delete(void * _ptr, size_t _size){ 
    MemoryManager::deallocate(_ptr, _size); 
}

Aber soweit ich sehen kann, gibt es keine Möglichkeit, die Größe innerhalb des Löschoperators zu bestimmen - wenn ich die Dinge so belassen möchte, wie sie jetzt sind, müsste ich dann die Größe der Speicherchunks selbst speichern?

Answer 1

Mehr Speicher als nötig zuweisen und die Größeninformationen dort speichern. Das macht Ihr Systemallokator wahrscheinlich schon. Etwa so (der Einfachheit halber mit malloc demonstrieren):

void *allocate(size_t size) {
    size_t *p = malloc(size + sizeof(size_t));
    p[0] = size;           // store the size in the first few bytes
    return (void*)(&p[1]); // return the memory just after the size we stored
}

void deallocate(void *ptr) {
    size_t *p = (size_t*)ptr; // make the pointer the right type
    size_t size = p[-1];      // get the data we stored at the beginning of this block

    // do what you need with size here...

    void *p2 = (void*)(&p[-1]); // get a pointer to the memory we originally really allocated
    free(p2);                   // free it
}

Answer 2

Sie könnten eine Zuordnung von Speicheradresse zu Größe für den vom Pool zugewiesenen Speicher aufbewahren. Wenn Sie löschen, prüfen Sie, ob der Zeiger in der Karte ist, wenn ja, löschen Sie diese Größe, wenn nicht, rufen Sie reguläres Löschen auf.

Answer 3

Für Klassentypen unterstützt C++ dies bereits direkt. Für Nicht-Klassentypen müssen Sie die Größe manuell speichern, wie die andere Lösung zeigt.

struct MyClass {
  void operator delete(void *p, size_t size) {
    MemoryManager::deallocate(p, size);
  }
};

Answer 4

Ab C++14 unterstützt der Standard die zweite size Parameter in der globalen löschen Zuweisungsfunktion. Das, was Sie tun wollen, ist jetzt nativ möglich.

http://en.cppreference.com/w/cpp/memory/new/operator_delete