Parallele Programmierung

Transkript

1 Parallele Programmierung 10. Vorlesung Thorsten Grosch Danke an Hendrik Lensch

2 Überblickbli Paralleles Sortieren Paralleler Speicherzugriff Scan Letzte reguläre Vorlesung Nächste Woche keine Vorlesung In zwei iwochen Wiederholung &F Fragen zur Klausur Nächste Übungen 9. Übung: Stoffsimulation 6 Punkte +3 Bonuspunkte 10. Übung: optional, nur noch Bonuspunkte 2

3 Bitonici Merge Sort

4 Bitonici Merge Sort [Batcher 1986] Beispiel aus GPU Gems Vertauscht werden (parallel) jeweils die beiden Elemente pro Pfeil Der Pfeil gibt die Richtung an (auf / absteigend) Wenn die beiden Werte gegen Pfeilrichtung eingetragen sind, dann wird vertauscht Woher kommen die Pfeile? Die Pfeile sind immer gleich (unabhängig von der Eingabe) Manchmal wird absteigend sortiert 4

5 Bitonici Sequence Ein Folge wird als Bitonic bezeichnet, wenn sie zunächst aufsteigend und dann absteigend sortiert ist (oder umgekehrt) Bsp: Oder: Verallgemeinerte Definition Eine Folge ist Bitonic, wenn man durch einen zyklischen Shift eine Folge erhält, die zunächst aufsteigend und dann absteigend sortiert ist Bsp

6 Bitonici Split Gegeben: Bitonic Sequenz (a0, a1,, an-1) ) Bitonic Split: Bilde zwei Sequenzen der halben Länge ( Min(a0, an/2), Min(a1,an/2+1), ) ( Max(a0, an/2), Max(a1,an/2+1), ) Dann gilt: 1. Beide Sequenzen sind Bitonic 2. Die Elemente der ersten Liste sind alle kleiner als die in der zweiten Liste Split Bsp. für n=8 :

7 Warum gelten die beiden Eigenschaften? Gegeben ist eine Sequenz mit Bitonic Eigenschaft Zunächst monoton wachsend, dann fallend Den Bitonic Split erhält man, indem man beide Hälften überlagert und jeweils komponentenweise Min/Max bildet Aufgrund der Bitonic Eigenschaft gibt es einen (unbekannten) Kreuzungspunkt der beiden Kurven Links von diesem Punkt gilt Das Minimum kommt aus der ersten Hälfte, das Maximum aus der zweiten Hälfte Rechts von diesem Punkt gilt Das Minimum kommt aus der zweiten Hälfte, das Maximum aus der ersten Hälfte beide Teilfolgen sind Bitonic Die Minimum-Sequenz liegt unterhalb der Maximum-Sequenz max min Hinweis: Diese Beschreibung gilt so nur, wenn das Maximum der Sequenz genau in der Mitte liegt Zyklischer Shift 7

8 Somit kann man folgendes folgern Mit Hilfe der Bitonic Split Operation kann die Folge in zwei Hälften unterteilt werden, wobei die erste Folge komplett kleiner ist als die zweite Folge Da die beiden entstehenden Folgen wieder die Bitonic Eigenschaft haben, kann das Verfahren rekursiv auf beide Teilfolgen angewandt werden Liegt also eine Bitonic Sequenz vor, so entsteht durch wiederholte Anwendung der Bitonic Split Operation eine sortierte Folge Bitonic Merge Sort 1. Erstellung der Bitonic Sequenz (Bitonic Merge) 2. Wiederholtes Anwenden der Bitonic Split Operation 8

9 Bitonici Merge Sort Bi Beispiel il Aufbau der Bitonic Sequenz Wiederholtes Anwenden der Bitonic Split Operation Stage 3: komplette Folge Bitonic Stage 2: Folge 1-4 Bitonic, Folge 5-8 Bitonic, Folge 1-4 kleiner als Folge 5-8 Stage 1: Folge 1-2 kleiner als Folge 3-4, kleiner als Folge 5-6, kleiner als Folge 7-8 9

