7. Parallele Algorithmen für FPGA-Implementierungen

Transkript

1 7. Parallele Algorithmen für FPGA-Implementierungen

2 Odd-Even-Transposition-Sort für 8 Elemente

3 Ein sinnvolles Werkzeug bei der Entwicklung und dem Beweis von Sortierverfahren ist das 0-1-Pinzip. 0-1-Prinzip (Knuth, 1973) Ein Sortiernetz sortiert genau dann eine Folge beliebiger Daten, wenn es alle Folgen von Nullen und Einsen sortiert.

4 Beweis: Sei S ein Sortiernetz, das alle Folgen von Nullen und Einsen sortiert, aber eine Folge x 0, x 1,...,x N-1 nicht sortiert. Der zu S gehörende Algorithmus werde mit A S bezeichnet. Sei π die Permutation, die die sortierte Folge repräsentiert (x π(0) x π(1) x π(2)... x π(n-1) und sei σ die Permutation, die A S produziert. x σ(0), x σ(1), x σ(2)..., x σ(n-1). Sei k der kleinste Index, für den x π(k) x σ(k). Also x π(i) = x σ(i) für alle i<k und x π(k) < x σ(k). Also gibt es ein r > k mit x π(k) = x σ(r). Wir definieren eine Folge x* i aus Nullen und Einsen: x* i = 0, falls x i x π(k) und x* i = 1, falls x i > x π(k) Was macht A S mit der Folge x* i, 0 i N-1? Es gilt: x i > x j => x* i x* j für alle i und j. Daher macht A S in (x* i ) genau dann eine Vertauschung, wenn er eine in (x i ) macht. Daher ist die Ausgabe die Folge x* σ(0), x* σ(1), x* σ(2)..., x* σ(n) = x σ(0), x σ(1), x σ(2),..., x σ(k-1), x σ(k),..., x σ(r),..., x σ(n). Aber x σ(k) ist 1 während x σ(r) 0 ist. Die Ergebnisfolge ist also nicht sortiert, d.h. die Annahme einer Folge (x i ) wie oben war falsch.

5 Das 0-1-Pinzip ist nützlich zum Beweis von Sortierverfahren. 1. Anstelle der möglichen n! Eingangskombinationen muß man nur 2 n überprüfen. 2. Durch Darstellung der Nullen in Weiß und der Einsen in Schwarz lassen sich Sortierverfahren einfach graphisch beweisen.

6 Merge Verfahren Als wir über Sortieren gesprochen haben, ist das Verfahren Merge-Sort als ein Verfahren genannt worden, dessen (Zeit-) Komplexität optimal ist. Und zwar im Gegensatz zu Quicksort benötigt Merge-Sort im Durchschnittsfall und im schlechtesten Fall O(n*log n) Schritte. Wir wollen uns jetzt das Verhalten der uns mittlerweile bekannten Parallelrechnermodelle am Beispiel des Verschmelzen (Merge) zweier sortierter Listen ansehen. Merge auf einem shared memory Parallelrechner Wir wollen eine Parallelrechner mit n Prozessoren verwenden, um zwei sortierte Listen der Länge n/2 zu einer sortierten Liste der Länge n zu verschmelzen. Der Gedanke des Algorithmus besteht darin, daß jeder Prozessor für ein Datum verantwortlich ist, und für dieses die Zielposition in der sortierten Liste berechnet. Dazu macht er eine binäre Suche in der jeweils anderen Liste, wodurch er die Anzahl der kleineren Elemente in der anderen Liste kennt. Andererseits kennt er auch aus der originalen Position seines Datums in der eigenen Liste die Anzahl der kleineren Elemente aus der eigenen Liste. Die Summe ist also die Gesamtanzahl der kleineren Elemente und damit die Zielposition.

7 Algorithmus MERGE_Parallel Eingabe: Zwei sortierte Listen A[0.. n/2-1] und A[n/2.. N-1] im globalen Speicher. Ausgabe: Eine sortierte Liste B[0.. N-1] mit den Elementen von A im globalen Speicher. Methode: Global A[0..n-1], B[0..n-1]; Local x, low, high, index; for_all P i, where 0 i n-1 pardo if i < n/2 then low:=n/2; high:=n-1 else low:=0; high:=n/2-1 endif; x := A[i]; {jeder Prozessor holt sich sein A[i]} repeat index := (low+high)/2 ; if x A[index] then high:= index-1 else low:= index+1 endif; until low > high; { jetzt schreibt jeder Prozessor den Wert an die Stelle, an die er gehört } B[high+i-n/2+1] := x endfor_all;

8 Beispiel: n = A = 1, 3, 7, 11, 12, 14, 15, 22, 4, 5, 6,10, 13, 16, 18, 21 P 0 : low = 8 high = B[ ] = B[0] := 1 index= x = 1 P 6 : low = high = B[ ] = B[11] := 15 index= x = 15 P 11 : low = high = 7 2 B[ ] = B[6] := 10 index= x = 10

9 Komplexität: Jeder Prozessor macht zunächst eine Operation konstanter Länge und läuft dann durch die repeat-schleife. Mit jedem Durchlauf wird der Suchraum halbiert, also sind es insgesamt log n Durchläufe. Die Zuweisung an B ist wieder konstant. Dabei ist zu beachten, daß jeder Prozessor auf eine andere Speicherstelle im gemeinsamen Speicher zugreift. Wenn in den Listen mehrmals derselbe Wert vorkommt, muß man beim Vergleich eine Vereinbarung treffen, z.b. der Wert der linken Liste wird als kleiner gewertet als derjenige der rechten Liste. Also Gesamtkomplexität: O(log n)

10 Bitonisches Mergen Das Sortierverfahren Bitonic Sort (Batcher, 1968) [Ba, Kn, CLR] ist eines der schnellsten Sortiernetze. Bei einem Sortiernetz ist die Reihenfolge der Vergleiche nicht von den Daten abhängig, anders als bei Sortierverfahren wie z.b. Quicksort oder Heapsort. Das Verfahren ist daher besonders für eine Implementierung in Hardware geeignet. Es ist darüber hinaus Grundlage vieler paralleler Sortierverfahren auf zweidimensionalen Gittern [TK, LSSS, SS]. Im folgenden wird das Sortiernetz Bitonic Sort auf Basis des 0-1-Prinzips entwickelt. Grundlagen Def.: Eine 0-1-Folge a = a 0,..., a n-1 heißt bitonisch, wenn sie höchstens zwei Wechsel zwischen 0 und 1 enthält, d.h. wenn Indexpositionen k, m {0,1,..., n-1} existieren mit a 0,..., a k-1 = 0, a k,..., a m-1 = 1, a m,..., a n-1 = 0 oder a 0,..., a k-1 = 1, a k,..., a m-1 = 0, a m,..., a n-1 = 1

11 Im folgenden Bild sind verschiedene Beispiele bitonischer 0-1-Folgen schematisch dargestellt (Nullen weiß, Einsen schattiert). 0 k-1 k m-1 m n-1 0 k-1 k m-1 m n-1 0=k m-1 m n-1 0=k m-1 m n-1 0=k n-1, m=n 0=k n-1, m=n

12 Def.: Sei n N, n gerade. Das Vergleichernetz B n ist wie folgt definiert: B n = [0 : n/2] [1 : n/2+1]... [n/2-1 : n-1] Beispiel: Vergleichernetz B 8 :

13 Satz: Sei n N, n gerade und a = a 0,..., a n-1 eine bitonische Folge. Die Anwendung des Vergleichernetzes B n auf a ergibt dann B n (a) = b 0,..., b n/2-1 c 0,..., c n/2-1 wobei die b i die kleineren Elemente und die c j die größeren Elemente sind, d.h. b i c j für alle i, j {0,..., n/2-1} und darüber hinaus gilt b 0,..., b n/2-1 ist bitonische Folge und c 0,..., c n/2-1 ist bitonische Folge. Beweis: Sei a 0,..., a n-1 eine bitonische 0-1-Folge. Schreibt man a in zwei Zeilen, dann ergibt sich folgendes Bild (Nullen sind wieder weiß, Einsen schattiert dargestellt): 0 n/2-1 n/2 n-1

14 Die Folge beginnt mit Nullen, dann kommen Einsen und dann wieder Nullen. Oder die Folge beginnt mit Einsen, dann kommen Nullen und dann wieder Einsen, wobei sich die Bereiche der Einsen auch überlappen können: a b c Ausganssituation Anwendung des Endsituation Vergleichernetzes Es sind noch eine ganze Reihe anderer Variationen möglich, einige sind im Bild unten dargestellt. Eine Anwendung des Vergleichernetzes B n entspricht einem Vergleich zwischen oberer und unterer Zeile; hierdurch wird in allen Fällen die im Satz angegebene Form hergestellt, d.h. alle b i sind kleiner oder gleich allen c j und b ist bitonisch und c ist bitonisch:

15 a b c a b c a b c

16 Sortieren Beginnen wir wieder mit der PRAM. Wie können wir unser Merge-Verfahren nutzen, um zu sortieren? Iterativ: for i:=1 to log n do for_all subsequences S of length 2 i pardo sort S by merging two sorted halfs Komplexität: T sort (n) = T sort (n/2) + T merge (n) T sort (1) = 0 T merge (n) = c * (log n) Dieses Gleichungssystem hat die Lösung: T sort (n) = c * (log n) + c * (log n/2) + c * (log n/4) c * = c * ( (log n) + (log n - 1) + (log n - 2) ) = c * (log n) * (log n +1)/2 = O (log 2 n)

17 Geht das auch schneller? Ja. Idee: Man benutzt n 2 Prozessoren, um n Daten zu sortieren. Seien die zu sortierenden Daten im Feld A[0..n-1]. B[0..n-1] soll durch den Algorithmus die sortierte Folge bekommen. Wir stellen uns die Prozessoren in einer nxn-matrix angeordnet vor. Alle Prozessoren in der i-ten Zeile bekommen das Element a i. Alle Prozessoren in der j-ten Spalte bekommen das Element a j. Nun vergleicht jeder Prozessor sein a i mit seinem a j. Wenn a i größer ist als a j, setzt er einen Wert g auf 1, sonst auf 0. In der i-ten Zeile ist jetzt a i mit allen anderen Werten verglichen worden. Und in den g-werten der i-ten Zeile stehen soviele Einsen, wie es kleinere Elemente als a i gibt. Nun werden diese g-werte addiert und die Summe wird im Prozessor (i,0) gesammelt. Sei die Summe s i. Schließlich schreibt Prozessor (i,0) den Wert a i nach B[s i ]. Das Feld B ist sortiert. Komplexität: Das Verteilen der Elemente in den Zeilen und Spalten kostet für eine CREW PRAM Zeit O(1). Wir haben überigens in einer Übungsaufgabe gezeigt, wie es mit einer EREW PRAM in O(log n) geht. Das Vergleichen im Prozessor braucht ebenfalls O(1) Zeit. Das Addieren der g-werte in den Zeilen dauert O(log n). Das Wegschreiben der Ergebnisse braucht wieder konstante Zeit O(1). Gesamtaufwand: O(log n)

18 Sortieren auf dem Mesh: Zunächst geht natürlich wieder derselbe Trick wie beim Übergang vom Mergen zum Sortieren auf der PRAM. Wir beginnen, eine Spalte des Mesh zu sortieren. Mit unserem Merge-Algorithmus machen wir aus zwei sortierten Spalten eine sortierte Doppelspalte. Zwei davon Mergen wir zu einem sortierten Block aus vier Spalten usw. bis wir schließlich zwei sortierte Hälften des Mesh zu einem ganzen sortierten Mesh mergen. Die Komplexität hierfür ist offenbar O(log n * n).

19 Komplexitätsrekurrenz: T sort (n,k) = T sort (n, k/2) + T merge (n,k) T merge (n,k) = n + 2k T sort (n,1) = n Für ein Feld der Kantenlänge n ergibt sich: T sort (n,n) = T sort (n, n/2) + T merge (n,n) = T sort (n, n/2) + (n+2n) = T sort (n, n/4) +(n+2n) + (n+2n/2) = T sort (n, n/8) +(n+2n) +(n+2n/2) +(n+2n/4) =... = T sort (n, 1) +(n+2n) +(n+2n/2) +(n+2n/4)+ +(n+2n/(n/2)) n + n*logn + 4n = n*logn +5n Die Komplexität für ein Feld der Kantenlänge n ist also O(log n * n).

20 Dieselbe Komplexität wird mit einem einfacheren Verfahren erreicht, daß den Satz von Batcher ausnutzt: Shear-Sort. Algorithmus Shear-Sort for i := 0 to log n - 1 do begin sort_rows_alternating; sort_columns end sort_rows Die Komplexität hierfür ist offenbar O(log n * n). Warum ist das ein Sortierverfahren? In jedem Durchlauf der Schleife wird die Anzahl der schmutzigen Zeilen halbiert, denn zwei aufeinanderfolgende Zeilen, eine nach rechts und eine nach links sortiert, bilden eine bitonische Folge. Durch das Sortieren der Spalten wird dabei eine Hälfte sauber, d.h. besteht nur aus 0en oder 1en. Nach log n Durchläufen ist also nur noch eine schmutzige Zeile vorhanden; diese wird im letzten Schritt sortiert.

21 Beispiel Shear-sort: Zeilen Spalten sortieren: sortieren: Zeilen Spalten sortieren: sortieren: Zeilen sortieren:

22 Geht das auch schneller? Ja. Idee: Man führt das Merge-Verfahren zwei-dimensional aus, d.h. man merged in einem Schritt vier Teilfelder der Größe n/2 x n/2 zu einem Feld der Größe n x n. Algorithmus Merge_neu: sort_rows_alternating; sort_columns; sort_rows_alternating; sort_columns; sort_rows Jeder dieser Schritte kann mit Odd-even-transposition-sort in n Schritten ausgeführt werden. Auf der folgenden Folie sieht man die Wirkung dieses Algorithmus an einem mit 0en und 1en besetzten Feld.

23

24 Komplexität des Sortierens: Für einen Merge Schritt (vier Felder der Größe k x k zu einem Feld der Größe 2k x 2k) benötigt man c * 2k Schritte. Die Felder der Größe 1 x 1 sind per se sortiert. Also gilt: T sort ( n) = T sort (( n)/2) + T merge ( n) T merge ( n) = c * n T sort (1) = 0 Dieses Gleichungssystem hat die Lösung T sort ( n) = T merge ( n) + T merge (( n)/2) + T merge (( n)/4) T merge (2) + 0 = c * n + c * ( n)/2 + c * ( n)/ c * 1 = c * (2 n - 1) = O( n)

25 Sortieren auf dem Hypercube: Sortiernetz Bitonic Sort Was brauchen wir, um aus dem Bitonic Merge ein Sortiernetz zu machen? Wir müssen nur dafür sorgen, daß unsere Eingangsfolge zu einer bitonischen Folge umsortiert wird. Nun sind insbesondere solche Folgen bitonisch, die aus zwei gegenläufig sortierten Hälften bestehen. D. h. wir können aus der Ursprungsfolge eine bitonische Folge machen, indem wir die erste Hälfte aufsteigend und die zweite Hälfte absteigend sortieren. Sort (n/2) (aufsteigend) Sort (n/2) (absteigend) Merge (n) Merge (n/2) Merge (n/2) Merge (n/4) Merge (n/4) Merge (n/4) Merge (n/4) Merge (2) Merge (2) Merge (2) Merge (2) Bitonic Sort für n Elemente

26 Das Sortiernetz Bitonic Sort ist rekursiv aus Vergleichernetzen B k für verschiedene Zweierpotenzen k aufgebaut. Dazu nimmt man in obiger Darstellung zum Sortieren der Folgen der Länge n/2 wieder ein bitonic-sort-netz. Man beginnt also mit allen Folgen der Länge 1. Diese sind per se sortiert. Je zwei solche Folgen bilden eine bitonische Folge der Länge 2. Diese wird durch einen Vergleich zu einer sortierten Folge der Länge zwei zusammengefaßt. Dabei wird jeweils die erste, dritte, fünfte,... aufsteigend, die zweite, vierte, sechste,... absteigend sortiert. Somit hat man lauter bitonische Folgen der Länge vier erzeugt. Durch ein bitonic-merge-netz werden diese sortiert. Wieder geht man so vor, daß die erste, dritte, fünfte,... Folge aufsteigend, die zweite, vierte, sechste,... absteigend sortiert werden. Auf diese Weise fährt man fort, bis man zwei gegenläufig sortierte Folgen der Länge n/2 hat. Diese bilden eine bitonische Folge der Länge n, die mit einem bitonic-merge- Netz sortiert wird. Die folgende Folie zeigt ein bitonic-sort-netz für n=8.

27 Bitonischer Sortierer für 8 Elemente

28 Komplexität Um aus zwei (gegenläufig) sortierten Folgen der Länge n/2 eine sortierte Folge der Länge n herzustellen, sind log(n) Vergleicherstufen erforderlich (z.b. die 3 = log(8) Vergleicherstufen im Bild oben). Die Anzahl der Vergleicherstufen T(n) des gesamten Sortiernetzes ergibt sich also wie folgt: T(n) = log(n) + T(n/2) Ferner ist jede einelementige Folge natürlich sortiert, somit gilt T(1) = 0 Die Lösung dieses Rekursionsgleichungssystems ist T(n) = log(n) + log(n)-1 + log(n) = log(n) (log(n)+1) / 2 Wir brauchen also O(log 2 n) Vergleicherstufen. Jede Vergleicherstufe des Sortiernetzes besteht aus n/2 Vergleichern; insgesamt sind dies also O(n log 2 (n)) Vergleicher.