tmemorystream.memory

[Rudirabbit]

Hallo

In einem Thread werden Daten in ein tmemorystream geschrieben.
Das wird mit der write Methode erledigt.
Ist ein Ringbuffer,also wenn das Ende des Streams erreicht ist, wird die Position wieder auf Anfang gestellt.
Das Funktioniert auch so.

Parallel dazu möchte ich auf die Daten zugreifen, ohne die read Methode zu benutzen.
Etwa so:

Delphi-Quellcode:

var wert:^byte;
     daten:byte;
begin
wert:=memorystream.memory;  

daten:=wert^;

inc(wert);...dec(wert);

Somit könnte ich mich im Stream frei bewegen, wenn ich mich an die Grenzen halte.
Doch leider zeigt memorystream.memory nicht auf die Daten des Streams
Wie komme ich auf die Adresse ?
Grüsse

[Klaus01]

Guten Morgen,

wäre es nicht eine Möglichkeit, dass Du dir einen
eigenen Stream zum Lesen erstellst.
In diese LeseStream packst Du dir dann per assign eine Kopie
des Streams der beschrieben wird - so eine Art Snapshot.

Grüße
Klaus

[r29d43]

Wie kommst du darauf, dass TStream.Memory nicht auf die Daten zeigt? Bei mir geht das ganz normal:

Delphi-Quellcode:

procedure TForm1.FormClick(Sender: TObject);
var AMemStream : TMemoryStream;
    Wert : ^byte;
    AByte : byte;
    I : integer;
begin
  AMemStream := TMemoryStream.Create;
  AMemStream.Size := 256;
  AMemStream.Position := 0;
  for I := 0 to 255 do AMemStream.WriteBuffer(I,SizeOf(Byte));

  Wert := AMemStream.Memory;
  for I := 0 to 255 do begin
    AByte := Wert^;
    Memo2.Lines.Add(IntToStr(AByte));
    inc(Wert);
  end;

  AMemStream.Free;
end;

[Rudirabbit]

Zitat:

Wie kommst du darauf, dass TStream.Memory nicht auf die Daten zeigt? Bei mir geht das ganz normal:

Ist aber bei mir so, ich habe Delphi 7 evtl. ist dort ein Bug


Wenn ich nur mit Pointern arbeite, also mir die Adresse mit MemStream.Memory hole, und dann den Wert des Pointers ändere funktioniert es.
Nicht aber mit der Write Methode. So wie in deinem Beispiel.
Keine Ahnung wohin (adresse) write schreibt.
Mit read bekomme ich die Daten auch wieder zurück.

Seltsam

Grüsse Rudi

[r29d43]

Also, ich hatte das kurz mit Turbo Delphi gecheckt, ...welches man mal hier aus dem Delphi-PRAXIS-Forum downloaden konnte.

Mit D7 (Personal) geht es allerdings auch (habe ich nämlich zufälligerweise auch noch auf dem PC, wegen der da wesentlich bessern Hilfe).

Die WriteBuffer-Methode beschreibt den StreamBuffer in Abhängigkeit von MemStream.Memory + MemStream.Position

Ein beliebter Fehler beim Schreiben/Lesen von Streams ist dabei häufig, diesen Offset-Pointer (= MemStream.Position) dann nicht wieder auf Null (=0) zurückzustellen, der bei jeder vorherigen Lese/Schreibaktion nämlich immer implizit mitläuft, btw.

[SirThornberry]

TMemoryStream.Memory zeigt schon auf den Speicher. Allerdings nur so lange bis neuer Speicher alociert werden muss. Wenn du mit der Write-Methode in den Stream schreibst und dieser dabei vergrößert werden muss, muss natürlich auch neuer Speicher angefordert werden. Und je nach Speichermanager kann es dabei natürlich passieren das der aktuelle Bereich nicht vergrößert werden kann und somit ein anderes Stück im Speicher verwendet werden muss. Tritt das ein zeigt dein Wert von Memory den du zuvor irgendwann geholt hast nicht mehr auf den Speicher sondern dorthin wo vorher etwas lag.

