Malloc () und Free () implementieren - teilen große Stücke auf

Der vorherige Artikel untersuchte die Auswirkungen der Wiederverwendung der Speicherblock -Wiederverwendung auf den Speicherverbrauch und optimierte Funktionen zur Reduzierung von Abfällen. Ein weiteres ernsthafteres Problem bleibt jedoch bestehen: Ein riesiger Speicherblock kann mehrere kleine Raumblöcke einnehmen, die ausgenutzt werden können. Weisen Sie beispielsweise einen großen Teil des Gedächtnisses aus und geben Sie nach der Veröffentlichung zwei kleinere Stücke aus:

 <code class="c">void *ptr1 = abmalloc(128); void *ptr2 = abmalloc(8); abfree(ptr1); void *ptr3 = abmalloc(8); void *ptr4 = abmalloc(8);</code>

Zu diesem Zeitpunkt kann der 128-Byte-freie Block nicht von der 8-Byte-Anforderung verwendet werden, was zu der nachfolgenden 8-Byte-Blockzuweisung führt, bei der der Haufen erneut erweitert werden muss, was zu einer geringen Speicherauslastung führt.

Eine hocheffiziente, aber komplexe Möglichkeit, dieses Problem zu lösen, besteht darin, "Mülleimer" zu verwenden: eine Liste von Stücken, die nach Größe gruppiert sind. Eine weitere einfachere Lösung besteht darin, die großen Stücke in kleinere Stücke zu teilen. Dieser Artikel übernimmt letztere.

Code Refactoring

Um den Code geringfügig zu refaktor. header_new() ist verantwortlich für die Zuordnung von Speicher und die Initialisierung von Blockheadern, was der Lesbarkeit und Wartung des Codes nicht förderlich ist. Wir teilen es in zwei Funktionen auf:

• header_plug() : Fügen Sie den initialisierten Block zwischen den vorherigen und nächsten Blöcken ein.
• header_init() : Initialisieren Sie die Metadaten (Größe und Verfügbarkeit) des Blocks.

Sie sind wie folgt:

 <code class="c">void header_init(header *header, size_t size, bool available) { header->size = size; header->available = available; } void header_plug(header *header, header *previous, header *next) { header->previous = previous; if (previous != NULL) { previous->next = header; } header->next = next; if (next != NULL) { next->previous = header; } }</code>

header_new() wird wie folgt geändert:

 <code class="c">header *header_new(header *previous, size_t size, bool available) { header *header = sbrk(sizeof(header) size); header_init(header, size, available); header_plug(header, previous, NULL); return header; }</code>

( last->previous->next = last; In abmalloc() kann diese Zeile gelöscht werden, da header_plug() jetzt für die Behandlung dieser Logik verantwortlich ist.)

Speicherblöcke geteilt

Implementieren Sie als nächstes header_split() . Wenn der ursprüngliche Block groß genug ist, teilen Sie ihn in zwei Teile auf:

• Blöcke der erforderlichen Größe;
• Der Rest und seine neuen Blöcke;

Überprüfen Sie zunächst, ob der Block groß genug ist:

 <code class="c">header *header_split(header *header, size_t size) { size_t original_size = header->size; if (original_size >= size sizeof(header)) {</code>

Wenn groß genug, teilen Sie den Block auf. Reduzieren Sie zunächst die Größe des aktuellen Blocks:

 header->size = original_size - size - sizeof(header);

Berechnen Sie den Zeiger auf den neuen Block:

 header *new_header = (header 1) header->size; // Corrected pointer calculation

Initialisieren Sie den Header eines neuen Blocks:

 header_init(new_header, size, true);

Schließen Sie den neuen Block mit der verknüpften Liste an:

 header_plug(new_header, header, header->next);

Wenn der ursprüngliche Block der letzte Block ist, aktualisieren Sie last Zeiger:

 if (header == last) { last = new_header; }

Kehren Sie zum neuen Block zurück:

 return new_header; } else { return header; } }

ABMALLOC () aktualisieren

Ändern Sie schließlich die Funktion abmalloc() und aufrufen, um den verfügbaren Block zu finden, rufen Sie header_split() auf, um zu versuchen, ihn zu teilen:

 <code class="c">if (header->available && (header->size >= size)) { header = header_split(header, size); header->available = false; return (void*)(header 1); // Cast to void* for correct return type }</code>

Wenn der Block geteilt werden kann, wird der neue Block zurückgegeben. Andernfalls wird der ursprüngliche Block zurückgegeben.

Hinweise zur Blocksegmentierung

Es ist zu beachten, dass der neue Block am Ende des ursprünglichen Blocks erstellt wird. Obwohl es am Anfang auch erstellt werden kann, kann das Erstellen eines neuen Blocks am Ende den neuen freien Block näher an den alten Block bringen, wodurch die Effizienz des nächsten abmalloc() -Anrufs verbessert wird.

Die Aufteilung großer Speicherbrocken ist ein Schritt zur Verbesserung der Speicherverwaltung, kann jedoch auch zu kleinen Stücken der Speicherfragmentierung führen, was zu größeren Anforderungen führt, die eine Ausdehnung des Haufens erfordern. Im nächsten Artikel wird untersucht, wie dieses Problem gelöst werden kann.

Das obige ist der detaillierte Inhalt vonMalloc () und Free () implementieren - teilen große Stücke auf. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!