Ein einfacher Bump-Allocator
Vergeben Sie Speicher linear.
Ein einfacher Bump-Allocator ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.
Die Idee des Bump-Allocators
Ein Bump-Allocator (auch Arena-Allocator genannt) ist das einfachste Design. Sie verwalten einen großen Puffer und einen einzigen Offset. Jede Speicheranforderung gibt einfach den aktuellen Offset zurück und verschiebt ihn anschließend um die angeforderte Größe nach vorn.
Es gibt keine Metadaten pro Block und keine Suche. Eine Speicheranforderung besteht im Wesentlichen aus einer einzigen Zeigeraddition und ist daher äußerst schnell.
Ein statischer Hintergrundpuffer
Für ein eigenständiges Beispiel hinterlegen wir den Allocator in einem statischen Array statt im Heap des Betriebssystems. Das Programm lässt sich überall kompilieren und ausführen, ganz ohne sbrk oder mmap.
Das Array stellt einen festen Byte-Pool bereit, den wir aufteilen können.
#define POOL_SIZE 1024
static unsigned char pool[POOL_SIZE];
static size_t offset = 0;Die zentrale bump-Funktion
Die Speicheranforderung prüft, ob noch genügend Platz vorhanden ist, speichert den Start, erhöht den Offset und gibt den Startzeiger zurück. Würde die Anfrage den Pool überlaufen lassen, gibt die Funktion NULL zurück.
Diese Überlaufprüfung ist die einzige Sicherheitsmaßnahme des Bump-Allocators.
void *bump_alloc(size_t size) {
if (offset + size > POOL_SIZE)
return NULL; /* out of pool */
void *p = &pool[offset];
offset += size;
return p;
}Ein vollständiger ausführbarer Bump-Allocator
Hier ist ein vollständiges Programm. Es reserviert zwei Ganzzahlen und eine kurze Zeichenkette aus dem Pool und gibt sie aus, um zu beweisen, dass der Allocator funktioniert.
Beachten Sie, wie wenig Code dafür im Vergleich zu einem echten malloc erforderlich ist.
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#define POOL_SIZE 1024
static unsigned char pool[POOL_SIZE];
static size_t offset = 0;
void *bump_alloc(size_t size) {
if (offset + size > POOL_SIZE) return NULL;
void *p = &pool[offset];
offset += size;
return p;
}
int main(void) {
int *a = bump_alloc(sizeof(int));
int *b = bump_alloc(sizeof(int));
char *s = bump_alloc(6);
*a = 10; *b = 32;
strcpy(s, "hi");
printf("%d %d %s\n", *a, *b, s);
printf("used = %zu\n", offset);
return 0;
}Kein einzelnes Freigeben
Der Nachteil: Ein Bump-Allocator kann keine einzelne Speicheranforderung freigeben. Da es keine Metadaten gibt, weiß er nicht, wo ein Block endet und der nächste beginnt, um den Speicher wiederzuverwenden.
Sie können die gesamte Arena nur auf einmal zurücksetzen, indem Sie den Offset wieder auf null setzen.
void bump_reset(void) {
offset = 0; /* frees everything at once */
}Warum das Zurücksetzen nützlich ist
Dieses Alles-oder-nichts-Modell eignet sich perfekt für phasenbasierte Aufgaben: Reservieren Sie während einer Anfrage oder eines Frames viele Objekte und setzen Sie die Arena zurück, wenn die Phase endet.
Game Engines und Compiler verwenden Arenas intensiv, weil das Zurücksetzen O(1) benötigt und die Verwaltung tausender einzelner Freigaben vermeidet.
/* Per-frame pattern */
for (int frame = 0; frame < 3; frame++) {
void *tmp = bump_alloc(128);
/* ... use tmp this frame ... */
bump_reset(); /* reclaim instantly */
}Verbleibenden Speicherplatz verfolgen
Es ist praktisch, anzuzeigen, wie viel Platz noch verfügbar ist. Dieser ergibt sich einfach aus der Poolgröße minus dem aktuellen Offset.
Aufrufer können damit entscheiden, ob sie den Inhalt leeren oder den Pool vergrößern müssen, bevor sie weiteren Speicher anfordern.
size_t bump_remaining(void) {
return POOL_SIZE - offset;
}Ein ausführbares Reset-Beispiel
Dieses Programm füllt einen Teil des Pools, gibt die Nutzung aus, setzt ihn zurück und zeigt, dass der Offset auf null zurückkehrt und der Speicher somit wiederverwendbar ist.
#include <stdio.h>
#include <stddef.h>
#define POOL_SIZE 256
static unsigned char pool[POOL_SIZE];
static size_t offset = 0;
void *bump_alloc(size_t s){ if(offset+s>POOL_SIZE) return NULL; void *p=&pool[offset]; offset+=s; return p; }
void bump_reset(void){ offset = 0; }
int main(void) {
bump_alloc(100);
printf("after alloc: used=%zu\n", offset);
bump_reset();
printf("after reset: used=%zu\n", offset);
return 0;
}Ausrichtung in einem Bump Allocator
Byteweises Verschieben kann Zeiger zurückgeben, die nicht korrekt ausgerichtet sind. Um sicherzugehen, runden Sie den Offset vor der Rückgabe eines Zeigers auf eine Ausrichtungsgrenze auf.
Die Berechnung behandeln wir später ausführlich. Beim Bump Allocator ist die Ausrichtung jedoch besonders wichtig, weil es sonst keine Padding-Bytes gibt.
static size_t align_up(size_t n, size_t a) {
return (n + a - 1) & ~(a - 1); /* a must be power of 2 */
}Ein ausgerichteter Bump Allocator
Indem wir die einzelnen Bestandteile kombinieren, richten wir den Offset vor jeder Allokation aus. Dadurch ist jeder zurückgegebene Zeiger für jeden gängigen Typ geeignet.
Der Preis dafür ist eine geringfügige interne Fragmentierung durch die Padding-Bytes.
#define ALIGN 16
void *bump_aligned(size_t size) {
offset = align_up(offset, ALIGN);
if (offset + size > POOL_SIZE) return NULL;
void *p = &pool[offset];
offset += size;
return p;
}Stärken und Grenzen
Bump Allocators sind unschlagbar schnell und trivial einfach, da sie keinen Overhead pro Objekt verursachen. Sie sind ideal, wenn Objekte dieselbe Lebensdauer haben.
Ihre Schwäche ist, dass sich einzelne Objekte nicht gezielt freigeben lassen. Bei unterschiedlichen Lebensdauern benötigen Sie das im nächsten Abschnitt behandelte Free-List-Design.
Kurze Überprüfung
Überlegen Sie, wie ein Bump Allocator Speicher zurückgewinnt.
Zusammenfassung
Ein Bump Allocator gibt Speicher aus, indem er einen Offset in einem Puffer weiterbewegt. Dadurch ist eine Allokation so günstig wie eine Zeigeraddition.
Für Geschwindigkeit und Einfachheit verzichtet er auf die individuelle Freigabe und gewinnt Speicher nur durch einen vollständigen Reset zurück. Richten Sie den Offset aus, damit die zurückgegebenen Zeiger für alle Typen gültig sind.
Häufig gestellte Fragen
Ist die Lektion „Ein einfacher Bump-Allocator“ kostenlos?
Ja — der vollständige Text von „Ein einfacher Bump-Allocator“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Ein einfacher Bump-Allocator“?
Vergeben Sie Speicher linear. Du übst C Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um C Academy zu starten?
Keine Vorkenntnisse erforderlich. C Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Ein einfacher Bump-Allocator“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser C Academy-Lektion Code schreiben und ausführen?
Ja. Jede C Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Wie malloc funktioniert
- Ein einfacher Bump-Allocator
- Freilisten und Wiederverwendung
- Ausrichtung und Aufteilung