HomeGEMDOSProzessfunktionenNetzwerkfunktionen

5.12 Speicherverwaltung

Maddalt Alternativen Speicher anmelden.
Malloc  Speicher reservieren bzw. freien Speicher erfragen.
Mfree   Speicherbereich freigeben.
Mshrink Speicherbereich verkleinern/vergrößern.
Mxalloc Speicherbereich reservieren.

Achtung: An dieser Stelle sei darauf hingewiesen, daß im Hinblick auf zukünftige Betriebssystem-Versionen zur Kommunikation zwischen verschiedenen Programmen benutzte oder über Zeiger zugewiesene Speicherbereiche global sein müssen (Mxalloc-Funktion mit Global-Flag). Andernfalls wird es beim Einsatz auf Rechnern mit PMMU (z.B. Atari-TT oder Falcon) zu Speicherschutzverletzungen kommen.

Querverweis: Programmstart und TPA   Prozessfunktionen   Speicherverwaltung in TOS   Speicherverwaltung in MagiC

5.12.1 Maddalt

Name: »Inform Gemdos of alternative memory« - Alternativen Speicher anmelden.
Gemdosnummer: 20
Deklaration: int32_t Maddalt ( void *start, int32_t size );
Beschreibung: Die GEMDOS-Routine Maddalt erlaubt es, einen Block von Alternate-RAM in die Speicherliste des GEMDOS aufzunehmen. Es gilt:
Parameter Bedeutung
   
start Anfangsadresse des Speichers
size Länge des Speicherbereichs


Hinweis: Der Block bleibt Eigentum von DOS und darf nicht zurückgefordert werden. Wenn hinzugefügte Blöcke nicht hintereinander liegen, ist die Anzahl der hinzufügbaren Blöcke auf ca. 12 beschränkt.

Nützlich könnte diese Funktion etwa beim Einsatz von VME-Bus-Karten im Atari-TT sein, wenn deren Speicher für GEMDOS zugänglich gemacht werden soll.
Ergebnis: Die Funktion liefert den Wert 0, oder eine negative Fehlermeldung.
Verfügbar: Die Funktion ist erst ab GEMDOS 0.19 verfügbar.
Gruppe: Speicherverwaltung
Querverweis: Binding   Mfree   Malloc   Mxalloc

5.12.1.1 Bindings für Maddalt

C: int32_t Maddalt ( void *start, int32_t size );
Assembler:
move.l    size,-(sp)   ; Offset 6
pea       start        ; Offset 2
move.w    #20,-(sp)    ; Offset 0
trap      #1           ; GEMDOS aufrufen
lea       $A(sp),sp    ; Stack korrigieren

5.12.2 Malloc

Name: »memory allocation« - Speicherplatz reservieren.
Gemdosnummer: 72
Deklaration: void *Malloc ( int32_t number );
Beschreibung: Die GEMDOS-Routine Malloc reserviert Speicherplatz, oder berechnet die Größe des verfügbaren Speichers. Für den Parameter number gilt:
Wert Bedeutung
   
-1 Länge des größten verfügbaren Blocks ermitteln
sonst Anzahl der zu reservierenden Bytes


Hinweis: Man darf sich nie darauf verlassen, daß tatsächlich so viele Bytes wie gewünscht alloziert wurden. Konstruktionen der Art Malloc(Malloc(-1L)) sind besonders in Multitasking-Systemen schlicht indiskutabel (Stichwort: Task-Wechsel).

Unter TOS untersützt das GEMDOS nur eine begrenzte Anzahl von Speicherblöcke. Aus diesem Grund sollte man die Funktion nicht zu häüfig innerhalb eines Programms nutzen, sondern größere Speicherblöcke (mindestens 16KBytes) reservieren und selbst verwalten.

Ferner sollte man folgende Punkte beachten:
  • der Speicherblock muß nicht leer sein

  • nacheinander allozierte Speicherblöcke müssen nicht zwingend zusammenhängen

  • niemals auf Speicherbereiche zugreifen, der nicht dem eigenen Prozess gehört. In Systemen mit Speicherschutz kommt es sonst zu einer Exception.



In MagiC wird dieser Aufruf auf Mxalloc mit den Modi 0 bzw. 3 zurückgeführt (abhängig von den Konfigurationsbits im Programmdatei-Header). Die Konfigurationsbits werden z.Zt. in der Basepage abgelegt.
Ergebnis: Die Funktion liefert als Ergebnis die Anfangsadresse des reservierten Bereichs. Ein Nullzeiger bedeutet, daß nicht mehr genügend Speicher zur Verfügung steht. Im Fall number = -1 wird die Länge des größten verfügbaren Speicherblocks zurückgegeben.
Verfügbar: Alle GEMDOS Versionen. GEMDOS Versionen kleiner 0.15 liefern für den Aufruf Malloc( 0L ) einen Zeiger auf ungültigen Speicher statt daß der Aufruf fehlschlägt wie er sollte.
Gruppe: Speicherverwaltung
Querverweis: Bindings für Malloc   Mfree   Mxalloc   Maddalt   Programmflags