10 Wie wird die Bitonici Sequenz aufgebaut? Zusammenfügen von zwei Bitonic Sequenzen zu einer Sequenz mit Bitonic Eigenschaft (Merge) Erster Schritt Erzeuge Bitonic Sequenzen der Länge 4 2El Elemente aufsteigend, dann 2El Elemente absteigend Dazu werden jeweils 2 aufeinanderfolgende Elemente der Original-Sequenz abwechselnd aufsteigend und absteigend vertauscht igend ren Aufstei sortier Absteig gend sortiere en Aufsteig gend sortiere en Absteige end sortiere en Zweiter Schritt Die vorhandenen 4-elementigen Bitonic Sequenzen werden dann sortiert Dazu wird die wiederholte Bitonic Split Operation auf jede 4-elementige Sequenz angewandt Die 4-elementigen Folgen werden dabei abwechselnd aufsteigend und absteigend sortiert Es entstehen Bitonic Sequenzen der Länge 8 Wiederholung der Merge-Operation bis komplette Folge Bitonic Aufsteig gend sortiere en Absteig end sortiere en 10

11 Bitonici Merge Sort Bi Beispiel il Bitonic Sequenzen der Länge 4 erzeugen (2 aufeinanderfolgende Werte abwechselnd aufsteigend / absteigend vertauschen) Bitonic Split auf 4- elementige Folgen anwenden 4-elementige Sequenzen sortieren (abwechselnd aufsteigend / absteigend) 8-elementige Gesamt- Sequenz sortieren Bitonic Split auf 8- elementige Gesamt- Folge anwenden 11

12 Bitonici Merge Sort : Länge & Richtung der Pfeile i=0..7 step 2 Länge der Bitonic Sequenz (step = 1.. log2n) stage 2 Länge der Bitonic Sequenz während Bitonic Split (stage = step.. 1) stage 1 2 Länge der Pfeile während Bitonici Split Der Pfeil zu einem Index i zeigt aufwärts, falls man in der ersten Hälfte der nächstgrößeren Bitonic Sequenz liegt Das andere Ende des Pfeils zu Index i befindet sich in aufsteigender Richtung, falls man in der ersten Hälfte der aktuellen Bitonic Sequenz liegt step ( i / 2 ) % 2 == 0 i % 2 stage 1 < 2 stage 12

13 CUDA Code (einfache Variante) global void bitonic_sort( int *a, int stepmax ) // stepmax = log(n) { int tid = threadidx.x; // this thread handles the data at its thread id for (int step = 1 ; step <= stepmax ; step++) { int stepnum = 1 << step; for (int stage = step ; stage > 0 ; stage--) { int offset = 1 << (stage - 1); // Pfeillänge int stagenum = 2 * offset; // Länge der Bitonic Sequenz int csign = ((tid % stagenum) < offset)? 1 : -1; // Tauschpartner auf/abwärts int cdir = ((tid / stepnum) % 2 == 0)? 1 : -1; // Pfeilrichtung int targetindex = tid + csign * offset; // Index anderes Ende Pfeil int val0 = a[tid]; // beide Werte auslesen int val1 = a[targetindex]; int minval = min(val0, val1); // min/max bilden int maxval = max(val0, val1); syncthreads(); // sync da in-place } } } a[tid] = (csign == cdir)? minval : maxval; // anderen Wert eintragen // falls gegen Pfeilrichtung syncthreads(); // ein Zeitschritt fertig Wieviele Zeitschritte werden benötigt? 13

14 csign / cdir cdir+ csign- i cdir+ csign+ cdircsign+ cdir- csign- cdir : Pfeilrichtung csign : Richtung für Tauschpartner Am Index i muß das Minimum der beiden Werte eingetragen werden, falls cdir == csign 14

15 Bitonici Merge Sort Analyse Paralleles Sortierverfahren N/2 Vertauschungen in jedem Zeitschritt (im Idealfall parallel) Pfeile unabhängig von den Eingangsdaten gut für GPU, alle Threads laufen zeitgleich, keine Sonderfälle i=1..log2n Steps mit jeweils i Stages Anzahl Zeitschritte log2 N log2 N(log2 N + 1) 2 i = O(log2 N) 2 i=11 Vgl. O(N log N) von CPU Verfahren Anzahl Vertauschungen 2 O ( N log 2 N) (Optimal wären O(N log N) Vertauschungen) Die vorgestellte, einfache Implementierung funktioniert nur für kleine Werte von N Shared Memory, Synchronisation 15

