You are on page 1of 18

MergeSort

Parallel
vs
Sequentiell

Studiengang: Angewandte Informatik (FHTW)


Fach: WP-Parallele Systeme
WP: PS Mergesort Parallel Angewandte Informatik

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

6. Parallel MergeSort-Monitor ............................................................................................. 11


6.1. Einfhrung................................................................................................................ 11
6.2. Benutzeroberflche................................................................................................... 11
6.3. Start des Monitors .................................................................................................... 12
6.4. Protokollaufbau ........................................................................................................ 12

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

25.01.2007 Seite 2 von 18


WP: PS Mergesort Parallel Angewandte Informatik

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

25.01.2007 Seite 3 von 18


WP: PS Mergesort Parallel Angewandte Informatik

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

- konkrete Nachbildung der Baumstruktur


- jeder Prozessor verteilt die ihm zugesandten Liste auf zwei Child-Prozessoren
- nach erfolgter Sortierung sendet Child-Prozessor sein Ergebnis an Parent-Prozessor -> dieser
merged beide Listen
- Probleme:
Nur eine Schicht Prozessoren in der Baumstruktur ist beschftigt (Childs)
Parents warten generell auf Child-Ergebnisse
Root (Godfather) muss gesamte Liste mergen, andere Prozessoren sind nicht mehr ausgelastet
- Skizze: * = Root arbeitet, = Prozessor arbeitet

Verteilungsphase *

Sortierungsphase

Mergephase

Abbildung 1 - Trivialer Ansatz

25.01.2007 Seite 4 von 18


WP: PS Mergesort Parallel Angewandte Informatik

2.2. Scatter Ansatz

- 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 *

Abbildung 2 - Scatter Ansatz

2.3. Pool Ansatz

- Verfgbare Prozessoren werden ber einen Pool verwaltet


- Root verteilt festgelegte Blockgren der Liste an verfgbare Prozessoren
- Sobald ein Prozessor mit der Sortierung seines Blockes fertig ist, sendet er diesen an Root
zurck, gelangt wieder in den Pool und erhlt vom Root einen neuen Block (solange, bis Liste
leer)
- ist die Liste leer, verteilt Root zwei sortierte Blcke an einen Prozessor (solange bis Liste
sortiert)
- dieser (oder schon der Root?) teilt beide Listen an einem gleichgroen Element auf (so dass
zwei Listen nur Elemente < Auswahlelement und zwei Listen nur Elemente >=
Auswahlelement enthalten) und verteilt z.B. die zwei hheren Listen an einen anderen
Prozessor
- beide Prozessoren mergen nun ihre zwei Listen und der Parent-Prozessor hngt diese
anschlieend aneinander und sendet sie an Root
- es entsteht quasi eine Baumstruktur, wobei die vorhandenen Prozessoren mehr ausgelastet
sind, als bei Ansatz 1 und 2
- Root dient nur als Organisationseinheit
- Idee: zum Schluss werden die Blcke immer grer, so dass immer weniger Prozessoren
beschftigt sind -> macht es Sinn, die greren Sortierlisten nicht mehr nur zu halbieren,
sondern zu dritteln und zu vierteln und somit auf 3 oder 4 Prozessoren zu verteilen?

25.01.2007 Seite 5 von 18


WP: PS Mergesort Parallel Angewandte Informatik

- Skizze: * = Root arbeitet, = Prozessor arbeitet

Verteilungsphase *
+
Sortierungsphase

Mergephase

*
-
Abbildung 3 - Pool Ansatz

25.01.2007 Seite 6 von 18


WP: PS Mergesort Parallel Angewandte Informatik

2.4. Streaming Ansatz

- Nachbildung eines binren Baumes


- Root-Prozess verteilt Gesamtliste auf die Prozesse der untersten Stufe der Baumstruktur ->
dort werden sie der Gre nach sortiert
- diese liefern dann sortierte Zahlen gestreamt an ihren Vater-Prozess (z.B. 1000 Zahlen werden
sortiert und sofort weitergeben, dann wird weiter sortiert)
- Prozess merged beide empfangenen Listen und leitet sie gestreamt an Vater-Prozess weiter ->
wartet auf neue Liste, wenn eine verbraucht wurde
- Root erhlt letztendlich zwei sortierte Listen und merged diese wieder zu einer Gesamtliste
- Skizze: * = Root arbeitet, = Prozessor arbeitet

Verteilungsphase *

Sortierungsphase

Mergephase

Abbildung 4 - Streaming Ansatz

25.01.2007 Seite 7 von 18


WP: PS Mergesort Parallel Angewandte Informatik

3. Daten

Generell muss entschieden werden, was fr Daten zu sortieren sind. Fr die Erstimplementierung
werden Zahlen vom Datentyp Long vorgesehen.

3.1. Ansatz Netzlaufwerk

- 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

3.2. Ansatz Arbeitsspeicher

- 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

4.1. per MPI

- 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

4.2. Monitoring Filesystem Root

- Oberflche wird in Java o.. programmiert


- beteiligte Prozessoren senden Arbeitsstatus an z.B. Root
- dieser schreibt sie in Datei
- Visualisierungprogramm wertet diese anschlieend aus
- Problem:
keine Live-Ansicht (es sei denn, Visualisierungsprogramm liest parallel die Datei mit)
ein Prozessor muss nur dafr da sein, Statusangaben von anderen Prozessoren zu
empfangen -> kann im Prinzip nicht der Root sein, da recv blockierend sind und er noch
die Arbeit verteilen muss

25.01.2007 Seite 8 von 18


WP: PS Mergesort Parallel Angewandte Informatik

