Performance-Optimierung

[VkPenguin]

Guten Tag zusammen,
ich habe nochmal eine Frage. Mein Programm ist inzwischen (Dank eurer Hilfe ) fast fertig, es tut im Prinzip, was ich möchte. Das "Problem" ist nur, das die Bildberechnung recht langsam ist. Wenn man ein Bild ausgewählt hat und die Berechnung starten lässt kann es bis zu 5 Minuten dauern, bis das neue Bild daraus fertig errechnet wurde. Meine Frage ist also, ob ihr vielleicht Möglichkeiten kennt, wie man seinen Code auf "Schwachstellen" überprüfen kann, die schneller/einfacher gelöst werden können.

Mir ist zum Beispiel aufgefallen, dass ich einige Proceduren/Funktionen häufig so Aufrufe:

Delphi-Quellcode:

For X:=0 To Bildbreite-1 Do
Begin
For Y:=0 TO Bildhöhe-1 Do
Begin
*Funktion/Procedur*
End;
End;

Wenn die Procedur dann aber solche Zeilen beinhaltet
Farbtoleranz:=Ceil(SB_Farbtoleranz.Position*255/100); bedeutet das ja, das ich sehr oft eine Rechnung durchführe, die aber immer die gleiche Konstante ergibt. Würde es sich lohnen, alle Funktionen/Proceduren so umzuschreiben, dass sie die Schleifen beinhalten, damit das nicht mehr passiert?

Das wäre einiges an Arbeit, aber wenn das Programm dadurch spürbar schneller wird würde ich es machen. Ich weiß nur nicht, wieviel so eine Rechnung bei heutigen PCs wirklich ausmacht.

Vielen Dank schon einmal für eure Tipps!

[himitsu]

Du greifst aber nicht zufällig auf Canvas.Pixels zu?

Wenn doch, dann kannst du Funktionsaufrufe optimieren wie du willst ... Pixels ist sowas von lahm, da fallen die 1-2 CPU-Ticks auch nicht mehr auf.

TCanvas.ScanLine ... gibt zu Pixels und ScanLine auch schon genügend Themen, welche man sich gerne durchlesen könnte.



Und ja, wenn immer wieder das Selbe berechnet wird und dabei immer das Selbe rauskommt, dann ist es natürlich schneller, wenn es nur einmal berechnet wird.

Funktionsaufrufe sind "Sprünge" und wenn dann auch noch "wenig" in der Funktion/Prozedur gemacht wird, dann kann sich das rumgespringe schon etwas auf die Zeit auswirken.
Inline-Funktionen

Delphi-Quellcode:

function xyz(i, i2: Integer): Integer; inline;
begin
  Result := i * i2;
end;

Solch eine Inlinefunktion ist fast wie ein Makro ... hier wird an der Stelle des Aufrufs nicht zur Prozedur gesprungen, sondern der enthaltene Code (wenn möglich) direkt da eingebaut, also so, als wenn man den Code direk dort hingeschrieben und nicht in eine Funktion ausgelagert hätte.



Und wie im anderen Thread schon erwähnt wurde, gibt es verschiedene Performance-Tools, welche einem die "Engstellen" nennen.
Oder man misst selber nach, indem man an verdächtigen Stellen die Zeit stoppt.

[VkPenguin]

Danke erstmal für deinen Tipp!
Habe mir gestern Abend noch ein paar Beiträge zu dem Thema durchgelesen und es hörte sich ja vielversprechend an, auch wenn ich es noch nicht zu 100% verstanden habe.
In der Hoffnung das zu ändern hab ich heute morgen einfach schnell ein kleines Programm zum Testen gemacht, welches nach ein bisschen rumprobieren auch funktionierte. Nun versuche ich, das ganze auf mein Hauptprogramm zu übertragen, ich erhalte jedoch immer einen Fehler. Gibt es da noch etwas über Scanline, das ich wissen müsste? Es scheint, als dürfte man "p^[X]" nur einmal benutzen, weil ich immer eine Exeption bekomme, wenn ich es ein zweites mal verwende, egal in welcher reihenfolge..