16 Bitonici Merge Sort: Vergleich mit CPUSortierung [Baraglia et al. 2009] 16

17 Bitonici Merge Sort: Vergleich mit anderen GPU Verfahren [Peters et al. 2011] 17

18 Anwendung Bitonici Merge Sort Szene mit vielen transparenten Flächen Alternative zu Sortierung auf der CPU Pro Pixel eine Liste aller dort rasterisierten Fragmente speichern pro Pixel auf der GPU sortieren Advances in Real-Time Rendering Course Siggraph 2010, Los Angeles, CA [Yang et al. 2010] 18

19 Speicherzugriff iff

20 Shared Memory & Bank Conflicts Der Zugriff auf Shared Memory ist genauso schnell wie der Zugriff auf ein Register, falls ki keine Bank kconflicts aufteten t Erklärung: Shared memory ist in Banks aufgeteilt 1 Bank = 32 Bit 16 Banks vorhanden Die Banks liegen interleaved im Speicher Beispiel shared float cache[64]; // 1 float = 32 Bit cache[0] bank 0 cache[1] bank 1 cache[15] bank 15 cache[16] bank 0 cache[17] bank 1... Annahme: 16 Threads laufen exakt zeitgleich (Half-warp) Dann können zeitgleiche Speicherzugriffe im Shared Memory parallel erfolgen, wenn sie auf verschiede Banks erfolgen 20

21 Shared Memory Bank Conflicts Idealfall Alle Threads greifen auf unterschiedliche Banks zu kein Bank conflict, parallel Schlechter Fall Mehrere Threads greifen auf die gleich Bank zu Zugriffe müssen serialisiert werden Kosten: Maximale Anzahl simultaner Zugriffe auf gleiche Bank Sonderfall Alle Threads greifen auf die gleiche Adresse zu kein Bank Conflict (broadcast) 21

22 Lineare Addressierung shared float shared[256]; Thread 0 Thread 1 Thread 2 Thread 3 Thread 4 Thread 5 float foo = shared[baseindex + s* threadidx.x]; Thread 6 Bank 6 Thread 7 s=1 Bank 0 Bank 1 Bank 2 Bank 3 Bank 4 Bank 5 Bank 7 Der Zugriff ist frei von Bank-Conflicts falls s keinen gemeinsamen Teiler mit der Anzahl der Banks hat: ggt(numbanks, s) = 1 numbanks=16 (G80) s muß ungerade sein Thread 15 Thread 0 Thread 1 Thread 2 Thread 3 Thread 4 Thread 5 Thread 6 Thread 7 s=3 Bank 15 Bank 0 Bank 1 Bank 2 Bank 3 Bank 4 Bank 5 Bank 6 Bank 7 Thread 15 Bank 15 22

23 Datentypen und dbank kconflicts Keine Konflikte falls Größe von Basistyp 32-bit: foo = shared[baseindex + threadidx.x] Probleme bei kleineren Datentypen: 4-way bank conflicts: shared char shared[]; foo = shared[baseindex + threadidx.x]; Thread 0 Thread 1 Thread 2 Thread 3 Thread 4 Thread 5 Thread 6 Thread 7 Thread 15 Bank 0 Bank 1 Bank 2 Bank 3 Bank 4 Bank 5 Bank 6 Bank 7 Bank 15 2-way bank conflicts: Thread 0 Thread 1 Thread 2 Thread 3 Thread 4 Thread 5 Thread 6 Thread 7 Bank 0 Bank 1 Bank 2 Bank 3 Bank 4 Bank 5 Bank 6 shared short shared[]; Bank 7 foo = shared[baseindex + threadidx.x]; Thread 15 Bank 15 23

