Prüfung eines Bitmaps auf Transparenz (gehts noch schneller)?

[Uwe Raabe]

Das TParallel.For über die 2819 Zeilen verursacht wahrscheinlich mehr Overhead als die Parallelisierung wettmachen kann. Wenn das ganze Bild ca. 80 ms braucht, dann sind das pro Zeile (also pro Iteration) ca. 0,03 ms. Das ist ein ganz schlechtes Verhältnis. Besser auf deutlich weniger Durchläufe beschränken und jede Iteration über ca. 100-500 Zeilen laufen lassen. Das sind dann pro Task ca. 3-15ms. Mit genügend freien Kernen sollte das merkbar sein.

[Harry Stahl]

Zitat von Uwe Raabe:

Das TParallel.For über die 2819 Zeilen verursacht wahrscheinlich mehr Overhead als die Parallelisierung wettmachen kann. Wenn das ganze Bild ca. 80 ms braucht, dann sind das pro Zeile (also pro Iteration) ca. 0,03 ms. Das ist ein ganz schlechtes Verhältnis. Besser auf deutlich weniger Durchläufe beschränken und jede Iteration über ca. 100-500 Zeilen laufen lassen. Das sind dann pro Task ca. 3-15ms. Mit genügend freien Kernen sollte das merkbar sein.

Ja, wäre eine mögliche Verbesserung. Doch damit steigt die Komplexität wieder an und es wird so ein unschönes unleserliches Ungetüm draus. Und ob es schneller ist?

Insofern wäre mir eine Standard-Lösung lieber, z.B. per ASM.

Kenne mich mit Assembler aber leider nicht so gut aus.
Aber hier muss ja letztlich nur über einen zusammenhängenden Speicherbereich, jeweils in Abständen von 4 Byte geprüft werden, ob das Byte dort <> 255 ist.

Nichts anderes macht ja im Prinzip meine Standard-Methode. Aber gibt es da nicht so einen Super ASM-Befehl, der das in einem Rutsch ohne Iteration erledigen kann?

[BUG]

Das mit der gröberen Aufteilung sollte man probieren.
Eventuell könnte man mit den Vektoreinheiten (SSE) noch was heraushole. Das wird dann aber haariger (kA. wie weit Delphi von alleine vektorisiert).

Edit:

Zitat von Harry Stahl:

Doch damit steigt die Komplexität wieder an und es wird so ein unschönes unleserliches Ungetüm draus. Und ob es schneller ist?[...] Insofern wäre mir eine Standard-Lösung lieber, z.B. per ASM.

Frei nach Herb Sutter "Free lunch is over". Parallelisieren ist die Standard-Lösung.
Und dein Problem ist wirklich noch einfach zu parallelisieren

[Harry Stahl]

Oder gibt es was in der Grafik-32 Bibliothek?

Oder DirectDraw? Irgendeine Lösung, welche die schnellere GPU nutzt, wäre natürlich auch willkommen.

[jaenicke]

Die Zeit sind hier 40 Millisekunden. Davon entfallen ca. 2 Millisekunden auf das Scanline und den Teil außerhalb der Schleife, 24 Millisekunden rein auf die Schleife, 8 Millisekunden auf den Vergleich und 6 Millisekunden auf den Zugriff auf den aktuellen Wert in der Schleife.

Sonderlich viel Optmierungspotential sehe ich dort deshalb leider nicht. Ich habe auch den Assemblercode angeschaut, der ist schon durch den Compiler gut optimiert. Auch ein einfaches Verschieben des Pointers auf das vierte Byte und dann jeweils um 4 Byte hat nichts gebracht, das war meine Idee.

Ob die GPU hier helfen kann, bin ich nicht so sicher, die ist eigentlich eher bei Fließkommaoperationen sehr schnell.

Die Lösung mit TParallel ist bei mir aber schon deutlich schneller als die Standardvariante. Allerdings erst ab dem zweiten Durchlauf, dann braucht es aber konstant etwas weniger als die halbe Zeit.

[noisy_master]

Moin,

eine Winzigkeit fällt mir noch ein, um das Ganze "minimal " schneller zu bekommen: dreh die Schleife um und lass alle Berechnungen daraus weg:

dec(z);
for x := z downto 0 do begin


Der Vergleich auf 0 ist "einfacher" und damit schneller als der Vergleich auf einen festen (berechneten) Wert.

Dürfte zwar nicht DER Bringer sein, aber wenn's auch nur ein Wenig hilft..

Gruß
Dirk

[Neutral General]

Zitat von noisy_master:

eine Winzigkeit fällt mir noch ein, um das Ganze "minimal " schneller zu bekommen: dreh die Schleife um und lass alle Berechnungen daraus weg:

Delphi optimiert das normalerweise (wenn möglich) von selbst beim compilieren.

[himitsu]

Zitat:

Aber gibt es da nicht so einen Super ASM-Befehl, der das in einem Rutsch ohne Iteration erledigen kann?

Nein, auch da sind schleifen nötig.

Delphi speichert den "Endwert", also 2 Variablen, was bei fester 0 nicht nötig ist, zusätzlich zum DEC x; JZ p; , statt einem DEC x; CMP x, z; JE p; , als Abbruchbedingung (oder so in etwa)

Delphi-Quellcode:

IstUngleich0 := False;
for x := z - 1 downto 0 do begin
  if PixelArrayPointerDerAktuellenZeileInPByte[x * 4 + 3] <> 0 then begin  // das + 3 besser vorher drauf rechnen
    IstUngleich0 := True;  
    Break;
  end;

Einzelbytezugriffe sind eh schlechter, also ...

Delphi-Quellcode:

IstUngleich0 := False;
for x := z - 1 downto 0 do begin
  if PixelArrayPointerDerAktuellenZeileInPLongWordOderTColor[x] and $ff000000 <> 0 then begin
    IstUngleich0 := True;  
    Break;
  end;

geht nur bei gerade Pixelanzahl

Delphi-Quellcode:

IstUngleich0 := False;
for x := z div 2 - 1 downto 0 do begin
  if PixelArrayPointerDerAktuellenZeileInPLargeWord[x] and $ff000000ff000000 <> 0 then begin  
    IstUngleich0 := True;  
    Break;
  end;

Bei einem 32-Bit-Bitmap kann man auch alle Zeilen zusammen in dieser einen Schleife behandeln, da die Zeilen im Speicher hintereinander liegen, ohne ein Offset/Align.

Oder ohne Offsetberechnungen mit einer For/While-Schleife, von PointerErstesPixel bis PointerLetztesPixel.