> Parallele Systeme Übung: 4. Übungsblatt Philipp Kegel Wintersemester 2012/2013. Parallele und Verteilte Systeme, Institut für Informatik

Transkript

1 > Parallele Systeme Übung: 4. Übungsblatt Philipp Kegel Wintersemester 2012/2013 Parallele und Verteilte Systeme, Institut für Informatik

2 Inhaltsverzeichnis 2 1 Besprechung des 4. Übungsblattes Aufgabe 9: Globales OR Aufgabe 10: Suchen im vorsortierten Array 2 Quicksort auf CRCW-PRAM

3 Globales OR 3 Gesucht ist die Lösung von: b 0 b 1 b n 1 (globales OR) Schreiben Sie einen sequentiellen Algorithmus für dieses Problem und geben Sie dessen Komplexität an. Sequentieller Algorithmus for (i = 1; i < n; ++i) b[0] = b[i]; /* Ergebnis in b[0] */ Komplexität: O(n)

4 Globales OR auf CREW-PRAM 4 Gesucht ist die Lösung von: b 0 b 1 b n 1 (globales OR) Geben Sie einen möglichst schnellen Algorithmus für eine CREW-PRAM an. Welche asymptotische Komplexität hat er? Algorithmus für CREW-PRAM-Reduktion mit assoziativem OR; n/2 Prozessoren for all n/2 procs: for (j = 0; j < (log(n - 1) + 1); ++j) if (pid % (1<<j) == 0 && (2*pid+(1<<j)) < n) /* Prozessor pid an Berechnung beteiligt, zweiter Operand vorhanden */ b[2*pid] = b[2*pid+(1<<j)]; /* Ergebnis in b[0] */ Komplexität: O(log n) nicht kostenoptimal: O(logn) n/2 > O(n)