24 Shared Memory Broadcast Jeder Thread liest das gleiche Element Thread 0 Bank 0 kein Bank Conflict Thread 1 Bank k1 x = shared[0]; Thread 2 Thread 3 Thread 4 Thread 5 Thread 6 Thread 7 Bank 2 Bank 3 Bank 4 Bank 5 Bank 6 Bank 7 Thread 15 Bank 15 24

25 Common Array Bank Conflict Patterns 1D Jeder Thread lädt 2 Elemente ins Shared Memory: Pro Zugriff: 2-way-interleaved loads 2-way bank conflicts: Thread 0 Bank 0 Thread 1 Thread 2 shared float shared[256]; Thread 3 int tid = threadidx.x; x; Thread 4 shared[2*tid] = global[2*tid]; shared[2*tid+1] = global[2*tid+1]; Bank 1 Bank 2 Bank 3 Bank 4 Bank 5 Bank 6 Sinnvoller Zugriff für eine CPU, da Cache Kohärenz ausgenutzt wird Aber: Für Shared Memory auf der GPU gibt es keine Cache Lines, sondern Banking Effekte Bank 7 Thread 8 Thread 9 Thread 10 Thread 11 Bank 15 25

26 Besserer Array Zugriff Jeder Thread lädt ein Element in blockdim Schritten shared[tid] = global[tid]; shared[tid + blockdim.x] = global[tid + blockdim.x]; Keine Bank Conflicts Vergleiche z.b. Reduce Durch große Schrittweiten werden Bank Conflicts vermieden (solange Schrittweite >= 16) Thread 0 Thread 1 Thread 2 Thread 3 Thread 4 Thread 5 Thread 6 Thread 7 Bank 0 Bank k1 Bank 2 Bank 3 Bank 4 Bank 5 Bank 6 Bank 7 Thread 15 Bank 15 26

27 Parallel l Prefix Sums / Scan

28 Scan (Parallel lprefix Sums) [Blelloch 1990] a0 a, a,...,, a N Gegeben ist eine Folge N 1 Bilde die Summe der ersten i Elemente Beispiel: a0, a0 + a1, a0 + a1 + a2,..., N N 1 a i i= 0 [ ] Scan [ ] Wofür braucht man das? Interessanterweise viele Anwendungen, z.b. wenn N Threads eine Ausgabe unterschiedlicher Länge in ein gemeinsames Ausgabearray produzieren: Was ist der Startindex für Thread i? 28

29 Scan auf fder CPU void scan( float* scanned, float* input, int length) { scanned[0] = input[0]; for(int i = 1; i < length; ++i) { scanned[i] = input[i] + scanned[i-1]; } } Einfache Schleife N-1 Additionen Wie funktioniert das parallel? 29

30 Einfacher paralleler l Scan Stride 1 a0 a1 a2 a3 a4 a a 5 6 a7 1 fertig Stride 2 a0 a0.. 1 a1.. 2 a2.. 3 a3.. 4 a a a fertig Stride 4 a0 a0.. 1 a0.. 2 a0.. 3 a1.. 4 a a a fertig a0 a0.. 1 a0.. 2 a0.. 3 a0.. 4 a0.. 5 a0.. 6 a fertig logn Zeitschritte 30

31 Pseudocode d einfacher, paralleler l Scan for d = 0 to log2n - 1 for all k in parallel if k >= 2^d a[k] += a[k 2^d] Warum kann das trotz Synchronisation zu Problemen führen? 31

32 Pseudocode d einfacher, paralleler l Scan mit Double Buffering for d = 0 to log2n 1 swap ping & pong for all k in parallel a[pong][k] = a[ping][k] if k >= 2^d a[pong][k] += a[ping][k 2^d] Double Buffering benötigt (!) Sonst evtl. gegenseitiges Überschreiben der Operanden bei der Addition Ausnahme: Für (Half-) Warp (16/32 Threads exakt im Gleichtakt) in-place Addition möglich 32

