Einen allgemeinen Überblick über die parallele Verarbeitung finden Sie in Andres Link in seinem Kommentar.
Hier ist mein nehmen auf GPU Parallelisierung:
Stellen Sie sich ein einfaches Szenario, in dem Sie jedes Pixel auf dem Bildschirm blau färben wollen. Wenn Sie wurden all dies auf der CPU in einem einzigen Thread auf einem hypothetischen 1024x1024 Pixel-Display zu tun, könnte man so etwas für eine 1024x1024 Bild
/// increase the blue component of an individual pixel
RGB32 TintPixelBlue(RGB32 inputPixel)
{
/// increase the blue component by a max of 10, but don't overflow the byte by going over
/// 0xFF
inputPixel.Blue += Math.Min(10,0xFF-inputPixel.Blue)
return inputPixel;
}
void DrawImageToScreen(Image image)
{
for(int y=0;y<pixels.Height;y++)
for(int x=0;x<pixels.Width;x++)
image[x,y]=TintPixelBlue(image[x,y]);
DrawMyImageToScreen(image);
}
schreiben, wird dieses 1.048.576 mal auszuführen haben, ein Pixel nach Ein weiterer. Das kann eine Weile dauern. Wenn Sie das zum Beispiel bei 60 Bildern/Sek. Tun müssen und eine Menge anderer Sachen zeichnen müssen (Ihre Szene oder andere Geometrie), können Sie Ihre Maschine zu einem kreischenden Stillstand bringen. Dies wird noch schlimmer, wenn Sie an einem größeren Bild arbeiten (zum Beispiel 1920x1080).
Parallelisierung eingeben. (Wirklich grober Pseudo-Code, siehe HLSL, CUDA oder OpenCL für die reale Sache)
RGB32 TintPixelBlue(RGB32 inputPixel)
{
/// increase the blue component by a max of 10, but don't overflow the byte by going over
/// 0xFF
inputPixel.Blue += Math.Min(10,0xFF-inputPixel.Blue)
return inputPixel;
}
void DrawImageToScreen(Image image)
{
GPU.SetImage(image);
GPU.SetPixelShader(TintPixelBlue);
Draw();
}
Mit einem einzigen Multi-Core-GPU (bis zu 512 Kernen auf NVidia Fermi und Tesla-Karten), können Sie den Schreib TintPixelBlue() Funktion in einer Shader-Sprache, die zum nativen Befehlssatz der GPU kompiliert wird. Sie übergeben dann das Image-Objekt an die GPU und sagen ihm, dass auf jedem Pixel TintPixelBlue() laufen soll. Die GPU kann dann alle 512 Kerne parallel nutzen, was effektiv die benötigte Zeit durch die Anzahl der Kerne teilt (minus Overhead und einige andere Dinge, die wir hier nicht sehen werden).
Statt 2^20 = 1.048.576 Iterationen auf der CPU erhalten Sie 1.048.576/512 oder 2^11 = 2048 Iterationen. Das ist (natürlich) eine Leistungssteigerung von etwa 500x. Der Schlüssel hier ist, dass jeder Eingang unabhängig ist: Sie brauchen die Ausgabe eines Pixels nicht, um einen anderen zu beeinflussen, so dass jeder freie Kern an jeder ausstehenden Eingabe arbeiten kann, ohne wirklich mit den anderen Kernen synchronisieren zu müssen.
Der eigentliche Spaß beginnt, wenn Sie mehrere GPUs in das System einsetzen. Tesla Arrays sind unglaublich schnell und power the world's fastest supercomputer. Angesichts der Tatsache, dass sie deutlich billiger als eine gleichwertige Reihe von traditionellen CPUs sind (vergleichen Sie die Kosten von 512 1,3 GHz CPUs, RAM, Rack-Platz, etc. vs $ 3000USD Tesla-Karte), werden sie sehr populär in der wissenschaftlichen Gemeinschaft für hart -Core-Nummer-Knirschen.
Hoffe, dass hilft.
http://en.wikipedia.org/wiki/Parallel_computing – Andres