5 Globales OR auf CREW-PRAM 5 Kostenoptimalität erreichbar? Ja, falls O(logn) p = O(n) p = n logn Aber: Zeitkomplexität steigt, falls Prozessorenzahl sinkt Jeder Prozessor sortiert sequential n = logn Elemente: O(logn) p Zeitkomplexität also O(log n) +O(logn) = O(logn) }{{}}{{} Sortieren Reduktion

6 Globales OR auf CRCW-COMMON-PRAM 6 Gesucht ist die Lösung von: b 0 b 1 b n 1 (globales OR) Geben Sie einen möglichst schnellen Algorithmus für eine CRCW-COMMON-PRAM und seine asymptotische Komplexität an. Algorithmus auf CRCW-COMMON-PRAM; n Prozessoren result = true; // Annahme: mindestens 1 Bit gesetzt /* result wird false, falls kein Bit gesetzt */ result = b[pid]; Komplexität: O(1) kostenoptimal: O(1) n = O(N)

7 Aufgabe 10: Suchen im vorsortierten Array 7 Schreiben Sie einen möglichst schnellen CREW-PRAM-Algorithmus für p < N Prozessoren, der nach einem Element in einem sortierten Array von N Elementen sucht und den Index des gesuchten Elements zurückliefert. Binäres Suchen auf einem Prozessor: Vergleiche das gesuchte Element e mit dem mittleren Element m des Arrays e = m fertig. e < m rekursive Suche auf linker Teilliste. e > m rekursive Suche auf rechter Teilliste. Idee für p Prozessoren: 2 Teillisten p Teillisten Annahme: keine doppelten Einträge, p und N sind Zweierpotenzen

8 Aufgabe 10: Suchen im vorsortierten Array 8 /* globale Variablen */ left, right // Grenzen des globalen Intervalls wert // zu suchender Wert result // Index des gefundenen Wertes /* lokale Variablen */ myleft, myright // Grenzen des Intervalls von Prozessor pid if (pid == 0) { left = 0; right = N; // Grenzen setzen result = -1; } // auf allen p Prozessoren: while (result == -1) { // solange Wert nicht gefunden // 1. berechne lokale Grenzen myleft = left + pid * ((right - left) / p); myright = left + (pid + 1) * ((right - left) / p); // 2. suche Wert if (a[myleft] == wert) // Wert gefunden result = myleft; else // Wert nicht gefunden if (a[myleft] < wert && wert <= a[myright - 1]) { // Wert ist in lokalem Intervall // -> als neues globales Intervall uebernehmen left = myleft; right = myright; }

9 Aufgabe 10: Suchen im vorsortierten Array 9 Algorithmus stellt sicher, dass immer genau ein Prozessor schreibend auf globale Variablen zugreift Komplexität? O(log p n) Asymptotisch, d. h. mit steigender Arraygröße schneller als auf einem Prozessor? Nein, da O(log p n) = O( log 2 n log 2 p ) = O(log 2n).

10 Quicksort auf CRCW-PRAM 10 Quicksort entspricht der Konstruktion eines Baums: Pivot-Element = Wurzel; kleinere Elemente = linker Teilbaum; größere Elemente = rechter Teilbaum Implementierung als CRCW-PRAM-Algorithmus mit drei Schritten 1 : 1 Baum konstruieren 2 Größen aller (linken und rechten) Teilbäume ermitteln 3 Elementposition in sortiertem Array ermitteln und sortieren Ausführung auf n Prozessoren einer pro Element 1 J. Keller et al. Practical PRAM Programming. Wiley, 2001.

11 Baum konstruieren 11 /* globale Variablen */ A[] // Array root // Wurzelknoten lchild[], rchild[] // linke/rechte Kinder /* lokale Variablen */ pid // Prozessor-ID bzw. Array-Index parent // Elternknoten root = pid; // Wurzel (Pivot) bestimmen parent = root; // Pivot lesen lchild[pid] = rchild[pid] = N; // Kindlisten initialisieren while (pid!= parent) // wiederhole bis alle Elemente Pivot sind if ( A[pid] < A[parent] (A[pid] = A[parent] && pid < parent) { /* Element pid kleiner/ gleich Pivot -> linker Teilbaum */ IAmALeftChild = 1; lchild[parent] = pid; // Pivot linker Teilbaum bestimmen if (pid!= lchild[parent]) // Element pid ist nicht Pivot parent = lchild[parent]; } // -> Pivot ist Elternknoten else { // Element pid groesser als Pivot -> rechter Teilbaum IAmALeftChild = 0; rchild[parent] = pid; // Pivot rechter Teilbaum bestimmen if (pid!= rchild[parent]) // Element pid ist nicht Pivot parent = rchild[parent]; } // -> Pivot ist Elternknoten

12 Größen aller Teilbäume ermitteln 12 /* globale Variablen */ lnum[], rnum[] // Groesse linker/ rechter Teilbaum /* lokale Variablen */ num // Groesse eigner Teilbaum IAmALeftChild // true, falls Element linker Kindknoten ist lnum[pid] = rnum[pid] = num = 0; if (pid!= root) if (lchild[pid] == N) if (rchild[pid] == N) num = 1; // pid ist Blattknoten else { // pid hat nur rechten Teilbaum while (rnum[pid] == 0); // Warte auf rnum[pid] num = rnum[pid] + 1; } else // pid hat linken Teilbaum... if (rchild[pid]==n) { //... aber keinen rechten Teilbaum while (lnum[pid] == 0); // Warte auf lnum[pid] num = lnum[pid] + 1; } else { //... und rechten Teilbaum while (lnum[pid] == 0 rnum[pid] == 0) // auf beides Warten num = lnum[pid] + rnum[pid] + 1; } // num ist jetzt Groesse des linken und rechten Teilbaums + 1 if (IAmALeftChild) lnum[parent] = num; else rnum[ parent] = num;

13 Array sortieren 13 Position im sortierten Array bestimmen /* globale Variablen */ order[] // Elementpositionen im sortieren Array /* lokale Variablen */ z // Position des Elternknotens order[ pid] = -1; // Positionsliste initialisieren if (pid == root) order[ pid] = lnum[ pid]; // Wurzel einsortieren else do z = order[parent]; while (z == -1); // auf eigenen Elternknoten warten if (IAmALeftChild) order[pid] = z - rnum[pid] - 1; else order[pid] = z + lnum[pid] + 1; Array sortieren A[order[pid]] = A[pid] // Array sortieren

14 Komplexität 14 Durchschnittliche Kosten für parallelen Algorithmus: 1 Baum konstruieren erstelle 1 Ebene je Iteration O(log n), falls Pivot immer optimal gewählt; gilt auch im Mittel (siehe Laufzeit Quicksort) 2 Größen aller Teilbäume bestimmen alle Ebenen bottom-up durchlaufen O(log n) 3 Position im sortierten Array bestimmen alle Ebenen top-down durchlaufen O(log n) 4 Array sortieren parallele Zuweisung aller Elemente O(1) (3 O(logn)+O(1)) n = O(nlogn) Durchschnittliche Kosten für sequentielle Implementierung: O(n log n) CRCW-PRAM-Algorithmus ist (im Mittel) kostenoptimal Worst case: Baum der Höhe n Kosten: O(n 2 ) entspricht ebenfalls Kosten der sequentiellen Implementierung

15 15 5. Übungsblatt im Web Nächste Übung am 12. Dezember 2012