ASM vs Delphi

[sakura]

Zitat von dizzy:

Gibt es zu FSTP nicht auch die Variante ohne "Pop"? Dann ließe sich das ewige nachladen verhindern.

Ja, hat aber auch keinen echten Speed-Zuwachs. Siehe Anhang.

......

[dizzy]

Das ist dann ja sogar die langsamste Variante! Sowatt!

\\edit: *hmpf* du hast nen Monitor links vom zentralen stehen, gell!? Form1.Left = -1200 oder so... Proll

[sakura]

Zitat von dizzy:

\\edit: *hmpf* du hast nen Monitor links vom zentralen stehen, gell!? Form1.Left = -1200 oder so... Proll

Wer weiß, es war auf dem mittleren der Monitore

......

[Kryoko]

Hm...erstmal Danke Sakura
Dann werd ich mich mal dran machen und da ein bisschen nach "deinem Vorbild" verbessern...

EDIT:
Mit welchem Processor, bitte?
Bei meinem Pentium M mit 1.6 Gig ist meine Methode jedes 2.te Mal die 2. schnellste...Deine hält jedoch fast immer die spitze (1 / 10 nicht...)



und btw: ich hab mit GetTickCount die Zeit gemessen...

[gekmihesg]

also bei mir sagt das testprogramm nur nen unterschied von so 5-10 ms
und welche methode jetzt schneller ist schwankt eigendlich dauernd.
aber vielleicht liegts daran das meine kiste so alt is...

[Kryoko]

Ausserdem ist es meiner bescheidene Meinung nach sehr unwahrscheinlich, das der vom Delphi-Compiler erstellte Code schneller sein soll als die von mir geschriebene Floatpointberechnung, obwohl Float register langsam sind...
Delphi added stehts Checks...
Das deins, Sakura, das schnellste ist, stimmt

[MaBuSE]

Zitat von sakura:

Und anschließend teste noch folgende, welche imo die schnellste sein sollte:

Delphi-Quellcode:

function VectorSetValue(const Value:Single): TVector3D;
asm
  mov edx, Value
  mov [eax], edx
  mov [eax + $04], edx
  mov [eax + $08], edx
end;

Deren Ergebnis ist i.A. identisch zur Pascal-Lösung, verzichtet aber auf das wiederholte Laden des Übergabewertes.

Bei dieser Lösung sollte man aber bedenken, dass sich durch eine Änderung am record TVector3D evtl. die Adressen ändern.

Beisp:

Delphi-Quellcode:

type
  TVector3D = record x, y, z: Single; end;

Dann funktioniert sakuras Lösung.

Delphi-Quellcode:

type
  TVector3D = record x, nein_tu_das_nicht, y, z: Single; end;

Ups, nun haben sich die Adressen geändert.

Delphi-Quellcode:

function VectorSetValue(const Value:Single): TVector3D;
asm
  mov edx, Value
  mov [eax], edx
  mov [eax + $08], edx
  mov [eax + $0c], edx
end;

Das ganze ist nun um 4 Byte verschoben, da single 4 Byte belegt.
Werden andere Typen verwendet z.B. Double statt Single, dann sind die Adressen auch entsprechend anders.

Das Delphi aus dem Original Quelltext macht, lässt sich sehr leicht mit dem CPU Fenster ermitteln.

Delphi-Quellcode:

type
  TVector3D = record x, y, z: Single; end;

function VectorSetValue(const Value:Single): TVector3D;
begin                  // <- hier Haltepunkt setzen (F5 Taste)
  Result.X := Value;
  Result.Y := Value;
  Result.Z := Value
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  x: TVector3D;
begin
  x := VectorSetValue(1);
  Caption := IntToStr(Round(x.x+x.y+x.z));  // Anmerkung: Diese Zeile ist nur da, 
                                            // damit Delphi mir mein x nicht wegoptimiert ;-)
end;

Wird die Applikation mit F9 gestartet, und der Button1 gedrückt, so bleibt der Debugger an der Stelle begin (in der Funktion VectorSetValue) stehen.
Mit "Menü -> Ansicht -> Debug-Fenster -> CPU" kann man das CPU Fenster öffnen.
hier steht nun folgendes:

Code:

Unit1.pas.30: begin
  0044D944 55                 push ebp
  0044D945 8BEC               mov ebp,esp
Unit1.pas.31: Result.X := Value;
  0044D947 8B5508             mov edx,[ebp+$08]
  0044D94A 8910               mov [eax], edx
Unit1.pas.32: Result.Y := Value;
  0044D94C 8B5508             mov edx,[ebp+$08]
  0044D94F 895004             mov [eax + $04], edx
Unit1.pas.33: Result.Z := Value;
  0044D952 8B5508             mov edx,[ebp+$08]
  0044D955 895008             mov [eax + $08], edx
...

[ebp+$08] ist die Adresse von Value, also kann man auch mov edx, Value schreiben.
Da das Register edx durch ein mov [eax],edx nicht verändert wird braucht man es nicht noch mal mit der Adresse von Value zu laden.
Daraus ergibt sich Sakuras Quelltext:

Code:

  mov edx, Value
  mov [eax], edx
  mov [eax + $04], edx
  mov [eax + $08], edx

Wenn nun ein verändertes Array (z.B. Double als Typ) verwendet wird, kann man im CPU Fenster sehen, was Delphi daraus macht und sein ASM entsprechend anpassen.

[pajofego]

Da wir schon beim Thema sind,

habe ich ganz kurz ein Frage: Gibt es eine mit SSE/SSE2, MMX und 3dNow optimierte Bibliothek für Vektoren- und Matrizenoperationen? Am liebsten wäre mir eine in Delphi aber falls es nur in C/C++ was gibt tut es zur Not auch!

Danke,

Gruss pajofego

[negaH]

Delphi-Quellcode:

function VectorSetValue(const Value: Single): TVector3D; 
asm 
  mov edx, Value 
  mov [eax].TVector3D.X, edx 
  mov [eax].TVector3D.Y, edx 
  mov [eax].TVector3D.Z, edx 
end;

Damit erledigt sich das Problem mit dem nachträglichen Anpassen des ASM.

Gruß Hagen

[Robert Marquardt]

Dafuer gibt es OpenCV von Intel, aber es gibt wohl noch keine Konversion nach Delphi fuer das API.