Tparallel und Bitmap-Bearbeitung

[Harry Stahl]

Ich würde gerne die TParallel-Library einsetzen, um verschiedene Bitmap-Routinen schneller zu machen.

Ich habe hier versucht, das mal für eine 24-Bit-Bitmap zu implementieren (Funktion, welche abhängig von einem Wert eine Bitmap aufhellt bzw. abdunkelt):

Delphi-Quellcode:

procedure Helligkeit(Bitmap: TBitmap; Const Original : TBitmap; Value: integer; IgnoreWhite: Boolean);
var
  x,y     : integer;
  Ziel    : ^TRGBTriple;
  Quelle  : ^TRGBTriple;
  n       : byte;
  ar      : array[0..255] of byte;
  RGBAQuelle, RGBAZiel: pRGBALine;
  OK: Boolean;
begin
  n := abs(value);

  if value > 0 then
    for x := 0 to 255 do if integer(x + n) > 255 then ar[x] := 255 else ar[x] := x + n
  else
    for x := 0 to 255 do if integer(x - n) < 0 then ar[x] := 0 else ar[x] := x - n;

    for y := 0 to Bitmap.Height-1 do begin
      Ziel   := Bitmap.Scanline[y];
      Quelle := Original.Scanline[y];

      TParallel.For(0, Bitmap.Width-1, procedure (L: Integer) // <-- Hier neu eingebaut
      begin
        if IgnoreWhite then begin
          OK := (Quelle^.rgbtBlue <> 255) or (Quelle^.rgbtGreen <> 255) or (Ziel^.rgbtGreen <> 255);
        end else begin
          OK := True;
        end;

        if OK then begin
          Ziel^.rgbtBlue  := ar[Quelle^.rgbtBlue];
          Ziel^.rgbtred   := ar[Quelle^.rgbtred];
          Ziel^.rgbtGreen := ar[Quelle^.rgbtGreen];
        end;

        inc(Ziel);
        inc(quelle);
      end)
    end;
end;

Leider kriege ich immer Zugriff-Exceptions (Access violations), bzw. Bild ist verzerrt und Programm hängt sich auf.

Jemand eine Idee, wie man das richtig macht? Muss ich den Zugriff auf das Bitmap schützen, wenn ja, wie am besten?

[Sir Rufo]

Nun überleg doch mal, wofür man das L benutzen könnte, wenn man mal unterstellt, dass Ziel und Quelle ein Array ist (ist es).

Und gleichzeitig frage dich, ob es gut ist, wenn man bei einer parallelen Bearbeitung überall den Bezugspunkt einfach so verschiebt Inc(Ziel); Inc(Quelle); .

Das kann man fast vergleichen mit "Wenn ein Ei 5 Minuten gekocht werden muss, wie lange müssen dann 10 Eier kochen?"

[himitsu]

Scanline: Ist das auch wirklich ein 32-Bit-Bitmap?

Und man durfte noch nie nicht-threadsichere Befehle in einem Thread ausführen.

• Inc z.B.

Außerdem sind alle deine lokalen Variablen sowas wie globale Variablen, welche in allen Threads "gleich" sind.

• B muß lokal in die Thread-Prozedur
• Quelle/Ziel darf nicht geändert werden, also auch eine lokale Thread-Variable und dann LokalQuelle:=Quelle+L;
• Pro Thread nur ein einziger Wert macht das nicht schneller, sondern sehr viel langsamer, da viele Threads. -> Anzahl=Breite*Höhe
  Wenn, dann eher pro Line, oder besser für mehrere Lines, ein Thread.

Eier? Oder ...
Wenn ein Kuchen bei 200°C 40 Minuten braucht, wie lange braucht er dann bei 800°C?

[Sir Rufo]

@himitsu

Das Argument "viele Threads" stimmt nicht, es sind "viele Aufgaben" die mit einem ThreadPool abgearbeitet werden. Da dürften nach einer gewissen "Warmlaufphase" nur eine Handvoll Threads aktiv sein.

