Geschwindigkeit von Schleifen

[Dennis07]

Danke bis hierher schonmal, allerdings könntet ihr mir vielleicht sagen, wie man herausfindet, woraus genauer die von dem Compiler erzeugten Schleifenquelltexte bestehen?
Denn bei der Ausführung des aktuellen Befehls, wird die For-Schleife beispielsweise als solches ausgeführt und es wird nicht zu einem Quelltext gesprungen.

[Zacherl]

Selbst wenn repeat .. until aus irgendeinem Grund schneller sein sollte als for .. do, würde ich hier (ua. aufgrund der Lesbarkeit des Codes) definitiv niemals optimieren. Solche Dinge sind meiner Meinung nach Compilersache!

Wie himitsu schon sagte sind es im Grunde genommen nur "gotos" (Jumps). Du solltest im Assembler Code Mnemonics wie JMP, JNZ, JE, JZ ... sehen (da gibts ne ganze Reihe). Bei for Schleifen wird irgendwo ein INC bzw. DEC zu finden sein und gelegentlich gehört auch noch ein CMP mit dazu. Kann man so generisch gar nicht sagen.

[Der schöne Günther]

Beispielbild im Anhang.

Schau mal unter Ansicht -> Debug-Fenster -> CPU-Ansicht


Wir sehen dass eine for-downto-Schleife in Assembler irgendwie anders (kürzer) ist als eine for-to.

[Zacherl]

Habs auch mal schnell ausprobiert.

[p80286]

Zitat von jfheins:

Die Geschwindigkeit von Schleifen ist ein erster Näherung "hinreichend schnell" und in zweiter "egal".

Eine for-in Schleife ist vermutlich einen *Hauch* langsamer, da da einige Funktionsaufrufe versteckt sind.
Es ist sinnvoller, sich auf andere Sachen zu konzentrieren:
1. Die Anweisungen in der Schleife
2. Brauche ich die Schleife? Kann ich eine bessere Datenstruktur einsetzen, die schneller ist und auf die Schleife verzichtet?

P.S.: Schleifen führen Anweisungen 0 bis x fach aus, if-then und case-of sind daher keine Schleifen.

das kann ich auch nur unterschreiben.
Zu seligen TP-Zeiten war es so, daß
for to Schneller war als while und repeat .
Diese beiden waren gleich schnell, den Unterschied machte die Abfrage der Abbruchbedingung aus, was aber nur relevant ist, wenn man um die Millisekunde feilschen muß.

Das if und case nichts mit Schleifen zu tun haben, wurde ja schon geschrieben - warum ist dieser Blödsinn eigentlich nicht auszurotten?.

Case wäre theoretisch schneller, wenn es mit einer Sprungtabelle realisiert würde, das ist allerdings nicht der Fall (soweit ich weiß), somit ist es letztlich für den Compiler egal was eingesetzt wird. Im Sourcecode bevorzuge ich case , da dies doch etwas übersichtlicher ist als ellenlange if..then..else -Konstrukte.


Gruß
K-H

P.S.
@Schönster Mann von allen
Ich glaube Du hast Dich verguckt, die Schleife ist in beiden Fällen gleich lang/groß
(inc cmp jnz)
Und was schneller ist,dec oder inc dazu hab ich auf die Schnelle nichts gefunden

[Dennis07]

Ah, danke, genau das habe ich gesucht Entschuldigt bitte, dass mir die Disassembly-Anzeige-Funktionalität nicht geläufig war
Dass eine For-Downto schneller ist als eine For-To, war mir ja schon klar, da ja eine For-To eh immer eine invertierte For-Downto ist.

[Zacherl]

Zitat von Dennis07:

Dass eine For-Downto schneller ist als eine For-To, war mir ja schon klar

Woraus hast du denn diese Aussage jetzt geschlussfolgert? Ist nämlich Blödsinn Wie auf meinem Screenshot zu sehen besteht sowohl die for .. to, als auch die for .. downto Schleife aus den exakt gleichen Instruktionen MOV, INC/DEC, CMP, JNE.

repeat .. until sieht auf den ersten Blick kompakter aus, als die anderen Schleifen (es fehlt das INC/DEC), aber man muss bedenken, dass die Zählervariable hier manuell im Schleifenkörper gesetzt werden muss. Demnach würde hier zumindest noch eine weitere Instruktion hinzukommen.

while .. true hat den größten Overhead, da vor Begin der eigentlichen Schleife nochmal dediziert geprüft wird, ob die Bedingung überhaupt erfüllt ist. Dieser Check (hier: CMP, JG) wird allerdings nur ein einziges Mal ausgeführt und beeinflusst daher die eigentliche Laufzeit der Schleife nicht.

Fazit:
In dem von mir getesteten Fall (lokale Funktion mit lokaler Zählervariable) sind alle Schleifen gleich performant.

[Neutral General]

Es kann da auch keinen großen Performanceunterschied geben. Letzendlich ist entweder nur die Syntax in Delphi anders und der Code Assemblercode ist der gleiche oder die Assemblerbefehle tauchen ggf. in einer minimal anderen Reihenfolge auf. Letztendlich läuft es immer auf eine bestimmte Kombination von cmp/inc/jmp hinaus.

[himitsu]

Daß for i := irgendwas downto 0 do oftmals schneller ist, als ein for i := 0 to irgendwas do ,
liegt nicht an der Richtung, sondern meistens nur daran, daß das Ende hartecodet werden kann und keine Variable zwischengespeichert/ausgewertet werden muß.

Denn bei for i := -irgendwas to 0 do und for i := 0 downto -irgendwas do wäre es praktisch andersrum.


PS: Ohne Optimierung entspricht diese For-Schleife

Delphi-Quellcode:

for i := 0 to xxx do begin
  ...
end;

intern jender While-Schleife.

Delphi-Quellcode:

i := 0;
Ende := xxx;  // Dieses hier ist auch der Grund, warum man Löschen besser rückwärts erledigt.
while xxx <= Ende do begin
  ...
  Inc(i);
end;

Nja, eigentlich eher dem

Delphi-Quellcode:

i := 0;
Ende := xxx;  // Dieses hier ist auch der Grund, warum man Löschen besser rückwärts erledigt.
if i <= Ende then
  repeat
    ...
    Inc(i);
  until xxx = Ende;  // = und nicht >=

Aber das fällt kaum auf, außer man manipuliert an der Schleifenvariable, um z.B. etwas ala for i := 0 to 9 step 3 do basteln, denn bei 0 to 10 landet man quasi in einer Endlosschleife, da die 10 übersprungen wird.

[Dejan Vu]

War da nicht mal was, dass der Vergleich auf 0 schneller ist, als der Vergleich auf '<Variable>'? Aber egal, das sind eh Peanuts.

Wichtig sind doch eh die inneren Werte (der Schleife).