Ansi-C: Memory Pool

[Jan (Gast)]

Hallo ich benötige für ein Embedded System eine Memory Pool 
Funktionalität.
Wie kann ich sowas in Ansi-C realisieren? Ich benötige da insgesamt vier 
Funktionen: MemCreatePool, MemAlloc, MemRelease, MemFree

Für jede Unterstützung sag ich schonmal vielen Dank.

[P. S. (Gast)]

Entschuldige, aber das ist nicht sonderlich schwer, reine Fleissarbeit - 
was willst du denn damit programmieren, wenn du das nicht an einem Tag 
hinbekommst?

[Karl H. (kbuchegg)]

Meinst du tatsächlich einen Pool oder einen allgemeinen Memory 
Allocator?
Ein Pool verwaltet gleichartige Datenstrukturen. Ein Allocator ist im 
Prinzip auch ein Pool, allerdings arbeitet er auf Byteebene und die 
Schwierigkeit besteht darin, dass der Allocator mit beliebig großen 
Anforderungen klar kommen muss. Daher muss man auf dieser Ebene ein 
wenig anders arbeiten.
Aber ein Pool kann im einfachsten Fall einfach nur ein Array von 
vorrätigen Datenstrukturen sein, die vom Pool verwaltet werden. Und das 
ist nun wirklich nicht so schwer. Alle Vorrätigen mit einer Freelist 
verketten. Bei einer Anforderung wird die erste aus der Freelist 
genommen. Bei der Rückgabe kommt er wieder in die Freelist hinein. 
Fertig.

[Jan (Gast)]

Ich möchte es gerne selber umsetzen. Mir fehlt da der richtige Ansatz.
Ich möchte einen festen Speicherbereich mit einer festen Größe vorgeben.
Das mit dem Pool ist mir nicht klar wie ich sowas in Ansi_C umsetzen 
muss.
Muss ich da den Speicherbereich nicht permannent vor anderen Zugriffen 
schützen (CriticalSection)?

[Karl H. (kbuchegg)]

Jan schrieb:
> Ich möchte es gerne selber umsetzen. Mir fehlt da der richtige Ansatz.
> Ich möchte einen festen Speicherbereich mit einer festen Größe vorgeben.
> Das mit dem Pool ist mir nicht klar wie ich sowas in Ansi_C umsetzen
> muss.

'Muss' ist in dem Fall sowieso das falsche Wort. 'Kann' trifft es viel 
besser.
Denn genauso wie es unzählige Möglichkeiten gibt, wie ein Hotelier seine 
Zimmer verwaltet und bei Anforderung ausgibt, genauso gibt es viele 
Möglichkeiten einen Pool zu bauen.

> Muss ich da den Speicherbereich nicht permannent vor anderen Zugriffen
> schützen (CriticalSection)?

Du denkst jetzt über Details nach, die völlig uninteressant sind. 
Zumindest im Moment.

Postuliere eine struct, die du in einen Pool stecken willst. Dieser 
struct verpasst do noch einen zusätzlichen Zeiger, den nennst du "next". 
Seine Aufgabe ist es, die einzelnen Einträge im Array zu verketten, also 
eine Liste innerhalb des Arrays aufzubauen.
Im Init verkettest du alle Arrayeinträge zu einer einzigen Liste und 
nennst diese die 'Freelist'. Natürlich gibt es da noch einen Zeiger auf 
den Anfang der Liste in einer static Variablen, nennen wir sie 
pFreeList.

Kommt eine Anforderung, schaust du in pFreeList nach. Ist der Zeiger 
nicht NULL, dann hat dein Pool einen Eintrag vorrätig. Du lieferst ihn 
und setzt gleichzeitig den pFreeList auf den Nachfolger des Eintrags 
(dazu brauchst du den next Pointer in der struct).

Wird eine struct zurückgegeben, so wird der next Zeiger dorthin gesetzt 
wo der pFreeList zur Zeit hinzeigt und pFreeList wird auf die 
zurückgegebene struct gesetzt.

Und das wars dann schon: Du hast einen Memory Pool gebaut, der viele 
struct in einem vorallokierten Array verwalten kann.


Wenn ich jetzt noch mehr ins Detail gehe, dann schreib ich dir praktisch 
schon deine Pool Verwaltung.

[Jan (Gast)]

Auf dieser Internetseite: 
http://openbook.galileocomputing.de/c_von_a_bis_z/021_c_dyn_datenstrukturen_003.htm#mj99a62629378300e719376434889e7c56, 
ist eine gute Erklärung wie man sowas machen könnte.

[P. S. (Gast)]

Karl heinz Buchegger schrieb:

> Ein Pool verwaltet gleichartige Datenstrukturen.

Ein Pool kann auch Speicherstuecke verschiedener Groesse verwalten. 
Generische Memory-Pools waren frueher gar nicht so unueblich um gegen 
Speicherlecks anzukaempfen.

[Jan (Gast)]

Beim Memory-Pool wird also das LIFO (siehe Link) Prinzip angewendet.

[Karl H. (kbuchegg)]

Jan schrieb:
> Beim Memory-Pool wird also das LIFO (siehe Link) Prinzip angewendet.

So hab ich das noch gar nie betrachtet.
Aber ja, man kann das so auffassen.
Am Stack liegen alle benutzbaren Datensätze. Wird einer gebraucht, so 
wird er vom Stack gepopt; wird der Datensatz vom Programm zurückgegeben, 
so wird er auf den Stack gepusht.