[himitsu]

Ja, aktiv sind gleichzeitig immer nur ein paar, aber insgesammt sind es sehr Viele.
Vermutlich also mehr Verwaltungaufwand, als Zeitersparnis.


Vorher gab es Einen Typen, der holte sich alle Infos und arbeitete das dann nacheinander ab.
Jetzt gibt es vielleicht 8 Leute, die rennen gleichzeitig zu einen Verwalter Hauptthread, holen sich durcheinanderredend irgendeine Arbeitsposition bearbeiten ein Pixel schreiben gleichzeitig in zwei Variablen rein und rennen dann wieder zum Pool-Verwalter, fragen ob noch ein Thread da ist, fragen wieder gleichzeitig den Verwalter Hauptthread und bearbeiten irgendin ein Pixel, bis alle Pixel Threads durch sind.

[Sir Rufo]

Es sind eben nicht insgesamt viele, es sind und bleiben eine Handvoll Threads, die, wenn einmal erzeugt, bis zum Ende des ThreadPools aktiv/schlafend bleiben. Diese Threads holen sich einfach die nächste Aufgabe, verarbeiten die und es geht wieder von vorne los. Da ist kaum ein Unterschied, ob ich jetzt eine Aufgabe mit 10 Einzelschritten oder 10 Aufgaben mit jeweils 1 Einzelschritt übergebe.

[himitsu]

OK, dann sind es eben massig anonyme Methoden (1), welche in einem Pool warten und von einer Hand voll Threads abgearbeitet werden.

1:
* kurzer Code von nichtmal annähern einer Millisekunde Rechenzeit
* der jeweils nur ein einziges Pixel verarbeitet

Die Verwaltung und Synchronisierung dieses Pools ist garantiert langsamer, als die eingesparte Zeit.
Über die Verarbeitung einer ganzen oder mehrere Zeilen, würde jede Methode länger rechnen und der Tool müsste gleichzeitig weniger verwalten.

[Dejan Vu]

Ich würde die Bearbeitung für jede ScanLine in einen separaten Thread verschieben, also vielleicht so:

Delphi-Quellcode:

TParallel.For(0, Bitmap.Height-1, procedure (Y: Integer) 
var
  Ziel : ^TRGBTriple;
  Quelle : ^TRGBTriple;
  OK: Boolean;

begin
  Ziel := Bitmap.Scanline[y];
  Quelle := Original.Scanline[y];
,,,

Grund:
1. Größere Abschnitte (vielleicht kann man die noch größer machen, jeder Thread X Scanlines auf einmal)
2. Keiner tritt dem anderen auf die Füße.

Die Vergleiche mit Eiern und Kuchen sind zwar boxkomisch, aber hier ist der Denkfehler ja der, das die Variablen unkontrolliert verwendet werden, und das sehe ich bei dem Eierkochenkuchenbackenvergleich nicht.

Diese TParallel-Library ist kein Hexenwerk und zaubern kann sie auch nicht. Das ist ein ziemlich banaler, aber sehr elegant zu verwendender Threadpool. Alles, was man über Threads weiß, muss man auch hier beherzigen. Wenn man die einzelnen Jobs nicht allzu granular aufteilt (1 Pixel ist SEHR granular) und den Scope/Zugriff der gemeinsam verwendeten Variablen beachtet (Füße, blaue Flecken und so), muss man sich wohl über die Anzahl der CPU-Kerne keine Gedanken mehr machen. Aber über den ganzen Rest schon.

[himitsu]

Ja, Ziel/Quelle in jeden Thread verschieben und zugleich hoffen, daß Scanline threadsafe ist.

[Dejan Vu]

Zitat von himitsu:

Ja, Ziel/Quelle in jeden Thread verschieben und zugleich hoffen, daß Scanline threadsafe ist.

=> Ansonsten vorher in ein Array packen.