33 CUDA: Einfacher Scan mit Double Buffering global void scangpu(float *outdata, float *indata) { shared float temp[2][n]; int thid = threadidx.x; int pong = 0; int ping = 1; temp[0][thid] = indata[thid]; syncthreads(); for (int offset = 1 ; offset < N ; offset *= 2) { pong = 1 - pong; ping = 1 - pong; temp[pong][thid] = temp[ping][thid]; if (thid >= offset) temp[pong][thid] += temp[ping][thid - offset]; } syncthreads(); } outdata[thid] = temp[pong][thid]; 33

34 Analyse Einfacher paralleler l Scan N parallele Threads log2n Schritte deutlich schneller als CPU Aber: Pro Schritt O(N) Additionen (N-1, N-2, N-4, ) Insgesamt O(Nlog2N) Additionen Seltsam: Die CPU Version braucht nur O(N) Additionen (?) 34

35 Besserer paralleler l Scan: Phase 1(Up-Sweep) Stride 1 a0 a1 a2 a3 a4 a a 5 6 a7 Stride 2 a0 a0.. 1 a2 a2.. 3 a4 a a a Stride 4 a0 a0.. 1 a2 a0.. 3 a4 a a a a0 a0.. 1 a2 a0.. 3 a4 a4.. 5 a6 a (Impliziter) Binärbaum, Blätter Wurzel, logn Zeitschritte, N-1 Additionen 35

36 Besserer paralleler l Scan: Phase 2(Down-Sweep) 0 a0 a0.. 1 a0.. 2 a0.. 3 a0.. 4 a a a Stride 1 0 a0 a0.. 1 a2 a0.. 3 a4 a a a Stride 2 0 a0 a0.. 1 a2 a0.. 3 a4 a a a Stride 4 0 a0 a0.. 1 a2 a0.. 3 a4 a4.. 5 a6 a (Impliziter) Binärbaum, Wurzel Blätter, logn Zeitschritte, N-1 Additionen 36

37 Analyse besserer Scan N parallele Threads 2log2N Zeitschritte Doppelt so viel wie vorher, trotzdem schneller durch weniger Speicherzugriffe In-place Insgesamt 2(N-1) Additionen Work Efficient Umsetzung in CUDA selber versuchen [Harris et al., GPU Gems 3] Alternative Implementierungen Letztes Element weglassen Auflösung der Bank Conflicts siehe ih [Harris et al. lgpug Gems 3] 37

38 Scan für große Arrays [Mark Harris] 38

39 Scan Anwendung Real-time Depth of Field siehe Übung [Harris et al. GPU Gems 3] 39

40 Depth of Field mit Scan Es gibt verschiede Verfahren zur Darstellung von Tiefenunschärfe Eine Möglichkeit ist ein Mittelwertfilter mit variierender Filtergröße Dazu wird ein z-wert festgelegt als Fokusebene Die Abweichung vom z-wert bestimmt pro Pixel die Filtergröße Also: FilterSize = const * abs(zbuffer[x,y] zfocus) +1 Einfache Implementierung Fragment Program (oder CUDA Kernel) bekommt Bild und zbuffer als Eingabe Pro Fragment wird ein (FilterSize x FilterSize) )Mittelwert-Filter berechnet Problem: sehr langsam für großen Filter 40

41 SummedArea Table Idee: Verwende Summed Area Table (SAT) Eine Summed Area Table enthält für jede Position (x,y) die Summe aller Pixelwerte, die im Rechteck links unter (x,y) liegen (2D Variante von Scan) Ay A Ax A = p( x, y) y A y x A x 41

42 Berechnung beliebiger Rechtecke B w A h C D A B D C D Mittelwert über Rechteck ABCD: (evtl. bei B,C,D um 1 Pixel links/unten korrigieren) A B C + w h D 42

43 Summed Area Table mit Scan z.b. so: 1. Scan horizontal pro Zeile danach 2. vertikaler Scan auf dem Ergebnis pro Spalte 43

44 Wi Weitere Anwendungen von Scan radix sort quicksort String comparison Lexical analysis Stream compaction Polynomial evaluation Solving recurrences Tree operations Range Histograms 44

45 Zusammenfassung Parallele Sortierung auf der GPU Speicherzugriffe Shared Memory Scan In zwei Wochen Fragestunde zur Klausur 45