4.3. Monitoring Network

- 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

- Visualisierung ber von MPI untersttztem MPE


- Nachteil: unbersichtlich
- Vorteil: einfach zu implementieren

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

p = Anzahl Prozessoren (= 7, 15, 31, 63)


tp = Rechenzeit bei p Prozessoren (=21, 17, 13, 11)
t1 = Rechenzeit bei einem Prozessor (= 35s)
sp = t1 / tp

Prozessoren
anzahl SpeedUp
7 1,66666667
15 2,05882353
31 2,69230769
63 3,18181818
Tabelle 1 - Berechnung des SpeedUp

normaler SpeedUp, da sp < p

25.01.2007 Seite 9 von 18


WP: PS Mergesort Parallel Angewandte Informatik

3,5

2,5
SpeedUp

1,5

0,5

0
7 15 31 63
Anzahl Prozessoren

Abbildung 5 - Verlauf des SpeedUp

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

Effizienz wird schlechter, Prozessoren nicht gut ausgelastet

25

20
Effizienz in %

15

10

0
7 15 31 63
Anzahl Prozessoren

Tabelle 3 - Verlauf der Effizienz

25.01.2007 Seite 10 von 18


WP: PS Mergesort Parallel Angewandte Informatik

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

Der Bildschirm teilt sich in 4 Bereiche ein:


In der Menzeile lsst sich die Geschwindigkeit der Abarbeitung einstellen und der
Sortiervorgang starten oder pausieren
Im Hauptfenster erscheinen die Prozessoren mit Ihrer Nummer und je 4 Fortschrittsbalken
o Done: Gibt an, wieweit dieser Prozessor mit seinem Gesamt-Sortiervorgang ist
o Out: Gibt die Gre und Stand der ausgehenden Pipeline zum bergeordneten Knoten
an
o In L/R: Diese beiden Fortschrittsbalken geben den Stand der eingehenden Pipeline der
beiden untergeordneten Knoten an
Im unteren Bereich erscheinen die eingehenden Nachrichten

Abbildung 6 - Screenshot Monitor

25.01.2007 Seite 11 von 18


WP: PS Mergesort Parallel Angewandte Informatik

6.3. Start des Monitors

Der Monitor kann in zwei Betriebsmodi gestartet werden:

Start als Socket-Server

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.

Start mit Protokolldatei

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

Nachfolgend wird beschrieben, in welcher Form der Monitor Protokoll-Eintrge


entgegennimmt:

Name Type Beschreibung


time long Zeitstempel (Millisekunden seit dem 1.1.1970)
type int Event-Typ
1 Anzahl Prozessoren (3, 7, 15, 31)
2 Gre Pipeline
3 Fllstand Pipeline
processor # int Nummer des Prozessors (beginnend mit 0)
pipeline # int Nummer der Pipeline
pipeline size / int Gre bzw. Fllstand der Pipeline
value
Tabelle 4 - Protokollaufbau Monitor

25.01.2007 Seite 12 von 18


WP: PS Mergesort Parallel Angewandte Informatik

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

Anzahl Zahlen 100.000 500.000 1 Mio 5 Mio 10 Mio 50 Mio


Zeit in s 0 2 4 12 35 430

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

Abbildung 7 - Diagramm Sequentiell

7.2. Parallel 15 Prozessoren

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

Abbildung 8 - Diagramm Parallel StreamSize 1.000

25.01.2007 Seite 13 von 18


WP: PS Mergesort Parallel Angewandte Informatik

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

Abbildung 9 - Diagramm Parallel StreamSize 10.000

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

Abbildung 10 - Diagramm Parallel StreamSize 100.000

StreamSize = 1.000.000
Anzahl Zahlen 10 Mio 50 Mio 100 Mio 125 Mio 250 Mio
Zeit in s 15 89 162 202 521

25.01.2007 Seite 14 von 18


WP: PS Mergesort Parallel Angewandte Informatik

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

Abbildung 11 - Diagramm Parallel StreamSize 1.000.000

Gesamt

250.000.000
125.000.000
100.000.000
Anzahl Zahlen

50.000.000 Streamsize = 100.000


10.000.000 Streamsize = 10.000
5.000.000 Streamsize = 1.000
1.000.000
500.000
100.000

0 100 200 300 400 500 600


Zeit in s

Abbildung 12 - Diagramm Parallel Gesamt

Vergleich Sequentiell und Parallel mit 15 Prozessoren

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

Abbildung 13 - Diagramm Vergleich Sequentiell und Parallel

25.01.2007 Seite 15 von 18


WP: PS Mergesort Parallel Angewandte Informatik

7.3. Parallel 31 Prozessoren

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

Abbildung 14 - Diagramm Parallel StreamSize 10.000 31

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

Abbildung 15 - Diagramm Parallel StreamSize 100.000 31

25.01.2007 Seite 16 von 18


WP: PS Mergesort Parallel Angewandte Informatik

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

Abbildung 16 - Diagramm Parallel StreamSize 1.000.000 31

Gesamt

250.000.000
Anzahl Zahlen

Streamsize = 1.000.000
100.000.000 Streamsize = 100.000
Streamsize = 10.000

10.000.000

0 100 200 300 400 500


Zeit in s

Abbildung 17 - Diagramm Parallel 31

25.01.2007 Seite 17 von 18


WP: PS Mergesort Parallel Angewandte Informatik

7.4. Jumpshot

Abbildung 18 - Jumpshot-Ausgabe fr 8MB 15 Prozessoren StreamSize=1000

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.

25.01.2007 Seite 18 von 18