OleVariant zu TBytes

[Photoner]

Hallo allerseits,


Habe ein Bitmap (24MB) das als OleVariant verpackt wird (poste ich bei Bedarf) und dann über COM verschickt wird. Geht gut und sogar sehr fix. Beim entpacken auf der aufrufenden Seite dauerts aber ewig. Den Grund dafür konnte ich schon identifizieren und ich habe ein Minimalbeispiel drumherum gestrickt. Der Kasus Knaxus ist der Cast von OleVariant nach TBytes. Habt ihr vielleicht eine Idee / einen Tipp warum das casten so lange dauert bzw. wie ich es schneller lösen könnte?

Beispiel (VCL Formular mit Button und Memo; Win32 DEBUG):

Delphi-Quellcode:

unit Unit2;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;

type
  TForm2 = class(TForm)
    Memo1: TMemo;
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    Ole   : OleVariant;
    { Public-Deklarationen }
  end;

var
  Form2: TForm2;
implementation

{$R *.dfm}

procedure TForm2.Button1Click(Sender: TObject);
var
  bytestr : TBytesStream;
  stamp1  : Integer;
  stamp2  : Integer;
  stamp3  : Integer;
//  byte    : Array of UInt8;
  byte    : TBytes;
begin
  try
    stamp1  :=  GetTickCount;
//  byte    :=  TBytes(Ole);
    byte    :=  Ole;
    stamp2  :=  GetTickCount;
//    bytestr :=  TBytesStream.Create(TBytes(Byte));
    bytestr :=  TBytesStream.Create(byte);
    stamp3  :=  GetTickCount;
  finally
    Memo1.Lines.Add('Stoppuhr Cast: '+IntToStr(stamp2-stamp1)+'ms');
    Memo1.Lines.Add('Stoppuhr Stream: '+IntToStr(stamp3-stamp2)+'ms');
    Memo1.Lines.Add('Größe: '+IntToStr(Round(bytestr.Size/(1024*1024)))+'MBytes');
    Memo1.Lines.Add('Array Größe:' +IntToStr(Length(byte)));
    bytestr.Free;
    byte  :=  nil;
  end;
end;

procedure TForm2.FormCreate(Sender: TObject);
var
  ptr : PByte;
  i   : Integer;
begin
  Ole :=  VarArrayCreate([0,25000053],varByte);
  ptr :=  VarArrayLock(ole);
  i   :=  0;
  for i :=  0 to 25000053 do begin
    ptr^  :=  Uint8(Random(255));
    inc(ptr);
  end;
  VarArrayUnlock(ole);
end;

end.

[hathor]

16 ms - vorher über 2000 ms!

Delphi-Quellcode:

Function VariantToBytes(Const Value: Variant): TBytes;
Var
  Size: Integer;
  pData: Pointer;
Begin
  Size := Succ(VarArrayHighBound(Value, 1) - VarArrayLowBound(Value, 1));
  SetLength(Result, Size);
  pData := VarArrayLock(Value);
  Try
    Move(pData^, Pointer(Result)^, Size);
  Finally
    VarArrayUnlock(Value);
  End;
End;


procedure TForm2.Button1Click(Sender: TObject);
var
  bytestr : TBytesStream;
  stamp1 : Integer;
  stamp2 : Integer;
  stamp3 : Integer;
// byte : Array of UInt8;
  byte : TBytes;
begin
  try
    stamp1 := GetTickCount;

//    byte := Ole;

    byte:=    VariantToBytes(ole);

    stamp2 := GetTickCount;
...

[Photoner]

Das rennt!
Dankeschön!

Die 2000ms waren echt nicht schön. War am Freitag schon todmüde und bin deswegen nicht mehr auf die simple Idee gekommen mal reinzudebuggen :wall:

Wen es noch interessiert:

Es wird beim Cast folgende Prozedur aus System.Variants aufgerufen:

Delphi-Quellcode:

// Copies data from the Variant to the DynamicArray
procedure DynArrayFromVariant(var DynArray: Pointer; const V: Variant; TypeInfo: Pointer);

http://docwiki.embarcadero.com/Libra...rayFromVariant

In dieser befindet sich ein repeat...until