[himitsu]

Also am Einfachsten/Sichersten wäre es wohl für Lese- und Schreibzugriffe je einen eigenen Positionsspeicher einzurichten (eventuell gleich direkt im Stream, um Fehler zu vermeiden).

Hab hier mal schnell 'nen kleinen Ringspeicher erstellt.

• Lese- und Schreiboperationen haben je 'ne eigene Positionsangabe
  (.PositionRead und .PositionWrite)
• DataSize liefert die Größe der Daten im Speicher
  (also das zwischen Lese- und Schreibposition)
• für die Kompatibilität zu TStream und Co. wird alles was .Position verwendet,
  je nach Einstellung in .DefaultOperations, an das Entsprechende(Read der Write) umgeleitet
• TRingBuffer = Basistyp
  TMemoryRingBuffer = Ringspeicher im RAM
  TFileRingBuffer = Ringspeicher in Datei
• Pufferüberlauf wird verhindert
  (beim Lesen/Schreiben wird die jeweils andere Position nicht überschritten)
• standardmäßig wird über eine CriticalSection alles threadsicher gemacht

[r29d43]

Zitat von SirThornberry:

TMemoryStream.Memory zeigt schon auf den Speicher. Allerdings nur so lange bis neuer Speicher alociert werden muss...

ist event. etwas unglücklich ausgedrückt, weil der Pointer "MemoryStream.Memory" nämlich bei einer Neu-Allocierung von Speicherplatz schon entsprechend mitgeändert wird. Bloß eben seine damit anfangs geladene Pointervariable "Wert" nicht. Die müsste er nach einer jeden solchen Write-Methode also immer wieder nur in etwa so erneuern:

Delphi-Quellcode:

Wert := MemoryStream.Memory + (Wert-oldMemoryPtr);
oldMemoryPtr := MemoryStream.Memory;

[himitsu]

Zitat von Rudirabbit:

Ist aber bei mir so, ich habe Delphi 7 evtl. ist dort ein Bug

'nen Bug kann da eigentlich nicht entstehen

Delphi-Quellcode:

TCustomMemoryStream = class(TStream)
private
  FMemory: Pointer;
  ..
public
  ..
  property Memory: Pointer read FMemory;
end;

.Memory greift direkt auf FMemory zu und dieses ist der Zeiger zum Speicher.

Wie bereits erwähnt, wird bei Größenänderung unter Umständen der Speicher an anderer Stelle neu reserviert.
Du könntest aber auch direkt beim Erstellen des Streams die Größe festlegen,
denn wenn die Größe nicht mehr verändert wird, dann wird sich FMemory/.Memory auch nicht ändern
> .SetSize (gleich nach Create)

[himitsu]

Was mir grad noch eingefallen ist, du kannst auch 2 Memory-Streams aus den selben speicherbereich loslassen und dann einen zum lesen und den anderen zum schreiben verwenden.
(mußt aber ebenfalls aufpassen, daß sich die Speicheradresse nicht verschiebt)

[add]
k.A. ob's richtig läuft (hab's nur mal schnell zusammengeschrieben),
aber eine/zwei Nachteile wird man bestimmt sofort sehen...
* da es kein Nachfahre von TStream ist, ist es auch nicht zu TStream und seinen Nachkommen kompatibel
* wenn das Ende es Puffers erreicht wird, wird nicht automatisch an den Anfang gesprungen
* das Schreiben über das Ende Puffers hinaus vegrößert den Speicher und es wird nicht am Anfang das Überhängende weitergeschriben (hier könnte man aber statt 'ner Vergrößerung des Speichers auch einfach 'ne Exception auslösen ... würde auch das ständige Ändern des ReadStream-Speichers ersparen)
* das Ganze ist so nicht Threadsicher
* ...

Delphi-Quellcode:

