Nun, nachfolgend möchte ich die Speicherzuteilung etwas vertiefen,

am Beispiel eines Halbenspeichers, der nach First Fit verwaltet wird. Also wir

haben eine Platzierungsstrategie bezogen auf den Halbenspeicher, auf die Halde.

Und die Sortierungsstrategie sozusagen, das Sortierkriterium entspricht dem First Fit

Verfahren mit einer gewissen Ähnlichkeit zu dem Next Fit, wie wir den gleich noch ein bisschen

erläutern werden. Nun, was wir hier brauchen ist zumindest erst mal eine Beschreibung einer Zelle,

die praktisch freien Speicher in der Halde denn letztendlich markieren würde. Und da sehen wir

dann halt hier so einen Datentyp, den man dafür verwenden kann. Das ist recht einfach gehalten.

Hier wir sagen einfach wie groß ist die Zelle und dann, wenn die Zelle sozusagen im Sinne von

freien Speicher eben auf der Freispeicherliste steht, dann haben wir halt noch einen Verkettungszeiger dazu.

Das wäre denn dieser Next, den wir haben. Wir hätten dann eine globale Variable List, die zeigt zum

Anfang dieser Freispeicherliste und dann die beiden zentralen Operation Acquire, um praktisch freien

Speicher, freien Halbenspeicher zu bekommen und Release um dann entsprechend nicht mehr benötigter

Speicher an die Halde dann letztendlich zurückzugeben. Also auf die Halde abzulegen, wenn man so will.

Nun freien Speicher erwerben ist an sich recht einfach. Hier ist die Acquire-Operation mal also

beispielhaft skizziert. Als Parameter sagen wir wie viel Bytes sozusagen wir haben wollen, da die

Halde der Freispeicher Vielfaches der Granularität Zelle. Denn halt müssen wir sozusagen aus der

Byte Anzahl, die wir als Parameter in eingeben, erstmal die Anzahl der Zellen berechnen, die dazu

passen würden. Also im Real Fall ist es denn so eine Operation, die man hier macht, wie in der

Zeile 12 dargestellt. Need würde dann also die Anzahl der Zellen der einer Halde denn repräsentieren,

die man praktisch anfordern würde, die man gerne belegen möchte. So und dann geht man ab Zeile 15

hier durch diese Freispeicherliste durch und schaut sich Element für Element an, ob da einfach ein

Element ist, was einfach wenigstens so groß ist, wie dieser Need Wert hier repräsentiert. Solange

die Zellen kleiner sind, gehen wir einfach weiter. Was schlimmstenfalls passieren kann, wir kommen

ans Ende halt an, dann würden wir aus der Wahlschleife hier oben rausgehen und mit Return 0

dann zurückkehren und damit einfach anzeigen wollen, dass wir keinen freien Speicher gefunden

haben. Nun in dem ELSPART gehen wir rein, wenn wir tatsächlich eine Zelle haben, die mindestens so

groß ist, wie die angeforderte Zellengröße. Jetzt prüfen wir nach, ob das ein genauer Match ist,

also ob sozusagen die gefunden Zelle etwas größer ist, als das was wir benötigen. Das ist

genau dann diese Fallunterscheidung hier in der Zelle 19, die das überprüft und in dem

entsprechenden Then Part dazu extrahieren wir dann praktisch den freien Bereich, den wir die

Adresse, die Anfangsadresse des freien Bereichs aus dieser gefundenen Zelle und der Trick ist

halt hier der, dass man praktisch, um jetzt Listenmanipulationen hier nicht durchführen

zu müssen, praktisch in der gefundenen Zelle, die ja größer ist als der Speicherbereich,

den man halt angefordert hat, dass man an den hinteren Anteil halt rangeht und praktisch den

freien Speicher innerhalb einer Zelle von hinten nach vorne vergibt. Das ist letztendlich die

Operation, die wir halt hier in den Zeilen 20 bis 22 finden, um dann praktisch eine Zellenmanipulation

zu machen, also die Größe der gefundenen Zelle de facto denn zu verändern. Wir wissen, da bleibt

ein Rest übrig, deshalb bleibt die Zelle auch in der Freispeicherliste halt drin, aber wir geben

dann als Anfangsadresse den hinteren Anteil in dieser Zelle zurück, damit eben dort auch wirklich

für die Anwendung, die den Acquireden aufgerufen hat, halt ein gültiger Pointerwert letztendlich

zustande kommt. Wenn wir feststellen, dass die Zelle exakt so groß ist wie die angeforderten,

wie die Speicheranforderungen, ja dann nehmen wir das Element tatsächlich aus der Liste halt raus

und das wäre dann die Operation, die wir in 24 und 25 richten machen würden. Nur Nextfit ist an sich

kaum unterschiedlich. Das Einzige, was wir hier bei Nextfit denn machen würden, ist eben, dass man

sich die Stelle vermerkt, an der man zuletzt fündig geworden ist mit einem Element. Das heißt, wir

würden halt einen weiteren Zeiger einführen, einen Last Zeiger. Neben dem Anfangszeiger der Liste

hätten wir dann einen Last Zeiger, der dann letztendlich genau in diesen Listeneintrag vermerkt.

Das wäre hier der Link-Eintrag, mit dem man hier gerade operiert, wo man festgestellt hat, das ist

die Stelle, wo wir zuletzt fündig geworden sind. Entweder war das ein genau exakt passendes Element