Architektur und Programmierung von Grafik- und Koprozessoren
21
0
0
Volltext
(2) Lernziele 1. Konstruktion paralleler Sortieralgorithmen - die Studierenden lernen, wie man mit Hilfe von Sortiernetzwerken parallele Sortieralgorithmen konstruieren kann. 2. Bitonic Sort - die Studierenden lernen den Bitonic Sort Algorithmus kennen, der, wenn man ihn parallel formuliert, eine günstige Zeitkomplexität aufweist. 3. GPU Implementierung - die Studierenden verstehen, wie man Bitonic Sort auf der GPU implementiert.. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(3) Parallele Sortieralgorithmen. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(4) Sortierproblem Gegeben: (Eingabesequenz) Menge A = {a0 , a1 , an−1 } mit Ordnung ≤. Gesucht: (Ausgabesequenz) Permutation A′ = {a′0 , a′1 , a′n−1 } sodass ∀a′i , a′j , i < j gilt: a′i ≤ a′j .. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(5) Vergleichsbasierte Sortieralgorithmen ▶ Iteriere in festgelegter Reihenfolge über die Eingabesequenz und vergleiche Elemente paarweise. Vertausche Elemente ai und aj basierend auf der Ordnungsrelation. ▶ Diverse vergleichsbasierte Sortieralgorithmen aus Grundstudium bekannt ▶ Insertion Sort, Selection Sort, Merge Sort, Quick Sort etc.. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(6) Insertion Sort Informell: Teilfolge Al ist bereits sortiert. Iteriere über alle a′ = al+1 , .., an−1 und sortiere diese in die Teilfolge Al ein. Die einelementige Teilfolge A0 erfüllt (trivial) die Eigenschaft, bereits sortiert zu sein. Starte daher Iteration mit a′ = al+1 = a1 . Vergleiche (von rechts nach links) alle a′ mit allen Elementen aus Al . Sobald Element a′′ ∈ Al gefunden, sodass a′′ > a′ , bilde neue Teilfolge A′l = {a0 , .., a′ , a′′ , .., al+1 } durch Einfügen von a′ an der richtigen Stelle und Verschieben der Elemente {a′′ , .., al } nach rechts.. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(7) Insertion Sort Beispiel 6 4 2 2 2 1. 4 6 4 4 4 2. 2 2 6 6 6 4. 8 8 8 8 7 6. 7 7 7 7 8 7. 1 1 1 1 1 8. Al = {6} Al = {4, 6} Al = {2, 4, 6} Al = {2, 4, 6, 8} Al = {2, 4, 6, 7, 8} Al = {1, 2, 4, 6, 7, 8}. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(8) Entscheidungsbäume Mit jedem vergleichsbasierten Sortieralgorithmus ist für jede Länge n der Eingabesequenz ein Entscheidungsbaum assoziiert, aus dem sich die Sequenz der Vergleichsoperationen für jede beliebige Eingabesequenz A ablesen lässt. Blätter für Permutationen A′ . (⇒ Entscheidungsbaum für |A| = n hat n! Blätter.) Innere Knoten des Entscheidungsbaums: i:j <. >. vergleicht die Eingabelemente ai und aj . Beim Traversieren des Baums entscheiden wir je nach Ergebnis, ob wir nach rechts oder links traversieren.. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(9) Entscheidungsbäume Beispiel: Insertion Sort, n = 3. 0:1 <. >. 1:2 <. 0:2 >. 012 <. 0:2. <. >. 102 >. 1:2. <. >. 021 201 120 210 .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(10) Entscheidungsbäume Beispiel: Insertion Sort, A = {8, 4, 2} A = {8, 4, 2} Al = {a0 }. 0:1 <. >. 1:2 <. 0:2 >. 012 <. 0:2. <. >. 102 >. <. 1:2 >. 021 201 120 210. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(11) Entscheidungsbäume Beispiel: Insertion Sort, A = {8, 4, 2} A = {8, 4, 2} a0 = 8 > a1 = 4 Al = {a1 , a0 }. 0:1 <. >. 1:2 <. 0:2 >. 012 <. 0:2. <. >. 102 >. <. 1:2 >. 021 201 120 210. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(12) Entscheidungsbäume Beispiel: Insertion Sort, A = {8, 4, 2} A = {8, 4, 2} a0 = 8 > a1 = 4 Al = {a1 , a0 }. 0:1 <. >. 1:2 <. 0:2 >. 012 <. a0 = 8 > a2 = 2. 0:2. <. >. 102 >. <. 1:2 >. 021 201 120 210. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(13) Entscheidungsbäume Beispiel: Insertion Sort, A = {8, 4, 2} A = {8, 4, 2} a0 = 8 > a1 = 4 Al = {a1 , a0 }. 0:1 <. >. 1:2 <. 0:2 >. 012 <. a0 = 8 > a2 = 2 a1 = 4 > a2 = 2. 0:2. <. >. 102 >. <. A′ = {a2 , a1 , a0 }. 1:2 >. 021 201 120 210. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(14) Entscheidungsbäume Beispiel: Insertion Sort, A = {2, 4, 3} A = {2, 4, 3} Al = {a0 }. 0:1 <. >. 1:2 <. 0:2 >. 012 <. 0:2. <. >. 102 >. <. 1:2 >. 021 201 120 210. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(15) Entscheidungsbäume Beispiel: Insertion Sort, A = {2, 4, 3} A = {2, 4, 3} a0 = 2 < a1 = 4 Al = {a0 , a1 }. 0:1 >. <. 1:2 <. 0:2 >. 012 <. 0:2. <. >. 102 >. <. 1:2 >. 021 201 120 210. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(16) Entscheidungsbäume Beispiel: Insertion Sort, A = {2, 4, 3} A = {2, 4, 3} a0 = 2 < a1 = 4 Al = {a0 , a1 }. 0:1 >. <. 1:2 <. 0:2 <. >. 012 <. a1 = 4 > a2 = 3. 0:2. >. 102 >. <. 1:2 >. 021 201 120 210. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(17) Entscheidungsbäume Beispiel: Insertion Sort, A = {2, 4, 3} A = {2, 4, 3} a0 = 2 < a1 = 4 Al = {a0 , a1 }. 0:1 >. <. 1:2 <. 0:2 <. >. 012 <. a0 = 2 < a2 = 4 A′ = {a0 , a2 , a1 }. 0:2. >. 102 >. <. 1:2 >. 021 201 120 210. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(18) Entscheidungsbäume Beispiel: Insertion Sort, A = {2, 4, 3} A = {2, 4, 3} a0 = 2 < a1 = 4 Al = {a0 , a1 }. 0:1 >. <. 1:2 <. 0:2 <. >. 012 <. a0 = 2 < a2 = 3 Al = {a0 , a1 }. 0:2. >. 102 >. <. a1 = 4 > a2 = 3 A′ = {a0 , a2 , a1 }. 1:2 >. 021 201 120 210. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(19) Sortiernetzwerke Sortiernetzwerke setzen sich aus Vergleichsmodulen zusammen: ai. min(ai,aj). aj. max(ai,aj). Diese haben zwei Eingabeports (links). Das Vergleichsmodul vergleicht die beiden Eingaben ai , aj und vertauscht sie basierend auf der Ordnung. Dies ist eine O(1) Operation. Das Ergebnis liegt auf den Ausgabeports (rechts) an. Vergleichsmodule sind über Leitungen miteinander verbunden.. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(20) Sortiernetzwerke Sortiernetzwerk angelehnt an Insertion Sort, das Eingabefolge A = {a0 , ..a5 } in sortierte Ausgabefolge A′ = {a′0 , ..a′5 } überführt. a0 a1 a2. a'0 a'1 a'2. a3 a4 a5. a'3 a'4 a'5. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(21) Sortiernetzwerke Dieses Netzwerk kann man auch etwas anders darstellen, dann sieht man, dass manche Vergleichsmodule parallel ausgeführt werden können. a0 a1 a2 a3 a4 a5. a'0 a'1 a'2 a'3 a'4 a'5. .. .. .. .. .. .. . . . . . . . .. . . . . . . . .. . . . . . . . .. . .. .. . .. .. .. .. .. ..
(22)
ÄHNLICHE DOKUMENTE
C++ spezifiziert keine Garbage Collection (der Standard schließt sie nicht explizit aus, aber es gibt keine Implementierungen, die mir bekannt sind). Daher m¨ ussen alle Ressourcen,
▶ Effizienz beim Konstruieren: BVHs für hunderdtausende Dreiecke können mit modernen Algorithmen in Sekundenbruchteilen aufgebaut werden.. k-d Bäume: Primitive können in zwei
I Desktop GPUs implementieren traditionell Immediate-Mode Rendering: Verarbeitung orientiert sich an Reihenfolge, in der Dreiecke submittiert wurden (nicht zu verwechseln
I Vor und nach Skalarprodukt m¨ ussen Threads synchronisiert werden, damit nicht schon andere Threads aus Warp anderen Block in Shared Memory laden... I Seit Nvidia Kepler
Bitonic Sort Bemerkung ▶ Das Vergleichsnetzwerk Nn partioniert also zwei 0-1 Folgen so, dass alle Elemente in der linken Hälfte ≤ den entsprechenden Elementen in der rechten
Grafik Pipeline Wichtig zu merken: Durchsatzraten auf verschiedensten Levels: ▶ Eingabedatenrate: Rate, mit der Kommandos und Geometrie an die GPU geschickt werden können..
ADD $R1 C Addiere den konstanten Wert C auf den Inhalt von Register $R1 4 TZ LD $R1 [S] Lade den Inhalt an Speicherstelle [S] in Register $R1 10 TZ ST [S] $R1 Speichere den Inhalt
Ihr paralleles GPU Programm verwendet zur Berechnung ein zweidimensionales Gitter der Größe N × N , sodass jedem Matrixelement aus der Ergebnismatrix C ein einzelner Thread