Hier mal eine Procedur (An der makierten Stelle kommt die Fehlermeldung):

Delphi-Quellcode:

procedure TForm1.AnalysePIC2;
type
PixArray = Array [1..3] of Byte;
VAR p: ^PixArray;
VAR X,Y,Farbtoleranz:Integer;
VAR RValSel,GValSel,BValSel:Byte;
Begin
// Standartwerte //
 PB_Small.Max:=PIC_Breite*3;
 PB_Small.Position:=0;
 AnyLine:=False;
 for X  := 0 to PIC_Breite do
  Begin
  PB_Small.Position:=PB_Small.Position+1;
  for Y  := 0 to PIC_Höhe do
   Begin
   Line[X,Y]:=False;
  End;
 End;
// /Standartwerte //

 PB_Main.Position:=PB_Main.Position+3;
 PIC_res.Assign(PIc_res2);
 Farbtoleranz:=Ceil(SB_Farbtoleranz.Position*255/100);
 RValSel:=GetRValue(Color_Analysefarbe.Selected);
 GValSel:=GetGValue(Color_Analysefarbe.Selected);
 BValSel:=GetBValue(Color_Analysefarbe.Selected);

 for Y  := 0 to PIC_Höhe-1 do
  Begin
  PIC_Res.ScanLine[Y];
  for X:=0 To PIC_Breite-1 do
   Begin
   if SB_Farbtoleranz.Position>0 then
    Begin
    if (((Abs(RValSel-P^[3]))<=Farbtoleranz) AND ((Abs(GValSel-P^[2]))<=Farbtoleranz) AND ((Abs(BValSel-P^[1]))<=Farbtoleranz)) then
     Begin
     AnyLine:=True;
     Line[X,Y]:=True;
     LinePTK:=LinePTK+1;
    End
    else
     Begin
     //Weiß

p^[3]:=255;

Delphi-Quellcode:

 
     p^[2]:=255;
     p^[1]:=255;
     Inc(p);
    End;
   End
   Else
    Begin
    if ((p^[3]=0) AND (p^[2]=0) AND (p^[1]=0)) then
     Begin
     AnyLine:=True;
     Line[X,Y]:=True;
     LinePTK:=LinePTK+1;
    End
    else
     Begin
     p^[3]:=255; //Weiß
     p^[2]:=255;
     p^[1]:=255;
     Inc(p);
    End;
   End;
  End;
 End;

.
.
.

Was mache ich denn falsch?

Und zu dem Inline: Verstehe ich es richtig, dass es also die Programmgeschwindigkeit erhöht, weil der PC dann nicht "hin und her springen" muss? Aber warum macht man das dann nicht immer? Die Datei wird vielleicht ein bisschen größer, aber soviel kann das doch nicht ausmachen, oder?

[Bummi]

warum arbeitest Du mit Zeigern
p: ^PixArray;

und nicht mit Variablen

p: PixArray;

Der Speicher auf den Du so zugreifst hängt im Irgendwo ...

[KarstenK]

Der Compiler sagt bestimmt uninitialisierte Variable p als Warnung.

Sicherlich fehlt hier was: PIC_Res.ScanLine[Y];

Ansonsten ist der Quelltext mit Bummis Hinweis wesentlich besser lesbar.

[VkPenguin]

Das ist ja der Teil, den ich nicht so wirklich verstanden habe. Aber hier war es mit der Begründung

Zitat:

Da ScanLine einen Zeiger erwartet

so, also hab ich es ersteinmal übernommen, ich dachte vielleicht wird es mir ja später dann dadurch klar..

Fehlermeldung an makierter Stelle:

---------------------------
Benachrichtigung über Debugger-Exception
---------------------------
Im Projekt Bubbelzmain.exe ist eine Exception der Klasse EAccessViolation mit der Meldung 'Zugriffsverletzung bei Adresse 004ABEC7 in Modul 'Bubbelzmain.exe'. Schreiben von Adresse 004445E6' aufgetreten.
---------------------------
Anhalten Fortsetzen Hilfe
---------------------------

Aber wenn ich diese Zeile an den Anfang schiebe funktioniert es, dafür erhalte ich den Fehler dann bei der If... Stelle. Und genau das meinte ich ja, das kann ich mir nicht erklären..

[Bummi]

Ich tue mir schwer in Deinem Code etwas mir bekanntes zu entdecken ...
Vielleicht findest Du in meinen Beispielen etwas was Dir bei Dir bekannt vor kommt.

Delphi-Quellcode:

type
  pRGBTripleArray = ^TRGBTripleArray;
  TRGBTripleArray = ARRAY[0..$effffff] OF TRGBTriple;
  pRGBQuadArray = ^TRGBQuadArray;
  TRGBQuadArray = ARRAY[0..$effffff] OF TRGBQuad;



Procedure InvertBitMap24(bmp:TBitMap);
CONST
  PixelCountMax = MaxInt / 3;

var
  pscanLine : pRGBTripleArray;
  x,y:Integer;
begin
    for Y := 0 to bmp.Height -1 do
     begin
         pscanLine := bmp.Scanline[y];
         for x := 0 to bmp.Width -1 do
           begin
           pscanLine[x].rgbtBlue   := pscanLine[x].rgbtBlue XOR 255;
           pscanLine[x].rgbtGreen   := pscanLine[x].rgbtGreen XOR 255;
           pscanLine[x].rgbtRed   := pscanLine[x].rgbtRed XOR 255;
           end;
     end;
end;

Procedure InvertBitMap32(bmp:TBitMap);
CONST
  PixelCountMax = MaxInt / 3;

var
  pscanLine : pRGBQuadArray;
  x,y:Integer;
begin
    for Y := 0 to bmp.Height -1 do
     begin
         pscanLine := bmp.Scanline[y];
         for x := 0 to bmp.Width -1 do
           begin
           pscanLine[x].rgbBlue   := pscanLine[x].rgbBlue XOR 255;
           pscanLine[x].rgbGreen   := pscanLine[x].rgbGreen XOR 255;
           pscanLine[x].rgbRed   := pscanLine[x].rgbRed XOR 255;
           end;
     end;
end;

Procedure InvertBitMap(bmp:TBitMap);
begin
  if bmp.PixelFormat=pf32Bit then  InvertBitMap32(bmp)
  else if bmp.PixelFormat=pf24Bit then  InvertBitMap24(bmp);
end;

[VkPenguin]

**

Danke euch beiden. KarstenK, Du hattest recht, an der Stelle fehlte was. Und Bummi, danke Deines Beispiels hab ich auch 1) verstanden was fehlte und 2) verstanden wie das Scanlineprinzip funktioniert. Jetzt gehts, ich hoffe den Rest des Programms kann ich nun auch umbauen. Aber dieser Teil ist jetzt schon einmal viel schneller als vorher.

*Edit*: Ach so, was war denn hiermit...?

Zitat:

Und zu dem Inline: Verstehe ich es richtig, dass es also die Programmgeschwindigkeit erhöht, weil der PC dann nicht "hin und her springen" muss? Aber warum macht man das dann nicht immer? Die Datei wird vielleicht ein bisschen größer, aber soviel kann das doch nicht ausmachen, oder?

[Bummi]

http://docs.embarcadero.com/products...tions_xml.html

[p80286]

Auch wenn es etwas OT wird, aus der D7-Hilfe:

Zitat:

Das reservierte Wort inline und die Direktive assembler werden aus Gründen der Abwärtskompatibilität beibehalten. Sie haben keine Auswirkungen auf den Compiler.

Ab wann steht Inline denn in der o.g. angesprochenen Art zur Verfügung?

Gruß
K-H