SetLength / Getmem / AllocMem out of memory Problem

[greenmile]

"z.B. verkettete Liste statt Array"

Was meinst Du genau damit?

[hoika]

Hallo,

kennst du keine verketteten Listen ? tztz ;)

Jedes Listen-Element ist ein Record oder eine Klasse,
wobei jedes Element seinen Nachfolger kennt.
Das letzte Element hat NIL als Nachfolger.
Kennt ein Elment auch seinen Vorgänger,
sprucht man von doppelt verketteten Listen.

Hier wird dann der Speicher immer häppchenweise
und nicht am Stück angefordert.




Heiko

[greenmile]

Hört sich gut an, hast Du ein Beispiel für mich?

Zitat:

Zitat von hoika

Hallo,

kennst du keine verketteten Listen ? tztz ;)

Jedes Listen-Element ist ein Record oder eine Klasse,
wobei jedes Element seinen Nachfolger kennt.
Das letzte Element hat NIL als Nachfolger.
Kennt ein Elment auch seinen Vorgänger,
sprucht man von doppelt verketteten Listen.

Hier wird dann der Speicher immer häppchenweise
und nicht am Stück angefordert.




Heiko

[himitsu]

verkettete Liste

das ganze nochmal kurz als Array ... zum Vergleich

Delphi-Quellcode:

TData = record
  name: String;
  typ:  Integer;
  ...
end;

TAsArray = Array of TData;

eine einfach verkettete Liste

Delphi-Quellcode:

PListe = ^TListe;
TListe = record
  next: PListe;

  name: String;
  typ:  Integer;
end;

var myList: PListe;

bei dieser verketten Liste ist es so, daß nur der Zeiger auf das erste Element in der Liste bekannt ist
und jede Element kennt dann seinen Nachfolger ... du kannst dich also vom ersten element aus zu allen anderen Elementen durchhangeln


und das wäre dann eine doppelt verkettete Liste

Delphi-Quellcode:

PListe = ^TListe;
TListe = record
  prev: PListe;
  next: PListe;

  name: String;
  typ:  Integer;
end;

var myList_first: PListe;
    myList_last:  PListe;

hier kennt dann jedes Element auch noch seinen Vorgänger ... das macht es dann einfacher diese Liste zu "editieren" (zu verändern, wie z.B. Einträge einzufügen oder zu entfernen)


Der Vorteil gegenüber dem Array ist dann einfach, daß diese Daten nicht stur alle in einer Reihe angeordnet sein müssen ... sie können sich also frei im verfügbaren Speicher verteilen und brauchen keinen gemeinsamen Speicherblock.


Was jetzt aber für dich eine "gute" Lösung wäre, das kommt darauf an, wie der Zugriff auf deine Daten aussieht, wie/ob diese auch mal verändert werden und vorallem welche und wieviele Daten du in jedem Element drinnen hast.

z.B. bei einem Array of String wäre es Schwachsinn dieses als verkettete Liste verwalten zu wollen, da so der Speicherverbrauch und auch der Verwaltungsaufwand wesentlich höher wäre, als beim Array.

[greenmile]

Danke für die Beispiele. Aber bei 800 MByte sorgt das ja ordentlich für Overhead.

[himitsu]

Drum sagte ich ja, es gibt mehrere Möglichkeiten, welche man dann entsprechend abwegen kann.

eine Möglichkeit wäre z.B. auch das Array einfach aufzuteilen

Delphi-Quellcode:

// statt
TMyArray = Array of Data;

// dieses
TMyArray = Array of Array of Data;

Das SetLength ist dann zwar ein bissl umständlich zu erledigen, aber zugreifen könnte man dann z.B. so
(wenn man davon ausgeht, daß nach jeweils 1000 Einträgen ein neues SubArray erstellt wurde)

Delphi-Quellcode:

MyArr[i]

MyArr[i div 1000, i mod 1000]

[add]
Length würde dann etwa so aussehn

Delphi-Quellcode:

// für's normale Array
Length(MyArr)

// eine kleine Funktion für das gesplittete Array
function MyLength(var MyArr: ...): Integer;
begin
  Result := High(MyArr) * 1000 + Length(MyArr[High(MyArr)]);
