Parallele For-Schleife in C# mit der freigegebenen variable

Ich versuche, parallele Verarbeitung zu beschleunigen, ein paar von verschachtelten Schleifen, aber ich habe Probleme dabei, die syntax Recht. Ich bin versuchen, um eine zu zählen, wie viele Pixel in einer bitmap sind entweder rot, weiß oder schwarz, die Werte, für die habe ich in einem enum anderswo.

In der seriellen Verarbeitung habe ich folgenden code, der gut funktioniert:

        Bitmap image = new Bitmap(@"Input.png");
        var colourCount = new int[3];

        for (var x = 0; x < image.Width; x++)
        {
            for (var y = 0; y < image.Height; y++)
            {
                switch (image.GetPixel(x, y).ToArgb())
                {
                    case (int)colours.red: colourCount[0]++; break;
                    case (int)colours.white: colourCount[1]++; break;
                    case (int)colours.black: colourCount[2]++; break;
                    default: throw new ArgumentOutOfRangeException(string.Format("Unexpected colour found: '{0}'", image.GetPixel(x, y).ToArgb()));
                }
            }
        }

Habe ich gesehen-code für die parallele for-Schleifen, die von Microsoft und von Stackoverflow, das aktualisieren einer gemeinsamen Variablen wie unten:

        Parallel.For<int>(0, result.Count, () => 0, (i, loop, subtotal) =>
        {
            subtotal += result[i];
            return subtotal;
        },
            (x) => Interlocked.Add(ref sum, x)
        );

Aber alle Beispiele verwenden eine einfache Art, wie ein int als die shared-variable und ich kann einfach nicht herausfinden, die syntax zu schreiben, um meine Größe von drei Arrays. Bin ich der Annäherung an diese alle falsch?

Übrigens, ich weiß in Bezug auf performance, GetPixel ist sehr langsam im Vergleich zu so etwas wie Bitmap.LockBits, ich versuche nur, um das Prinzip der parallelen Schleifen Recht.

InformationsquelleAutor Andrew Jones | 2013-06-14
  1. 4

    Können Sie eine überlastung der Parallel.Für und ermöglicht es Ihnen, zu halten thread-lokale Zustand. In diesem Fall erstellen wir ein int[3] array für jeden thread, der erzeugt wird. Innerhalb jeder iteration der parallelen Schleife, die wir nur zu aktualisieren, die lokalen array localColourCount. Schließlich, wenn der thread zurückgezogen werden, aggregieren wir die Ergebnisse der einzelnen lokale array in das Globale, colourCount; da dies jedoch ist eine gemeinsame Datenstruktur, setzen wir den gegenseitigen Ausschluss beim Zugriff auf es.

    Bitmap image = new Bitmap(@"Input.png");
var colourCount = new int[3];

Parallel.For(0, image.Width,

    //localInit: The function delegate that returns the initial state
    //           of the local data for each task.
    () => new int[3],

    //body: The delegate that is invoked once per iteration.
    (int x, ParallelLoopState state, int[] localColourCount) =>
    {
        for (var y = 0; y < image.Height; y++)
        {
            switch (image.GetPixel(x, y).ToArgb())
            {
                case (int)colours.red: localColourCount[0]++; break;
                case (int)colours.white: localColourCount[1]++; break;
                case (int)colours.black: localColourCount[2]++; break;
                default: throw new ArgumentOutOfRangeException(
                             string.Format("Unexpected colour found: '{0}'", 
                             image.GetPixel(x, y).ToArgb()));
            }
        }
    },

    //localFinally: The delegate that performs a final action
    //              on the local state of each task.
    (int[] localColourCount) =>
    {
        //Accessing shared variable; synchronize access.
        lock (colourCount)
        {
            for (int i = 0; i < 3; ++i)
                colourCount[i] += localColourCount[i];
        }
    });

    Diesem code wird davon ausgegangen, dass Bitmap.GetPixel thread-sicher ist, die möglicherweise oder möglicherweise nicht der Fall sein.

    Andere Sache, die Sie brauchen zu beachten ist, dass jede ArgumentOutOfRangeException Instanzen kombiniert in einem AggregateException, so müssen Sie einstellen das error-handling-code.

    • Braucht man eigentlich nicht lock in Ihrem localFinally. Sie könnte stattdessen verwenden Interlocked.Add() in der Schleife. Obwohl lock macht es offensichtlich richtig.
    • Mehrere Aufrufe von Interlocked.Add weniger effizient als ein einzelner lock. (Auf jeden Fall wäre der Fall, wenn die colourCount Bestand aus zehn Elementen; sicher nicht für 3.) Pro Albahari: "Alle Interlocked's Methoden generieren einen vollständigen Zaun." Die wiederholte cache-Invalidierung Aufwand könnte mehr als die Kosten für die einzelne Sperre.
    • Vielen Dank für den Beitrag, es macht viel mehr Sinn für mich jetzt. Sie sind richtig in der Annahme, dass GetPixel ist nicht thread-sicher, in der Tat den Zugriff auf die Bilder-Eigenschaften oder-Methoden scheint zu sein, ein no-no, also ich muss herausfinden, einen Weg, aber ich habe die Schleife an sich funktioniert gut. Nochmals vielen Dank!
    InformationsquelleAutor Douglas
Schreibe einen Kommentar