Gleitkommadivision im Inline-Assembler

[everdream]

Hallo,
ich überlege ein Programm von mir mit dem Assembler zu optimieren. Assemblerprogrammierung beherrsche ich grundlegend, allerdings habe ich bis jetzt noch nichts mit Gleitkommawerten gemacht.

--> Lohnt es sich überhaupt eine Divisionsfunktion dafür zu schreiben oder kann man da keine Zeit sparen?

Falls es sich lohnt würde ich mich über Ansätze/Beispiele/Links freuen.

Vielen Dank schonmal, everdream :cyclops:

[Oxmyx]

Bei einer einfachen Division kannst du nichts optimieren. Im Gegenteil, durch den Methodenaufruf wird das ganze sogar langsamer, als wie wenn du einfach den Compiler das machen lässt, was er am besten kann.

[everdream]

Okay, dann werd' ich den Algorithmus wohl erstmal so lassen. Vielen Dank für die Info!

[everdream]

Doch nochmal ne Frage... :roll:

Zitat:

durch den Methodenaufruf wird das ganze sogar langsamer

Und wenn ich das ganze ohne Methodenaufruf mache? Ich muss nur an 3 oder 4 Stellen dividieren.

[Oxmyx]

Auch dann kannst du keine Verbesserung gegenüber dem Compiler erreichen.

[himitsu]

der Compiler über auch nur die Varible/Zahl an due Fließkommaeinheit (FPU) und läßt diese rechnen

da kannst du nichts verbessern, oder was willst du denn da sonst machen?

[everdream]

Hab mir noch nich viele Gedanken drüber gemacht wie genaus das dann aussehen soll, aber meißtens sind asm berechnungen doch schneller, oder irre ich mich da?

[OregonGhost]

Mit 3DNow! bzw. SSE kannst du deine Fließkommaberechnungen sicherlich etwas beschleunigen, wenn du die Eigenheiten dieser Befehlssätze ausnutzen kannst. Ansonsten ist eine Assembly-Berechnung keineswegs unbedingt schneller und bei Berechnungen, die sich nicht parallelisieren lassen, helfen dir auch SSE und Co. nicht.

[himitsu]

Delphi wandelt deinen Pascal-Code auch in ASM-Code um und Delphi kennt ganz viele Optimierungen.

Delphi-Quellcode:

r3 := r1 / r2;

asm
  fld &r1   // r1 > FPU-Register
  fdiv &r2  // FPU-Register := FPU-Register / r2
  fstp &r3  // FPU-Register > r3
  wait      // warten bis FPU fertig mit rechnen ist
end;

da geht nicht's mehr schneller ;)
und Delphi macht es schon so (abgesehn wenn die Variablen noch irgendwohergeladen werden müssen, aber da mußt du es ja auch anders machen)

[everdream]

Beim Inline -ssembler stehen mir doch die aktuell gültigen delphi-variablen zur verfügung, oder hab ich da was falsch verstanden? Das würde ja heißen, dass ich die variablen eben nicht extra irgendwo her laden müsste...

Naja, jedenfalls gabt ihr mich davon überzeugt, dass sich in meinem fall eine optimierung per asm wohl nicht lohnt. Danke nochmal für die Antworten!

[sirius]

Was denkst du denn, was eine Variable ist und woher der Wert in die FPU kommt? :cat:

[dizzy]

Zumal hier offenbar eine ganze Menge Grundlagen fehlen. Assembler von Hand zu basteln ist auch selten der erst beste Ansatz. In dem aller größten Teil aller Fälle, wo etwas scheinbar triviales auf ein mal langsam scheint, kann man am Algo an und für sich drehen. Da stecken gewöhnlich mehr als 60% des Optimierungspotentials bei komplexeren Operationen.
Eine Division ist aber auch eine elementare Operation die so direkt von der CPU bzw. FPU mit einer Anweisung durchgeführt wird, und so ziemlich jeder Compiler bekommt es noch auf die Kette diese ganz ganz grundlegenden Dinge optimal zu übersetzen.
Die einzige Chance ist wieder der Algo: Völlig abhängig von der Aufgabe eines Algos kann man hier und da grad Divisionen vermeiden oder durch geschickte Mathematik in schnellere Operationen aufdröseln, aber das ist dermaßen Problemspezifisch, dass dessen Erkennung und Durchführung automatisch eher nicht hinhaut. Ähnlich schaut es mit der Möglichkeit der parallelen Verarbeitung via MMX/SSE aus. Aber auch das sind beides zunächst einmal algorithmische Ansätze, bei denen - ausser bei MMX/SSE - kein einziges Handgeschriebenes Wort Assembler nötig ist.
Wenn irgendwann mal der Algo an und für sich ausgereizt ist, und zudem komplex genug dass ein Automat nicht eine beste Optimierung in Maschinencode schafft, dann kann man sich dran machen, und noch die letzten paar wenigen Prozente an Geschwindigkeit via Handmade-Assembler herauskitzeln. Das lohnt dann häufig mehr wenn man parallelisieren kann; als Beispiel hierfür kann man u.a. 2D-Vektoren anführen, deren elementaren Operationen man ganz hübsch mit SSE verarbeiten kann, da bei denen die 2 Koordinaten unabhängig voneinander sind, und die selben OPs mit ihnen durchgeführt werden.
Aber hier landet man ganz tief in den Details eines Algos, welcher an und für sich schon optimiert sein sollte.

Und eine einzelne Division ohne Kontext eines Algos bietet aufgrund dessen, dass sie elementar ist, genau 0 Optimierungspotential. Was Delphi da raus bringt, ist schon das best mögliche für diesen Fall.

Ich würde ausserdem etwas Lektüre zu Prozessorarchitektur/Registern und Compilern empfehlen. Dann wirst du auch schnell merken, dass dein Vorhaben hier prinzipbedingt zu nicht viel führen wird.

LG,
dizzy

[Chemiker]

Hallo everdream,


schau Dir mal diesen relativ neuen ASM-Beitrag
an, es geht zwar nicht um eine Divisionsfunktion, aber er verdeutlicht dafür sehr gut das man mit dem Richtigen (Schnellen) – Algorithmus mehr Leistung erzielen kann.
Kurz gesagt: Guter Algorithmus + Pascal = Gute Leistung
Schlechter Algorithmus + ASM = Schlechte Leistung

Bis bald Chemiker