end;

[greenmile]

Es geht um ein Array of Byte. Die externe Funktion ruft ein OnRead / OnWrite Callback auf. Im "OnRead" wird übergeben, ab welcher Position wieviel Bytes gelesen und in einen Buffer geschrieben werden. Bei "OnWrite" wird übergeben, wieviel Bytes an welcher Position in den lokalen Puffer geschrieben werden.

Übergeben wird dann zum Beispiel 4096 Bytes an Position X (z.B. 600 MByte). Momentan erledige ich das mit einem Array of Byte, weil da Position 4096 ja bekannt ist (mittels Move(MyArrayOfByte[ReadOffset],ReadBuffer,ReadSize)). Wenn ich das alles aber aufsplitte, dann ist u.U. genau bei 4000 schluß und ich muss die restlichen 96 Bytes woanders lesen.

[himitsu]

Die über 800 MB dann so im RAM behalten zu wollen ist dann aber wohl eher ein Designfehler in der Anwendung.

Hier würde sich dann eine MMF anbieten ... diese in der entsprechenden Größe erstellt

dann einfach nur den Bereich z.B. 4096 Bytes ab Position sound so in den Speicher mappen, die Daten da reinkopieren und dann den Bereich eventuell gleich wieder freigeben.


für alle möglichen anderen Fälle ginge z.B. sowas (also ab Delphi 2006)
dieses stellt quasi ein einfaches dynamisches Array mit gesplittetem Datenbereich dar

Delphi-Quellcode:

Type TSplittArray<Typ> = Record
  Private
    Var _SplittSize: Integer;
      _Data: Array of Array of Typ;
    Function  Getter(Index: Integer):             Typ;  Inline;
    Procedure Setter(Index: Integer; Const Value: Typ); Inline;
  Public
    Procedure SetSplittSize(i: Integer);
    Procedure SetLength    (i: Integer);
    Function  Length:          Integer; Inline;
    Function  High:            Integer; Inline;
    Property  Value[Index: Integer]: Typ Read Getter Write Setter; Default;

    //Procedure Push(Const Value: Typ);
    //Function  Pop: Typ;
  End;

Function TSplittArray<Typ>.Getter(Index: Integer): Typ;
  Begin
    Result := _Data[Index div _SplittSize, Index mod _SplittSize];
  End;

Procedure TSplittArray<Typ>.Setter(Index: Integer; Const Value: Typ);
  Begin
    _Data[Index div _SplittSize, Index mod _SplittSize] := Value;
  End;

Procedure TSplittArray<Typ>.SetSplittSize(i: Integer);
  Begin
    If Assigned(_Data) Then System.Error(reInvalidOp);
    _SplittSize := i;
  End;

Procedure TSplittArray<Typ>.SetLength(i: Integer);
  Var i2: Integer;

  Begin
    i2 := System.High(_Data);
    System.SetLength(_Data, (i - 1) div _SplittSize + 1);
    For i2 := i2 to System.High(_Data) - 1 do
      System.SetLength(_Data[i2], _SplittSize);
    If i > 0 Then
      System.SetLength(_Data[System.High(_Data)], i mod _SplittSize);
  End;

Function TSplittArray<Typ>.Length: Integer;
  Var i: Integer;

  Begin
    i := System.High(_Data);
    Result := i * 1000 + System.Length(_Data[i]);
  End;

Function TSplittArray<Typ>.High: Integer;
  Begin
    Result := Length - 1;
  End;

{Procedure TSplittArray<Typ>.Push(Const Value: Typ);
  Var i: Integer;

  Begin
    i := Length;
    SetLength(i + 1);
    Setter(i - 1, Value);
  End;

Function TSplittArray<Typ>.Pop: Typ;
  Var i: Integer;

  Begin
    i := High;
    Result := Getter(i);
    SetLength(i);
  End;}

[hoika]

Hallo,

was ist dass denn für eine Datei,
wo du alle 800 MB im Speicher haben musst ?


Heiko

[greenmile]

Ein RamDrive