;BMBMemPoollibrary v1.2 von J.Oertli and Q/BMB
;=============================================


ACHTUNG! Dises Library benötigt Kickstart 3.0 oder höher
ACHTUNG! Die Kickstart version wird nur getestet, wenn
ACHTUNG! die Option runtime Errors aktiviert ist!!!

NEWTYPE.mempool
  memorypool.l          ;Pointer auf mempool sonst NULL.
  requirements.l        ;MemoryType des Pools.
END NEWTYPE


FUNKTION: CreatePool
--------------------------------------------------------------------
SYNTAX: n.l=CreatePool (#MemPool,Requirements,PuddleSize,ThreshSize)
MODUS:  AMIGA

Diese Funktion erzeugt ein neues MemoryPool. Konnte kein MemPool
erzeugt werden, so gibt diese Funktion False zurück, ansonsten True.
Ist schon ein Pool mit der selben Objektnummer eingerichtet, so wird dieser
freigegeben.


  #MemPool      =Objektnummer
  Requirements.l=Speichertyp zulässige Werte sind:

                                #MEMF_ANY       =$00000 ;Egal
                                #MEMF_PUBLIC    =$00001 ;PublicRam
                                #MEMF_CHIP      =$00002 ;ChipRam
                                #MEMF_FAST      =$00004 ;Fasram
                                #MEMF_CLEAR     =$10000 ;vorher löschen
                                #MEMF_LARGEST   =$20000 ;größter Bereich


                 Will man nun zum Bleistift Fastram, welches vorher gelöscht
                 werden soll, so kann man als Parameter $10000|$4 oder 
                 einfacher $10004 übergeben werden.
  PuddleSize.l  =MemoryPools verwalten den Speicher in Elementen, die ihre
                 größe dynamisch anpassen. der Wert PuddleSize, stellt die
                 maximale Grösse eines Elements dar. Wird mit AllocPooled
                 mehr Speicher reserviert, als in einem Element platzt hat,
                 so wird einfach ein neues Element angefühgt.
                 So ist es möglich, das viele verschiedene Speicherbereiche in 
                 ein und dem selben Element zusammen gefasst werden.
  ThreshSize.l  =Dieser wert stellt ein maximal Wert dar, wird mit AllocPolled
                 ein Speicherbereich reserviert, welcher grösser ist als 
                 ThreshSize, so wir nicht erst versucht, den Block in dem 
                 aktuellen Element unterzubringen, sondern es wird gleich ein
                 neues Element mit einer festen grösse erzeugt. 

Durch dieses System, wird die Speicherfragmentierung auf einem Minimum
gehalten! Deshalb, sollte immer wenn Kickstart 3.0 zu verfühgung steht,
über ein MemoryPool speicher reserviert werden!!! Natürlich wird wenn das
Programm beendet wird alle MemoryPool, gelöscht.

ACHTUNG! Wird ein MemoryPool mit Free MemPool gelöscht, so wird auch aller
ACHTUNG! Speicher der über dieses MemoryPool reserviert wurde freigegeben.
ACHTUNG! Deshalb sollte man darauf achten, dass nach Free MemPool auf kein
ACHTUNG! Speicherblok mehr zugegriffen wurd, welcher über dieses MemPool
ACHTUNG! reserviert wurde!!! Ansonsten ->GURU.

FUNKTION: AllocPooled
--------------------------------------------------------------------
SYNTAX: n.l=AllocPooled (#MemPool,Bytesize)
MODUS:  AMIGA

Diese Funktion reserviert speicher über ein MemoryPool.
Konnte Speicher reserviert werden, so gibt diese Funktion die Adresse
zurück, oder NULL wenn kein Speicher reserviert werden konnt.

  #MemPool      =Objektnummer es ist darauf zu achten, das auch wirchlich
                 ein MemoryPool erstell worden ist. Der Speicher bereich
                 ist vom selben Speichertyp, wie das MemoryPool.
  Bytesize.l    =Grösse des Speicerbereichs der reserviert werden soll.

BEFEHL: FreePooled
--------------------------------------------------------------------
SYNTAX: FreePooled #MemPool,Memoryblock
MODUS:  AMIGA

Diese Befehl, gibt ein Speicherblock, welcher mit AllocPooled reserviert
wurde, wieder frei. Es muss umbeding darauf geachtet werden, das der
Speicherbereich vom selben MemoryPool freigegen wird, wie von dem er auch
reserviert wurde.

  #MemPool      =Objektnummer das MemoryPools
  Memoryblock   =Adresse das Speicher bereiches.

FUNKTION: PooledSize
--------------------------------------------------------------------
SYNTAX: n.l=PooledSize (Memoryblock)
MODUS:  AMIGA/BLITZ

Diese funktion gibt die Größe eines mit AllocPooled reservierten Speicher-
bereiches zurück. Die Größe kann auch mit n.l=Peek.l (Memoryblock-4) aus-
gelesen werden!


        ;Speicher reservieren mit der BMBMemPoolLib
        ;

        DEFTYPE.l MEM

        If ExecVersion>=39                    ;Immer Kickstartversion testen!
          If CreatePool(1,$10001,51200,51200) ;MemoryPool erzeugen....
            MEM=AllocPooled (1,1024)          ;Speicher anfordern (1024 Bytes)
            If MEM  ;Immer testen, ob auch Speicher frei war...
;             .
;             .
;             .
              FreePooled 1,1024   ;Und Speicher wieder freigeben...
            End If
            Free MemPool (1)  ;MemoryPool löschen...
          End If
        End If
        End