Achtung. Optimierung beim Compiler

[s.h.a.r.k]

Schau mal hier.

Auf Delphi-Treff war mal ein guter Artikel dazu, finde den gerade aber nicht mehr.

PS: Thread solltest du auch ein einer T(Object)List verwalten, z.B.. Da hast du auch nicht das Problem einen freien Platz suchen zu müssen.

// edit
Soweit ich das noch weiß, optimiert der Compiler das dahingehend, da die CPU scheinbar leichter und schneller um 1 dekrementieren als inkrementieren kann. Aber einen Unterscheid sollte in deinem Programm nicht auftreten. Beim Debuggen findet du lediglich die "falschen" Werte, intern wird aber alles richtig ausgeführt.

// edit 2:
Hier, ganz unten findest du das auf Delphi Treff.

[jfheins]

Grund ist dass sehr einfach auf "=0" geprüft werden kann. ein "=100?" läuft also auf ein "x-100=0?" 'raus

Aber eigentlich sollte die Compileroptimierung keine Änderung des Verhaltens zeigen - wie du richtig festgestellt hast, lässt der Compilrr die Schleife vorwärts laufen sobald es einen Unterschied macht (=> eine Ausgabe erzeugt o.ä.)

Kann mit
{O+} und {O-}
gesteuert werden

[DelTurbo]

Zitat von jfheins:

Grund ist dass sehr einfach auf "=0" geprüft werden kann. ein "=100?" läuft also auf ein "x-100=0?" 'raus

Ne, das ist so nicht richtig. Wie ich oben schrieb braucht es ein cmp (Assembler) weniger. Richtig rum sähe das so aus

mov [register+?],0 // Startwert
schleife:
inc [register+?] // Wert einen hochzählen
cmp [register+?],$5a // Vergleichen ob MAX erreicht ist.
jne schleife

nach der Optimierung sieht es so aus

mov [register+?],$5a // MAX Wert
schleife:
dec [register+?] // Einen vom MAX abziehen
jnz schleife // Wenn nicht 0 dann weiter

Das ist extra so "platt" geschrieben das auch leute die kein Assembler können es verstehen sollten.

Gruss

PS.: Danke, das mit dem {O+} und {O-} werde ich mir merken.

EDIT: Ich weiss nicht was ihr mit Debugger meint. Ich meine das CPU-Fenster. Da sieht man wirklich was abgeht.

[himitsu]

Zitat von DelTurbo:

PS.: Danke, das mit dem {O+} und {O-} werde ich mir merken.

Oder sieh dich mal in den Projektoptionen um. :

Zitat von DelTurbo:

EDIT: Ich weiss nicht was ihr mit Debugger meint. Ich meine das CPU-Fenster. Da sieht man wirklich was abgeht.

Rate mal, wer dir Zugang zu diesem Fenster gewährt?

[DelTurbo]

Jo,

in den Projektoptionen habe ich das ja ausgemacht nachdem ich den salat gesehen habe. Es geht nur darum das man es dort z.b. Generell ausmacht und einzelne Proceduren optimiert. Oder halt andersrum.

Steht aber so auch in meinem ersten post.

Zitat:

Gibt es flags/parameter womit man teile des programms von der optimierung ausschliessen kann?

[SirThornberry]

Die Frage war eben ob es überhaupt notwendig ist an der Stelle die Optimierung abzuschalten. Denn wie bereits erwähnt wurde sollte sich die Optimierung nicht derart auswirken das eine falsche Logic entsteht.

[DelTurbo]

Zitat von SirThornberry:

Denn wie bereits erwähnt wurde sollte sich die Optimierung nicht derart auswirken das eine falsche Logic entsteht.

Macht es aber....

[himitsu]

Hab noch nie mitbekommen, daß es dadurch Probleme gibt.

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}

var
  i: Integer;
  InUse: Array[0..20] of Boolean;
  Sr, S: String;
begin
  for i := 0 to 20 do
    InUse[i] := Boolean(Random(2));
  Sr := '';
  for i := 0 to 20 do begin
    // zählt problemlos rückwärts
    if not InUse[i] then Sr := Sr + 'j' else Sr := Sr + 'n';
  end;
  S := '';
  for i := 0 to 20 do begin
    WriteLn(i);
    if not InUse[i] then S := S + 'j' else S := S + 'n';
  end;
  WriteLn(Sr);
  WriteLn(S);
end.

[JasonDX]

Zitat von s.h.a.r.k:

Soweit ich das noch weiß, optimiert der Compiler das dahingehend, da die CPU scheinbar leichter und schneller um 1 dekrementieren als inkrementieren kann.

Nein, der Compiler optimiert die Schleife so, dass sie nicht von n..m, sondern von (n-m-1)..0 läuft. Da bei Operationen wie Inc- und Dekrementieren bereits das Zero-Flag gesetzt wird, wenn der Wert 0 wird, erspart man sich einen Vergleich pro Schleifendurchlauf.

Zitat von s.h.a.r.k:

Aber einen Unterscheid sollte in deinem Programm nicht auftreten. Beim Debuggen findet du lediglich die "falschen" Werte, intern wird aber alles richtig ausgeführt.

Ja, der Zugriff auf InUse[i] erfolgt in der richtigen Reihenfolge. Der Compiler speichert sich den Zeiger auf InUse[0], und inkrementiert diesen bei jedem Schleifendurchlauf, während der Index dekrementiert wird. Läuft insgesamt schneller, und das Array wird in der korrekten Reihenfolge abgearbeitet.

greetz
Mike

[hoika]

Hallo,

was mich eh interessiert.
Wieso hast du beim Debuggen die Optimierung angeschaltet ?


Heiko