Eine Einführung in die Programmiersprache C und ... - C /C++ Ecke

Eine Einführung in die Informatik und die Programmiersprache C
26.1 Selbstgeschriebene Speicherverwaltung
Gelegentlich ist es Erforderlich, aus Effizienzgründen selbst eine Speicherverwaltung zu schreiben.
Diese kann dabei auf Geschwindigkeit oder Speicherausnutzung optimiert werden.
Die standardmässige Speicherverwaltung führt meistens eine Liste der freien Speicherblöcke, und
sucht sich bei der Anforderung von Speicher einen Block passender Grösse, oder zerteilt einen grösseren
Block falls kein passender Block vorhanden ist. Bei der Freigabe wird ensprechend versucht,
den Block mit einem benachbarten freien Block in der Liste zusammenzufassen, sonst wird er in die
Liste der freien Blöcke aufgenommen. Um die Verwaltung zu vereinfachen werden dabei die
Blockgrössen auf ein vielfaches einer Basisblockgrösse aufgerundet, dadurch ergibt sich ein Mittelweg
zwischen Geschwindigkeit und effizienter Speicherausnutzung.
Wenn man eine sehr schnelle Speicherverwaltung benötigt, geht das am einfachsten mit einem Array,
dabei muss man aber die Einschränkung einer fixen Blockgrösse in Kauf nehmen.
static char MyMemory[50][128] = {0}; /* 50 Blöcke a 128 Bytes */
void *FastMalloc(void) /* Keine Grössenangabe, da fixe Blockgrösse */
{
int i;
for (i = 0; i < 50; i++) { /* Freien Block suchen */
if (MyMemory[i][0] == 0) {
MyMemory[i][0] = 1; /* Block als Belegt markieren */
return &(MyMemory[i][0]); /* Zeiger auf reservierten Block */
/* zurueckliefern */
}
}
return NULL; /* keinen freien Speicher gefunden */
}
void FastFree(void *Mem)
{
*((char *)(Mem)) = 0; /* Block als Frei markieren */
}
Bei dieser Version gilt die Einschränkung, das im ersten Byte des Speicherblocks nie der Wert 0
abgelegt werden darf, weil sonst der Block als Frei angesehen wird. In vielen Anwendungen ist das
kein Problem, und sonst muss einfach ein Zeiger auf das zweite Byte des Blocks zurückgegeben
werden, dann hat der Anwender keinen Zugriff auf das Flag-Byte am Anfang:
/* Aenderung in FastMalloc: */
return &(MyMemory[i][1]); /* Zeiger auf Zweites Byte zurueck */
/* Aenderung in FastFree: */
*(((char *)(Mem))-1) = 0; /* Block als Frei markieren */
Wenn man mehrere Blockgrössen benötigt, kann man einfach für jede Blockgrösse ein eigenes Array
benutzen, und die grösse der Arrays dem zu erwartenden Speicherbedarf anpassen. Speicheranforderungen
des Anwenders werden jeweils auf die nächstgrösste Blockgrösse aufgerundet, und der
Block aus dem entsprechenden Array angefordert.
Bei grossen Arrays kann anstelle eines Flagbytes eine Indexliste aufgebaut werden. In jedem freien
Block ist im vordersten Byte/Wort der Index des naechsten freien Blocks eingetragen, so wird eine
Liste der freien Blocks aufgebaut welche schnelleres finden eines freien Blocks erlaubt. Die Speicherverwaltung
muss sich den Index des ersten freien Blocks merken (Head der Liste).
Freigegebene Blöcke werden zuvorderst in die Liste eingehängt, und angeforderte Blöcke werden
wiederum vom Listenanfang genommen (Somit ist nur ein 'Head-Pointer' notwendig).
Gedruckt am 11.09.2008 13:04:00 Letzte Änderung am: 11. September 2008 Version 2.4, I. Oesch 101/147