5.12.2.1 Bindings für Malloc

C: void *Malloc ( int32_t number );
Assembler:
move.l    number,-(sp) ; Offset 2
move.w    #72,-(sp)    ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #6,sp        ; Stack korrigieren

5.12.3 Mfree

Name: »memory free« - Speicherplatz freigeben.
Gemdosnummer: 73
Deklaration: int32_t Mfree ( void *block );
Beschreibung: Die GEMDOS-Routine Mfree gibt einen mit Malloc reservierten Speicherbereich wieder frei.

Der Parameter block enthält die Anfangsadresse des freizugebenden Speicherbereichs.

Hinweis: In fast allen GEMDOS-Versionen wird nicht überprüft, ob der freizugebende Block dem betreffenden Prozess auch gehört. Daher ist vor allem in Multitasking-Systemen besondere Vorsicht angebracht.
Ergebnis: Die Funktion liefert folgende Resultate:
Wert Bedeutung
   
E_OK kein Fehler aufgetreten
EIMBA falsche Speicherblockadresse
Verfügbar: Alle GEMDOS Versionen.
Gruppe: Speicherverwaltung
Querverweis: Binding   Malloc   Mxalloc   Maddalt

5.12.3.1 Bindings für Mfree

C: int32_t Mfree ( void *block );
Assembler:
pea       block        ; Offset 2
move.w    #73,-(sp)    ; Offset 0
trap      #1           ; GEMDOS aufrufen
addq.l    #6,sp        ; Stack korrigieren

5.12.4 Mshrink

Name: »memory shrink« - Speicherbereich verkürzen oder vergrößern.
Gemdosnummer: 74
Deklaration: int32_t Mshrink ( void *block, int32_t newsiz );
Beschreibung: Die GEMDOS-Routine Mshrink verkürzt oder vergrößert einen bereits reservierten Speicherbereich. Es gilt:
Parameter Bedeutung
   
block Anfangsadresse des Speicherblocks
newsiz neue (geänderte) Länge des Blocks; in MagiC zusätzlich:
-1 = ermitteln der größtmöglichen Größe des Speicherblocks
 0 = Block freigeben


Hinweis: Es wird i.d.R. nicht überprüft, ob der Speicherblock dem Aufrufer überhaupt gehört. Die Möglichkeit einen Speicherblock zu vergrößern, steht z.Zt. nur in MagiC zur Verfügung. Allerdings funktioniert dies nur, wenn über dem betreffenden Block ein genügend großer freier Block vorhanden ist, und die TOS-Kompatibilität deaktiviert wurde.
Ergebnis: Die Funktion liefert folgende Resultate:
E_OK : kein Fehler aufgetreten
EIMBA : falsche Blockadresse
EGSBF : Block würde vergrößert
Verfügbar: Alle GEMDOS Versionen.
Gruppe: Speicherverwaltung
Querverweis: Binding   Malloc   Mfree

5.12.4.1 Bindings für Mshrink

C: int32_t Mshrink ( void *block, int32_t newsiz );
Assembler:
move.l    newsiz,-(sp)  ; Offset 8
pea       block         ; Offset 4
move.w    #0,-(sp)      ; Offset 2
move.w    #74,-(sp)     ; Offset 0
trap      #1            ; GEMDOS aufrufen
lea       $C(sp),sp     ; Stack korrigieren


Hinweis: Der Null-Parameter wird beim C-Binding normalerweise automatisch hinzugefügt.

5.12.5 Mxalloc

Name: »Allocate memory (with preference)« - Speicherplatz reservieren.
Gemdosnummer: 68
Deklaration: void *Mxalloc ( int32_t amount, int16_t mode );
Beschreibung: Die GEMDOS-Routine Mxalloc reserviert einen Speicherbereich der Größe amount. Über die Bits des Parameters mode kann die gewünschte Speicherart spezifiziert werden; es gilt:
Bits Bedeutung
   
0-2 Behandlung des TT-RAMs
0 = nur ST-RAM
1 = nur TT-RAM
2 = egal, ST-RAM bevorzugt
3 = egal, TT-RAM bevorzugt
3 reserviert
4-7 Speicherschutz-Modus
0 = Abhängig von den Programmflags
1 = Privat
2 = Global
3 = Super
4 = nur lesbar

