Ich bin neu bei Grand Central Dispatch und habe einige Tests durchgeführt, bei denen ein Bild bearbeitet wurde. Im Grunde genommen führe ich einen Graustufenalgorithmus sowohl sequentiell als auch unter Verwendung von GCD aus und vergleiche die Ergebnisse.

Hier ist die grundlegende Schleife:

UInt8 r,g,b;
uint pixelIndex;
for (uint y = 0; y < height; y++) {
    for (uint x = 0; x < width; x++) {
        pixelIndex = (uint)(y * width + x);

        if (pixelIndex+2 < width * height) {
            sourceDataPtr = &sourceData[pixelIndex];

            r = sourceDataPtr[0+0];
            g = sourceDataPtr[0+1];
            b = sourceDataPtr[0+2];

            int value = (r+g+b) / 3;
            if (value > MAX_COLOR_VALUE) {
                value = MAX_COLOR_VALUE;
            }

            targetData[pixelIndex] = value;
            self.imageData[pixelIndex] = value;
        }
    }
}

Es läuft einfach durch und nimmt den Durchschnittswert für Rot, Grün und Blau und verwendet diesen für den Grauwert. Sehr einfach. Jetzt zerlegt die Parallelversion das Bild grundsätzlich in Teile und berechnet diese Teile dann separat. Nämlich 2, 4, 8, 16 und 32 Portionen. Ich benutze die grundlegende GCD, übergebe also jeden Teil als eigenen Block, damit er gleichzeitig abläuft. Hier ist der GCD-Code:

dispatch_group_t myTasks = dispatch_group_create();

for (int startX = 0; startX < width; startX += width/self.numHorizontalSegments) {
    for (int startY = 0; startY < height; startY += height/self.numVerticalSegments) {
        // For each segment, enqueue a block of code to compute it.
        dispatch_group_async(myTasks, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
             // grayscale code...
        });
    }
}
dispatch_group_wait(myTasks, DISPATCH_TIME_FOREVER); 

Alles funktioniert gut. Aber was ich nicht verstehe, ist die Beschleunigung / CPU-Auslastung. Beim Ausführen von Tests im Simulator (der meine Dual-Core-CPU verwendet) erhalte ich:

~ 0.0945s Laufzeit nacheinander~ 0.0675s Laufzeit mit GCD

Dies ist eine Beschleunigung von ca. 28% (in der sequentiellen Version 72%). Theoretisch ist auf einer 2-Kern-Maschine eine 100% ige Beschleunigung das Maximum. Das ist also noch nicht alles und ich kann nicht herausfinden warum.

Ich überwache die CPU-Auslastung und die maximale Auslastung liegt bei 118%. Warum erreicht sie nicht näher an 200%? Wenn jemand eine Idee hat, was ich ändern soll oder was der Schuldige hier ist, würde ich es sehr schätzen.

Meine Theorien:

Nicht genug Arbeit auf der CPU (aber das Bild ist ~ 3.150.000 Pixel)Nicht genug Zeit, um bis zu 200% zu feuern? Vielleicht benötigt jeder Thread eine längere Laufzeit, bevor er so viel von der CPU aufnimmt?Ich dachte, dass der Overhead vielleicht ziemlich hoch war, aber ein Test zum Starten von 32 leeren Blöcken in eine Warteschlange (auch in einer Gruppe) dauerte maximal ~ 0,0005 Sekunden.