(Pseudocode:
-wiederhole(
hole nächstes Element aus Variant;
hole Zeiger auf nächstes Element im Feld;
Fallkonstrukt Variantelementtyp -> passende Wertzuweisung von Feldelement; )
-bis (-Ist letztes Element aus Variant erreicht?; )

bei dem die 2000ms verbraten werden.
Ich müsste jetzt das raten anfangen welcher Teil so viel Zeit in Anspruch nimmt. Es wäre auf jeden Fall geschickter gewesen das Fallkonstrukt vor die Schleife zu ziehen (Da der Typ (DAVarType) auch nur einmal gesetzt wird; wäre halt mehr Tipparbeit gewesen).

Noch mal danke für die schlanke und schnelle Lösung!

[Uwe Raabe]

Die Methode DynArrayFromVariant ist eben für unterschiedliche Arrays geeignet. Bei einem

Delphi-Quellcode:

Array of String

würde der beschleunigte Ansatz nicht sonderlich gut funktionieren.

[himitsu]

Oder bei einem VariantArray aus vielen Variants, wo jeweils ein Byte drin ist.
Oder vielleicht auch mit Typkonvertierung viele Bytes und man übernimmt die in ein Array of Integer.
Oder ...

[Photoner]

Zitat:

Zitat von Uwe Raabe (Beitrag 1263796)

Die Methode DynArrayFromVariant ist eben für unterschiedliche Arrays geeignet. Bei einem

Delphi-Quellcode:

Array of String

würde der beschleunigte Ansatz nicht sonderlich gut funktionieren.

Das habe ich auch nicht behauptet, sondern dass der Ausgabetyp "DAVarType" fest ist und das case of somit nur einmal aufgerufen werden muss :-D

[Uwe Raabe]

Zitat:

Zitat von Photoner (Beitrag 1263802)

Das habe ich auch nicht behauptet, sondern dass der Ausgabetyp "DAVarType" fest ist und das case of somit nur einmal aufgerufen werden muss :-D

Wie sollte das denn gehen? Der Wert von Value ändert sich doch mit jedem Index. Also muss die Zuweisung an das Array-Element auch für jeden Index aufgerufen werden.

Man könnte allerdings für jeden case-Fall die Schleife ausprogrammieren. Das sähe aber doch recht bescheiden aus.

[himitsu]

Das CASE ist schnell, da das DAVarType bereits vor der Schleife bestimmt wurde (der Typ des DynArray steht ja fest, da alle Einträge vom selben type sind)

Und ein allgemeiner Code kann nunmal die Werte der Felder nur einzeln auslesen.
Wenn man es schneller braucht und den Aufbau kennt, dann kann man das natprlich auch selber implementieren und direkt drauf zugreifen.

[Photoner]

Zitat:

Zitat von himitsu (Beitrag 1263811)

Das CASE ist schnell, da das DAVarType bereits vor der Schleife bestimmt wurde (der Typ des DynArray steht ja fest, da alle Einträge vom selben type sind)

Und ein allgemeiner Code kann nunmal die Werte der Fehler nur einzeln auslesen.
Wenn man es schneller braucht und den Aufbau kennt, dann kann man das natprlich auch selber implementieren und direkt drauf zugreifen.

Da stimme ich zu.

Zitat:

Zitat von Uwe Raabe (Beitrag 1263806)

...

Wie sollte das denn gehen? Der Wert von Value ändert sich doch mit jedem Index. Also muss die Zuweisung an das Array-Element auch für jeden Index aufgerufen werden.

...

Gute Frage was passiert wenn sich die Values vom Typ her unterscheiden. Himitsu hats schon geschrieben DAVarType wird durch das Array vorgegeben.

[Uwe Raabe]

Zitat:

Zitat von Photoner (Beitrag 1263817)

Zitat:

Zitat von Uwe Raabe (Beitrag 1263806)

...

Wie sollte das denn gehen? Der Wert von Value ändert sich doch mit jedem Index. Also muss die Zuweisung an das Array-Element auch für jeden Index aufgerufen werden.

...

Gute Frage was passiert wenn sich die Values vom Typ her unterscheiden. Himitsu hats schon geschrieben DAVarType wird durch das Array vorgegeben.

Und was genau willst du mir jetzt damit sagen?