Alle anderen Werte sind undefiniert, und für zukünftige Zwecke reserviert.
14 No-Free-Modus
Wenn dieses Bit gesetzt ist und der Besitzer dieses Speichers terminiert, wird der Speicherbereich nicht freigegeben, sondern an das Betriebssystem vererbt. Dieser Modus ist nur für das Betriebssystem interessant, und steht normalen Anwenderprogrammen nicht zur Verfügung.


Alle weiteren Bits sind für zukünftige Zwecke reserviert. Mit dem Wert -1 für amount kann man die Länge des größten zusammenhängend verfügbaren Speicherblocks (abhängig von mode) erfragen.

Unter MagiC werden alle Speicherallozierungen mitprotokolliert. Wenn die mit LIMITMEM vorgegebene Beschränkung überschritten wird, wird ein Nullzeiger zurückgegeben. Im Fall amount = -1 wird das Minimum von freiem Speicher und noch nicht ausgeschöpfter LIMITMEM-Beschränkung zurückgegeben. Ausnahmen sind Aufrufe des Bildschirm-Managers (SCRENMGR), der die Menüs kontrolliert. Dadurch wird sichergestellt, daß auch per LIMITMEM beschränkte Programme keine Probleme mit dem Redraw bei Menüs haben.

Hinweis: Ein Problem besteht darin, festzustellen, wann die erweiterten Modi (Bits 3 und folgende) benutzt werden dürfen. Einige ältere Versionen des GEMDOS kommen nämlich nicht mit diesen Modi zurecht, und sorgen z.T. für den Absturz der Applikation bzw. des ganzen Systems. Aus diesem Grund testen viele Programmierer explizit auf das Vorhandensein von MiNT/MultiTOS oder Versionen von MagiC >= 2.0. Alternativ kann auch die Funktion Mxmask benutzt werden.
Ergebnis: Die Funktion liefert als Ergebnis die Anfangsadresse des reservierten Bereichs als typenlosen Zeiger. Mxalloc liefert als Ergebnis eine 0, wenn nicht mehr genügend Speicher vorhanden ist.
Verfügbar: Diese Funktion existiert erst ab GEMDOS-Version 0.19.
Gruppe: Speicherverwaltung
Querverweis: Binding   Mfree   Malloc   Maddalt   Programmflags

5.12.5.1 Bindings für Mxalloc

C: void *Mxalloc ( int32_t amount, int16_t mode );
Assembler:
move.w    mode,-(sp)    ; Offset 6
move.l    amount,-(sp)  ; Offset 2
move.w    #68,-(sp)     ; Offset 0
trap      #1            ; GEMDOS aufrufen
addq.l    #8,sp         ; Stack korrigieren

5.12.5.2 Mxmask

/*
   Mxmask() liefert eine Bitmaske mit der man das Moduswort eines
   Mxalloc() Aufrufs maskieren sollte, falls man Protectionbits
   benutzen möchte. Dies ist notwendig, da Mxalloc() bei der Angabe
   von Protectionbits leider in einigen GEMDOS Implementierungen
   fehlerhafte Resultate liefert, die in der Folge zum Absturz des
   Systems fuehren koennen. ((c) 1994 Martin Osieka)
   Anwendungsbeispiel:
   mxMask = Mxmask();
   p = mxMask ? Mxalloc( size, 0x43 & mxMask) : Malloc( size); */

SHORT Mxmask (void)
{
    void *svStack;      /* Supervisor-Stack */
    int32_t sRAM, sRAMg;   /* ST-RAM          */
    int32_t aRAM, aRAMg;   /* Alternate RAM   */

    /*
    // Beispieltabelle moeglicher Werte:
    //           | newfashion  | oldfashion
    // sRAM aRAM | sRAMg aRAMg | sRAMg aRAMg
    //   1    0  |   1     0   |   1     1
    //   0    2  |   0     2   |   2     2
    //   1    2  |   1     2   |   3     3
    */

    svStack = (void *) Super( 0);  /* unterbinde Taskwechsel */

    sRAM  = (int32_t) Mxalloc( -1, 0);
    sRAMg = (int32_t) Mxalloc( -1, 0x40); /* im Fehlerfall Mxalloc( -1, 3) */
    aRAM  = (int32_t) Mxalloc( -1, 1);
    aRAMg = (int32_t) Mxalloc( -1, 0x41); /* im Fehlerfall Mxalloc( -1, 3) */

    Super( svStack);  /* erlaube Taskwechsel */

    if (sRAM == -32)
        return 0x0000;  /* Mxalloc() ist nicht implementiert */

    else if ( ((sRAM + aRAM) == sRAMg) && ((sRAM + aRAM) == aRAMg) )
        return 0x0003;  /* oldfashion Mxalloc() */

    else
        return 0xFFFF;

} /* Mxmask */

Querverweis: GEMDOS   Speicherverwaltung


HomeGEMDOSProzessfunktionenNetzwerkfunktionen