Type THackMemoryStream = Class(TMemoryStream);

  TMemRingBuffer = Class
  Private
    ReadStream:  THackMemoryStream;
    WriteStream: TMemoryStream;
    Function  GetReadPosition:    LongInt;
    Procedure SetReadPosition (P: LongInt);
    Function  GetWritePosition:   LongInt;
    Procedure SetWritePosition(P: LongInt);
    Function  GetSize:            LongInt;
    Procedure SetSize         (S: LongInt);
  Public
    Constructor Create(Size: LongInt);
    Destructor  Destroy; Override;

    Procedure Clear;
    Function  ReadSeek (Offset: LongInt; Origin: TSeekOrigin): LongInt;
    Function  WriteSeek(Offset: LongInt; Origin: TSeekOrigin): LongInt;

    Function  Read       (Var   Buffer; Count: LongInt): LongInt;
    Function  Write      (Const Buffer; Count: LongInt): LongInt;
    Procedure ReadBuffer (Var   Buffer; Count: LongInt);
    Procedure WriteBuffer(Const Buffer; Count: LongInt);

    Property ReadPosition:  LongInt Read GetReadPosition  Write SetReadPosition;
    Property WritePosition: LongInt Read GetWritePosition write SetWritePosition;
    Property Size:          LongInt Read GetSize Write SetSize;
  End;

Function TMemRingBuffer.GetReadPosition: LongInt;
  Begin
    Result := ReadStream.Position;
  End;

Procedure TMemRingBuffer.SetReadPosition(P: LongInt);
  Begin
    ReadSeek(P, soBeginning);
  End;

Function TMemRingBuffer.GetWritePosition: LongInt;
  Begin
    Result := WriteStream.Position;
  End;

Procedure TMemRingBuffer.SetWritePosition(P: LongInt);
  Begin
    WriteSeek(P, soBeginning);
  End;

Function TMemRingBuffer.GetSize: LongInt;
  Begin
    Result := WriteStream.Size;
  End;

Procedure TMemRingBuffer.SetSize(S: LongInt);
  Begin
    WriteStream.Size := S;
    ReadStream.SetPointer(ReadStream.Memory, ReadStream.Size);
  End;

Constructor TMemRingBuffer.Create(Size: LongInt);
  Begin
    ReadStream  := THackMemoryStream.Create;
    WriteStream := TMemoryStream.Create;
    SetSize(Size);
  End;

Destructor TMemRingBuffer.Destroy;
  Begin
    ReadStream.SetPointer(nil, 0);
    ReadStream.Free;
    WriteStream.Free;
  End;

Procedure TMemRingBuffer.Clear;
  Begin
    WriteStream.Clear;
    ReadStream.SetPointer(ReadStream.Memory, ReadStream.Size);
  End;

Function TMemRingBuffer.ReadSeek(Offset: LongInt; Origin: TSeekOrigin): LongInt;
  Begin
    Result := ReadStream.Seek(Offset, Origin);
  End;

Function TMemRingBuffer.WriteSeek(Offset: LongInt; Origin: TSeekOrigin): LongInt;
  Begin
    Result := WriteStream.Seek(Offset, Origin);
  End;

Function TMemRingBuffer.Read(Var Buffer; Count: LongInt): LongInt;
  Begin
    Result := ReadStream.Read(Buffer, Count);
  End;

Function TMemRingBuffer.Write(Const Buffer; Count: LongInt): LongInt;
  Begin
    Result := WriteStream.Write(Buffer, Count);
    ReadStream.SetPointer(ReadStream.Memory, ReadStream.Size);
  End;

Procedure TMemRingBuffer.ReadBuffer(Var Buffer; Count: LongInt);
  Begin
    ReadStream.ReadBuffer(Buffer, Count);
  End;

Procedure TMemRingBuffer.WriteBuffer(Const Buffer; Count: LongInt);
  Begin
    WriteStream.WriteBuffer(Buffer, Count);
    ReadStream.SetPointer(ReadStream.Memory, ReadStream.Size);
  End;