Ich hatte mir das mit der Speicherbereinigung mal wie folgt vorgestellt.
Der Speicher ist in Chunks aufgeteilt. Die MMU kann über denn
Typ oder einen
length Parameter ermitteln wie lang jeder Chunk ist.
Nun gibt es eine Reihe von Register die alle Adressen im Speicher enthalten.
Register | Beschreibung |
pFree | Anfang des freien Bereichs |
pCurrent | Anfang aktueller Chunk |
pNext | Anfang nächster Chunk |
Typ | Typ aktueller Chunk |
Size | Länge aktueller Chunk |
pRead | Leseadresse |
pWrite | Schreibadresse |
Am Anfang stehen alle Register auf Null
Nun wird wie folgt vorgegangen
- wenn pCurrent==pNext:
- wenn pCurrent>=pFree:
- pFree auf pWrite setzen
- pCurrent auf 0 setzen
- pNext auf 0 setzen
- pRead auf 0 setzen
- pWrite auf 0 setzen
- zum Anfang zurück
- wenn pCurrent<pFree:
- Typ von Chunk an pCurrent ermitteln und in Typ speichern
- Länge von Chunk an pCurrent ermitteln und in Size speichern
- pNext um Size erhöhen
- wenn pRead==pWrite oder Typ==Frei:
- pCurrent auf pNext setzen
- pRead auf pNext setzen
- pWrite um Size erhöhen
- zum Anfang zurück
- wenn pCurrent!=pNext:
- Aus Speicheran Postion pRead und in pWrite schreiben
- pRead um 1 erhöhen
- pWrite um 1 erhöhen
- wenn pRead==pNext:
- pCurrent auf pNext setzen
- zum Anfang zurück
Wenn ich jetzt Daten aus dem Speicher brauche muss ich denn Chunk ermitteln prüfen ob der Chunk pCurrent ist wenn ja muss ich die Adresse falls sie unter pRead liegt die Differenz zwischen pRead und pWrite verringeren.
Die Daten Chunks können über einen RADIX-Tree gefunden werden.
Der Die Zeiger im Tree müssen natürlich aktualisiert werden wenn ein Chunk bewegt wird.
Das zu implementieren wird nicht so leicht ;(