Professional Documents
Culture Documents
Parallel
vs
Sequentiell
0. Inhaltsverzeichnis
0. Inhaltsverzeichnis............................................................................................................... 2
0.1. Abbildungsverzeichnis ............................................................................................... 3
0.2. Tabellenverzeichnis.................................................................................................... 3
1. Sequentieller Algorithmus.................................................................................................. 4
2. Paralleler Algorithmus ....................................................................................................... 4
2.1. Trivialer Ansatz.......................................................................................................... 4
2.2. Scatter Ansatz............................................................................................................. 5
2.3. Pool Ansatz ................................................................................................................ 5
2.4. Streaming Ansatz ....................................................................................................... 7
3. Daten .................................................................................................................................. 8
3.1. Ansatz Netzlaufwerk .................................................................................................. 8
3.2. Ansatz Arbeitsspeicher............................................................................................... 8
4. Visualisierung..................................................................................................................... 8
4.1. per MPI....................................................................................................................... 8
4.2. Monitoring Filesystem Root....................................................................................... 8
4.3. Monitoring Network................................................................................................... 9
4.4. Jumpshot..................................................................................................................... 9
5. Entscheidung ...................................................................................................................... 9
5.1. Berechnungen............................................................................................................. 9
7. Auswertung ...................................................................................................................... 13
7.1. Sequentiell................................................................................................................ 13
7.2. Parallel 15 Prozessoren ......................................................................................... 13
7.3. Parallel 31 Prozessoren ......................................................................................... 16
7.4. Jumpshot................................................................................................................... 18
7.5. Fazit.......................................................................................................................... 18
0.1. Abbildungsverzeichnis
Abbildung 1 - Trivialer Ansatz ............................................................................................ 4
Abbildung 2 - Scatter Ansatz ............................................................................................... 5
Abbildung 3 - Pool Ansatz ................................................................................................... 6
Abbildung 4 - Streaming Ansatz.......................................................................................... 7
Abbildung 5 - Verlauf des SpeedUp .................................................................................. 10
Abbildung 6 - Screenshot Monitor..................................................................................... 11
Abbildung 7 - Diagramm Sequentiell ................................................................................ 13
Abbildung 8 - Diagramm Parallel StreamSize 1.000......................................................... 13
Abbildung 9 - Diagramm Parallel StreamSize 10.000....................................................... 14
Abbildung 10 - Diagramm Parallel StreamSize 100.000................................................... 14
Abbildung 11 - Diagramm Parallel StreamSize 1.000.000................................................ 15
Abbildung 12 - Diagramm Parallel Gesamt....................................................................... 15
Abbildung 13 - Diagramm Vergleich Sequentiell und Parallel ......................................... 15
Abbildung 14 - Diagramm Parallel StreamSize 10.000 31................................................ 16
Abbildung 15 - Diagramm Parallel StreamSize 100.000 31.............................................. 16
Abbildung 16 - Diagramm Parallel StreamSize 1.000.000 31........................................... 17
Abbildung 17 - Diagramm Parallel 31 ............................................................................... 17
Abbildung 18 - Jumpshot-Ausgabe fr 8MB 15 Prozessoren StreamSize=1000 .............. 18
0.2. Tabellenverzeichnis
Tabelle 1 - Berechnung des SpeedUp .................................................................................. 9
Tabelle 2- Berechnung der Effizienz ................................................................................. 10
Tabelle 3 - Verlauf der Effizienz........................................................................................ 10
Tabelle 4 - Protokollaufbau Monitor.................................................................................. 12
1. Sequentieller Algorithmus
Mergesort ist ein rekursiver Sortieralgorithmus, der hnlich nach dem Prinzip Teile und herrsche
arbeitet. Er betrachtet die zu sortierenden Daten als Liste und zerlegt sie in kleinere Listen, die jede fr
sich sortiert werden. Die sortierten kleinen Listen werden dann im Reiverschlussverfahren zu
greren Listen zusammengefgt bis wieder eine sortierte Gesamtliste erreicht ist. DieKomplexitt
betrgt O(nlog(n)).
2. Paralleler Algorithmus
2.1. Trivialer Ansatz
Verteilungsphase *
Sortierungsphase
Mergephase
- Vollstndige Verteilung der zu sortierenden Liste auf alle verfgbaren Prozessoren (Scatter)
- Anschlieendes Merge durch Root-Prozessor
- Probleme:
einzelne Prozesse mssen riesige Datenmengen bewltigen
Root arbeitet am Ende enorm lange (muss gesamte Liste mergen), andere Prozessoren
sind nicht mehr ausgelastet
- Skizze: * = Root arbeitet, = Prozessor arbeitet
Verteilungsphase *
Sortierungsphase
Mergephase *
Verteilungsphase *
+
Sortierungsphase
Mergephase
*
-
Abbildung 3 - Pool Ansatz
Verteilungsphase *
Sortierungsphase
Mergephase
3. Daten
Generell muss entschieden werden, was fr Daten zu sortieren sind. Fr die Erstimplementierung
werden Zahlen vom Datentyp Long vorgesehen.
- Daten werden in einer sich auf dem Netzlaufwerk befindlichen zentralen Datei vorgehalten
- Fragestellung:
entweder liest und schreibt jeder Prozessor selbst seinen Teil in der Datei und bekommt
vom Root nur eine Index-Nachricht
oder Root liest und schreibt die Datei, verteilt an und erhlt von Prozessoren die Daten
-> exklusives oder konkurrierendes Zugriffskonzept?
- Problem: SAN ist schneller als Festplattenzugriff -> Performance-Verlust
- Daten werden im Arbeitsspeicher in einem Array oder einer Liste vorgehalten und vom Root
verteilt
- Problem: wenn zu viele Daten, knnte Arbeitsspeicher nicht ausreichen -> Swap auf die
Festplatte -> Performanceverlust
4. Visualisierung
- Evaluierung, ob eine Oberflche in C oder C++ geschrieben werden kann, mittels der MPI
umzugehen wei
- wenn ja, senden beteiligte Prozessoren whrend des Arbeitsvorgangs Statusangaben zum Root
-> wertet diese aus und zeigt sie live an
- wenn nein, anderen Ansatz whlen
- Die Prozesse senden per Netzwerk ihren Zustand an einen bei Root registrierten Listener
- Das versenden geschieht per TCP/IP
Nachteil:
- Es wird aufgrund der Netwerklatenz und bertragungszeit nie eine Echtzeitdarstellung sein
Vorteil:
- Der Prozess kann gecached und zu Demonstrationszwecken verlangsamt dargestellt werden.
4.4. Jumpshot
5. Entscheidung
Fr die Implementierung des parallelen Mergesorts wurde als erstes der Pool-Ansatz gewhlt.
Nachdem sich dessen Umsetzung nach gewisser Zeit als zu komplex und nicht realisierbar
herausstellte, wurde der Streaming-Ansatz verfolgt. Dabei wird die Streamsize variabel einstellbar
gehalten, um die verschiedenen Auswirkungen auf die Rechenzeit untersuchen zu knnen.
Zustzlich fiel die Entscheidung hinsichtlich der Datenhaltung auf die Dateiverwaltung. Es gibt
jeweils eine zentrale Eingabe- und Ausgabedatei, welche sich im Netzwerk befinden.
Fr die Visualisierung wurde sowohl ein eigener Monitor entwickelt, als auch das schon vorhandene
Jumpshot genutzt.
5.1. Berechnungen
SpeedUP
Prozessoren
anzahl SpeedUp
7 1,66666667
15 2,05882353
31 2,69230769
63 3,18181818
Tabelle 1 - Berechnung des SpeedUp
3,5
2,5
SpeedUp
1,5
0,5
0
7 15 31 63
Anzahl Prozessoren
Effizienz:
ep = sp/p = t1 / p*tp
Prozessoren
anzahl SpeedUp Effizienz
7 1,66666667 23,8095238
15 2,05882353 13,7254902
31 2,69230769 8,68486352
63 3,18181818 5,05050505
Tabelle 2- Berechnung der Effizienz
25
20
Effizienz in %
15
10
0
7 15 31 63
Anzahl Prozessoren
6. Parallel MergeSort-Monitor
6.1. Einfhrung
Der Parallel MergeSort-Monitor ist ein Visualisierungs-Programm, welche die Anordnung der am
Sortiervorgang beteiligten Prozessoren sowie deren Fortschritt und Kommunikation darstellt.
Dabei erhlt der Monitor die Statusinformationen von den einzelnen Knoten ber eine Socket-
Schnittstelle. Alternativ ist es auch mglich, eine vorhandene Protokolldatei in den Monitor
einzulesen und so im Nachhinein den Sortiervorgang zu visualisieren.
Da der Sortiervorgang auch in nur wenigen Sekunden ablaufen kann, bietet der Monitor eine so
genannte Speed-Funktion, mit der die Abarbeitung auf 10% der Originalgeschwindigkeit
herabgesetzt werden kann. Ebenso kann der Vorgang beschleunigt werden.
6.2. Benutzeroberflche
Dabei fungiert der Monitor als Server, der eingehende Nachrichten von mpi-Knoten
per Socket-Verbindung entgegennimmt. Als Parameter ist der Port anzugeben, auf
dem der Server lauschen soll.
Alternativ kann ein vorhandenes Protokoll angegeben werden. Der Dateiname wird als
Parameter beim Start des Programmes angegeben.
Der Aufbau der Protokolldatei wird unten beschrieben.
6.4. Protokollaufbau
7. Auswertung
Getestet wurde zunchst der sequentielle Mergesort und anschlieend der parallele Mergesort mit 15
und 31 Prozessoren und verschiedenen Streamsize-Gren.
7.1. Sequentiell
60.000.000
50.000.000
Anzahl Zahlen
40.000.000
30.000.000
20.000.000
10.000.000
0
0 2 4 12 35 430
Zeit in s
StreamSize = 1.000
Anzahl Zahlen 100.000 500.000 1 Mio 5 Mio 10 Mio 50 Mio 100 Mio 125 Mio 250 Mio
Zeit in s 0 1 1 6 16 128 303 339 997
300.000.000
250.000.000
200.000.000
Anzahl Zahlen
150.000.000
100.000.000
50.000.000
0
0 1 1 6 16 128 303 339 997
Zeit in s
StreamSize = 10.000
Anzahl Zahlen 100.000 500.000 1 Mio 5 Mio 10 Mio 50 Mio 100 Mio 125 Mio 250 Mio
Zeit in s 0 1 1 5 13 74 151 196 516
300.000.000
250.000.000
Anzahl Zahlen
200.000.000
150.000.000
100.000.000
50.000.000
0
0 1 1 5 13 74 151 196 516
Zeit in s
StreamSize = 100.000
Anzahl Zahlen 100.000 500.000 1 Mio 5 Mio 10 Mio 50 Mio 100 Mio 125 Mio 250 Mio
Zeit in s 0 1 2 7 17 90 161 200 519
300.000.000
250.000.000
Anzahl Zahlen
200.000.000
150.000.000
100.000.000
50.000.000
0
0 1 2 7 17 90 161 200 519
Zeit in s
StreamSize = 1.000.000
Anzahl Zahlen 10 Mio 50 Mio 100 Mio 125 Mio 250 Mio
Zeit in s 15 89 162 202 521
300.000.000
250.000.000
Anzahl Zahlen
200.000.000
150.000.000
100.000.000
50.000.000
0
15 89 162 202 521
Zeit in s
Gesamt
250.000.000
125.000.000
100.000.000
Anzahl Zahlen
500
450
400
Zeit in Sekunden
350
Sequentiell
300
15 P - Streamsize 1000
250
15 P - Streamsize 10000
200
15 P - Streamsize 100000
150
100
50
0
100.000 500.000 1000000 5000000 10000000 50000000
Anzahl Zahlen
StreamSize = 10.000
Anzahl Zahlen 1 Mio 10 Mio 100 Mio 250 Mio
Zeit in s 1 14 144 416
300.000.000
250.000.000
Anzahl Zahlen
200.000.000
150.000.000
100.000.000
50.000.000
0
1 14 144 416
Zeit in s
StreamSize = 100.000
Anzahl Zahlen 1 Mio 10 Mio 100 Mio 250 Mio
Zeit in s 2 13 156 389
300.000.000
250.000.000
Anzahl Zahlen
200.000.000
150.000.000
100.000.000
50.000.000
0
2 13 156 389
Zeit in s
StreamSize = 1.000.000
Anzahl Zahlen 10 Mio 100 Mio 250 Mio
Zeit in s 15 159 391
300.000.000
250.000.000
Anzahl Zahlen
200.000.000
150.000.000
100.000.000
50.000.000
0
15 159 391
Zeit in s
Gesamt
250.000.000
Anzahl Zahlen
Streamsize = 1.000.000
100.000.000 Streamsize = 100.000
Streamsize = 10.000
10.000.000
7.4. Jumpshot
Diese Abbildung zeigt den generellen Arbeitsablauf des parallelen Algorithmus. Dabei verdeutlicht
sie das Problem der optimierten Zahlenverteilung. Da in unserem Fall der erste Prozessor alle
Daten verteilt, warten die sich im Baum in der untersten Stufe befindlichen Prozessoren
unterschiedlich lang auf ihre Daten und sind somit zu verschiedenen Zeit fertig und arbeiten nur
selten parallel. Dieses Zeitproblem wandert nacheinander in alle Stufen des Baumes.
7.5. Fazit
Die Implementierung eines optimalen und effizienten parallelen Mergsorts stellte sich als sehr
schwierig heraus.
Unser Hauptproblem war letztendlich, dass die Daten von einem Prozessor verteilt wurden und
somit keine vollstndig parallele Abarbeitung erreicht wurde. Dieses Problem knnte durch eine
vorherige Aufteilung der Daten auf die Prozessoren umgangen werden, allerdings mssten dann
die Daten per Hand verteilt und dabei die Streamsize beachtet werden.
Zustzlich konnten wir berechnen, dass die Kommunikations- und Sendezeit der Daten generell
hher als die Rechenzeit ist. Dieses Problem liee sich mit einem schnelleren Netzwerk
optimieren.