Parallele Algorithmen - Ra.informatik.tu-darmstadt.de - Technische ...

Globaler Zellularautomat:
Parallele Algorithmen
Diplomarbeit
von
Christine Ehrt
Prüfer: Prof. Dr. Rolf Hoffmann
Betreuer: Dipl.-Ing. Wolfgang Heenes
Fachgebiet Rechnerarchitektur
Fachbereich Informatik
Technische Universität Darmstadt
29. November 2005

Erklärung
Ich versichere, dass ich diese Arbeit ohne unzulässige fremde Hilfe und nur unter Benutzung
der in der Arbeit angegebenen Literatur und sonstigen Hilfsmitteln angefertigt
habe.
Darmstadt, den 29. November 2005
Danksagung
Im Rahmen meines Studiums und meiner Diplomarbeit haben mir viele Menschen sehr
geholfen. Bei einigen möchte ich mich gerne persönlich bedanken:
Dipl.-Ing. Wolfgang Heenes, der mit seinem Repititorium erstmals in mir das Interesse
für die Technische Informatik weckte und dies dann mit dem Rechnertechnologiepraktikum
noch vertiefte. Außerdem war er während meiner Diplomarbeitsphase immer für
mich da und hat eine für mich individuell sehr intensive und gute Betreuung geboten.
Prof. Dr. Rolf Hoffmann, der mit seinen für mich interessanten Vorlesungen dieses Interesse
noch weiter vertieft hat und mir schließlich auch ermöglichte, in diesem Gebiet
meine Diplomarbeit zu schreiben.
Dipl.-Inform. Mathias Halbach, der mir bei Problemen der Implementierung geholfen
hat.
Herrn Endisch, der sein 1999 gegebenes Versprechen eingehalten und meine gesamte
Diplomarbeit auf grammatikalische und Rechtschreibfehler überprüft hat. Außerdem
hat er mich mit seinen Anmerkungen oft zum Nachdenken gebracht und somit zu einer
besseren Arbeit beigetragen.
Meinen Freunden, die mir sowohl als Stütze als auch Korrekturleser zur Seite standen:
Marcel Thies, Silke Schneider, Denis Endro und Stefan Müller.
Ihnen allen spreche ich hiermit meinen herzlichen Dank aus und hoffe, mit meiner Diplomarbeit
ihre Erwartungen erfüllt zu haben.
2

Inhaltsverzeichnis
1. Einleitung 10
1.1. Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2. Aufwandsbetrachtung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3. Struktur der Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2. Zellularautomaten und andere Modelle 13
2.1. Die Random-Access-Maschinen . . . . . . . . . . . . . . . . . . . . . . . 13
2.1.1. Prinzip der RAM . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.1.2. Die P-RAM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2. Die Pointer-Maschinen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2.1. Maschinenmodelle der Pointer-Maschinen . . . . . . . . . . . . . . 16
2.2.1.1. Kolmogorov-Uspenskii Maschinen . . . . . . . . . . . . . 16
2.2.1.2. Storage Modification Maschines . . . . . . . . . . . . . . 16
2.2.1.3. Knuths Linking Automat . . . . . . . . . . . . . . . . . 17
2.2.1.4. Die LISP Maschinen . . . . . . . . . . . . . . . . . . . . 17
2.2.2. Programmiermodelle der Pointer-Maschinen . . . . . . . . . . . . 17
2.2.3. Parallel-Pointer Maschinen . . . . . . . . . . . . . . . . . . . . . . 18
2.3. Die Zellularautomaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.3.1. Der klassische Cellular Automata“ (CA) . . . . . . . . . . . . . 19
”
2.3.1.1. Tesselation CA . . . . . . . . . . . . . . . . . . . . . . . 20
2.3.1.2. Iterative CA . . . . . . . . . . . . . . . . . . . . . . . . 21
2.3.1.3. Dynamische CA . . . . . . . . . . . . . . . . . . . . . . 21
2.3.1.4. CA Networks (CAN) . . . . . . . . . . . . . . . . . . . . 21
2.3.2. Der Structurally Dynamic Cellular Automata“ (SDCA) . . . . . 21
”
2.3.2.1. Das Relative Location Modell . . . . . . . . . . . . . . . 22
2.3.2.2. Das Labeled Link Modell . . . . . . . . . . . . . . . . . 23
2.3.2.3. Das Symmetric Modell . . . . . . . . . . . . . . . . . . . 23
2.3.3. Der Dynamic Structure Cellular Automata“ (DSCA) . . . . . . . 23
”
2.3.4. Der Global Cellular Automata“ (GCA) . . . . . . . . . . . . . . 24
”
3. Die Modellierung von Graphenalgorithmen auf dem GCA 27
3.1. Erkennung von zusammenhängenden Komponenten eines Graphen . . . . 28
3.1.1. Der Warshall-Algorithmus . . . . . . . . . . . . . . . . . . . . . . 28
3.1.1.1. Der Warshall auf einem Einprozessor-System . . . . . . 29
3

3.1.1.2. Der Warshall-Algorithmus auf dem GCA . . . . . . . . . 30
3.1.2. Der Floyd-Warshall-Algorithmus . . . . . . . . . . . . . . . . . . 34
3.1.3. Der Algorithmus von Hirschberg et al. . . . . . . . . . . . . . . . 36
3.1.3.1. Ablauf auf der P-RAM . . . . . . . . . . . . . . . . . . . 36
3.1.3.2. Komplexitätsbetrachtung auf der P-RAM . . . . . . . . 42
3.1.3.3. Modellierung auf dem GCA . . . . . . . . . . . . . . . . 46
3.1.3.4. Komplexitätsbetrachtung und Verbesserungen auf dem
GCA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.1.3.4.1. Speicherzellenmodellierung . . . . . . . . . . . . 49
3.1.3.4.2. Laufzeitkomplexitätsverbesserung . . . . . . . . 53
3.2. Minimal aufspannende Bäume . . . . . . . . . . . . . . . . . . . . . . . . 54
3.2.1. Der Kruskal-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . 54
3.2.1.1. Der Heap-Sort . . . . . . . . . . . . . . . . . . . . . . . 55
3.2.1.2. Der Heap-Sort auf dem GCA . . . . . . . . . . . . . . . 58
3.2.1.3. Der Kruskal auf dem GCA . . . . . . . . . . . . . . . . . 65
3.2.2. Modifikation des Hirschberg für minimal aufspannende Bäume . . 68
3.2.2.1. Realisierung auf dem GCA . . . . . . . . . . . . . . . . 73
3.2.3. Derzeitiger Forschungsstand . . . . . . . . . . . . . . . . . . . . . 74
3.3. NP-vollständige Probleme . . . . . . . . . . . . . . . . . . . . . . . . . . 75
3.3.1. Das Graphenfärbbarkeitsproblem . . . . . . . . . . . . . . . . . . 76
3.3.1.1. Kantenfärbung von bipartiten Graphen . . . . . . . . . . 78
3.4. Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
4. Die Modellierung von Krypto-Algorithmen auf dem GCA 91
4.1. Der erweiterte euklidische Algorithmus . . . . . . . . . . . . . . . . . . . 91
4.2. Die Anwendung des Chinesische Restsatzes . . . . . . . . . . . . . . . . . 93
4.3. Einordnung der Anwendung des Chinesischen Restsatzes . . . . . . . . . 97
5. Implementierungseigenheiten 99
6. Zusammenfassung und Ausblick 101
A. Traversierungsstrategien 103
A.1. Backtracking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
A.2. Divide and Conquer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
B. Parallele Algorithmische Techniken 109
B.1. Die Balanced-Binary-Tree-Technik . . . . . . . . . . . . . . . . . . . . . . 109
B.2. Die Doubling-Technik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
B.3. Die Divide-and-Conquer-Technik . . . . . . . . . . . . . . . . . . . . . . 111
C. Implementierungen der Algorithmen 112
C.1. Warshall-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
C.2. Hirschberg-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
C.3. Kruskal-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
4

C.4. Modifizierter Hirschberg-Algorithmus . . . . . . . . . . . . . . . . . . . . 117
C.5. Euler-Färbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
C.6. Chinesischer Restsatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
5

Abbildungsverzeichnis
2.1. Darstellung der Nachbarschaftsbeziehung nach von Neumann . . . . . . . 19
2.2. Darstellung der Nachbarschaftsbeziehung nach Moore . . . . . . . . . . . 20
2.3. [CNG + 01]: CAN network of the Sarno SCIDDICA model . . . . . . . . . 22
2.4. Entscheidungsbaum zur Bestimmung der Veränderung der Daten . . . . 26
3.1. Beispielgraph Warshall . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.2. Schematische Darstellung des Warshall-Algorithmus auf dem GCA . . . . 31
3.3. Zelleninitialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.4. Ablauf des Warshall-Algorithmus in der Theorie . . . . . . . . . . . . . . 32
3.5. Ablauf des Warshall-Algorithmus auf dem GCA . . . . . . . . . . . . . . 33
3.6. Beispielgraph Hirschberg . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.7. Hirschberg Ergebnis erster Schritt, erster Durchlauf . . . . . . . . . . . . 39
3.8. Hirschberg Ergebnis vierter Schritt, erster Durchlauf . . . . . . . . . . . 39
3.9. Hirschberg Ergebnis fünfter Schritt, erster Durchlauf . . . . . . . . . . . 40
3.10. Hirschberg Ergebnis erster Schritt, zweiter Durchlauf . . . . . . . . . . . 40
3.11. Hirschberg Ergebnis zweiter Schritt, zweiter Durchlauf . . . . . . . . . . 41
3.12. Hirschberg Ergebnis vierter Schritt, zweiter Durchlauf . . . . . . . . . . . 41
3.13. Hirschberg fünfter Schritt, zweiter Durchlauf . . . . . . . . . . . . . . . . 42
3.14. Minimumbestimmung mit der Doubling-Technik . . . . . . . . . . . . . . 44
3.15. Balanced-Binary-Tree in der Graphenrepräsentation . . . . . . . . . . . . 45
3.16. Schematische Darstellung des Hirschbergs auf dem GCA . . . . . . . . . 47
3.17. Speicherzellenrealisierung 1 . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.18. Speicherzellenrealisierung 1a . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.19. Speicherzellenrealisierung 1b . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.20. Speicherzellenrealisierung 2 . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.21. Min-Heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.22. In einen Heap eingelesener Vektor . . . . . . . . . . . . . . . . . . . . . . 56
3.23. Min-Heap nach dem Entfernen des ersten Elements . . . . . . . . . . . . 57
3.24. Erster Schritt zur Wiederherstellung der Heap-Eigenschaft . . . . . . . . 57
3.25. Der wieder hergestellte Heap . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.26. Darstellung des Heaps auf dem GCA . . . . . . . . . . . . . . . . . . . . 59
3.27. Beispiel des parallel ablaufenden Heap-Sorts, Bild1 . . . . . . . . . . . . 59
3.28. Beispiel des parallel ablaufenden Heap-Sorts, Bild2 . . . . . . . . . . . . 60
3.29. Beispiel des parallel ablaufenden Heap-Sorts, Bild3 . . . . . . . . . . . . 60
6

3.30. Beispiel des parallel ablaufenden Heap-Sorts, Bild4 . . . . . . . . . . . . 61
3.31. Beispiel des parallel ablaufenden Heap-Sorts, Bild5 . . . . . . . . . . . . 61
3.32. Beispiel des parallel ablaufenden Heap-Sorts, Bild6 . . . . . . . . . . . . 62
3.33. Beispiel des parallel ablaufenden Heap-Sorts, Bild7 . . . . . . . . . . . . 62
3.34. Repräsentation der Ebenen des Baums durch die Zellen des GCA . . . . 63
3.35. Realisierung des Kruskal-Algorithmus auf dem GCA . . . . . . . . . . . . 66
3.36. Realisierung des Kruskal-Algorithmus ohne Bus . . . . . . . . . . . . . . 67
3.37. Realisierung des Kruskal-Algorithmus mit Bus-Zelle . . . . . . . . . . . . 67
3.38. Beispielgraph für den Hirschbergalgorithmus zur Berechnung minimaler
Spannbäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
3.39. Teilergebnisgraph nach dem ersten Schritt des Hirschberg . . . . . . . . . 71
3.40. Teilergebnis nach dem zweiten Schritt des Hirschberg . . . . . . . . . . . 72
3.41. Teilergebnis nach dem ersten Schritt des zweiten Durchlaufs . . . . . . . 72
3.42. Teilergebnis nach dem zweiten Schritt des zweiten Durchlaufs . . . . . . 73
3.43. Bipartite und nicht bipartite Graphen . . . . . . . . . . . . . . . . . . . . 77
3.44. Outerplanarer Graph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
3.45. Ein Halin-Graph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
3.46. Ein Bipartiter Graph mit Euler-Zerlegung . . . . . . . . . . . . . . . . . 79
3.47. Bipartiter Beispielgraph für die Euler-Zerlegung . . . . . . . . . . . . . . 82
3.48. Bipartiter Beispielgraph nach der Ersetzung der Kanten . . . . . . . . . . 82
3.49. Bipartiter Beispielgraph nach der Kantensortierung . . . . . . . . . . . . 83
3.50. Successorbestimmung für die Kanten des bipartiten Beispielgraphen . . . 84
3.51. Die Kanten-Zellen nach der Doubling-Technik . . . . . . . . . . . . . . . 85
3.52. Auswahl eines Zyklusses . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
3.53. Festlegen der Ablaufreihenfolge . . . . . . . . . . . . . . . . . . . . . . . 86
4.1. Initialisierung des GCA um den Chinesischen Restsatz anzuwenden . . . 96
4.2. Die Variable m wurde mit der Doubling-Technik ausgerechnet . . . . . . 96
4.3. Alle Zellen haben den korrekten Wert in der Variable m . . . . . . . . . . 97
A.1. Die erste Dame ist auf dem Feld positioniert . . . . . . . . . . . . . . . . 103
A.2. Die zweite Dame ist auf dem Feld positioniert . . . . . . . . . . . . . . . 104
A.3. Die dritte Dame ist auf dem Feld positioniert . . . . . . . . . . . . . . . 104
A.4. Die vierte Dame ist auf dem Feld positioniert . . . . . . . . . . . . . . . 105
A.5. Die fünfte Dame ist auf dem Feld positioniert . . . . . . . . . . . . . . . 105
A.6. Die fünfte Dame ist auf dem Feld repositioniert . . . . . . . . . . . . . . 105
A.7. Die vierte Dame ist auf dem Feld repositioniert . . . . . . . . . . . . . . 106
A.8. Startsituation des Quicksorts . . . . . . . . . . . . . . . . . . . . . . . . . 107
A.9. Quicksort nach der Vorsortierung . . . . . . . . . . . . . . . . . . . . . . 107
A.10.Rekursiver Aufruf des Quicksorts . . . . . . . . . . . . . . . . . . . . . . 108
B.1. Mittelwertbestimmung mit der Balanced-Binary-Tree-Technik . . . . . . 110
B.2. Abstandsbestimmung mit der Doubling-Technik . . . . . . . . . . . . . . 111
7

Listings
3.1. Der Warshall-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.2. Der leicht modifizierte Warshall-Algorithmus . . . . . . . . . . . . . . . . 29
3.3. Der Hirschberg-Algorithmus auf der P-RAM . . . . . . . . . . . . . . . . 37
3.4. Weitere Unterteilung des ersten Schritts des Hirschberg-Algorithmus . . . 43
3.5. Minimumbestimmung mit der Doubling-Technik . . . . . . . . . . . . . . 43
3.6. Eulerfärbung für bipartite Graphen . . . . . . . . . . . . . . . . . . . . . 80
4.1. Der erweiterte euklidische Algorithmus in C . . . . . . . . . . . . . . . . 93
5.1. Effizienztest für Threads in C . . . . . . . . . . . . . . . . . . . . . . . . 99
B.1. Berechnung der Summe mit der Balanced-Binary-Tree-Technik . . . . . . 110
C.1. Implementierung des Warshall-Algorithmus . . . . . . . . . . . . . . . . . 112
C.2. Implementierung des Hirschberg-Algorithmus . . . . . . . . . . . . . . . . 113
C.3. Implementierung des Kruskal-Algorithmus . . . . . . . . . . . . . . . . . 115
C.4. Implementierung des modifizierten Hirschberg-Algorithmus . . . . . . . . 117
C.5. Implementierung der Eulerfärbung . . . . . . . . . . . . . . . . . . . . . 119
C.6. Implementierung des Chinesischen Restsatzes . . . . . . . . . . . . . . . 125
8

Tabellenverzeichnis
3.1. Laufzeit der betrachteten Algorithmen . . . . . . . . . . . . . . . . . . . 89
3.2. Abhängigkeiten der Daten für die Graphen-Algorithmen . . . . . . . . . 90
3.3. Abhängigkeiten der Verbindungen für die Graphen-Algorithmen . . . . . 90
4.1. Berechnungstabelle des euklidischen Algorithmus . . . . . . . . . . . . . 92
4.2. Berechnungstabelle des erweiterten euklidischen Algorithmus . . . . . . . 92
4.3. Berechnung des Inversen von M 1 modulo m 1 . . . . . . . . . . . . . . . . 95
4.4. Berechnung des Inversen von M 2 modulo m 2 . . . . . . . . . . . . . . . . 95
4.5. Berechnung des Inversen von M 3 modulo m 3 . . . . . . . . . . . . . . . . 95
4.6. Abhängigkeiten der Daten und Verbindungen für den Chinesischen Restsatz. 98
5.1. Ausführungszeiten ohne Threads und mit Threads . . . . . . . . . . . . . 100
9

1. Einleitung
Dieses Kapitel wird zuerst eine Motivation liefern, parallele Systeme näher zu betrachten
und anschließend einen Überblick über diese Arbeit geben. Zudem wird in diesem Kapitel
der Begriff der Aufwandsbetrachtung, wie er in dieser Arbeit verwendet wird, definiert.
1.1. Motivation
Schon seit Jahren liest man oft, dass die Möglichkeiten zur Leistungssteigerung der Prozessoren
durch Vermehrung der Transistoren bald ausgereizt seien. Es wird befürchtet,
dass die Strukturen dann nicht mehr in dem Maße weiter verkleinert werden können,
wie es nötig wäre, um eine Leistungssteigerung durch kleinere und dadurch mehr Transistoren
zu erzielen. Eine Möglichkeit, die Leistungsfähigkeit weiter zu steigern, bieten
die Quantenrechner. Diese sind zur Zeit aber noch nicht ausreichend erforscht und produzierbar
1 , um Marktreife zu erlangen.
Davon abgesehen stellen Quantenrechner die Informatik vor bislang ungeahnte Probleme,
müssen dann doch neue Kryptoverfahren entwickelt 2 und auf eine andere als bislang
gewohnte Weise implementiert werden. Es ist davon auszugehen, dass die Quantenrechner
in den nächsten Jahren noch nicht reif für die Massenproduktion sind, weshalb man
sich nach anderen Alternativen zur Leistungssteigerung umgesehen hat.
Der geschickte Aufbau von parallelen Architekturen und eine gute Programmierung für
sie bieten die Möglichkeit, Laufzeitverbesserungen zu erlangen, ohne die Anzahl der
Transistoren pro Chip bzw. Prozessor zu erhöhen. Aus diesem Grund sind parallele
Systeme und der Aufbau von neuen parallelen Architekturen in letzter Zeit wieder vermehrt
im Interesse der Wirtschaft. So stellten Sony, Toshiba und IBM letztens den
Cell-Prozessor [Web05] vor, einen Chip, der über insgesamt neun Prozessoren verfügt
und unter anderem in die PS3 (Playstation 3) eingebaut werden soll.
Mit dieser Entwicklung werden Parallelrechner für die breite Bevölkerung und damit
auch für Nicht-Akademiker interessant. Es wird dadurch nötig, sich Gedanken zu machen,
wie man die bisherigen sequentiellen Algorithmen geschickt auf ein paralleles System
übertragen kann.
1 Es ist bereits gelungen, im Labor einen Quantenrechner zu bauen, der die Zahl 15 faktorisiert. Größere
Quantenrechner sind bislang noch nicht gelungen.
2 Elliptische Kurven gelten bislang als sicher gegenüber Angriffe mit Quantenrechnern. Zudem wurden
auch schon Kryptoverfahren auf Quantenrechnern entwickelt, die sicher sind. Allerdings ist auch hier
die Technik noch nicht ausgereift genug, als dass Marktreife erlangt würde.
10

Natürlich kann man die Algorithmen unverändert ausführen und nur ein Prozessor des
Systems berechnet das Problem. Allerdings verliert man so viel Performance und es
scheint angeraten, sich zu überlegen, wie man die neuen Möglichkeiten besser nutzen
kann.
Diese Arbeit gibt einen Überblick über einige Algorithmen, welche teilweise an die neuen
Umstände angepasst sind, teilweise schon für sie entwickelt wurden und effizient auf parallelen
Systemen arbeiten. Um die Effizienz zu bestimmen, wird eine Aufwandsbetrachtung
der einzelnen Algorithmen betrieben, welche auch auf die Parallelität angepasst
wurde. Im Folgenden wird eine Erklärung zur Aufwandsbetrachtung abgegeben, danach
wird dargestellt, wie sich die Arbeit aufbaut.
1.2. Aufwandsbetrachtung
Bei Mehrprozessorsystemen ist immer zu beachten, dass nicht nur die Laufzeitkomplexität
für die Komplexitätsbetrachtung wichtig ist. Stattdessen ist immer auch die Anzahl
der Prozessoren sowie die benötigten Verbindungen zwischen den Prozessoren wichtig.
Ohne diese Angaben ist kein korrekter Vergleich zwischen zwei verschiedenen Realisierungen
möglich. Wenn hier also eine Abschätzung der Komplexität gegeben wird, dann
ist es auch zwingend notwendig, die Anzahl der Prozessoren und sofern möglich die
Anzahl der Verbindungen anzugeben.
Die O-Notation wird hier nicht nur für die Zeitabschätzung benutzt, sondern auch für
die Anzahl der Prozessoren verwendet, d. h. O(1) Prozessoren bedeutet eine konstante
Anzahl an Prozessoren. Die gegebenen Abschätzungen sind für die maximal sinnvolle
Anzahl an Prozessoren gegeben. Manchmal ließe sich das Ergebnis auch mit weniger
Prozessoren erzielen, allerdings dann zu ungunsten der Laufzeit. Damit die Abschätzung
also vergleichbar bleibt, wurde hier auf Modifikationen, welche die Anzahl der Prozessoren
auf Kosten der Laufzeit minimieren, verzichtet. Ist es jedoch möglich, die Anzahl
der Prozessoren zu verringern, ohne dabei Laufzeiteinbußen hinzunehmen, so sind diese
Modifikationen oder eine Referenz auf die entsprechende Literatur angegeben.
1.3. Struktur der Arbeit
In der Wissenschaft werden parallele Systeme schon seit langem erforscht, was zu einer
Vielzahl an Modellen geführt hat. Meist sind diese Modelle auf eine bestimmte Aufgabe
hin modelliert oder haben sich aus einem Single-Prozessor-Modell heraus entwickelt. In
Kapitel 2 soll eine Übersicht über einige parallele Modelle gegeben werden. Da viele
Modelle existieren, erhebt diese Arbeit keinen Anspruch auf Vollständigkeit oder Gewichtung
bezüglich der Auswahl.
Im dritten Kapitel werden dann Graphenalgorithmen auf dem parallelen Modell des
Global Cellular Automata“ (GCA) angegeben und eine Aufwandsbetrachtung der einzelnen
Algorithmen
”
betrieben.
11

Im vierten Kapitel wird ein kryptographischer Algorithmus auf dem GCA modelliert
und auch hierfür eine Komplexitätsbetrachtung angestellt.
Im fünften Kapitel wird auf die Eigenheiten der Implementierung, wie z. B. das unterschiedliche
Laufzeitverhalten eines Algorithmus bei Modifikationen der Implementierung,
eingegangen.
Im sechsten Kapitel wird dann ein Fazit gezogen und aufgezeigt, wo noch Forschungsbedarf
besteht.
12

2. Zellularautomaten und andere
Modelle
Innerhalb der Automatentheorie war es schon immer so, dass mehrere gleichmächtige
Modelle existierten. Diese wurden teilweise zeitgleich entwickelt, und unterschieden sich
oft nur in Kleinigkeiten oder einer verschiedenen Herangehensweise an die Problematiken.
Wird ein Modell entwickelt, so richtet sich der Aufbau des Modells immer danach, was
man mit dem Modell erreichen möchte. Möchte man mit einem Modell z. B. natürliche
Vorgänge in ihrer Feinheit möglichst realitätsnah nachempfinden, wird man es anders
entwickeln als ein Modell, das dazu dient, Studenten die Möglichkeiten von Automaten
zu verdeutlichen.
Bei einem Modell, das eine bestimmte Situation simulieren soll, wird das Modell eventuell
komplexer und unverständlicher, wenn sich dadurch die Problematik in dem Modell
leichter formulieren lässt. Ein Modell hingegen, dass für die Lehre entwickelt wurde, wird
so einfach wie möglich gehalten werden, damit es auch für einen Laien leicht verständlich
ist. Lösungen sollen auf diesem Modell dann zwar immer noch möglich sein, aber
komplexere Probleme sind deutlich schwieriger auf einem solchem Modell zu simulieren
als auf einem speziell entwickelten Automatenmodell. Ein Problem bei einem einfachen
Modell ist stets auch, dass die Gefahr besteht, dass von der Realität so weit abstrahiert
wird, dass das resultierende Modell nicht mehr der Realität entspricht.
So wie sich verschiedene Modelle in der klassischen Automatentheorie gebildet haben,
wurden auch mehrere Modelle für parallele Systeme gebildet, teilweise davon beeinflusst,
welches klassische Modell zu Grunde gelegt wurde, teilweise aber auch auf anderen Ideen
aufbauend. In den anschließenden Abschnitten sollen einige Automatenmodelle vorgestellt
werden. Falls vorhanden, wird dabei zunächst auf die Single-Prozessor-Variante
eingegangen, bevor die parallelen Möglichkeiten erläutert werden.
2.1. Die Random-Access-Maschinen
Ein Modell, das neben der Turing-Maschine 1 verwendet wird, um Studenten die Berechenbarkeit
verständlicher zu machen, ist die Random-Access-Maschine (RAM). Dieses
Modell ist in seiner Programmiersprache ähnlich zu Assembler und eignet sich aufgrund
1 Turing-Maschinen werden u. a. in [Sch01] eingeführt und erklärt.
13

seiner Einfachheit u. a. zur Betrachtung der Terminierung von Programmen. Das Prinzip
der RAM soll nun erläutert werden, bevor das Modell dann zur parallelen RAM
(P-RAM) erweitert wird.
2.1.1. Prinzip der RAM
Die RAM verfügt über eine CPU mit abzählbar unendlich vielen Registern, in denen
beliebig große natürliche Zahlen gespeichert werden können. Auf den Werten kann die
CPU arithmetische Operationen ausführen, zusätzlich kann die CPU jederzeit auf den
Speicher zugreifen und von dort Werte in die Register lesen oder Werte in den Speicher
schreiben.
Der Arbeitsablauf der CPU wird von einem Programm festgelegt, welches sich im Speicher
befindet. Eventuell benötigte Eingaben für das Programm stehen ebenfalls an definierten
Stellen im Speicher. Das Programm besteht aus arithmetischen Instruktionen
sowie Speicherzugriffsbefehlen. Um den normalen Programmfluss zu modifizieren, sind
außerdem bedingte Sprünge erlaubt. Die Instruktionen des Programms werden gemäß
eines Takts abgearbeitet und die CPU beendet ihre Arbeit bei Programmende.
Bei der Aufwandsbetrachtung eines Programms auf der RAM müssen drei Aspekte unterschieden
werden:
• Die Programmgröße bestimmt sich aus der Anzahl der Instruktionen, welche das
Programm bilden.
• Die Speichergröße bestimmt sich aus der Anzahl der vom Programm genutzten
Speicherzellen.
• Der Zeitaufwand, bestimmt sich aus der Anzahl der Takte, welche benötigt werden,
bis das Programm abgearbeitet ist.
2.1.2. Die P-RAM
Das erste Kapitel von [KKT01] liefert eine Möglichkeit zur Parallelisierung des RAM-
Modells. Da alle Berechnungen von der CPU ausgeführt werden, kann die RAM dadurch
parallelisiert werden, dass es nicht mehr eine einzige CPU gibt, sondern mehrere Prozessoren.
Diese Prozessoren arbeiten synchron, besitzen also einen gemeinsamen Takt und
haben Zugriff auf einen gemeinsamen Speicher.
Der Datenaustausch zwischen den Prozessoren geschieht über den gemeinsamen Speicher.
Ein Prozessor schreibt seine Werte in eine Speicherzelle und andere Prozessoren
können sie dort bei Bedarf lesen. Ein Nachteil an dieser Modellierung ist, dass sichergestellt
werden muss, dass keine zwei Prozessoren zur gleichen Zeit auf eine Speicherzelle
schreiben wollen.
14

Aufgrund solcher Schreibkonflikte kann es zu Dateninkonsistenzen kommen. Diese Dateninkosistenzen
können dadurch vermieden werden, dass eine Speicherzelle, auf die schreibend
zugegriffen wird, gesperrt und erst nach dem erfolgreichen Schreibvorgang wieder
freigegeben wird. Um die synchrone Arbeitsweise der Prozessoren zu gewährleisten wird
angenommen, dass alle Speicheroperationen die gleiche Zeit benötigen.
Neben dem gemeinsamen Speicher gibt es noch einen privaten Speicher, auf den nur
jeweils ein Prozessor Zugriff hat. Zudem verfügt jeder Prozessor über eine eindeutige
Kennung (ID) damit die Prozessoren unterschieden werden können, da verschiedene
Prozessoren verschiedene Instruktionen ausführen können.
Der gemeinsame Speicher kann in vier verschiedenen Modi betrieben werden: EREW,
CREW, CRCW und CROW.
EREW bedeutet ”
exclusive read, exclusive write“ und bezeichnet den Modus, in dem
pro Zeittakt jeweils nur maximal ein Prozessor lesend oder schreibend auf die gleiche
Speicherzelle zugreifen darf.
CREW bedeutet ”
concurrent read, exclusive write“ und erlaubt den lesenden Zugriff
mehrerer Prozessoren auf eine Speicherzelle, aber auf eine Speicherzelle schreibend zugreifen
darf nur ein Prozessor pro Takt.
CRCW bedeutet ”
concurrent read, concurrent write“ und erlaubt sowohl den parallel lesenden
als auch den parallel schreibenden Zugriff auf eine Speicherzelle. In diesem Modus
muss im Programm darauf geachtet werden, dass keine Dateninkonsistenzen entstehen.
CROW bedeutet ”
concurrent read, owners write“. In diesem Modus wird jeder Speicherzelle
genau ein Prozessor zugeordnet, welcher auf diese Speicherstelle schreibend
zugreifen darf. Alle anderen Prozessoren dürfen nur lesend zugreifen. Bei diesem Modell
entstehen keine Dateninkonsistenzen. Nachzulesen ist dieser Modus u. a. in [DR86].
2.2. Die Pointer-Maschinen
Unter dem Begriff Pointer-Maschine finden sich viele verschiedene Modelle in der Literatur.
Obwohl all diese Modelle Gemeinsamkeiten haben, differieren sie auch an diversen
Stellen. In [BA95] wurde der Versuch unternommen, sowohl die Gemeinsamkeiten als
auch die Unterschiede der verschiedenen Pointer-Maschinen herauszuarbeiten.
Ziel dieses Abschnittes ist es, die verschiedenen Modelle vorzustellen. Anschließend wird
dann erläutert, wie sich eine Parallel-Pointer-Maschine aufbaut. Bei der Vorstellung der
Pointer-Maschinen wird dabei Bezug auf die Unterteilung von [BA95] genommen und
zwischen Maschinenmodellen und Programmiermodellen unterschieden.
Allen Pointer-Maschinen gemeinsam ist die Modellierung des Speichers als durch Pointer
verbundene Knoten eines Graphen. Aufgrund dieser Gemeinsamkeit kann diese Art
der Modellierung des Speichers als Charakteristikum der Pointer-Maschinen verwendet
werden.
15

2.2.1. Maschinenmodelle der Pointer-Maschinen
Innerhalb der Maschinenmodelle muss eine weitergehende Unterscheidung getroffen werden.
[BA95] unterscheidet beispielsweise zwischen atomistischen und High-level Modellen,
wobei die High-level Modelle nicht auf Symbolen, sondern auf Datentypen arbeiten.
Unter Datentypen wird hierbei ein Konstrukt wie die Integer unter C verstanden. Es
gibt also für einen Datentypen einen definierten Wertebereich und darauf definierte
Funktionen. High-level Modelle befinden sich demnach näher an dem Prinzip der Programmiersprachen.
Allerdings ist ein Modell, das auf bestimmte Datentypen festgelegt
ist, nicht mehr so allgemein vergleichbar, wie Modelle, welche auf Symbolen arbeiten.
Hier sollen repräsentativ drei verschiedene atomistische Maschinen vorgestellt werden,
um zu verdeutlichen, welche Vielfalt sich hinter dem Begriff Pointer-Maschine verbringt.
2.2.1.1. Kolmogorov-Uspenskii Maschinen
In der Kolmogorov-Uspenskii Maschine wird der Speicher als ungerichteter endlicher
Graph dargestellt. Zusätzlich existiert eine endliche Menge an Labeln und jede Kante hat
eines dieser Label. Zwei zu dem gleichen Knoten inzidente Kanten müssen verschiedene
Labels haben.
Innerhalb des Graphen gibt es einen ausgezeichneten Knoten, den aktiven Knoten, dessen
Nachbarschaft die aktive Zone beschreibt. Dabei ist mit der Nachbarschaft aber nicht nur
die direkte Nachbarschaft gemeint, sondern alle Knoten, welche innerhalb eines festen,
aber beliebigen Radius liegen.
Innerhalb des Modells sind unbedingte Sprünge, Eingaben, Ausgaben, bedingte Sprünge
und Speichermodifiktationen erlaubt. Die Speichermodifikationen ermöglichen das Erzeugen
von neuen Knoten sowie das Umbiegen von Kanten.
2.2.1.2. Storage Modification Maschines
Die Storage Modification Maschinen, kurz SMM, definieren den Speicher als gerichteten
endlichen Graph. Auch hier gibt es eine endliche Menge an Labels, woraus jede Kante
ein Label als Kantenmarkierung erhält. Allerdings müssen bei diesem Modell nur zu
dem selben Knoten eingehende Kanten verschiedene Labels haben, aus einem Knoten
ausgehende Kanten können die gleiche Markierung haben.
Eine weitere Veränderung gegenüber dem Kolmogorov-Uspenskii Maschinen ist der nicht
definierte Radius der aktiven Zone 2 . Ansonsten erlaubt die SMM die gleichen Operationen
wie die Kolmogorov-Uspenskii Maschinen. In der Literatur hat sich die SMM
größtenteils als Repräsentant der atomistischen Pointer-Maschinen durchgesetzt.
2 In der Definition von Schönhage war keine Forderung zur Definition des Radius enthalten.
16

2.2.1.3. Knuths Linking Automat
Dieser Automat ist der SMM sehr nahe verwandt. Der einzige Unterschied besteht darin,
dass in Knuths Modell für jeden Knoten zusätzlich eine feste Anzahl an Wertefeldern
vorgesehen sind, in denen Symbole eines gegebenen Alphabets stehen.
2.2.1.4. Die LISP Maschinen
Die Atomistic Full LISP Maschine (AFLM) definiert, vergleichbar zur SMM, den Speicher
als gerichteten endlichen Graphen und auch sonst ist das Modell dem der SMM
sehr nahe. Allerdings beinhaltet in dem AFLM Modell jeder Knoten noch exakt zwei
Wertefelder, in denen entweder Symbole des Alphabets oder Pointer stehen können.
Die Atomistic Pure LISP Maschine (APLM) definiert sich genauso wie die AFLM, mit
der Einschränkung, dass die Wertefelder nach der Erzeugung des Knotens nicht mehr
verändert werden dürfen. Da auch die Pointer in den Wertefeldern stehen, kann so kein
Zyklus entstehen, weil ein Pointer bei der Erzeugung eines neuen Knotens nur auf einen
bereits vorhandenen Knoten gesetzt werden kann und somit auch noch kein Pointer auf
den neuen Knoten zeigt. Mit dieser Einschränkung erreicht man, dass keine Nebeneffekte
von Funktionen auftreten und dass die Semantik einfacher wird.
2.2.2. Programmiermodelle der Pointer-Maschinen
In [BA95] ist das Programmiermodell der Pointer-Maschine so definiert, dass man für eine
gegebene abstrakte Datenstruktur eine geeignete Repräsentation als gerichteten Graphen
findet. Auf diesem gerichteten Graphen sind die Operationen ”
add node“, ”
add
pointer“, ”
get pointer“ und ”
delete pointer“ erlaubt. Alle gewünschten Funktionen auf
der abstrakten Datenstruktur müssen mit Hilfe dieser Operationen implementiert werden.
Die Zeitkomplexität wird dann durch die Gesamtzahl der Operationsaufrufe bestimmt,
während der Platzbedarf sich anhand der Anzahl der ”
add node“ bestimmt.
Bei der Implementierung des Union-Find-Problems 3 hat sich noch eine Klasse von speziellen
Pointer-Algorithmen herauskristallisiert, die ”
Separable Pointer“-Algorithmen.
Diese Algorithmen garantieren, dass nach jeder Operation der Graph in disjunkte Untergraphen
zerlegt werden kann, wobei keine Kante von einem Untergraphen zu einem
anderen führt.
3 Das Union-Find-Problem startet mit Mengen, die im Verlauf eines Algorithmus vereinigt werden
können (Union). Zudem können Elemente in diesen Mengen gesucht werden (Find). Da dies die
einzigen Operationen sind, die bei der Klasse an Problemen zugelassen sind, haben sie der Klasse
ihren Namen gegeben.
17

2.2.3. Parallel-Pointer Maschinen
In [GK96] haben die Autoren, aufbauend auf Knuths Linking Automat, die Parallel-
Pointer-Maschine (PPM) definiert, um darauf einen Sortieralgorithmus zu modellieren.
Das Modell besitzt mehrere synchronisierte Prozessoren, welche auf einen gemeinsamen
Speicher zugreifen. Der Speicher kann entweder nach dem EREW, dem CREW oder dem
CRCW Pinzip betrieben werden. Er ist als gerichteter Graph repräsentiert und erlaubt
nur die Zugriffe, welche durch die Pointer-Maschinen definiert sind.
Innerhalb des Graphen beinhaltet jeder Knoten eine konstante Anzahl an Wertefeldern
und eine konstante Anzahl an Pointern zu anderen Knoten.
Prozessoren haben eine konstante Anzahl an Registern, in denen Pointer stehen, welche
einen Zugriff auf den Speicher ermöglichen. Der gesamte Datenaustausch der Prozessoren
geschieht über den gemeinsamen Speicher, es existiert keine andere Kommunikationsmöglichkeit.
Die Prozessoren können den Speicher aktiv modifizieren, indem sie bei
Bedarf in einem Schritt neue Speicherzellen erstellen.
Da die gesamte Ein- und Ausgabe der PPM aus Pointern besteht, ist es wichtig festzulegen,
welche Operationen erlaubt sind und welche nicht. Erlaubte Pointer Operationen
sind:
• Kopieren eines Pointers in ein Pointer-Register des Prozessors.
• Schreiben eines Pointer-Registers-Inhalts des Prozessors in eine Pointer-Speicherzelle
• Vergleichen von zwei Pointer-Registerinhalten auf Äquivalenz
• Lesen des Speicherinhalts, auf den ein Pointer zeigt.
Verboten ist Pointer-Arithmetik wie z. B. indexierte Addressierung. Zusätzlich darf ein
Prozessor auf Werte (nicht auf Pointer) die normalen Arithmetik- und Vergleichsoperationen
ausführen.
2.3. Die Zellularautomaten
Das erste Mal wurden Zellularautomaten von John von Neumann vorgeschlagen, welcher
auf der Suche nach einer selbstreproduzierenden Maschine war. Es gelang ihm,
einen Zellularautomaten anzugeben, welcher mit 29 Zuständen fähig war, sich selbst zu
reproduzieren. Später wurde dieser Automat von Signorini auf einer SIMD-Maschine
implementiert ([Sig89]).
Schon von Neumann zeigte, dass man mit dem Zellularautomaten jede beliebige Turingmaschine
simulieren kann. Dieser Beweis wird beispielsweise in [Sar00] und [ARS71]
nachvollzogen. [Sar00] bietet zudem eine gute Übersicht über die Entwicklung von Zellularautomaten.
18

Im Folgenden wird zuerst der klassische Zellularautomat (CA) vorgestellt und auf einige
seiner Varianten eingegangen. In den nachfolgenden Abschnitten werden dann weitergehende
Variationen des CA vorgestellt. Es wird zusätzlich erläutert, in welcher Art und
Weise sie sich von dem Original unterscheiden.
2.3.1. Der klassische ”
Cellular Automata“ (CA)
Der Zellularautomat, den von Neumann ursprünglich vorschlug, besteht aus in einem unendlichen
Gitter angeordneten Zellen (mesh-connected). Das Gitter kann eine beliebige
Dimension haben, jedoch arbeiten die meisten Algorithmen auf dem ein- oder zweidimensionalen
Gitter. Jede Zelle innerhalb des Gitters führt ein eigenes Programm aus
und kann auf seine Nachbarzellen lesend, aber nicht schreibend zugreifen.
Die Art und der Radius der Nachbarschaft können vom Benutzer festgelegt werden, allerdings
ist man auf die Möglichkeiten der Gitterstruktur beschränkt. Die am weitesten verbreiteten
Nachbarschaften sind die von Neumann“ und die Moore“ Nachbarschaften.
” ”
Diese beiden Nachbarschaftsbeziehungen unterscheiden sich ab einem zweidimensionalen
Gitter darin, dass die von Neumann“ Nachbarschaft nur die horizontalen und vertikalen
”
Zellen als Nachbarn betrachtet (siehe Abbildung 2.1), während in der Nachbarschaft von
Moore“ auch die diagonalen Zellen als Nachbarn betrachtet werden (siehe Abbildung
”
2.2).
Der CA verfügt über keinen gemeinsamen Speicher, das heißt, alle Daten, welche im
Verlauf der Berechnung gebraucht werden, müssen entweder aus der Initialkonfiguration
errechenbar oder ein Teil der Initialisierung sein.
Abbildung 2.1.: Nachbarschaftsbeziehung der Zellen eines CA in einem zweidimensionalen
unendlichen Gitters nach von Neumann.
Formal besteht der CA aus einem Viertupel M=(N,d,r,δ), wobei die einzelnen Werte
folgende Bedeutung haben:
N = die Definition, welche Nachbarschaftsbeziehung benutzt wird,
d = die Dimension des Gitters,
r = der Radius der Nachbarschaft,
19

Abbildung 2.2.: Nachbarschaftsbeziehung der Zellen eines CA in einem zweidimensionalen
unendlichen Gitters nach Moore.
δ = die Überführungsfunktion.
Bei dieser Definition wird vorausgesetzt, dass die Zellen anfangs initialisiert sind.
In der Literatur findet man oft (z. B. [Maj94], [Sar00]) eine Unterteilung der Zellularautomaten
in vier Klassen:
• Die erste Klasse der CA beendet ihre Berechnung zu einem Zeitpunkt in einem
stabilen Zustand, welcher sich von da an nicht mehr ändert.
• Die zweite Klasse zeigt ein periodisches Verhalten, d. h. es gibt einen immer wiederkehrenden
Ablauf von Konfigurationen, welcher sich nach einiger Zeit einstellt
und dann nicht mehr unterbrochen wird.
• Die dritte Klasse zeigt ein chaotisches Verhalten. Es wird im Verlauf der Evolution
(Berechnungen) keine Konfigurationsfolge erreicht, welche sich periodisch
wiederholt.
• Die vierte Klasse führt im Laufe der Evolution zu komplexen lokalen Strukturen,
welche manchmal über mehrere Generationen bestehen bleiben. [Maj94] stellt fest,
dass alle CA, welche zu universellen Berechnungen fähig sind, in dieser Klasse
liegen, auch wenn nicht alle Automaten dieser Klasse universelle Berechnungen
durchführen können.
Da die Zellularautomaten zu vielen Forschungen angeregt haben, wurden bald einige
Modifikationen eingeführt. Eine gute Zusammenfassung dieser Modifikationen bietet
[Sar00], dort sind alle Modifikationen außer dem CA Network zusammengefasst. Nachfolgend
sollen die Modifikationen erläutert werden.
2.3.1.1. Tesselation CA
Diese Spezialform des CA benötigt keine Initialisierung, sondern verfügt über eine Eingabe,
welche beim Start an alle Zellen angelegt wird. Anschaulich kann man sich das so
20

vorstellen, dass jede Zelle über eine endliche Anzahl an Regeln verfügt und die Eingabe
darüber entscheidet, welche Regel angewendet werden soll. Tesselation CAs werden auch
zeitveränderliche CA genannt.
2.3.1.2. Iterative CA
Bei dieser Spezialform erhält nur eine Zelle eine Eingabe. Interessant ist diese Art von
CA u. a. bei Studien zur Spracherkennung. Die eindimensionalen iterativen CA erkennen
kontextfreie Sprachen in O(n 2 ) Schritten und die nichtdeterministischen zweidimensionalen
iterativen CA können in linearer Zeit jedes Wort akzeptieren, welches von einer
nichtdeterministischen Mehrkopf-Turingmaschine akzeptiert wird. Dennoch sind die iterativen
CA merklich langsamer in der Ausführung als die konventionellen CA.
2.3.1.3. Dynamische CA
Bei den dynamischen CA darf mit der Zeit sowohl die Anzahl der Zellen als auch deren
Verbindungen zu den Nachbarn variieren. Es kann also geschehen, dass eine Zelle von
einem Zeitpunkt zu einem anderen ihre Nachbarschaft ändert oder dass eine Zelle neu
erschaffen oder zerstört wird. Eine Verallgemeinerung dieses Ansatzes findet sich im
GCA, welcher später vorgestellt wird.
2.3.1.4. CA Networks (CAN)
In [CNG + 01] versuchen die Autoren mit Hilfe von Zellularautomaten Schlammlawinen
und Muren (Gerölllawinen) zu simulieren. Da solche Simulationen oft komplexe Zusammenhänge
mit vielen einwirkenden Eigenschaften abbilden müssen, werden viele Zellularautomaten
in einem Netzwerk eingesetzt. Dabei hat jeder CA des Netzwerks eine
bestimmte Aufgabe und andere CAs können lesend auf die Ergebnisse zugreifen.
Das setzt natürlich voraus, dass die CA nicht nur parallel, sondern auch sequentiell
nacheinander arbeiten können. Die aus [CNG + 01] entnommene Abbildung 2.3 zeigt den
von den Autoren vorgestellten Modellaufbau und verdeutlicht, dass die CA in einem
CAN sowohl parallel als auch seriell arbeiten können. Dabei entsprechen die mit A1 bis
A5 nummerierten Knoten den Zellularautomaten und die dunklen Knoten dienen zur
Ablaufsteuerung.
Mit dem Netzwerk wird neben einer Datenparallelität auch eine Aufgabenparallelität erreicht
und es können auch solche Probleme berechnet werden, die sich aus unvereinbaren
Teilaufgaben zusammensetzen.
2.3.2. Der ”
Structurally Dynamic Cellular Automata“ (SDCA)
Die den SDCA auszeichnende Neuerung ist, dass die Verbindungen zwischen den Zellen
des Automaten zur Laufzeit verändert werden können. Dafür gibt es zwei Funktionen,
21

Abbildung 2.3.: Das CAN-Netzwerk, welches von [CNG + 01] verwendet wird, um das
SCIDDICA-Modell darzustellen.
die Kopplungs- und die Entkopplungsfunktion, die entweder neue Verbindungen anlegen
(koppeln) oder bestehende Verbindungen löschen (entkoppeln). Eine Einschränkung
dabei ist, dass nur bereits verbundene Zellen entkoppelt werden dürfen und nur solche
Zellen aneinander gekoppelt werden dürfen, die über genau einen Zwischenknoten eine
Verbindung haben. Dieses Modell wurde von Ilachinsky und Halpern vorgestellt, um so
in der Lage zu sein, u. a. das menschliche Gehirn besser nachbilden zu können.
In [Maj94] stellt der Autor Majercik das von Ilachinsky und Halpern entworfene SDCA-
Modell vor und äußert seine Kritik. Daraufhin entwickelt er drei alternative Modelle,
welche im Folgenden näher erläutert werden. Zudem enthält der Text auch eine Betrachtung
der Laufzeitgeschwindigkeiten der verschiedenen Modelle sowie eine Konstruktion,
um einen beliebigen CA mit einem ULRL 4 SDCA mit Speed-Up von zwei zu simulieren.
2.3.2.1. Das Relative Location Modell
In diesem Modell kann die Zustandsübergangsfunktion nicht nur auf den Status einer
jeden Nachbarzelle zugreifen, sondern kennt auch deren (von der anfragenden Zelle aus
gesehen) relative Adresse. Die Verbindungsübergangsfunktion kennt zu jeder Zelle des
Auotmaten den Verbindungsstatus (0 = unverbunden, 1 = verbunden, 2 = im nächsten
Schritt verbindbar) und handelt dann den Regeln entsprechend, legt also im nächsten
Schritt eine Verbindung an, zerstört Verbindungen im nächsten Schritt oder lässt die
Verbindung unberührt. Sowohl die Zustandsübergangs- als auch die Verbindungsübergangsfunktion
müssen rekursiv berechenbar sein.
Dieses Modell kann variiert werden, indem die Anzahl der Verbindungen beschränkt
wird (Bounded Links Relative Location Model) oder nicht (Unbounded Links Relative
Location Model).
Der Nachteil dieses Modells ist, dass man bei vielen Simulationen nicht voraussetzen
kann, dass eine Zelle wirklich die relative Adresse ihrer Nachbarn kennt. So ist einer
Zelle des menschlichen Gehirns z. B. nicht bekannt, wo genau ihr Verbindungspartner
sitzt. Sie benötigt dieses Wissen auch nicht, um ein korrektes Ergebnis zu liefern.
4 ULRL = Unbounded Links Relative Location
22

2.3.2.2. Das Labeled Link Modell
In diesem Modell kennt die Zelle die relative Adresse ihrer Nachbarn nicht. Dafür hat
jede Verbindung der Zelle ein Label, welches die Zustandsübergangsfunktion mit in die
Berechnungen einbeziehen kann.
In diesem Modell (wie in allen anderen hier vorgestellten SDCA Modellen) werden die
Verbindungen als bidirektional angesehen. Trotzdem können zwei Nachbarzellen verschiedene
Labels für ein und dieselbe Verbindung haben. Auf diese Weise können auch
unidirektionale Verbindungen modelliert werden, indem eine Zelle das Label der Verbindung
auf ignorieren setzt.
Die Verbindungsübergangsfunktion arbeitet vergleichbar zu der des vorhergehenden Modells.
Auch hier kann wieder die Anzahl der Verbindungen einer Zelle beschränkt werden
(Bounded Links Labeled Link Model) oder nicht (Unbounded Links Labeled Link Model).
Auch wenn dieses Modell schon annehmbarer als das vorherige ist, so verfügt es doch
noch nicht über eine endliche Übergangstabelle wie der konventionelle CA. Um diese
endliche Übergangstabelle zu erreichen, wird das Bounded Links Labeled Link Model
weiter eingeschränkt, indem die Menge der möglichen Labels endlich ist (Finite Labels
Labeled Links Model). Da jede Zelle eine endliche Anzahl an Verbindungen hat und
diese Verbindungen jeweils eine von endlich vielen unterschiedlichen Labels haben kann,
entstehen nur endlich viele Einträge in der Übergangstabelle.
2.3.2.3. Das Symmetric Modell
In diesem Modell weiß eine Zelle nur, welche Zustände wie oft unter ihren Nachbarn
vertreten sind, aber nicht, welcher Nachbar welchen Zustand hat. Bei Problemen wie
dem ”
Game of Life“ ist dies keine Einschränkung, aber es kann Probleme geben, bei
denen diese Einschränkung massiv ist.
Majercik betont, dass dieses Modell als Vermittler zwischen dem ursprünglichen Modell
von Ilachinsky und Halpern und den eben vorgestellten Modellen dienen soll.
Auch in diesem Modell kann wieder zwischen einer beschränkten Anzahl von Verbindungen
pro Zelle (Bounded Links Symmetric) und einer unbeschränkten Anzahl (Unbounded
Links Symmetric) unterscheiden.
2.3.3. Der ”
Dynamic Structure Cellular Automata“ (DSCA)
Der DSCA erweitert den CA dermaßen, dass das Modell nun auch auf Eingaben von
außen reagieren kann.
Innerhalb des CA können Nachrichten versendet werden, die verschiedene Eventtypen
haben und die Funktion der Zelle beeinflussen. In [MWIS02] wird dieses Prinzip anhand
23

von Feuer-Simulationen erklärt, wobei der CA die Simulation der Feuerausbreitung vornimmt.
Damit auch Funkenflug in die Berechnungen eingehen kann, existiert ein Generator,
welcher entsprechende Nachrichten an den CA sendet und damit dessen Zustände
aktiv beeinflusst.
Die Vorstellung von Nachrichten, welche an Zellen des CA geschickt werden, ob über
einen internen Verteiler oder nicht, scheint zunächst einmal dem Prinzip des CA zu
widersprechen. Dieses besagt, dass nur lesend auf Zellen zugegriffen werden kann.
Allerdings kann der interne Verteiler so organisiert sein, dass er selbst kein aktives Mitglied
des CA ist, aber alle Zellen des CA lesend auf ihn zugreifen können. Dieser Verteiler
stellt dann für jede Zelle einen Port bereit, auf den die Zelle jeweils vor ihrem Berechnungsschritt
lesend zugreift, um zu sehen, ob eine Nachricht für sie vorhanden ist. Da der
verwendete CA asynchron ist, muss der Verteiler reagieren, wenn die Nachricht abgeholt
wird und diese löschen, da sonst eine Nachricht mehrfach von der Zelle abgeholt werden
kann.
2.3.4. Der ”
Global Cellular Automata“ (GCA)
Der GCA ([HVH03]) erlaubt es Zellen, im Laufe der Evolution ihre Nachbarschaft zu
verändern. Außerdem können zwei verschiedene Zellen eines GCA verschiedene Übergangsfunktionen
und Nachbarschaften haben. Die Zellen eines GCA können also verschiedene
Aufgaben erfüllen.
Mit der Möglichkeit, die Nachbarschaft immer an die aktuelle Aufgabenstellung anzupassen,
ergibt sich ein sehr mächtiges Modell, welches aber Einschränkungen unterliegt,
um noch realisierbar zu sein. So muss z. B. die Gesamtheit der im Verlauf der Berechnungen
einbezogenen Nachbarzellen schon beim Aufbau bekannt sein, damit die benötigten
Verbindungen eingeplant werden können.
Um die aktuelle Nachbarschaft bestimmen zu können, ist es nötig, dass die Nachbarschaft
entweder wie beim SDCA über eine Übergangsfunktion bestimmt werden kann oder von
Anfang an für jede Zelle für jede Generation die Nachbarschaft, z. B. in einer Tabelle,
festgelegt ist.
Der GCA erlaubt es, dass Zellen, welche nicht direkt zur Zelle benachbart liegen, in die
Nachbarschaft der Zelle aufgenommen werden. Somit verzichtet dieses Modell auf eine
Gitterstruktur wodurch sich Nachrichten schneller im Automaten ausbreiten können.
Die zellulare Lichtgeschindigkeit 5 (s. u.a. [Hoc98]) wird in diesem Modell überschritten.
Einen Überblick über den GCA liefert auch [Hee01], dort wird der Begriff der zellularen
Lichtgeschwindigkeit näher erläutert.
5 Im CA spricht man von der Zellularen Lichtgeschwindigkeit, da Nachrichten bei jeder Generation nur
um eine Zelle weitergereicht werden können. Der GCA durchbricht diese Beschränkung, da nun die
Nachbarschaftsbeziehung dynamisch ist und somit mehrere Zellen bei einer Generation übersprungen
werden können (bezüglich der Gitterstruktur).
24

Da der GCA dynamisch ist, können sich seine Daten und seine Verbindungen (Pointer)
zur Laufzeit abhängig von gewissen Gegebenheiten ändern. Eine grobe Unterteilung, die
auch in [Hee01] getroffen wird, ist die Unterteilung in Zeitabhängigkeit, Ortsabhängigkeit
und Datenabhängigkeit. Zusätzlich wird hier noch eine Abhängigkeit von den Verbindungen
an sich eingeführt. Diese vier Punkte können (und werden im weiteren) noch
weiter differenziert werden:
• Die Datenabhängigkeit kann dahingehend untersucht werden, ob die Daten bzw.
die Verbindungen der Zelle im nächsten Schritt von den eigenen Daten und/oder
von den Daten ihrer Nachbarn abhängt. Im weiteren werden die eigenen Daten mit
d und die Daten der Nachbar-Zellen mit d* bezeichnet.
• Die Zeitabhängigkeit benötigt keiner weiteren Verfeinerung. Es muss nur festgestellt
werden, ob die Zellen zu einer bestimmten Zeit immer einer bestimmten
Veränderung unterliegen. Die Zeit wird im weiteren mit t bezeichnet.
• Die Ortsabhängigkeit kann auch dahingehend unterteilt werden, dass geschaut
werden muss, ob eine Veränderung der Daten bzw. der Verbindungen einer Zelle
davon abhängig ist, wo die eigene Zelle bzw. die Nachbarzelle angeordnet ist. Der
Ort der eigenen Zelle wird im weiteren mit l der Ort der Nachbar-Zelle mit l*
bezeichnet.
• Die Verbindungsabhängigkeit bezeichnet eine Abhängigkeit der Daten oder der
Verbindungen in der nächsten Generation von der momentanen Verbindung der
eigenen Zelle oder der Nachbar-Zellen. Ein Beispiel hierfür findet sich in Kapitel
4. Die Verbindung der Zelle wird mit p, die Verbindung der Nachbar-Zelle mit p*
bezeichnet.
Die Unterteilungen sind immer für eine Zelle mit einem Nachbarn formuliert. Betrachtet
man eine Zelle, die mehrere Nachbarn hat, dann bezeichnen d*,l* und p* eine geeignete
Verknüpfung aller Nachbarn. Es erscheint im weiteren Verlauf sinnvoll, die Daten und
die Verbindungen einer Zelle getrennt zu betrachten, da sie sich unabhängig voneinander
ändern können. Mit Hilfe der Unterteilung 6 kann man die Daten (d) und die Verbindung
(p) der Zelle in der nächsten Generation als Funktion ihrer Abhängigkeiten formulieren:
d’= f(d,d*,t,l,l*,p,p*) und p’= g(d,d*,t,l,l*,p,p*).
Je nach auf dem GCA realisierten Algorithmus ist die Funktion nur von einem Teil der
Parameter abhängig. In Abbildung 2.4 wurde die weitere Unterteilung der Daten-, Ortsund
Verbindungsabhängigkeit ignoriert. Mit Hilfe des dort angegebenen Baums können
die Parameter der Verbindungs- bzw. Datenübergangsfunktion gefunden werden.
6 Die Unterteilung repräsentiert nur entweder die Abhängigkeit der Daten oder der Verbindungen.
Zwar kann die Unterteilung auf beide angewendet werden, aber es ist nicht möglich, beide Abhängigkeiten
mit Hilfe dieser Unterteilung zeitgleich zu bestimmen.
25

Abbildung 2.4.: Innerhalb des Baums steht in dem Kasten immer eine Abhängigkeit. Ist
diese Abhängigkeit gegeben, so muss die Abzweigung nach links, sonst
die nach rechts verwendet werden. Wurden alle Knoten abgelaufen, kann
man ablesen, von welchen Variablen z. B. die Daten der nächsten Generation
abhängig sind.
Da das Modell des GCA im Weiteren zur Modellierung von Algorithmen genutzt wird,
werden dort noch Beispiele aufgezeigt, wie man die Möglichkeiten des GCA effizient
nutzen kann.
26

3. Die Modellierung von
Graphenalgorithmen auf dem GCA
Graphenalgorithmen haben auch heute noch eine große Bedeutung in der Informatik, da
man mit ihrer Hilfe viele Probleme sehr anschaulich und effizient lösen kann. Graphen
werden definiert durch zwei Mengen: die Menge V der Knoten und die Menge E der
Kanten. Dabei verbindet eine Kante aus E immer zwei Knoten aus V. Kanten können
gerichtet (die Kante kann nur in eine Richtung durchlaufen werden) oder ungerichtet
(die Kante kann in beiden Richtungen durchlaufen werden) sein.
Ein Graph selber kann in vielen Varianten im Rechner repräsentiert sein, wobei eine der
häufigeren Darstellungen die Matrix ist. Zur Veranschaulichung dieser Matrixrepräsentation
soll hier der Graph aus Abbildung 3.1 dienen, welcher durch die folgende Matrix
A repräsentiert werden kann.
Abbildung 3.1.: Ein gerichteter Beispielgraph, welcher sowohl einen Zyklus enthält als
auch einen Knoten, der keine ausgehenden Kanten hat.
⎛
A =
⎜
⎝
0 1 0 1 0
0 0 1 0 0
1 0 0 0 0
0 0 0 0 1
0 0 0 0 0
Der Vorteil dieser Darstellung ist, dass die i-te Zeile der Matrix die ausgehenden Verbindungen
und die i-te Spalte die eingehenden Verbindungen des i-ten Knotens repräsentiert.
Allerdings muss man alle Zeileneinträge der i-ten Zeile abgehen, um genau festzu-
⎞
⎟
⎠
27

stellen, welche Nachfolger der Knoten i hat. Möchte man aber testen, ob eine Verbindung
zwischen dem i-ten und dem j-ten Knoten existiert, so reicht eine Anfrage.
Einer der größten Nachteile dieser Repräsentation ist allerdings, dass man auf einem
klassischen Einprozessor-System minimal O(n 2 ) Schritte benötigt, wenn ein Problem
mit der Matrizendarstellung arbeitet und einen Großteil des Graphen betrachten muss.
Im Laufe dieser Arbeit wird deutlich werden, dass es nicht möglich ist, diesen Aufwand zu
minimieren. Allerdings ist es möglich, Teile des Aufwands auf die Hardware zu verlagern
und so einen Speed-Up zu erzielen.
Diese Aussage wird am Beispiel des Warshall-Algorithmus noch deutlicher werden, wobei
klar sein sollte, dass ein Aufwand von O(n) bedeutet, dass der Algorithmus eine Laufzeit
von O(n) hat, falls nicht explizit etwas anderes erwähnt wird.
3.1. Erkennung von zusammenhängenden Komponenten
eines Graphen
In vielen Aufgabenstellungen aus der Praxis ist es wichtig, zu erkennen, ob Komponenten
eines Graphen zusammenhängen. So möchte man z. B. effizient testen, ob alle Computer
eines Netzwerks verbunden sind.
Auf einem Rechner mit einem Prozessor kann man hier u. a. den Warshall-Algorithmus
anwenden, welcher die transitive Hülle berechnet und somit die Erreichbarkeitsmatrix
liefert. Dabei steht eine 1 in Zeile A und Spalte B der Matrix immer dafür, dass es einen
Weg zwischen dem Punkt A und dem Punkt B gibt, eine 0 dementsprechend dafür, dass
kein Weg existiert. Der Algorithmus von Warshall benötigt auf einem Einprozessor-
System eine Laufzeit von O(n 3 ). Im folgenden Abschnitt wird schrittweise hergeleitet,
wie man den Warshall-Algorithmus auf dem GCA modellieren kann und wie es möglich
ist, eine Laufzeit von O(n) zu erreichen.
3.1.1. Der Warshall-Algorithmus
Der Warshall-Algorithmus ist eine Spezialisierung des Kleene-Algorithmus und je nach
Literatur berechnet er die reflexive-transitive-Hülle 1 oder nur die transitive Hülle 2 . Ein
Vorteil der Berechnung der reinen transitiven Hülle ist, dass man sehr leicht mit dem
Warshall-Algorithmus testen kann, ob ein Graph Zyklen enthält.
Da es für die Erkennung von zusammenhängenden Komponenten irrelevant ist, ob die
Hülle reflexiv ist oder nicht, wird im weiteren der Warshall-Algorithmus verwendet,
1 Bei der reflexiven Hülle existiert von jedem Knoten eine Verbindung zu sich selber. Auf der Diagonalen
stehen also nur Einsen. Die reflexive-transitive Hülle erfüllt die Bedingung der reflexiven Hülle
zusätzlich zu den Bedingungen der transitiven Hülle.
2 Hier steht auf der Diagonale nur dann eine 1, wenn es von dem Knoten aus möglich ist, wieder zu
dem Knoten zu kommen
28

welcher rein die transitive Hülle berechnet. Nachzulesen sind der Warshall-Algorithmus
und der im nächsten Kapitel folgende Floyd-Warshall-Algorithmus u.a. in [CLRS01] auf
Seite 632-634.
3.1.1.1. Der Warshall auf einem Einprozessor-System
Eine Eigenschaft, die alle Algorithmen haben, welche vom Kleene-Algorithmus abstammen,
ist die Nutzung des Transitknotenkonzepts. Transitknoten bedeutet hierbei, dass
jeder Knoten i nur dann neue Verbindungen aufnehmen darf, wenn für ihn eine Verbindung
zum Transitknoten besteht. Alle anderen Verbindungen des Knotens werden für
diesen Schritt ignoriert.
Besteht die Verbindung zum Transitknoten, so kann der Knoten i zu jedem Knoten j, mit
dem der Transitknoten verbunden ist, seinerseits eine Verbindung aufbauen. Es werden
also Wege der Länge zwei erlaubt, welche über den Transitknoten gehen müssen.
Programmiert man den Warshall-Algorithmus, so gestaltet er sich einfach: er besteht
aus drei ineinander geschachtetelten Schleifen und der Formulierung des Transitknotenprinzips
(Zeile 4 im nachfolgenden Algorithmus). In C formuliert sieht der Algorithmus
dann folgendermaßen aus:
Listing 3.1: Der Warshall-Algorithmus
1 for (k=0; k < AnzahlKnoten ; k++) {
2 for ( i =0; i < AnzahlKnoten ; i++) {
3 for ( j =0; j < AnzahlKnoten ; j++) {
4 A[ i ] [ j ]= A[ i ] [ j ] | | (A[ i ] [ k ] && A[ k ] [ j ] )
5 }
6 }
7 }
Man kann den Algorithmus noch ein wenig verbessern, indem man die Abfrage, ob eine
Verbindung von i nach k besteht (die Abfrage A[i][k] in Zeile 4), vor die innere Schleife
zieht. In der Modellierung auf dem GCA wird der modifiziert Warshall-Algorithmus
verwendet, welche auch noch ausnutzt, dass eine Überprüfung keine Änderung ergibt,
wenn der zu modifizierende Knoten der Transitknoten ist:
Listing 3.2: Der leicht modifizierte Warshall-Algorithmus
1 for (k=0; k < AnzahlKnoten ; k++) {
2 for ( i =0; i < AnzahlKnoten ; i++) {
3 if (k!= i && A[ i ] [ k]==1) {
4 for ( j =0; j < AnzahlKnoten ; j++) {
5 A[ i ] [ j ]= A[ i ] [ j ] | | A[ k ] [ j ] )
6 }
7 }
8 }
9 }
29

Trotz dieser Verbesserung spart man im worst-case nur einen Durchlauf der inneren
Schleife und somit ist der Aufwand auf O(n 3 ) abzuschätzen. Da der best-case (die innere
Schleife wird so selten wie möglich durchlaufen, das bedeutet, nur auf der Diagonalen
stehen Einser) sehr unwahrscheinlich ist, wäre nur noch der average-case interessant. In
der Regel wird man eine Zeile ca. zur Hälte mit Einsen befüllt haben. Daraus folgt, dass
man ca. die Hälfte der inneren Schleifendurchläufe einsparen kann. Dies ergibt dann
eine Laufzeit von O(n 2 × n 2 ), was aber in der O-Notation wieder auf O(n3 ) abgeschätzt
wird. Diese Modifikation bringt also einen Laufzeitgewinn, aber die Laufzeitkomplexität
ändert sich dadurch nicht.
3.1.1.2. Der Warshall-Algorithmus auf dem GCA
Um einen Algorithmus auf einem parallelen Modell wie dem GCA effizient zu modellieren,
muss zunächst hergeleitet werden, welche Schritte parallelisierbar sind:
Bei dem Warshall-Algorithmus ist ersichtlich, dass die Herleitung der Verbindungen der
Länge 2 jeweils nur von dem Startknoten und dem Transitknoten abhängig sind. Alle
anderen Knoten werden an dieser Stelle ignoriert. Also kann man alle Knoten parallel
als Startknoten betrachten und die Verbindungsmöglichkeiten testen. Hierfür benötigt
man O(n) Prozessoren, um wirklich alle Knoten parallel abzuarbeiten.
Eine weitere Möglichkeit zur Parallelisierung bietet sich für jeden Knoten bei der Herstellung
der Verbindungen an sich. Im Normalfall wird zuerst überprüft, ob der Startknoten
eine Verbindung zum Transitknoten hat, und falls dies der Fall ist, wird für jeden anderen
Knoten geprüft, ob es nun eine Verbindung zu ihm gibt oder schon früher gab. Parallelisiert
man diesen Vorgang, so werden die Verbindungen zu allen Knoten ausgehend von
einem festem Startknoten und einem festen Transitknoten gleichzeitig gesucht.
Modelliert man nun diese Parallelisierungsvorschläge auf dem GCA, so äußert sich das
folgendermaßen:
• Um bei einem gegebenem Transitknoten alle Knoten parallel als Startknoten abzuarbeiten,
muss dafür gesorgt werden, dass jede Zeile der Matrix durch eine Zelle
repräsentiert wird [3.2]. Die Zellen können alle parallel arbeiten und garantieren
so die gewünschte Parallelität. Da nur ein lesender Zugriff auf die Zelle, welche
den Transitknoten repräsentiert, nötig ist, ist diese Art der Modellierung mit den
Bedingungen des GCA konform.
• Um bei einem gegebenem Transitknoten und einem gegebenem Startknoten alle
Verbindungen parallel zu prüfen und zu modifizieren, gibt es zwei Möglichkeiten:
Bei der ersten Möglichkeit wird jeder einzelne Eintrag einer Zeile durch eine Zelle
repräsentiert. Es werden also n 2 Zellen benötigt. Eines der dabei auftretenden
Probleme ist, dass die Zellen feststellen müssen, mit welchen anderen Zellen sie zu
kommunizieren haben. Da eine Zeile durch mehrere Zellen repräsentiert wird, ist
einerseits auf die Zelle der eigenen Zeile lesend zuzugreifen, welche die Verbindung
30

zum Transitknoten repräsentiert, und andererseits ist die entsprechende Zelle des
Transitknotens zu lesen. Dies führt einerseits zu einem hohen Kommunikationsbedarf
3 und andererseits zu der Forderung einer Logik, die erkennt, welche Zelle
angesprochen werden muss.
Die zweite Möglichkeit besteht darin, die Zeilen der Matrix jeweils wieder durch
eine Zelle repräsentieren zu lassen. Um dabei einen parallelen Abgleich der Zeileneinträge
zu garantieren, wird ein Bussystem verwendet. Jeder Knoten weiß, welcher
Knoten aktuell der Transitknoten ist, also auch der Transitknoten an sich. Beim
Start des Taktes legt der Transitknoten seine Zeile auf den Bus und jeder Knoten,
welcher eine Verbindung zu dem Transitknoten hat, kann sich dessen Werte
dann vom Bus holen. Zellen, welche keine Verbindung zum Transitknoten haben,
ignorieren den Bus bis zum nächsten Taktzyklus. Bei dieser Realisierung werden
O(n) Verbindungen benötigt, allerdings ist es möglich, gleich eine Logik einzubauen,
welche den i-ten Zeileneintrag mit dem i-ten Eintrag auf dem Bus verodert.
Die zugrundeliegende Logik ist also sehr einfach und ebenso effizient wie der erste
Lösungsansatz.
Beide Lösungsansätze erfüllen die Anforderung. Der erste Lösungsansatz benötigt
insgesamt O(n 2 ) Prozessoren und O(1) Leitungen. Der zweite Ansatz kommt mit
O(n) Prozessoren aus, benötigt dafür aber auch ein Verbindungssystem mit O(n)
Leitungen.
Abbildung 3.2.: Jede Zelle kennt eine Zeile der Matrix und ihre ID.
Abbildung 3.3.: Die 5 Zellen des GCA dieses Beispiels werden wie abgebildet initialisiert.
Beispiel Wenn der Graph aus Abbildung 3.1 auf den GCA abgebildet werden soll,
dann wird der GCA wie in 3.3 initialisiert. Der Ablauf des Warshall-Algorithmus, der
in 3.4 anhand des Graphen veranschaulicht wird, geschieht auf dem GCA dann wie in
Abbildung 3.5.
3 Die i-te Zelle einer Zeile muss sowohl eine Verbindung zu allen anderen Zellen ihrer eigenen Zeile als
auch eine Verbindung zu der i-ten Zelle aller anderen Zeilen haben.
31

Abbildung 3.4.: Der Ablauf des Warshall-Algorithmus in der Graphen-Darstellung. Der
Transitknoten ist grau hinterlegt, neu hinzugefügte Kanten gestrichelt
dargestellt.
32

In Abbildung 3.4 entspricht der Graph a) dem ersten Schleifendurchlauf der Schleife
aus Zeile 1. Knoten v 0 wird als Transitknoten gewählt und alle Kanten eingefügt, die
durch Wege über diesen Transitknoten möglich werden. In diesem Fall hat nur v 2 eine
Kante zu v 0 und dementsprechend kann auch nur v 2 neue Kanten erhalten. Diese neuen
Kanten von v 2 nach v 1 und v 3 werden in Abbildung 3.4 gestrichelt dargestellt. Nach
dem gleichen Prinzip sind auch die restlichen Schritte des Warshall-Algorithmus in den
Abbildungsteilen b) - e) dargestellt.
Abbildung 3.5.: Der Ablauf des Warshall-Algorithmus auf dem GCA. Da die Zell-ID hier
nicht benötigt wird, wurden sie in der Abbildung zugunsten der Übersichtlichkeit
weggelassen.
In Abbildung 3.5 sind die einzelnen Generationen des GCA dargestellt. Dabei sind für
jede Generation die Zellen mit Zellinhalt und Verbindung angegeben. In der ersten Generation
testen alle Zellen, ob sie eine Verbindung zur ersten Zelle haben und fragen gegebenenfalls
deren Zeile ab. In der nächsten Generation ist dann die Zeile schon mit der
abgefragten Zeile verodert und es wird auf die nächste Zelle zugegriffen. Dies geschieht
bis zur n-ten Generation, in der auf die n-te Zelle lesend zugegriffen und somit der letzte
Schritt des Warshall-Algorithmus ausgeführt wird. Am Ende dieses n-ten Schritts repräsentieren
die Zellen des GCA die einzelnen Zeilen der Matrix, welche die transitive
Hülle der Ausgangsmatrix ist.
Es kann das in Kapitel 2.3.4 vorgestellte Schema angewendet werden, um die Abhängigkeit
der Daten und der Verbindungen für die nächste Generation festzustellen. Dabei
33

wird die Realisierung betrachtet, die keinen Bus verwendet. Stattdessen werden Verbindungen
zwischen den Zellen aufgebaut, mit deren Hilfe der Zellinhalt ausgelesen wird.
Es bedarf einer getrennten Betrachtung der Abängigkeit für die Daten und für die Verbindungen:
• Die Daten sind nicht abhängig von der Zeit. Es kann nicht festgestellt werden,
dass sich die Daten zu einem Zeitpunkt auf einen bestimmten Wert setzen. Eine
Abhängigkeit von der Zeit würde z. B. bestehen, wenn die Daten der Zelle in
regelmässigen Abständen neu initialisiert würden.
Die Daten einer Zelle ändern sich auch nicht in Abhängigkeit von dem Ort, an
dem die Zelle sich im GCA befindet.
Allerdings sind die Daten der nächsten Generation abhängig von den Daten der
momentanen Generation. Betrachtet man diese Abhängigkeit genauer, so stellt
man fest, dass die Daten auch von den Daten der Nachbar-Zelle abhängig sind.
Eine Abhängigkeit von der Verbindung liegt nicht vor, die Daten ändern sich nicht
unter zur Hilfenahme der Verbindung an sich, sondern nur der Daten auf die die
Verbindung zeigt.
Es ergibt sich die Veränderungsfunktion: d’ = f(d,d*).
• Da in der i-ten Generation auf die i-te Zelle zugegriffen wird, sind die Verbindungen
abhängig von der Zeit.
Die Verbindungen der Zelle in der nächsten Generation sind nicht abhängig von
dem Ort oder der Verbindung der Zelle.
Eine Abhängigkeit der Verbindung der Zelle in der nächsten Generation von den
Daten der Zelle liegt in der konkreten Simulation vor. Bei dem Warshall-Algorithmus
repräsentiert eine Zelle immer einen Knoten. Man kann nun immer eine Verbindung
aufbauen, egal ob von dem Knoten eine Verbindung zu dem i-ten Knoten
existiert oder nicht. In dem Falle sind die Verbindungen nur abhängig von der
Zeit. Allerdings kann man den Verbindungsaufbau auch davon abhängig machen,
ob in dem Graphen eine Verbindung zu dem i-ten Knoten existiert. In dem Falle
ist dann die Verbindung der nächsten Generation sowohl von der Zeit als auch
von den eigenen Daten abhängig. Bei dieser Betrachtung wird davon ausgegangen,
dass nur dann eine Verbindung aufgebaut wird, wenn auch im Ursprungsgraphen
eine Verbindung existierte.
Daraus folgt die Funktion: p’ = g(t,d).
3.1.2. Der Floyd-Warshall-Algorithmus
Die Ergebnismatrix des Floyd-Warshall-Algorithmus erlaubt nicht nur die Einsicht, ob
ein beliebiger Punkt A mit einem beliebigem Punkt B verbunden ist, sondern auch wie
groß die Summe der Kantenwertungen der kürzesten Verbindung zwischen ihnen ist.
34

Da sowohl Warshall-Algorithmus als auch Floyd-Warshall-Algorithmus Spezialisierungen
des Kleene-Algorithmus sind, unterscheiden sie sich lediglich in den Funktionen, die sie
verwenden, um die einzelnen Matrix-Einträge zu verknüpfen. Während der Warshall-
Algorithmus die logischen Funktionen und und oder benutzt, verwendet der Floyd-
Warshall-Algorithmus die Funktionen min und plus.
Der Floyd-Warshall-Algorithmus wird immer dann benutzt, wenn nicht nur wichtig ist,
ob es eine Verbindung gibt, sondern es auch nötig ist, zu wissen, wie teuer diese Verbindung
ist. Eine mögliche Anwendung wäre beispielsweise der Aufbau eines Mehrprozessorsystems
mit verschiedenen Verbindungen. Dann ist es einerseits wichtig zu wissen,
dass kein Prozessor isoliert ist (also entweder keine anderen Prozessoren ansprechen oder
von keinem anderen Prozessor angesprochen werden kann). Andererseits ist es wichtig
zu wissen, welche Kommunikationszeiten zwischen den Prozessoren benötigt werden.
Der globale Takt ist dann mindestens auf den höchsten Wert der Ergebnismatrix des
Floyd-Warshall-Algorithmus zu setzen.
Die Realisierung auf dem GCA gestaltet sich ebenso wie die Realisierung des Warshall-
Algorithmus: jede Zeile der Matrix wird durch eine Zelle des GCA repräsentiert. Allerdings
muss beachtet werden, dass der Floyd-Warshall-Algorithmus nicht auf einer
binären Matrix arbeitet, sondern auf einer Matrix von Integern.
Eine Reduktion des Zeitaufwands auf O(n) mittels O(n) Leitungen ist hier zwar auch
möglich, allerdings kann der Zeileninhalt nicht einfach auf einen Bus gelegt werden.
Möchte man alle Inhalte einer Zeile übertragen, so hat man die Möglichkeit, entweder
jeweils den i-ten Zeileneintrag komplett oder das jeweils i-te Bit aller Zeileneinträge
gleichzeitig zu übertragen. Der Aufwand mag bei beiden Möglichkeiten gleich erscheinen,
allerdings benötigt man beim Übertragen des jeweils i-ten Elements O(n) Schritte,
während man beim Übertragen der Bits einer Zeile nur O(1) Schritte benötigt, da die
Größe eines Integers nicht von der Eingabegröße abhängig ist. Für kleine Graphen ist
also die erste Lösung zu präferieren, während bei zunehmender Knotenanzahl die zweite
Lösung ein besseres Verhalten an den Tag legt.
Auch hier besteht die Möglichkeit, insgesamt O(n 2 ) Prozessoren zu benutzen und jeden
Eintrag der Matrix durch eine Zelle darzustellen. Diese Lösung bedarf einer sinnvollen
Verbindungslogik, welche zeitgleich die Verbindung des eigenen Knotens zum Transitknoten
und die Verbindung vom Transitknoten zum gewünschten Zielknoten abfragt.
Bevor eine Addition stattfinden darf, muss getestet werden, ob der Verbindungswert
zum Transitknoten gleich 0 ist. Ist der Wert gleich 0, so ist der alte Wert unverändert
zurückzuschreiben und die Berechnung ist beendet. Ist er ungleich 0, müssen die beiden
erhaltenen Werte addiert werden und das Minimum zwischen dem Ergebnis aus der
Addition und dem alten Wert ist nun in den Zellspeicher zu schreiben.
Der Floyd-Warshall-Algorithmus funktioniert auf dem GCA entsprechend dem Warshall-
Algorithmus, es wird lediglich die Berechnungsfunktion geändert. Diese geht aber nicht
in das Schema aus Kapitel 2.3.4 ein, weswegen sich die selben Abhängigkeiten wie beim
Warshall-Algorithmus ergeben:
d’ = f(d,d*) und p’ = g(t,d).
35

3.1.3. Der Algorithmus von Hirschberg et al.
Auf einem Multiprozessor-System kann man entweder den modifizierten Warshall verwenden,
um zusammenhängende Komponenten zu erkennen, oder man nutzt den Algorithmus
von Hirschberg et al., welcher bereits so modelliert wurde, dass er die Möglichkeiten
eines Multiprozessor-Systems ausnutzt.
Der Algorithmus von Hirschberg et al. ist ursprünglich in [GR98] als ein Algorithmus auf
der P-RAM vorgestellt worden. Bei diesem Algorithmus wird versucht, unter Ausnutzung
der nebenläufigen 4 Fähigkeiten eines Modells wie der P-RAM, die zusammenhängenden
Komponenten eines Graphen zu bestimmen. Auch hier wird der Algorithmus zunächst
schematisch im Original vorgestellt und dann wird dargestellt, wie dieser Algorithmus
auf dem GCA modelliert werden kann.
3.1.3.1. Ablauf auf der P-RAM
Der Algorithmus von Hirschberg et al. durchläuft insgesamt O(log(n))-mal eine Schleife.
Nach jedem Schleifendurchlauf hat er eine Menge von zusammenhängenden Komponenten.
Diese Komponenten werden in dem n-dimensionalen Vektor C gespeichert, wobei
an der Stelle i genau dann der Wert j steht, wenn der Knoten i zu der Komponente
j gehört. Innerhalb einer Komponente gilt immer, dass die kleinste Nummer aller zugehörigen
Knoten die Nummer der Komponente bestimmt. So wird die Eindeutigkeit
der Benennung gewährleistet. Der Algorithmus bestimmt diese Komponenten in zwei
Phasen nun folgendermaßen:
• Die erste Phase bestimmt eine Verbindung von jeder Komponente zu der erreichbaren
Komponente mit der niedrigsten Nummer, die in dem n-dimensionalen Vektor
T gespeichert wird.
Zu diesem Zweck muss erst von jedem der Komponente angehörigen Knoten die
Verbindung zu dem kleinsten Knoten, der nicht der Komponente angehört, gesucht
werden. Der Wert von dessen Komponente muss anschließend gespeichert werden.
Danach wird von all diesen Verbindungen diejenige ausgesucht, die zu der niedrigsten
Komponente ungleich der eigenen führt. Diese Verbindung wird gleichzeitig
dem Repräsentanten der eigenen Komponente zugeordnet.
Diese Phase setzt sich aus zwei Teilschritten zusammen.
• Die zweite Phase sorgt dafür, dass alle Komponenten, die eine Verbindung zueinander
haben, zusammengelegt werden und alle in ihnen enthaltenen Knoten auf
den Knoten mit der niedrigsten Nummer verweisen.
4 Man spricht davon, dass zwei Befehle parallel abarbeitbar sind, wenn man die Befehle zeitgleich
ausführen kann. Nebenläufig bedeutet hingegen, dass es egal ist, in welcher Reihenfolge die Befehle
ausgeführt werden. Die Befehle können also parallel abgearbeitet werden oder aber in jeder
Kombination sequentiell hintereinader ohne dass es zu Konflikten kommt.
36

Um diese Aufgabe zu erfüllen, muss zuerst eine Kopie des Vektors T angelegt
werden. Diese Kopie wird in dem Vektor B abgespeichert.
Danach wird O(logn)-mal der Schritt der Doubling-Technik 5 angewendet, in der
Hoffnung, somit auf den niedrigsten Knoten der Gesamtkomponente zu verweisen.
Innerhalb der Komponente kann es dazu kommen, dass ein Zyklus der Länge zwei
entsteht, der dafür sorgt, dass bei der Doubling-Technik die Komponente wieder
in zwei zerfällt. Aus diesem Grund wird an die Doubling-Technik anschließend das
Minimum des Ergebnisses der Doubling-Technik mit dem Nachfolger des ursprünglichen
Werts gebildet. Dieser Wert wird dann wieder an die entsprechende Stelle
des C-Vektors geschrieben.
Somit stehen dann die neu gefundenen Komponenten wieder im Vektor C und der
nächste Durchlauf des Algoritmus kann beginnen. Die zweite Phase besteht aus
drei Teilschritten.
Nachdem die Funktionsweise im Groben beschrieben wurde, soll nun der gesamte Algorithmus
in Pseudocode beschrieben werden. Dabei wird die gleiche Terminologie wie
in [GR98] benutzt. Im Pseudocode wird eine parallele Abarbeitung der Aufgabe immer
durch ein ”
for all ... in parallel“gefordert. Ansonsten ist der Pseudocode ähnlich
der gewohnten Lesart von C, wobei min j bedeutet, dass das Minimum bezüglich j gesucht
wird. Der angegebene Pseudocode muss log(n)-mal wiederholt werden, damit das
korrekte Ergebnis erreicht wird.
Listing 3.3: Der Hirschberg-Algorithmus auf der P-RAM
1 for a l l vertices i in parallel do
T( i )

⎛
B =
⎜
⎝
0 0 0 1 0 0 0 0
0 0 1 1 0 0 1 0
0 1 0 0 1 1 0 0
1 1 0 0 0 0 0 1
0 0 1 0 0 0 0 0
0 0 1 0 0 0 0 0
0 1 0 0 0 0 0 0
0 0 0 1 0 0 0 0
⎞
⎟
⎠
Abbildung 3.6.: Beispielgraph für den Algorithmus von Hirschberg
Im ersten Teilschritt wird von jedem Knoten ausgehend die Kante zum Nachbarn mit
der kleinsten Nummer gesucht, der noch nicht in der gleichen Komponente enthalten ist.
Dieser Nachbar wird in den Vektor T gespeichert, welchen man wieder als Grundlage
für einen gerichteten Graphen verwenden kann (der Wert j an der Stelle i impliziert eine
gerichtete Verbindung von i nach j). Interpretiert man den Vektor T in dieser Weise, so
entsteht am Ende des ersten Schritts der Graph aus Abbildung 3.7.
Im ersten Durchlauf ändert der zweite Teilschritt nichts am Vektor T, da bislang 8
Komponenten existieren, in denen jeweils nur ein Knoten, der Repräsentant, enthalten
ist. Ein Minimum über alle Elemente der Komponente wird also nichts ändern und
Abbildung 3.7 repräsentiert somit auch das Ergebnis des zweiten Teilschritts des ersten
Durchlaufs.
Im dritten Teilschritt wird nunmehr eine Kopie angelegt, welche für den fünften und
letzten Teilschritt benötigt wird.
Im vierten Teilschritt wird nun log(n) mal die Doubling-Technik angewendet. Dabei setzt
jeder Knoten seinen Nachfolger auf den Nachfolger seines ursprünglichen Nachfolgers.
Diese Aktion wird im Algorithmus log(n)-wiederholt, bis schließlich als Ergebnis der
Graph aus Abbildung 3.8 entsteht. Der Vektor T wird dafür wieder wie vorne beschrieben
interpretiert.
Auffällig am Ergebnis nach dem vierten Schritt ist, dass nun vier und nicht mehr, wie
nach dem zweiten Schritt, zwei Komponenten vorhanden sind. Solches Auseinanderreißen
von Komponenten ist allerdings unerwünscht, weshalb der fünfte Schritt wieder
38

Abbildung 3.7.: Ergebnis nach dem ersten und zweiten Teilschritt des ersten Durchlaufs.
Abbildung 3.8.: Ergebnis nach dem vierten Teilschritt des ersten Durchlaufs.
dafür sorgt, dass Komponenten, die im zweiten Schritt zusammenhängend waren, auch
nach dem fünften Schritt wieder zusammenhängend sind. Da das Auseinandergehen einer
Komponente nur durch die Doubling-Technik auftreten konnte, muss dieser Schritt
im Nachhinein noch einmal kritisch nachgeprüft werden. Dies kann man erreichen indem
man das Minimum bildet, da immer der Knoten mit der kleinsten Nummer als
Repräsentant der Komponente definiert ist.
Das Minimum wird über zwei Werte gebildet. Der erste Wert ist der direkte Nachfolger
des Knotens i nach dem vierten Teilschritt. Der zweite Wert berechnet sich mit Hilfe der
Kopie aus Teilschritt drei. Zunächst wird in der Kopie nachgesehen, welchen Nachfolger
der Knoten i nach dem zweiten Teilschritt hatte. Dann wird für diesen Nachfolger der
Nachfolger nach dem vierten Teilschritt gesucht. Dieser Nachfolger schließlich ist die
zweite Eingabe für das Minimum. Das Ergebnis des Minimums ist der neue Nachfolger
des betrachteten Knotens. Nachdem dieses Verfahren für jeden Knoten angewendet
wurde, erhält man den Graphen aus 3.9.
Die zwei neu entstandenen Komponenten versucht man im zweiten Durchlauf zusammenzufassen.
Gäbe es in diesem Durchlauf noch mehr als zwei Komponenten, so wäre
mit einer Verringerung der Komponentenanzahl von mindestens der Hälfte zu rechnen,
außer die Komponenten hängen nicht zusammen 6 .
6 Da nicht zusammenhängende Komponenten nicht zusammengefasst werden können, kommt es bei
einem nicht zusammenhängenden Graphen dazu, dass sich die Anzahl der zusammenhängenden
Komponenten in einem Durchlauf eventuell nicht halbiert.
39

Abbildung 3.9.: Ergebnis nach dem fünften Teilschritt des ersten Durchlaufs.
Abbildung 3.10.: Ergebnis nach dem ersten Teilschritt des zweiten Durchlaufs.
Im ersten Teilschritt des zweiten Durchlaufs wird wieder in jedem Knoten gesucht, ob
eine Verbindung zu einem Knoten aus einer anderen Komponente möglich ist und falls
ja wird die günstigste genommen. In diesem Beispiel ist es nur den Knoten 4 und 2
möglich, eine Verbindung zu einer anderen Komponente herzustellen. Das Ergebnis am
Ende dieses Teilschritts ist in Abbildung 3.10 zu sehen.
Im zweiten Teilschritt wird nun für jeden Knoten i überprüft, ob es einen Knoten j gibt,
welcher am Anfang des Durchlaufs auf den Knoten i gezeigt hat (C(j)=i) und nun nicht
mehr auf i zeigt (T(j)!=i). Existiert mindestens ein solcher Knoten, so wird der kleinste
Knoten j gewählt und der Nachfolger von i auf den Nachfolger von j gesetzt (T(i)=T(j)).
Solch eine Anweisung wird nur für die Knoten ausgeführt, die vorher Repräsentanten
ihrer Gruppe waren, da nur solche noch am Anfang im Vektor C auftauchen. In diesem
Beispiel trifft das auf den Knoten 1 zu; dieser war vorher Repräsentant seiner Komponente
und nun gibt es einen Knoten (Knoten 4), welcher nicht mehr auf den Knoten 1
zeigt. Also zeigt Knoten 1 nun auch nicht mehr auf sich selber, sondern auf Knoten 2,
den Nachfolger von Knoten 4. Der einzige andere Knoten, der für eine Veränderung in
Frage käme, ist Knoten 2. Da dieser aber in seiner Komponente der Einzige ist, welcher
eine Verbindung in die andere Komponente findet, muss der Nachfolger nicht mehr umgesetzt
werden. Ist ein Knoten nicht der Repräsentant seiner Komponente, so wird er
wieder auf seinen Ausgangswert gesetzt (T(i)=C(i)), da die Verbindung zu der anderen
Komponente nur einfach benötigt wird und diese vom Repräsentanten ausgeht. Das Ergebnis
nach Teilschritt zwei des zweiten Durchlaufs sieht dann wie in Abbildung 3.11
40

Abbildung 3.11.: Ergebnis nach dem zweiten Teilschritt des zweiten Durchlaufs. Um Verwirrung
aufgrund von Kantenüberschneidungen zu vermeiden, wurden
die Positionen der Knoten teilweise variiert.
aus.
Teilschritt drei legt wieder eine Kopie des Vektors T für den letzten Schritt an. Im vierten
Teilschritt wird nun wieder die Doubling-Technik angewendet, was zu Abbildung 3.12
führt.
Abbildung 3.12.: Ergebnis nach dem vierten Teilschritt des zweiten Durchlaufs.
Auch hier sind wieder mehrere Komponenten entstanden, obwohl eigentlich die Komponenten
zusammengefasst werden sollten. Das liegt daran, dass im Graphen ein Zyklus
enthalten war und somit jeder der beteiligten Knoten zwangsläufig früher oder später auf
sich selber zeigt. Dieser Missstand wird im fünften Teilschritt bereinigt. Da der Knoten
1 die im gesamten Graphen kleinste Nummer hat, wird sich sein Wert bei der Minimumbildung
nicht ändern, gleiches gilt für alle anderen Knoten, welche auf Knoten 1 zeigen.
Knoten 2 zeigt nach dem vierten Teilschritt auf sich selber, aber in der Kopie (B) zeigt
er auf Knoten 1, welcher nach dem vierten Teilschritt auch auf sich selber zeigt. Das
Minimum von 2 und 1 ist 1, Knoten 2 zeigt also ab jetzt auf Knoten 1. Das gleiche
Prinzip wird nun noch auf Knoten 4 und 8 angewendet. Beide zeigen in der Kopie auf 1
und werden somit im fünften Teilschritt wieder auf den Knoten 1 umgebogen.
41

Da nun alle Knoten auf Knoten 1 zeigen, kann man erkennen, dass es eine große zusammenhängende
Komponente im Graphen gibt, mit andern Worten, der Graph ist
zusammenhängend. Der Algorithmus wird die fünf Teilschritte noch einmal durchlaufen,
da log 2 (8) = 3. Es wird sich jedoch nichts mehr ändern, da keine Verbindung zu
einer anderen Komponente mehr gefunden werden kann. Das Beispiel kann also hier als
abgeschlossen betrachtet werden. Das Endergebnis wird in Abbildung 3.13 graphisch
dargestellt. Bei einem nicht zusammenhängenden Graphen würden nach Terminierung
des Algorithmus im Vektor C mindestens zwei unterschiedliche Repräsentanten stehen.
Man kann direkt aus dem Vektor auslesen, wie groß die Komponenten sind und welche
Knoten zu ihnen gehören.
Abbildung 3.13.: Ergebnis nach dem fünften Schritt des zweiten Durchlaufs. Um Verwirrung
aufgrund von Kantenüberschneidungen zu vermeiden, wurden
auch hier die Position der Knoten teilweise variiert.
3.1.3.2. Komplexitätsbetrachtung auf der P-RAM
Der Algorithmus benötigt, so wie er vorgestellt wurde, eine Laufzeit von
O(log 2 (n)) bei der Benutzung von O( n2 ) Prozessoren. In diesem Abschnitt soll verdeutlicht
werden, dass diese Abschätzung gerechtfertigt
log(n)
ist.
Da die fünf Teilschritte (im Folgenden nur noch Schritte genannt) des Algorithmus
log(n)-mal wiederholt werden, darf jeder Schritt nicht mehr als eine Laufzeit von
O(log(n)) haben, damit die Gesamtlaufzeit von O(log 2 (n)) erfüllt ist. Die Aufgabe dieses
Abschnitts ist es also, für jeden Schritt darzulegen, dass er wirklich in O(log(n)) Zeit
ablaufen kann.
Für den ersten Schritt ist nicht offensichtlich, dass er in O(log(n)) ausführbar ist. Immerhin
müssen potentiell n Werte bestimmt und daraus das Minimum gebildet werden.
Um diesen Schritt in der gewünschten Zeit ausführen zu können, muss man geschickt
zusätzliche Prozessoren einsetzen. In [GR98] wird der erste Schritt in drei Teilschritte
42

1(a) bis 1(c) aufgeteilt und für jeden der Teilschritte die Komplexität bestimmt. Die
Teilschritte gestalten sich wie folgt (∞ aus dem Original wurde hier durch 2n ersetzt):
Listing 3.4: Weitere Unterteilung des ersten Schritts des Hirschberg-Algorithmus
1 1(a) : for a l l i , j , 1

Abbildung 3.14.: Eine Möglichkeit, aus n Werten in log(n) Schritten das Minimum zu
finden. Die Prozessoren vergleichen mit ihrem Nachbarn und speichern
das Minimum ab. Danach wird der Nachbar umgesetzt. Das Minimum
steht nach der Ausführung immer an erster Stelle.
Wendet man statt der Doubling-Technik die modifizierte Balanced-Binary-Tree-Technik 7
an, dann reichen
n Prozessoren pro Spalte und dabei wird eine Laufzeit von O(log(n))
log(n)
garantiert. Insgesamt benötigt der erste Schritt dann eine Laufzeit von O(log(n)) und
O( n2 ) Prozessoren. Im Folgenden soll zuerst die Balanced-Binary-Tree-Technik vorgestellt
werden und dann wird dargestellt, wie man die Anzahl der Prozessoren dahinge-
log(n)
n
hend verändern kann, dass man mit O( ) Prozessoren die gleiche Laufzeitkomplexität
log(n)
erreicht.
Bei der Balanced-Binary-Tree-Technik [Abbildung 3.15] hält jede Zelle zwei Werte der
Matrixspalte aus 1(a) und bildet hieraus das Minimum.
Es berechnen also n−1 Prozessoren parallel das Minimum ihrer Werte. Jede Zelle hat in
diesem Modell eine Vaterzelle und jede Vaterzelle hat zwei Kindzellen, was dazu führt,
dass die Balanced-Binary-Tree-Technik immer n = 2 m Werte erwartet (ist dies nicht
der Fall, müssen Dummy-Einträge ergänzt werden, bis die Bedingung erfüllt ist). Die
Vaterzelle bestimmt nun das Minimum der Kindzellen und liefert diesen Wert an seine
Vaterzelle weiter. Insgesamt halbiert sich die Anzahl der Zellen auf jeder Stufe, bis in
der Spitze nur noch eine Zelle existiert, die Wurzel. Nachdem diese Wurzelzelle ihrerseits
das Minimum gebildet hat, kann der korrekte Wert aus der Wurzel ausgelesen werden.
Die Laufzeitkomplexität entspricht nun der maximalen Weglänge von der Wurzel zu
einem Blatt, was in einem vollständigen Binärbaum log(n) ist. Wie bei der Doubling-
Technik werden hier jedoch O(n) Prozessoren oder Zellen pro Spalte benötigt, was zu
einer Gesamtzahl von O(n 2 ) benötigten Zellen führt.
7 Ein Beispiel für die Balanced-Binary-Tree-Technik wird gegeben. Eine genaue Beschreibung findet
sich im Anhang.
44

Abbildung 3.15.: Die Balanced-Binary-Tree Technik mit der maximalen Anzahl der Prozessoren.
Bei der weniger prozessoraufwendigen Variante werden die
Aufgaben der Prozessoren der oberen Schichten noch von den Prozessoren
der untersten Schicht mit erledigt.
Die Anzahl der Zellen lässt sich leicht minimieren, indem man Zellen erlaubt, ihre eigene
Vaterzelle zu sein um somit mehrfach benutzt zu werden. Durch diese Maßnahme lässt
sich die Anzahl der benötigten Zellen zwar auf n reduzieren, jedoch entspricht dies in der
2
O-Notation immer noch einer Anzahl von O(n) Prozessoren pro Spalte. Um die Anzahl
n
der Prozessoren also auf O( ) zu reduzieren, muss man also die Anzahl der in der
log(n)
untersten Reihe benötigten Prozessoren minimieren.
Um die Anzahl der Prozessoren nun weiter zu minimieren, teilt man die n Werte, aus
denen das Minimum gesucht werden soll, in p Gruppen. Jede dieser p Gruppen hat ⌊ n⌋
p
Elemente, außer einer, welche n−(p−1)⌊ n ⌋ Elemente hat. Es werden nun p Prozessoren
p
gebraucht, welche jeweils in einer Gruppe sequentiell das Minimum suchen. Da jede
Gruppe maximal ⌊ n⌋ Elemente hat, werden maximal p ⌊n ⌋ -1 Schritte gebraucht, um
p
n
das Minimum der Gruppe zu bestimmen. Setzt man p auf , so werden O( n
)
log(n) log(n)
Prozessoren für die Gesamtlösung benötigt und die Laufzeitkomplexität ist weiterhin
O(log(n)).
Um die Laufzeitkomplexität zu verdeutlichen, werden die Arbeitsschritte noch einmal
aufgeführt: Es werden insgesamt log(n)−1 Minimumbestimmungen aus zwei Elementen
benötigt (der obere Teil des Baums), die in O(1) möglich sind und eine Minimumbestimmung
aus einer Gruppe mit ⌈ n ⌉ Elementen. Dieses Minimum der Gruppe benötigt
p
⌈ n n
⌉ − 1 Schritte, wobei p als gewählt wurde. Die Gruppenminimumsbestimmung
p log(n)
benötigt demnach log(n) − 1 Schritte, was insgesamt 2log(n) − 2 Schritte ergibt, also
O(log(n)). Es wurde also eine Methode gefunden, sowohl die Zeitschranke als auch die
gewünschte Schranke der Prozessoren einzuhalten.
Der zweite Schritt kann genauso wie der erste Schritt in drei Teilschritte zerlegt werden,
die sich dann ähnlich wie die drei Teilschritte des ersten Schritts in O(log(n)) Laufzeit
und mit O( n2 ) Prozessoren realisiern lassen.
log(n)
Schritt drei ist offensichtlich in O(1) realisierbar. Das Kopieren von n Werten kann mit n
45

Prozessoren in zwei Schritten erledigt werden (ein Schritt den Wert lesen und ein Schritt
den Wert in die neue Variable schreiben).
Die Zuweisung des vierten Schritts ist mit n Prozessoren in O(1) möglich, allerdings
muss die Anweisung log(n) mal wiederholt werden, was sich auch mit mehr Prozessoren
nicht vermeiden lässt. Der Zeitaufwand des vierten Schritts ist also O(log(n)) und kann
nicht optimiert werden. Das bedeutet, dass auch die Laufzeit des Gesamtalgorithmus
nicht mehr verbessert werden kann.
Der fünfte Schritt ist wieder mit n Prozessoren in O(1) realisierbar.
Da alle Schritte in maximal O(log(n)) ausführbar sind und der vierte Schritt minimal
O(log(n)) Schritte benötigt, ist anschaulich dargelegt, weshalb der Algorithmus eine
Laufzeitkomplexität von O(log(n) 2 ) hat. Die Anzahl der Prozessoren lässt sich noch auf
O( n2
log 2 n)
) reduzieren, wie in [CLC82] dargestellt ist.
3.1.3.3. Modellierung auf dem GCA
Da der Algorithmus von Hirschberg schon so konstruiert ist, dass er die parallelen
Möglichkeiten der P-RAM ausnutzt, ist es nicht mehr nötig, zu überprüfen, an welchen
Stellen er sich parallelisieren lässt. Die eigentliche Aufgabe bei diesem Algorithmus
liegt nunmehr darin, zu überprüfen, ob alle parallelen Möglichkeiten der P-RAM, die hier
genutzt werden, sich auch auf dem GCA nutzen lassen. Allerdings wird hier zunächst
einmal ein Ansatz der Modellierung verfolgt, der verständlich ist, auch wenn dadurch die
Laufzeitkomplexität schlechter wird. Nachdem die Modellierung veranschaulicht wurde,
wird darauf eingegangen, wie die Laufzeit optimiert werden kann.
Auf die erste Abweichung trifft man bei den Vektoren T,B und C. Diese werden im Algorithmus
von Hirschberg als globale Variablen genutzt, auf die alle Prozessoren sowohl
lesend als auch schreibend zugreifen dürfen. Da der GCA über keinen globalen Speicher
verfügt und auch auf die Zellinhalte fremder Zellen nicht schreibend zugegriffen werden
darf, ist das ein Problem.
Diese Problematik lässt sich mit dem GCA jedoch elegant umgehen, indem man die
Vektoren auf die Prozessoren aufteilt. Mit diesem Lösungsansatz hält dann jede Zelle i
die Werte T[i],B[i] und C[i]. Da jede Zelle i nur auf den i-ten Wert schreibend zugreift,
ist damit bereits das Problem des Schreibens auf Zellinhalte fremder Zellen gelöst.
Ein Nachteil dieses Lösungansatzes ist allerdings, dass der Kommunikationsaufwand
recht hoch wird. Allein im vierten Schritt ist es sehr wahrscheinlich, dass auf den Zellinhalt
anderer Zellen zugegriffen werden muss. Der Kommunikationsaufwand ist dabei
weniger das Problem, als vielmehr die Tatsache, dass viele Verbindungen am Anfang
hergestellt werden müssen, die im weiteren Verlauf eventuell ungenutzt bleiben.
Um auch diese Problematik zu umgehen, wird eine Zelle als Speicherzelle ausgezeichnet,
auf die alle Zellen lesend zugreifen. Damit diese Zelle aber immer die korrekten
Variableninhalte bereit hält, muss sie am Ende jedes Schritts bei jeder Zelle den aktuellen
Stand der entsprechenden Variable abfragen. Das heißt, die Speicherzelle fragt nach
46

Abbildung 3.16.: Schematischer Aufbau des GCA, welcher den Hirschberg-Algorithmus
bearbeitet. Es existieren sowohl von der Speicherzelle“ zu jeder Rechenzelle“
Verbindungen als auch von jeder Rechenzelle“ zu der
”
” ”
” Speicherzelle“. Jede Rechenzelle“ beinhaltet neben den Variablen T,
”
B und C auch noch eine Zeile der Matrix.
Schritt eins bei allen Zellen an, welchen Wert sie in ihrer Variable T halten (da nur T
geändert wurde, ist es nicht nötig, die anderen Variablen abzufragen). Die Antwort der
Zelle i wird dann an die i-te Stelle des Vektors T der Speicherzelle geschrieben. In jedem
Schritt des Algorithmus sind also k+1 Takte nötig; k Takte um die Aufgabe des Schritts
zu lösen und ein Takt, um die Variablen in die Speicherzelle zu übertragen. Zusätzlich
muss jede Zelle, außer der Speicherzelle, noch eine Zeile der Matrix halten, so dass Zelle
i die i-te Zeile der Matrix bearbeitet. Der Aufbau wird in Abbildung 3.16 noch einmal
veranschaulicht.
Nachdem der Aufbau der Zellen festgelegt wurde, muss überlegt werden, wie die einzelnen
Schritte des Algorithmus damit abgearbeitet werden können. Hier wird o. B. d.
A. davon ausgegangen, dass es kein Problem ist, den Ablauf log(n)-mal zu wiederholen,
d.h. wenn es gelingt, die einzelnen Schritte auf dem GCA lauffähig zu modellieren, wird
der gesamte Algorithmus auf dem GCA lauffähig sein.
• Erster Schritt: Im ersten Schritt muss für jede Zelle jeweils der Nachbar mit
dem kleinsten Index gesucht werden. Dies geschieht einfach, indem jede Zelle die
Matrixzeile, die sie beinhaltet, von vorne durchläuft und bei der ersten gefundenen
Eins stoppt. Nun muss noch gesucht werden, ob dieser Nachbar j gewählt werden
darf. Dazu wird eine Anfrage an die Speicherzelle gestellt, wobei der Eintrag C(j)
angefragt wird. Daraufhin testet die Zelle, ob der zurückgelieferte Wert gleich dem
Wert in der eigenen C Variable ist. Ist dies der Fall, so muss die Zeile so lange
weiter durchlaufen werden, bis ein j gefunden wird, das beide Bedingungen erfüllt.
Kommt die Zelle an das Ende der Zeile ohne ein passendes j gefunden zu haben,
wird der Wert der C Variable in T gespeichert.
47

Da alle Zellen parallel arbeiten, ist der erste Schritt hier eigentlich beendet, allerdings
muss in dieser Modellierung noch dafür gesorgt werden, dass die Speicherzelle
wieder aktualisiert wird. Um dieses Ziel zu erreichen fragt die Speicherzelle nun
parallel bei allen Zellen an und speichert deren Wert T in ihrem Vektor T ab.
• Zweiter Schritt: Im zweiten Schritt sind immer die Paare T(j) und C(j) interessant.
Natürlich kann man jede Zelle bei der Speicherzelle nachfragen lassen,
allerdings wollen ja alle Zellen alle T(j) und C(j) wissen, weshalb es geschickter ist,
die Speicherzelle die Koordination übernehmen zu lassen. Innerhalb von n Takten
stellt sie jeweils das Paar (T(j), C(j)) bereit und jede Zelle, die noch auf der Suche
nach ihrem Wert ist, kann sich dieses Paar abholen. Die Zellen selbst übernehmen
dann intern die Überprüfung, ob das Tupel die Bedingung erfüllt oder nicht.
Da nur T(j) abgespeichert werden muss, kann dieses Verfahren noch dahingehend
optimiert werden, dass die Speicherzelle nur solche Paare bereitstellt, die ungleich
sind. Allerdings wird dann ein Abbruchtupel benötigt, damit die Zellen wissen,
dass sie ihren Wert C in der Variablen T speichern sollen.
Anschließend muss wieder die Speicherzelle von allen Zellen die T-Werte abfragen
und an der korrekten Stelle ihres Vektors T speichern.
• Dritter Schritt: Da jede Zelle i ihren aktuellen Wert T(i) kennt, kann das Kopieren
des Vektors T in der Speicherzelle und der Werte T(i) in den Zellen gleichzeitig
geschehen.
• Vierter Schritt: Im vierten Schritt wird log(n)-mal der folgende Ablauf durchgeführt:
Jede Zelle fragt bei der Speicherzelle den Wert an, der im Vektor T an der Stelle
T(i) steht (den Wert T(i) kennt die Zelle ja bereits, da er in ihrer eigenen Variable
T steht). Die Antwort der Speicherzelle wird in der Variablen T der anfragenden
Zelle gespeichert.
Nachfolgend muss wieder die Speicherzelle ihren Vektor T aktualisieren und erst
dann darf die Schleife erneut durchlaufen werden.
• Fünfter Schritt: In diesem Schritt muss jede Zelle genau einmal bei der Speicherzelle
anfragen. Gefragt wird in diesem Fall nach dem Wert des Vektors B an
der Stelle T(i). Daraufhin bildet jede Zelle für sich das Minimum und speichert
den Wert in C. Nachdem jede Zelle mit ihrer Berechnung fertig ist, fragt die Speicherzelle
wieder alle Werte C der Zellen ab und aktualisiert so ihren Vektor C.
Die Simulation auf dem GCA ist also möglich. Aufgrund der Speicherzelle hat man zwar
mehr Aktualisierungsaufwand, allerdings müssen die Zellen nicht mehr untereinander
kommunizieren. Dadurch können viele Verbindungen eingespart werden. Diese Modellierung
ist nicht laufzeitoptimal. Im nächsten Abschnitt werden Möglichkeiten untersucht,
die Speicherzelle effizient zu modellieren und die Laufzeitkomplexität zu verbessern.
48

Abbildung 3.17.: Erster Ansatz zur Realisierung der Speicherzelle. Jede Zelle hat n Verbindungen
zur Speicherzelle und die Speicherzelle hat eine Verbindung
zu jeder Zelle.
3.1.3.4. Komplexitätsbetrachtung und Verbesserungen auf dem GCA
Gegenüber der Modellierung auf der P-RAM sind bei der vorgestellten Modellierungsvariante
erhebliche Geschwindigkeitseinbußen hinzunehmen. Während der Originalalgorithmus
mit O(log(n) 2 ) auskommt, benötigt schon der erste Schritt in der eben erläuterten
Realisierung im worst-case O(n) Schritte. Eine Laufzeitkomplexität besser als
O(nlog(n)) ist hiermit also nicht zu realisieren. Dennoch wird zunächst auf die Realisierungsmöglichkeiten
der Speicherzelle eingegangen, bevor erläutert wird, wie die Laufzeitkomplexität
verringert werden kann.
3.1.3.4.1. Speicherzellenmodellierung Die Gründe, die für die Einführung einer Speicherzelle
in der Modellierung sprachen, waren einerseits die bessere Verständlichkeit und
andererseits die Reduktion der benötigten Leitungen und ein geringerer Kommunikationsaufwand.
Ohne Speicherzelle muss jede Zelle auf jede andere Zelle lesend zugreifen
können, d.h. bei n Zellen werden O(n 2 ) Leitungen benötigt, um eine korrekte Kommunikation
zu ermöglichen.
Ein erster Ansatz ist es, der Speicherzelle n Ports zur Verfügung zu stellen, an denen sie
dann immer die passende Variable anlegt [Abbildung 3.17]. Im ersten Schritt würde beispielsweise
an den Port i der Wert C(i) angelegt. Damit die Zellen sich den gewünschten
Wert abholen können, muss jede Zelle über eine Verbindung zu jedem einzelnen Port der
Speicherzelle verfügen. Da jede Zelle einen Teil des aktuellen Werts der gerade veränderten
Variable hält, muss die Speicherzelle auch eine Verbindung zu jeder Zelle haben.
Insgesamt benötigt man also n 2 + n Verbindungen (n Verbindungen pro Zelle zuzüglich
49

den n Verbindungen der Speicherzelle). Ein Vorteil ist, dass die Kommunikation in zwei
Takten (erster Takt: Speicherzelle stellt den Wert bereit, zweiter Takt: Zelle liest den
Wert) abläuft und gleich alle interessanten Variableninhalte abgefragt werden können.
Diesen ersten Ansatz kann man noch überschaubarer gestalten, indem man einen Bus
einführt, welcher die Variablen bereitstellt [Abbildung 3.18].
Abbildung 3.18.: Modifizierter Ansatz der Speicherzellenrealisierung. Jede Zelle sowie
die Speicherzelle haben Zugriff auf jeden Wert des Busses.
Wenn die Zellen einen Wert von der Speicherzelle erfragen wollen, schreibt die Speicherzelle
den gesamten Vektor der Variablen auf den Bus. Die Zellen können dann vom Bus
die Werte lesen, welche sie interessieren. In der Aktualisierungsphase der Speicherzelle
schreiben dann die Zellen ihren Variablenwert, welcher ihrer Zell-ID entspricht, auf die
Leitung des Busses. Da jede Zelle eine einzigartige Zell-ID hat, kommt es zu keinerlei
Schreibkollisionen.
Diese Realisierung erscheint zwar strukturierter, allerdings werden noch mehr Verbindungen
benötigt: zuzüglich zu den n 2 + n Verbindung der ersten Realisierung sind auch
noch die n Verbindungen des Busses nötig. Außerdem gilt es zu beachten, dass in der
ersten Realsierung nur unidirektionale Verbindungen gebraucht wurden, in dieser Modifikation
allerdings die n Verbindungen der Speicherzelle sowie mindestens eine Verbindung
pro Zelle bidirektional sind. Der Zugriff ist weiterhin in zwei Takten möglich und somit
ist diese Variante zumindest dahingehend interessant, dass sie den Denkansatz für den
nächsten Ansatz liefert.
In der zweiten Modifikation des ersten Ansatzes wird auf die Speicherzelle gänzlich verzichtet
[Abbildung 3.19]. In der letzten Realisierungsvariante wurde ersichtlich, dass der
50

Abbildung 3.19.: Realisierung durch einen Datenbus ohne Speicherzell. Jede Zelle kann
auf eine Stelle des Busses schreibend und auf alle lesend zugreifen.
Bus die Kommunikation mindestens genauso gut koordinieren kann wie die Speicherzelle.
Der Vorteil der Speicherzelle, dass sie Daten zwischenspeichern kann, wird hier
nicht effektiv genutzt und dementsprechend kann auf die Speicherzelle auch verzichtet
werden. Wenn Variablen abgefragt werden sollen, schreibt jede Zelle i die entsprechende
Variable auf die i-te Stelle des Busses. Da dies alle Zellen parallel machen, kann sofort im
nächsten Takt darauf gelesen werden. Für einen Variablenaustausch sind also weiterhin
nur zwei Takte nötig. Allerdings kann eine Zelle (die Speicherzelle) eingespart werden
und die Anzahl der benötigten Verbindungen sinkt wieder auf n 2 + 2n unidirektionale
Verbindungen. Erlaubt man bidirektionale Verbindungen, so werden nur noch n 2 + n
Verbindungen benötigt, wovon n Verbindungen bidirektional sind.
Ein völlig anderer Ansatz wird in der in Abbildung 3.20 dargestellten zweiten Realisierung
verfolgt. Hier wurde die Anzahl der Verbindungen auf 2n reduziert. Die Speicherzelle
stellt jeder Zelle einen Port zur Verfügung, aus dem sie die für sie interessanten Werte
auslesen kann. Zusätzlich stellt jede Zelle der Speicherzelle einen Port zur Verfügung, an
dem die Speicherzelle ihrerseits Werte auslesen kann.
Der Verbindungsaufwand ist deutlich geringer als bei den ersten Realisierungen, allerdings
ist mehr Logik und Kommunikation notwendig, damit jede Zelle auch wirklich den
Wert erhält, den sie benötigt. Voraussetzung für diese Realisierung ist, dass alle Zellen
zeitgleich funktionieren, also immer den gleichen Schritt des Algorithmus bearbeiten und
die Speicherzelle zudem weiß, welcher Schritt gerade aktuell ist.
Jede Zelle, die eine Anfrage an die Speicherzelle stellen möchte, schreibt den benötigten
Index in ihren Port, ansonsten wird ein als ”
none“ definierter Wert in die Variable des
Ports geschrieben. Im nächsten Schritt liest die Speicherzelle parallel die Portvariablen
aller Zellen aus und bearbeitet die Werte in einem Takt. Wieder einen Schritt später
schreibt sie die angefragten Werte an die entsprechenden Ports, wo sich die Zellen im
nächsten Takt die Werte abholen können. Der Ablauf benötigt also fünf Takte.
Einer der Vorteile dieser Realisierung sind allerdings die ”
none“ Werte, die möglich sind,
was im Weiteren noch genauer erläutert wird. In vielen Schritten ist nicht klar, wie
lange ein Prozessor wirklich braucht, bis er ein Ergebnis gefunden hat. So muss z. B. im
ersten Schritt einerseits die Zeile durchlaufen und dann noch der entsprechende Wert C
51

Abbildung 3.20.: Jede Zelle hat einen Port in der Speicherzelle, auf den sie lesend zugreift
und zusätzlich einen eigenen Port, auf den die Speicherzelle lesend
zugreifen kann.
abgefragt werden. Wenn nicht im ersten Anlauf ein passender Wert gefunden wird, muss
der Ablauf wiederholt werden. Wurde der Wert gefunden, wird die Zelle den none“ Wert ”
in die Portvariable schreiben und so anzeigen, dass sie fertig ist. Haben alle Zellen einen
none“ Wert in der Portvariable, so kann die Speicherzelle schließen, dass der Schritt
”
erfolgreich abgearbeitet wurde und dies den Zellen mitteilen, indem sie einen definierten
Wert an ihre Portvariablen anlegt. Dies setzt natürlich voraus, dass die Zellen auch dann
lesend auf die Portvariable zugreifen, wenn sie selber keinen Wert angefordert haben.
Die Laufzeitkomplexität wird durch diese Modifikation zwar nicht verringert, aber der
Algorithmus wird dennoch beschleunigt.
Wählt man den zweiten Modellierungsansatz, so benötigt man O(n) Prozessoren mit
O(n) Verbindungen und einer Laufzeit von O(nlog(n)), wobei n die Anzahl der Knoten
ist.
Mit diesem zweiten Ansatz kann man nun wieder versuchen, den Algorithmus in das
in Kapitel 2.3.4 vorgestellte Schema einzuordnen. Auch hier ist wieder eine getrennte
Betrachtung der Abhängigkeiten der Daten und der Verbindungen der nächsten Generation
notwendig. Da der Algorithmus von Hirschberg allerdings aus fünf Schritten
besteht, wird nachfolgend die Betrachtung nach diesen Schritten gegliedert:
• Im ersten Schritt wird abhängig von den eigenen Daten der Zelle eine Anfrage
an die Speicherzelle gestellt. Abhängig von deren Antwort ändern sich die Daten
der Zelle. Daraus ergibt sich eine Abhängigkeit der Daten von den eigenen Daten
und den Daten der Nachbar-Zelle (in diesem Fall die Speicherzelle). Von der Zeit,
der genauen Position der Zelle oder der Verbindung an sich sind die Daten nicht
52

abhängig. Die einzige Verbindung der Zelle in diesem Schritt ist die Verbindung
zur Speicherzelle und diese wird nicht geändert. Aus diesem Grund ergeben sich
in diesem Schritt keine Abhängigkeiten der Verbindungen.
• Im zweiten Schritt werden Tupel von der Speicherzelle bereitgestellt und von den
anderen Zellen gelesen. Abhängig von den eigenen Daten werden die Daten der
Speicherzelle weiter verwendet oder nicht. Somit ergibt sich wieder eine Abhängigkeit
der Daten von den eigenen Daten sowie den Daten der Nachbar-Zelle. Auch
hier verändert sich die Verbindung nicht, weshalb hier wieder keine Abhängigkeiten
für diese festgestellt werden können.
• Der dritte Schritt umfasst das Kopieren des Wertes (bzw. Vektors für die Speicherzelle)
T in den Wert (Vektor) B. Das heißt, dass sich die Daten nur abhängig von
den eigenen Daten ändern. Es werden keine Verbindungen benutzt oder verändert,
weshalb wieder keine Abhängigkeiten für die Verbingungen bestehen.
• Im vierten Schritt wird wieder von der Zelle ein Wert der Speicherzelle gelesen und
abhängig davon der eigene Wert geändert. Da der aus der Speicherzelle gelesene
Wert abhängig von den eigenen Daten ist, ergibt sich wieder die Abhängigkeit der
Daten von den eigenen Daten und den Daten der Nachbar-Zelle. Es werden auch
hier keine Verbindungen verändert.
• Im fünften Schritt wird wieder ein Wert aus der Speicherzelle ausgelesen. Abhängig
von diesem gelesenen Wert und dem eigenen Wert wird dann der neue Wert bestimmt.
Es ergibt sich also eine Abhängigkeit von den eigenen Daten und den
Daten der Nachbar-Zelle. Auch hier werden keine Verbindungen verändert, es ergeben
sich dafür also keine Abhängigkeiten.
Mit Hilfe des Speicherzellen-Konzepts ist es gelungen, dass der Algorithmus im Laufe
der Zeit keine Änderungen an den Verbindungen vornehmen muss. Auch sind die Daten
immer nur abhängig von den eigenen Daten und den Daten der Speicherzelle. Die Speicherzelle
bildet keine Ausnahme bei den Zellen. Sie hängt implizit von den eigenen Daten
ab, da die Zellen ihren Wert abfragen und mit deren Hilfe ihren neuen Wert berechnen.
Es ergeben sich also die Funktionen: d’ = f(d,d*) und p’ = g().
3.1.3.4.2. Laufzeitkomplexitätsverbesserung Alle Techniken, welche in der Komplexitätsbetrachtung
des Algorithmus auf der P-RAM angewendet wurden, sind auch auf
dem GCA anwendbar. Mit Hilfe der Speicherzelle verhält sich der GCA fast ebenso wie
die P-RAM und die regelmäßige Auffrischung des Speichers der Speicherzelle ist aufgrund
der hohen Nebenläufigkeit in O(1) möglich und wirkt sich somit nicht negativ auf
die Komplexitätsbetrachtung aus.
53

3.2. Minimal aufspannende Bäume
Bäume sind zusammenhängende, azyklische Graphen. Das bedeutet in einem ungerichteten
Graphen, dass es von jedem Knoten zu jedem anderen Knoten genau einen Weg gibt.
Ein aufspannender Baum ist ein Baum, welcher aus einem Graphen durch das Entfernen
von Kanten entstanden ist. Ein minimal aufspannender Baum ist ein aufspannender
Baum, dessen Summe an Kantenwertung minimal ist. Solche minimal aufspannenden
Bäume werden z. B. in Netzwerken verwendet, um aus einer Menge von möglichen
Verbindungen diejenigen auszuwählen, welche die geringsten Kosten verursachen und
trotzdem eine Verbindung zwischen allen Komponenten garantieren.
In der sequentiellen Programmierung gibt es viele Algorithmen zur Bestimmung von
minimal aufspannenden Bäumen. Die Algorithmen, welche im Grundstudium der Informatik
gelehrt werden, sind der Algorithmus von Kruskal und der Algorithmus von
Prim. Beide liefern einen minimal aufspannenden Baum, allerdings stecken vollkommen
unterschiedliche Ansätze hinter den Algorithmen. Aus diesem Grund werden die beiden
Algorithmen auch meist verwendet, um zu illustrieren, dass verschiedene Ansätze zu
richtigen Ergebnissen führen können.
Der Algorithmus von Kruskal startet mit einer sortierten Menge an Kanten und den
Knoten des Baums, die als eigenständige Wälder 8 betrachtet werden. Im Verlauf des
Algorithmus wird dann die kleinste Kante des Graphen genommen und überprüft, ob
durch das Aufnehmen dieser Kante zwei Wälder verbunden werden oder nicht. Wenn
keine zwei Wälder verbunden werden, entstünde mit dem Aufnehmen der Kante ein
Zyklus, weshalb die Kante verworfen wird. Ansonsten wird die Kante aufgenommen und
die beiden Wälder werden zu einem Wald zusammengefasst.
Der Algorithmus von Prim hat einen Startknoten, welcher anfangs die Menge der aufgenommenen
Knoten repräsentiert. Im Verlauf des Algorithmus wird immer die Kante
gesucht, die einen Knoten aus dieser Menge mit einem Knoten außerhalb der Menge
verbindet und dabei die minimale Kantenwertung hat. Diese Kante wird dann in den
minimalen Spannbaum aufgenommen und die Menge wird um den Knoten erweitert, der
nicht in der Menge war und nun durch die Kante verbunden wurde. Da keine Kanten
betrachtet werden, die nicht genau einen Knoten in der Menge als Start oder Ziel haben,
können keine Zyklen entstehen.
3.2.1. Der Kruskal-Algorithmus
Auch beim Algorithmus von Kruskal 9 muss betrachtet werden, inwiefern der Algorithmus
parallelisierbar ist. Betrachtet man den Algorithmus kritisch, so muss man feststellen,
8 Ein Baum ist ein zusammenhängender, azyklischer Graph. Ein Wald besteht aus mehreren Bäumen,
die nicht unbedingt zusammenhängen müssen.
9 Eine Erklärung zu Kruskal findet sich in [Gü92] auf Seite 170-173. In diesem Buch finden sich auch
andere Graphenalgorithmen, u. a. der Warshall-Algorithmus.
54

dass die Kanten nicht parallel überprüft werden können, weil nicht parallel getestet werden
kann, ob ein Zyklus ensteht. Da der Kruskal allerdings eine Sortierung der Kanten
fordert, bietet sich dort eine Möglichkeit zur Parallelisierung 10 . Da der Kruskal in jedem
Schritt nur die kleinste Kante fordert und nicht nötigerweise von Anfang an eine sortierte
Liste benötigt, kann die Sortierung parallel zur Zyklenüberprüfung stattfinden. Auf dem
GCA existieren viele Sortieralgorithmen, u. a. das bitonische Mischen (s. [Hee01]), das
sich hier aber nicht so gut eignet. Ein Sortier-Algorithmus, welcher sich sowohl parallelisieren
lässt als auch in jedem Schritt die kleinste Kante zur Verfügung stellen kann, ist
der Heap-Sort. Dieser soll in dem folgenden Abschnitt an einem Beispiel näher erklärt
werden, bevor dann der Kruskal mit dem Heap-Sort auf dem GCA modelliert wird.
3.2.1.1. Der Heap-Sort
Da hier immer die kleinste Kantenwertung gesucht wird, kann in diesem Falle ein Min-
Heap verwendet werden, d. h. der Vaterknoten enthält immer einen kleineren Wert als
seine Söhne. Damit steht dann immer der kleinste Wert des Baums in der Wurzel.
Abbildung 3.21.: Ein Min-Heap: In der Wurzel steht immer ein kleinerer Wert als in
den Söhnen. Außerdem ist der Baum fast vollständig.
Um den Heap aufzubauen und am Ende alle Bedingung wie in Abbildung 3.21 zu erfüllen,
wird die zu sortierende Menge als Vektor eingelesen. In diesem Fall sollen Kanten sortiert
werden, es wird also ein Baum der Höhe log(|E|) bei der Wurzel beginnend schrittweise
gefüllt. Dabei kommt das erste Element in die Wurzel, das zweite in den linken Sohn
der Wurzel, das dritte in den rechten und dann wird die nächste Ebene von links nach
rechts aufgefüllt. Im weiteren wird der Heap allgemein für n Werte beschrieben.
Ein Baum, in dem jede Ebene bis auf die letzte vollständig gefüllt und dessen letzte
Ebene von links beginnend ohne Lücken gefüllt ist, wird fast vollständig genannt. Wird
der Baum wie beschrieben aufgebaut, so ist er fast vollständig. Der Baum dient dabei
lediglich der Visualisierung der Vorgänge beim Ablauf des Algorithmus, denn der
Algorithmus selbst arbeitet auf dem Vektor. Dieser Vektor kann genau dann als fast
vollständiger Baum interpretiert werden, wenn es keine freien Einträge im Vektor gibt.
10 Dieser Vorschlag wird auch in [Kru05] gemacht. Dort wird allerdings eine andere Möglichkeit vorgeschlagen,
den Heap zu parallelisieren.
55

Im Folgenden wird der Algorithmus weiterhin am Baum erklärt, da dies anschaulicher
ist.
Ist der Baum wie oben beschrieben gefüllt worden, so entspricht er noch nicht der Bedingung,
dass die Wurzel immer kleiner als ihre Söhne sein muss. Dazu werden die Knoten
der vorletzten Ebene überprüft, ob sie Söhne haben, deren Wert kleiner ist als ihr eigener.
Ist dies der Fall, so wird mit dem Sohn getauscht, der den kleineren Wert enthält.
Als Beispiel wird der Baum betrachtet, der durch den Vektor (7, 5, 10, 1, 3, 4, 9, 6)
beschrieben wird. Eine graphische Darstellung des Baums findet sich in Abbildung 3.22.
Abbildung 3.22.: Nach dem Einlesen des Vektors in den Baum ist zwar ein fast
vollständiger Baum entstanden, er erfüllt allerdings noch nicht die
Heap-Eigenschaft.
Um die Heapeigenschaft herzustellen wird zuerst der Wert 1 überprüft, ob er kleiner
als sein Sohn ist. Dies ist der Fall, also wird als nächstes der Wert 10 überprüft, ob er
kleiner als seine Söhne mit den Werten 4 und 9 ist. Da hier die Bedingung nicht erfüllt
ist, wird der Wert 10 mit dem Wert 4 getauscht und dieser Teilbaum erfüllt nun für
sich die Heap-Bedingung. Anschließend wird der Wert 5 und dessen zwei Söhne mit den
Werten 1 und 3 verglichen. Nun muss der Wert 1 mit dem Wert 5 getauscht werden, was
dazu führt, dass auch nachgeprüft werden muss, ob der Wert 5 kleiner als der Wert 6 ist,
der nun sein Sohn ist. Dies ist der Fall, deshalb ist die Vertauschung damit abgeschlossen
und die Wurzel kann nun geprüft werden. Da 7 aber größer als die 1 ist, muss auch hier
wieder getauscht werden. In diesem Fall ist die 7 aber auch größer als ihre neuen Söhne 5
und 3 und muss deshalb mit 3 getauscht werden. Damit ist die initiale Heap-Herstellung
abgeschlossen, der Heap aus Abbildung 3.21 wurde hergestellt und die erste sortierte
Kante kann entnommen werden.
Das Entnehmen eines Werts in einem Heap gestaltet sich dermaßen, dass er mit dem Wert
getauscht wird, der im Heap in der untersten Ebene an der rechtesten Stelle steht. Diese
Stelle wird dann in allen nachfolgenden Schritten ignoriert. Durch die Vertauschung hat
der Baum nun ein zu betrachtendes Element weniger. Der hieraus resultierende Baum
ist in 3.23 dargestellt.
Die Wiederherstellung der Heap-Eigenschaft gestaltet sich immer gleich und soll hier nur
exemplarisch erklärt werden. Da vor dem Vertauschen die Heap-Eigenschaft erfüllt war,
müssen maximal log(n) Vertauschungen durchgeführt werden, bis die Heap-Eigenschaft
56

Abbildung 3.23.: Der kleinste Wert wurde aus dem Heap entfernt und die Heap-
Eigenschaft ist verletzt.
Abbildung 3.24.: Der Wert der Wurzel wurde mit dem Wert des linken Sohns vertauscht.
Die Heap-Eigenschaft muss für den linken Sohn wieder hergestellt werden.
wieder hergestellt ist. Zuerst wird die Wurzel mit dem kleineren Wert ihrer Söhne vertauscht,
in diesem Fall ist dies die 3 aus dem linken Teilbaum. Damit muss am rechten
Teilbaum nichts mehr geändert und nur noch der linke Teilbaum betrachtet werden. Der
Baum, der nach der ersten Vertauschung entsteht, ist in Abbildung 3.24 zu sehen.
Im linken Teilbaum werden wieder der Wert der Wurzel mit den Werten der Söhne
verglichen und anschließend wird die 6 mit der 5 ausgetauscht. Die Wiederherstellung der
Heap-Eigenschaft ist somit abgeschlossen und Abbildung 3.25 zeigt den resultierenden
Heap.
Abbildung 3.25.: Nach der zweiten Vertauschung ist die Heap-Eigenschaft wieder hergestellt.
Nun folgt wieder das Entfernen eines Wertes, die Wiederherstellung usw. bis der Heap
nur noch aus einem Element besteht. Im sequentiellen Fall läuft der Heap mit einer
Laufzeit von O(nlog(n)), da n mal die Heap-Eigenschaft wieder hergestellt werden muss
und das Wiederherstellen maximal log(n) Schritte benötigt.
57

Der Heap-Sort eignet sich zur Parallelisierung, da jeder Wert innerhalb des Heaps durch
einen Prozessor repräsentiert werden kann. Die Möglichkeiten zur Parallelisierungen und
wieviele Prozessoren wirklich benötigt werden, sollen im nächsten Abschnitt erläutert
werden.
3.2.1.2. Der Heap-Sort auf dem GCA
Der Heap-Sort kann auf dem GCA dadurch realisiert werden, dass jeder zu sortierende
Wert durch eine Zelle repräsentiert wird. Durch diese Realisierung werden O(n) Zellen
benötigt. Jede Zelle muss wissen, ob sie einen Blattknoten oder einen Wurzelknoten
repräsentiert. Der Knoten, der die Wurzel des gesamten Baums repräsentiert, muss dies
auch wissen, da er eine Sonderstellung hat.
In regelmässigen Abständen muss ein Wurzelknoten abfragen, ob er einen größeren Wert
besitzt, als seine Söhne. Da beim GCA nicht schreibend auf andere Zellen zugegriffen
werden darf, müssen auch die Söhne überprüfen, ob sie einerseits einen kleineren Wert
als ihr Vater haben und andererseits, ob ihr Wert kleiner ist als der Wert des anderen
Sohns der Wurzel. Ist einer der beiden Werte kleiner als der eigene, so muss ein
Sohnknoten nichts machen, ein Wurzelknoten hingegen erkennt dadurch, dass der Wert
getauscht werden muss. Ein Sohnknoten erkennt einen nötigen Tausch dadurch, dass er
bei allen Vergleichen den kleinsten Wert hat. Ein Sonderfall muss hier noch betrachtet
werden: Sind gleiche Werte innerhalb des Heaps erlaubt, so werden Zell-IDs eingeführt,
um festzustellen, welches der linke und welches der rechte Sohn einer Zelle ist. Zudem
kann dann eine Zelle feststellen, ob sie ein linker oder ein rechter Sohn ist. Hat nun eine
Sohnzelle den gleichen Wert wie die Wurzel, so wird deswegen nicht getauscht. Haben
beide Söhne den gleichen Wert und es muss getauscht werden, so wird immer der Wert
des linken Sohns genommen. In anderen Worten bedeutet das, dass eine Zelle, wenn sie
bei einem Vergleich feststellt, dass sie den gleichen Wert hat, nachprüft, ob der gleiche
Wert in einer Zelle mit niedriegerer ID steht. Ist dies der Fall, so ist der gleiche Wert
entweder in der Wurzel oder im linken Sohn und es muss nichts getan werden. Ansonsten
wird wie gewohnt verglichen, ob ein Tausch notwendig ist.
Für den Schritt des Vertauschens ist es wichtig, dass der GCA synchron arbeitet, denn
um die Werte zu tauschen, muss einerseits die Sohnzelle auf die Wurzelzelle und die
Wurzelzelle ihrerseits auf die Sohnzelle lesend zugreifen. Wenn bei diesem Schritt der
Automat nicht synchron arbeitet, ist einer der Werte bereits überschrieben, bevor die
andere Zelle ihn gelesen hat. Nach dem Vertauschen muss die Sohnzelle überprüfen,
ob sie ein Blatt ist oder ihrerseits wieder Söhne hat. Der Wert der Vaterzelle ist zu
diesem Zeitpunkt schon wieder abgreifbar. Eine Zelle muss sowohl Verbindungen zu
ihren Söhnen als auch zu ihrem Vater haben. Die Möglichkeiten den Heap auf dem GCA
darzustellen ist in Abbildung 3.26 zu sehen. Auffallend ist hierbei, dass die Wurzel-Zelle
des Heaps lesenden Zugriff auf alle Zellen hat, um die Vertauschungen durchzuführen,
die jeweils notwendig sind, um die Liste zu sortieren. Da der Heap hier in einer Form
verwendet wird, bei der es egal ist, dass die eingegebene Liste im Verlauf des Algorithmus
zerstört wird (wichtig ist nur, dass immer zum richtigen Zeitpunkt der jeweils kleinste
58

Abbildung 3.26.: Die Heap-Zellen des GCA kennen sowohl ihren Vater als auch ihre
Söhne, sowie ihre Nachbarn. Die Wurzel-Zelle des Heaps hat eine Verbindung
zu jeder Zelle, damit sie die Werte tauschen kann. Jede Zelle
weiß zudem, ob sie ein Blatt darstellt oder nicht.
Abbildung 3.27.: Der in den Heap eingelesene Vektor.
Wert in der Wurzel steht), reicht es, wenn die Wurzel die Werte liest und die Blattknoten
sich deaktivieren.
Die Synchronisation der Deaktivierungen kann wieder durch die Zell-ID erfolgen, indem
die Zellen aufsteigend in der Reihenfolge durchnummeriert werden, in der sie auch befüllt
werden. Zudem erhält jede Zelle das Wissen, wieviele Zellen es insgesamt im Heap gibt
und das Wissen, nach wievielen Takten ein Blatt deaktiviert wird. Die Zellen testen alle
parallel zur gleichen Zeit, ob sie die zu deaktivierende Zelle sind und dekrementieren dann
die maximale Anzahl an Zellen. Die Zelle, die festgestellt hat, dass sie deaktiviert werden
muss, tut dies dann auch. Eine Zelle, die vor dem deaktivieren ihre Söhne überprüfen
musste, kann leicht feststellen, ob dies auch nach der Deaktivierung notwendig ist, indem
sie die Nummer ihres Sohns mit der noch nicht dekrementierten Anzahl an maximalen
Zellen vergleicht. Ist der einzige Sohn die zu deaktivierende Zelle, so muss kein Vergleich
mehr durchgeführt werden, ansonsten läuft der Vergleich wie bereits beschrieben ab.
Der Ablauf des Heap-Algorithmus wird parallelisiert und im Folgenden anhand von
Graphiken erklärt. Damit das Beispiel aussagekräftig wird, muss ein größeres Beispiel
gewählt werden, da das vorherige Beispiel nicht deutlich machen würde, dass der Algorithmus
wirklich so funktioniert. Das Beispiel baut auf dem Vektor (7, 5, 10, 1, 3, 4, 9,
6, 12, 15, 2, 20, 22, 14) auf und wird in Abbildung 3.27 als Baum dargestellt.
59

Abbildung 3.28.: Der Heap nach Herstellung der Heap-Eigenschaft. Der Schritt der Herstellung
muss noch sequentiell erfolgen, mehrere Prozessoren können
dazu zwar verwendet werden, ermöglichen aber keine Laufzeitverbesserung.
Abbildung 3.29.: Der Eintrag der Wurzel wird mit dem letzten Eintrag getauscht. Der
letzte Eintrag wird für den weiteren Ablauf des Heap-Algorithmus ignoriert.
Die initiale Herstellung der Heap-Eigenschaft kann zwar parallel geschehen, aber eine
Verbesserung der Laufzeit ist nicht zu erwarten. Nach der Herstellung der Heap-
Eigenschaft sieht der Baum wie in Abbildung 3.28 aus.
Im nächsten Schritt wird nun der oberste Eintrag mit dem Eintrag der untersten Ebene,
welcher am weitesten rechts steht, vertauscht. In diesem Fall wird also die 1 mit der 14
getauscht. Dies wird in Abbildung 3.29 verdeutlicht.
Im nächsten Schritt muss die Wurzel ihren Wert mit den Werten ihrer Söhne vergleichen.
Da dies der Anfang des Algorithmus ist, müssen nur die Wurzel und ihre beiden Söhne
arbeiten, die restlichen Zellen sind inaktiv. Nach dem Vertauschen sieht der Baum wie in
Abbildung 3.30 aus. Nach der Vertauschung steht der kleinste Wert wieder in der Wurzel
des Baums, die Wurzel kann also wieder mit dem letzten Wert getauscht werden.
Im nächsten Schritt tauscht die Wurzel wieder ihren Wert mit dem letzten Wert und zeitgleich
führt der linke Sohn die Vertauschung aus, die nötig ist, um die Heap-Eigenschaft
wieder herstellen zu können. Der linke Sohn hat nach dieser Vertauschung den kleinsten
Wert des linken Teilbaums und kann im nächsten Schritt der Wurzel wieder zum
60

Abbildung 3.30.: Die Wurzel wurde vertauscht und der Vergleich mit den Söhnen fand
statt. In der Wurzel steht nun wieder der kleinste Wert des Baums.
Abbildung 3.31.: Die Wurzel wurde erneut vertauscht. Zeitgleich hat der linke Sohn seine
Ausgleichsfunktion ausgeführt und beinhaltet wieder den kleinsten Wert
dieses Teilbaums.
Vergleich dienen. In diesem Schritt sind also die Wurzel, ihr linker Sohn, sowie dessen
beiden Söhne beschäftigt. Verdeutlicht wird dieser Vorgang in Abbildung 3.31.
Nun muss sowohl die Wurzel wieder mit ihren Söhnen den Vergleich ausführen. Genauso
muss auch der zweite Knoten der dritten Ebene einen Vergleich mit seinen Söhnen
ausführen. Die Vergleiche können zeitgleich stattfinden und somit werden zwei Vertauschungen
in diesem Schritt ausgeführt. Nach dem Vertauschen hat die Wurzel wieder
den kleinsten Wert. Der resultierende Baum ist in Abbildung 3.32 zu sehen.
Der Algorithmus arbeitet nach dem selben Prinzip weiter. Ein letztes Beispiel soll Abbildung
3.33 liefern. In einem Schritt tauscht die Wurzel ihren Eintrag mit dem letzten Wert
und im nächsten wird dann die Vertauschung mit den Söhnen ausgeführt. Die anderen
Knoten verhalten sich in ihrer Ebene immer gleich. Die Ebenen mit gerader Nummer
prüfen im zweiten Takt, ob sie mit ihrem Vater tauschen müssen, und im dritten, ob ein
Tausch mit den Söhnen nötig ist. Ebenen mit einer ungeraden Nummer testen bei den
ungeraden Takten, ob ein Tausch mit dem Vater nötig ist, und in den geraden Takten
vergleichen sie ihren Wert mit dem ihrer Söhne.
Nach der Initialisierungs- und Herstellungsphase ermöglicht der parallele Heap-Sort nach
jedem zweiten Schritt das Entnehmen des kleinsten Werts. Der Heap-Sort muss n mal
61

Abbildung 3.32.: Die Wurzel hat wieder mit dem kleineren Wert ihrer Söhne getauscht.
Zeitgleich hat der zweite Knoten der dritte Ebene den Vergleich und
die Vertauschung mit seinen Söhnen durchgeführt.
Abbildung 3.33.: Die Wurzel wurde wieder mit dem letzten Element vertauscht, zeitgleich
hat der linke Sohn den Wert mit seinem linken Sohn getauscht.
den niedrigsten Wert liefern, bevor die gesamte Liste sortiert ist. Damit hat der Heap-
Sort eine Komplexität von O(n). Innerhalb dieser Zeitgrenze können auch die Initialisierung
sowie die anfängliche Herstellung der Heapeigenschaft erledigt werden.
Die Zelle, deren Wert in die Wurzel gelesen wird, nachdem der minimale Wert aus der
Wurzel ausgewertet wurde, muss sich nach dem Lesen deaktivieren. Wie dies ermöglicht
werden kann, wurde bereits beschrieben. Zudem muss diese Zelle bei ungeraden Takten
aus dem Vergleich ausgeklammert werden, da sonst ein Element eventuell doppelt im
Baum vorkommt und ein Element fälschlicherweise gelöscht wird. Durch die Parallelisierung
kann die Heap-Eigenschaft nicht mehr garantiert werden und der Algorithmus
funktioniert nur deshalb, weil die Heap-Eigenschaft anfangs hergestellt ist und die Wiederherstellung
von oben beginnt und somit der Wurzel recht schnell der nächste minimale
Wert zur Verfügung gestellt werden kann.
Diese Art der Realisierung benötigt unnötig viele Zellen, da die meisten Zellen einer
Ebene inaktiv sind und der Heap zudem verhältnismäßig schnell abgebaut wird.
Um Zellen zu sparen, können die Zellen einer Ebene zusammengefasst werden. Jede
Ebenen-Zelle beinhaltet dann eine Liste, welche die Werte beinhaltet, die auf einer Ebene
sind. Die einzige Zelle, welche eventuell zwei Aktionen in einem Takt durchführen müsste,
62

Abbildung 3.34.: Jede Zelle repräsentiert eine Ebene des Baums aus Abbildung 3.21. Die
Wurzel muss lesend auf alle Zellen zugreifen können.
ist die Zelle, welche die letzte Ebene repräsentiert, da diese zeitgleich in einen Vergleich
nach oben und eine Austauschaktion von der Wurzel verstrickt sein kann. Aber auch
wenn man für jede Vertauschungsaktion zwei Takte ansetzt, damit kein Konflikt entsteht,
verschlechtert sich die Komplexitätsklasse nicht.
Die Zelle, welche die letzte Ebene repräsentiert, muss dies wissen, damit sie sich entsprechend
verhält. Unbelegte Plätze werden in dieser Zelle durch ein x gekennzeichnet und
wenn die Wurzel sich den letzten Wert geholt hat, muss dieser aus der Liste gelöscht
werden. Sind alle Werte der Zelle auf x, so geht sie in den inaktiven Modus. Die Zelle der
darüberliegenden Ebene erkennt nun, dass sie die letzte Ebene repräsentiert und verhält
sich dementsprechend. Wenn die Wurzel die letzte Ebene ist, dann ist der Algorithmus
beendet. Eine Möglichkeit, die Zellen die Ebenen des Baums darstellen zu lassen, ist in
Abbildung 3.34 gegeben.
Zu klären ist noch, wie der Nachbar, der Vater und die Söhne eines Werts der Zelle
identifiziert werden können. Rechnet man nach, welchen Wert der j-te Wert der i-ten
Ebene repräsentiert, so stellt man fest, dass er genau den (2 i−1 + (j − 1))-ten Wert
im gesamten Baum repräsentiert. Innerhalb eines Baums, dessen Werte von 1 bis n
nummeriert werden, hat der i-te Wert seine Söhne an der (2 ∗ i)-ten und der (2 ∗ i + 1)-
ten Stelle. Die Zelle muss zum Ausrechnen der Stelle des Vaters eines Werts nur die Stelle
des zu vergleichenden Werts durch zwei teilen und abrunden und hat somit die Position
des Vaters bestimmt. Die Stellen der Söhne bestimmen sich dadurch, dass die Stelle mal
zwei für den einen Sohn und mal zwei und plus eins für den zweiten Sohn genommen
wird. Natürlich benötigt die Zelle auch das Wissen darüber, ob der Wert überhaupt
einen Vater bzw. Söhne hat. Dazu dient die Information über die Ebene und die Blatt-
Einträge, die für jeden Wert angeben, ob er ein Blatt repräsentiert. Der Nachbar wird
abhängig davon, ob der Wert selber an einer geraden oder einer ungeraden Stelle steht,
gefunden: Der Nachbar eines Werts an einer ungeraden Stelle steht rechts vom Wert,
ansonsten links.
Soll der Heap am Ende eine sortierte Liste liefern und nicht wie hier nur regelmäßig
die kleinste Kante zur Abfrage bereitstellen, benötigt jede Zelle zudem einen Zähler,
welcher ihrer Werte für den Heap noch betrachtet werden. Die Zelle der letzten Ebene
63

muss dann auch dafür sorgen, dass ihr letzter Wert nicht nur gelesen wird, sondern auch
der Wert der Wurzel an diese Stelle geschrieben und der Zähler der zu beachtenden
Werte um eins erniedrigt wird. Da jedes Datum einmal zurückgeliefert werden muss,
kann die Laufzeit nicht besser werden. Allerdings wird das Wiederherstellen des Heaps
parallel zu der Ausgabe der Kanten ausgeführt und kann somit für den Algorithmus
als konstant angesehen werden. Der Heap-Sort benötigt demnach auf dem GCA eine
Laufzeit von O(n).
Möchte man nun den Heap-Sort wieder in das in Kapitel 2.3.4 vorgestellte Schema
einordnen, so sind vorher ein paar Design-Entscheidungen zu treffen:
Es wird davon ausgegangen, dass eine Sohnzelle ihren Status (letzte Ebene oder nicht)
daran feststellen kann, dass die Verbindung zu ihrem Sohn inaktiv ist. Die Daten sind
also abhängig von der eigenen Verbindung.
Innerhalb der Zelle der letzten Ebene wird abhängig von der Zeit jeweils ein anderes
Datum von der obersten Ebene ausgelesen. Dieses Datum wird anschließend von der
Zelle auf x gesetzt und somit ignoriert. Die Daten sind also abhängig von der Zeit.
Die Vertauschungen innerhalb des Heaps sind abhängig von den Daten der eigenen und
der Vater- bzw. Sohnzelle. Da eine Vertauschung eine Veränderung der Daten bedeutet,
ergibt sich hier eine Abhängigkeit der Daten von den eigenen Daten sowie der Daten der
Nachbar-Zellen.
Der Status ist implizit abhängig von dem Ort der Zelle. Allerdings wird der Status
geschickter durch die Verbindung getestet, dann kann die Zelle sich an einem beliebigem
Ort innerhalb des GCA befinden. Aus diesem Grund sind die Daten nicht ortsabhängig.
Die Verbindung der eigenen Zelle sind von den Verbindungen der Nachbar-Zellen abhängig.
So setzt eine Zelle ihre eigene Sohn-Verbindung auf inaktiv, wenn der Sohn seine Verbindung
zum Vater auf inaktiv gesetzt hat. Die Verbindung ist also abhängig von der
Verbindung des Sohns, allerdings nicht von der eigenen Verbindung.
Wurde das letzte Datum aus der Zelle ausgelesen (alle Werte sind auf x), so wird die
Verbindung zum Vaterknoten deaktiviert. Die Verbindung ist damit abhängig von den
eigenen Daten.
Die oberste Ebene nimmt innerhalb des Heap-Sorts eine Sonderstellung ein, da sie auf
alle Kanten lesend zugreifen muss. Diese Verbindungen werden mit der Zeit verändert,
es wird nacheinander auf verschiedene Zellen (entspr. Ebenen) lesend zugegriffen. Da
diese Veränderung nur die Vaterzelle betrifft, welcher eine besondere Position hat, ist
die Veränderung der Verbindungen abhängig von dem eigenen Ort innerhalb des GCA.
Zusätzlich ergibt sich hier eine Abhängigkeit der Verbindungen der Zelle von der Zeit.
Mit Hilfe dieser Betrachtungen ergeben sich folgende Abhängigkeitsfunktionen:
d’= f(t,p,d,d*) und p’ = g(t,l,p*,d).
64

3.2.1.3. Der Kruskal auf dem GCA
Die Hauptarbeit des Kruskals, das Sortieren der Kanten nach ihrem Kantengewicht, wurde
im vorherigen Abschnitt erklärt. Nun gilt es noch, die Wälderverwaltung geschickt auf
dem GCA zu modellieren. Prinzipiell kann diese Verwaltung in einem Vektor geschehen,
in dem für jeden Knoten die Nummer steht, welche den Wald repräsentiert, zu dem der
Knoten gehört. Allerdings muss dann immer dafür gesorgt werden, dass eine neu aufgenommene
Kante auch dazu führt, dass die ganze Liste aktualisiert wird, da alle Knoten
eines Waldes den gleichen Repräsentanten haben müssen. Dies würde im ungünstigsten
Fall O(n) Schritte benötigen, weshalb anzuraten ist, sich Gedanken darüber zu machen,
wie diese Information geschickter abgespeichert werden kann.
Wird jeder Knoten durch eine Zelle repräsentiert, so kann dafür gesorgt werden, dass er
eine Verbindung zu allen Knoten herstellt, die zum gleichen Wald wie er gehören. Wird
dann der Wert eines Knoten des Waldes geändert, da zwei Wälder zusammengefasst
wurden, stellen alle benachbarten Zellen dies fest und übernehmen die Veränderung.
Diese Art der Verwaltung ist sehr verbindungsaufwendig, da im schlimmsten Fall jede
einen Knoten repräsentierende Zelle eine Verbindung zu anderen Zellen der gleichen Art
benötigt. Dies ergibt einen Bedarf von n 2 Leitungen allein für die Informationsverwaltung.
Wie beim Warshall-Algorithmus bietet sich hier jedoch ein Bus an, um das Problem zu
umgehen. Jeder Knoten speichert für sich nur, zu welchem Wald er gehört. Muss dieser
Wert geändert werden, so wird auf den Bus einerseits der Wert i gelegt, der geändert
werden soll, und andererseits der neue Wert j, auf den der Wert i gesetzt werden soll.
Somit kann man mit einem Bus der Größe 2∗log 2 (n) auskommen, wobei n die Anzahl der
Knoten beschreibt. Jeder Knoten braucht ebensoviele Leitungen, mit denen er lesend auf
den Bus zugreifen kann. Zudem benötigt man noch eine Zelle, welche den eigentlichen
Kruskal ausführt und somit schreibend auf den Bus und lesend auf alle Informationszellen
zugreifen können muss.
Hat diese Zelle sich eine Kante von der Wurzelzelle des Heaps geholt, so liest sie die
Werte der beiden beteiligten Knoten aus. Sind die die Nummern des Waldes, zu dem
die Knoten gehören, gleich, so wird die Kante verworfen. Ansonsten wird die größere
der beiden Nummern durch die kleinere ersetzt, indem auf die oberen log 2 (n) Leitungen
des Busses der größere und auf die unteren log 2 (n) Leitungen der kleinere Wert gelegt
wird. Im nächsten Takt aktualisieren sich dann alle Zellen, die zum Wald des größeren
Wertes gehören. Innerhalb dieses Takts liest die rechnende Zelle die nächste Kante.
Dieser Vorgang wird solange wiederholt, bis entweder nur noch ein Baum vorhanden ist
oder keine Kanten mehr vorhanden sind (Wurzel des Heaps auf inaktiv gesetzt). Um
festzustellen, ob alle Knoten verbunden sind, muss die rechnende Zelle nur einen Zähler
mitführen, der jedes Mal inkrementiert wird, wenn eine Kante aufgenommen wird. Ein
Baum mit n Knoten hat genau n − 1 Kanten und demnach kann aufgehört werden,
wenn diese n − 1 Kanten gefunden wurden. Der schematisierte Aufbau des Kruskals ist
in Abbildung 3.35 zu sehen.
Mit der Parallelisierung des Kruskals kann eine Verbesserung der Laufzeit von
65

Abbildung 3.35.: Die rechnende Zelle des Kruskal braucht schreibenden Zugriff auf den
Bus und lesenden Zugriff auf alle Zellen, die Knoten repräsentieren als
auch auf die Wurzel der Heap-Zellen.
O(|E|log(|E|)) auf O(|E|) erreicht werden. Allerdings ist die wirkliche Laufzeit des Kruskal
direkt vom aktuellen Problem abhängig, da nicht nötigerweise alle Kanten überprüft
werden müssen. Die benötigten Zellen des Heap-Algorithmus sind abhängig von der Anzahl
der Kanten, da diese sortiert werden. Um die Laufzeitverbesserung zu erreichen,
wurden log 2 (|E|) Zellen für den Heap sowie |V |+1 Zellen für den Kruskal und die Informationsverwaltung
investiert. Der Heap benötigt 3 ∗ (log 2 (|E|) − 1) − 1 unidirektionale
Verbindungen 11 und der eigentliche Kruskal noch einmal (2 ∗ log 2 (|V |) ∗ |V |) + (|V | + 1)
unidirektionale Verbindungen sowie einen Bus der Breite 2 ∗ log 2 (|V |).
Ist es nicht nötig, dass die Kruskal-Zelle im nächsten Schritt ihre Werte schon wieder
überschreiben kann, ist ein Bus nicht notwendig. Die Kruskal-Zelle legt ihren Wert nicht
mehr auf den Bus, sondern jede Knoten-Zelle hat eine Verbindung zur Kruskal-Zelle und
fragt direkt dort die Änderungen ab. Um zu vermeiden, dass ungültige Daten abgefragt
werden, wird ein Valid-Bit eingeführt, welches dafür sorgt, dass nur gültige Daten abgeholt
werden. Die Kruskal-Zelle schreibt nun den zu ändernden Wert in die Variable
Change und den Wert, durch den ersetzt wird, in die Variable Keep. Jede Knoten-Zelle,
deren Waldnummer mit dem Wert aus Change übereinstimmt, setzt diesen nun auf den
Wert aus Keep. Damit kann ein Takt gespart werden, in dem sonst die Kruskal-Zelle
auf den Bus geschrieben hätte. Da alle Zellen nur lesenden Zugriff auf die Kruskal-Zelle
erhalten, entstehen bei diesem Vorgehen keine Konflikte. Der Aufbau wird in 3.36 veranschaulicht.
Wenn es wie im Fall des Warshall-Algorithmus keine ausgezeichnete Zelle gibt, auf die
alle Zellen lesend zugreifen können, dann muss eine Extra-Zelle genutzt werden, die
11 Zwischen allen Ebenen des Baumes wird eine Verbindung nach oben und eine nach unten benötigt.
Bei log 2 (|E|) Ebenen sind dies 2∗log 2 (|E|)−2 Verbindungen. Zudem wird noch eine Verbindung von
der Wurzelzelle zu allen anderen Zellen benötigt; dies sind noch einmal log 2 (|E|) − 2 Verbindungen.
66

Abbildung 3.36.: Die rechnende Zelle des Kruskal braucht lesenden Zugriff auf alle Zellen,
die Knoten repräsentieren, sowie die Wurzel der Heap-Zellen. Die
Knoten-Zellen holen sich die Werte Valid, Change und Keep von der
Kruskal-Zelle und wissen dann, ob ihre Variable Waldnr. geändert werden
muss.
Abbildung 3.37.: Die rechnende Zelle des Kruskal braucht lesenden Zugriff auf alle Zellen,
die Knoten repräsentieren, sowie die Wurzel der Heap-Zellen. Die
Bus-Zelle holt die Werte Valid, Change und Keep von der Kruskal-
Zelle und speichert diese. Die Knoten-Zellen können dann diese Werte
aus der Bus-Zelle auslesen.
den Bus ersetzt. Die Extra-Zelle hat lesenden Zugriff auf jede Zelle, die im Laufe der
Berechnungen einen Wert bereitstellt. Im Beispiel des Kruskal-Algorithmus betrifft dies
nur die eine Zelle und solch ein Aufbau sähe wie in 3.37 aus. Die Bus-Zelle holt den Wert
67

von der betreffenden Zelle ab und alle Zellen, welche auf diesen Wert zugreifen müssen,
können den Wert dann bei dieser Zelle auslesen. Der Aufbau spart im Falle des Kruskal
keine Leitungen ein, sondern im Vergleich mit dem oben beschriebenen Aufbau werden
sogar mehr Leitungen benötigt, da die Bus-Zelle lesend auf die Kruskal-Zelle zugreifen
muss.
Betrachtet man aber als Vergleich den Warshall-Algorithmus, so würde bei einer lesenden
Verbindung von jeder der n Zellen zu jeder Zelle mit n Leitungen insgesamt (n − 1) ∗ n 2
Leitungen benötigt. Im Aufbau mit der Bus-Zelle benötigt man allerdings nur von jeder
der n Zellen n Leitungen zum lesenden Zugriff auf die Bus-Zelle und n Leitungen von
der Bus-Zelle zu jeder anderen Zelle. Insgesamt sind dies dann (n+1) ∗n Leitungen und
es ergibt sich eine Ersparnis um den Faktor n.
Die Komplexität eines Algorithmus wird sich bei der Verwendung der Bus-Zelle gegenüber
dem Bus nicht ändern, da die gleiche Anzahl an Schritten wie bei der Verwendung
des Busses benötigt werden. Der einzige Unterschied besteht darin, dass auf
den Bus etwas geschrieben werden muss, während die Bus-Zelle sich aktiv den aktuellen
Wert holt.
Je nach Aufgabenstellung und Aufbau kann eine der beiden Lösungen Vorteile gegenüber
der anderen haben. Die Verwendung der Bus-Zelle abstrahiert das Verbindungsnetzwerk
und passt somit eventuell besser in das Modell des GCA. Im Prinzip wurden die gleichen
Überlegungen wie in Kapitel 3.1.3.4.1 angestellt, bloß dass hier versucht wird, den Bus
einzusparen, ohne dabei mehr Leitungen zu benötigen.
Die Einordnung des Algorithmus in das in Kapitel 2.3.4 vorgestellte Schema bedarf in
dem Fall des Kruskals (Heap-Sort wurde bereits getrennt betrachtet) nur noch einer
Betrachtung der Daten. Die Verbindungen sind in der Lösung statisch und somit ist für
diese die Funktion p’ = g().
Die Daten der einzelnen Zellen sind sowohl von den Daten der eigenen Zelle als auch von
den Daten der Nachbar-Zellen abhängig. So ist die Kruskal-Zelle auf die oberste Zelle
des Heaps angewiesen, dass sie von dort die Daten erhält. Gleichzeitig benötigt sie auch
die Daten der Knoten-Zellen um festzustellen, ob zwei Wälder verbunden werden oder
ein Zyklus entsteht.
Von der eigenen Position oder der Zeit sind die Daten nicht abhängig. Auch von den
Verbindungen an sich sind die Daten nicht abhängig.
Es ergibt sich also als Funktion für die Daten: d’ = f(d,d*).
3.2.2. Modifikation des Hirschberg für minimal aufspannende
Bäume
Der Hirschberg bestimmt die zusammenhängenden Komponenten für einen Graphen, indem
er die Knoten als eine Menge von Wäldern auffasst und die Kanten sucht, die Wälder
verbinden. Der Algorithmus leistet also im Grunde schon das Geforderte. Allerdings werden
momentan noch nicht die verwendeten Kanten gespeichert und auch die Auswahl
68

geschieht noch nicht nach der minimalen Kantenwertung. Um dies zu ermöglichen, muss
einerseits der Matrix erlaubt werden, auch Werte größer als eins zu speichern 12 . Andererseits
muss dafür gesorgt werden, dass die verwendeten Kanten gespeichert werden.
Um die Kanten zu speichern, muss man zuerst betrachten, nach welchem Schritt die
Kanten feststehen und wieviele und welche Informationen bis dahin verloren gegangen
sind.
Als erstes stellt man fest, dass nach dem zweiten Teilschritt die Wahl der Kanten abgeschlossen
ist. Die darauf folgenden Teilschritte drei bis fünf dienen dazu, die Komponenten
zusammenzufassen. Nach dem zweiten Teilschritt können also die Kanten in die
Kantenliste des minimalen aufspannenden Baum aufgenommen werden. Um diese Kanten
korrekt aufzunehmen, muss nun noch betrachtet werden, welche Informationen im
Original-Hirschberg-Algorithmus in den ersten beiden Teilschritten verloren gehen. Falls
diese Informationen für die minimal aufspannenden Bäume wichtig sind, so müssen sie
geeignet gesichert werden 13 . Anzumerken ist hier, dass der Algorithmus, falls der Graph
nicht zusammenhängt, keinen minimalen aufspannenden Baum, sondern einen Wald von
minimal aufspannenden Bäumen findet. Eine offensichtliche Veränderung ist, dass nun
nicht mehr die Kante zur Komponente mit der geringsten Nummer gesucht wird, sondern
die Kante zu einer benachbarten Komponente, welche die geringste Kantenwertung
hat.
Im ersten Teilschritt wählt jeder Knoten eine Kante zu einer benachbarten Komponente
und speichert die Nummer der Komponente ab. Der Knoten, zu dem die Kante führt,
geht dabei verloren. Um später auf den Ziel-Knoten der Kante zugreifen zu können,
muss dieser abgespeichert werden. Somit steht der Ziel-Knoten beim zweiten Teilschritt
als Information zur Verfügung. Auch wenn diese Information nur für die Kanten wichtig
ist, ist sie essentiell, da ohne die korrekten Kanten kein minimal aufspannender Baum
gebildet werden kann.
Im zweiten Teilschritt wird nun für jede Komponente die Kante mit der geringsten
Wertung gesucht und für die weiteren Teilschritte verwendet. Die verwendete Kante
wird zum Repräsentanten der Komponente umgebogen. In diesem Schritt geht also die
Information verloren, von welchem Knoten die Kante ursprünglich ausging. Auch diese
Information muss gespeichert werden.
Damit sind alle nötigen Informationen gesichert, es bleibt nur noch das Problem, dass
beim zweiten Schritt pro neuer Komponente auch ein Zyklus der Länge zwei entsteht,
welcher natürlich nicht in den minimal aufspannenden Baum aufgenommen werden darf.
Dieser Zyklus muss erkannt werden und die diesen Zyklus auslösende Kante 14 darf nur
12 Um Konflikte zu vermeiden, wird hier davon ausgegangen, dass alle Werte positiv sind. Da in den
meisten Fällen minimale Kosten für irgendwelche Aktionen gesucht werden und die Kosten dabei
nicht negativ werden können, ist dies eine gerechtfertigte Annahme.
13 In [GR98] wird die Theorie hinter den Modifikationen erklärt, aber welche Modifikationen explizit
wirklich nötig sind, wird nicht erwähnt. Die hier vorgestellten Aktionen werden dort unter ”
housekeeping“
zusammengefasst.
14 Der Zyklus entsteht dadurch, dass zwei Komponenten die gleiche Kante wählen und sie somit im
gerichteten Graphen des ersten Teilschritts in jede Richtung einmal verwendet wird.
69

einmal aufgenommen werden. Um diesen Zyklus zu finden, kann man die bereits gespeicherten
Informationen nutzen. So ist der Nachfolger des Nachfolgers eines Knotens dieses
Zykluses immer wieder der Knoten selber. Es gilt also für jeden Knoten i eines solchen
Zyklus, dass T[T[i]]=i ist. Natürlich kann man argumentieren, dass es mehr als eine minimale
Kante zwischen den beiden Komponenten geben kann. In diesem Fall wäre nicht
sicher, dass beide Komponenten wirklich die gleiche Kante gewählt haben. Allerdings
darf auch in diesem Fall nur eine von beiden Kanten genutzt werden, da sonst ein Zyklus
entsteht und der entstehende Graph kein Baum mehr ist. Da beide Kanten minimal
sind, ist es egal, welche Kante weiter verwendet und welche verworfen wird. An dieser
Stelle entsteht ein Indeterminismus, der sich aber in einer konkreten Implementierung
aufgrund der dort verwendeten Auswahlkriterien nicht mehr auftritt.
Im Weiterem wird erst ein Beispiel für die Berechnung von minimalen aufspannenden
Bäumen mit Hilfe des Hirschberg-Algorithmus gegeben und dann wird gezeigt, dass die
nötigen Informationen auch auf dem GCA gespeichert und verwendet werden können.
Beispiel Für dieses Beispiel wird das Beispiel aus Kapitel 3.1.3.1 dahingehend geändert,
dass es einerseits gewichtet ist (d. h. jede Kante hat zusätzlich ein Gewicht, welches die
Kosten ausdrückt) und andererseits noch Kanten hinzugenommen werden, damit der
Graph nicht schon an sich ein minimal aufspannender Baum ist. Als Beispiel soll also
der von der Matrix
⎛
C =
⎜
⎝
0 3 0 1 5 0 0 0
3 0 1 2 0 0 2 0
0 1 0 0 1 1 2 0
1 2 0 0 0 0 0 1
5 0 1 0 0 0 0 0
0 0 1 0 0 0 0 0
0 2 2 0 0 0 0 2
0 0 0 1 0 0 2 0
beschriebene Graph dienen. Gezeichnet gestaltet sich der Graph wie in Abbildung 3.38.
⎞
⎟
⎠
Da der Ablauf des Algorithmus von Hirschberg bereits früher in dieser Arbeit erklärt
wurde, beschränke ich mich hier auf die Erklärung und Abbildung des ersten und zweiten
Teilschritts jedes Durchlaufs. Diese beiden Teilschritte sind immerhin für die Bestimmung
des minimalen aufspannenden Baums ausschlaggebend.
Abbildung 3.39 repräsentiert den Graphen nach dem Ablauf des ersten Schritts. Abweichend
von den Abbildungen in Kapitel 3.1.3.1 werden hier alle Kanten beibehalten
und die von den Knoten gewählten Kanten werden dadurch gekennzeichnet, dass sie
gestrichelt und gerichtet dargestellt werden. Da in diesem Schritt jeder Knoten noch
eine Komponente darstellt, werden diese Kanten alle genommen. Die doppelt genutzten
Kanten von 0 nach 3 und von 1 nach 2 werden nur einmal in den resultierenden Graphen
aufgenommen. Nach dem zweiten Schritt ergibt sich also der Graph aus Abbildung 3.40.
70

Abbildung 3.38.: Dieser ungerichtete Graph verfügt sowohl über Zyklen als auch über unterschiedliche
Kantenwertungen. Anhand dieses Graphen soll im weiteren
der Algorithmus verdeutlicht werden.
Abbildung 3.39.: Jeder Knoten hat sich die Kante mit der minimalen Kantenwertung
ausgewählt. Wenn mehrere solcher Kanten existieren, wird die zum
Knoten mit der kleinsten Nummer gewählt.
Die in den minimalen Spannbaum aufgenommenen Kanten sind dick und ungerichtet
dargestellt. In den nachfolgenden Teilschritten werden nun die Knoten 0, 3 und 7 sowie
die Knoten 1, 2, 4, 5 und 6 zu Komponenten zusammengefasst und für den Algorithmus
auch entsprechend gekennzeichnet.
Im ersten Teilschritt des zweiten Durchgangs wird dann von jedem Knoten eine Kante
mit minimaler Kantenwertung zu der anderen Komponente gesucht. Es entsteht der
Graph aus Abbildung 3.41. Die im vorhergehenden Durchgang gefundenen Baumkanten
sind weiterhin dick, die neu gewählten Kanten sind wieder gestrichelt dargestellt.
Nun sucht jede Komponente die von ihr ausgehende Kante mit der minimalen Wertung.
Bei diesem Beispiel könnte es zu dem weiter vorne beschriebenen Problem kommen, da es
denkbar ist, dass die erste Komponente die Kante (3,1) und die zweite Komponente die
71

Abbildung 3.40.: Nach dem zweiten Teilschritt sind die Kanten bereits in den minimalen
Spannbaum aufgenommen. Dabei wurde darauf geachtet, dass doppelt
benutzte Kanten nur einfach aufgenommen werden. Die Kanten, die
schon sicher im minimal aufspannenden Baum enthalten sind, sind
hier durch dicke Linien gekennzeichnet.
Abbildung 3.41.: Nach dem ersten Teilschritt des zweiten Durchlaufs sind wieder von jedem
Knoten eine Kante zu einer benachbarten Komponente ausgewählt
worden. Da Knoten 5 und 2 über keine Verbindung zu der anderen
Komponente verfügen, wählen sie sich keine Kante. Die bereits im minimal
aufspannenden Baum enthaltenen Kanten sind dick dargestellt,
die neu gewählten Kanten wieder gestrichelt und gerichtet.
Kante(6,7) wählt. In der praktischen Realisierung ist dies jedoch eher unwahrscheinlich,
nimmt man doch in der Regel immer den ersten Wert, den man findet, außer es lässt
sich ein kleinerer finden. Dem folgend gehen wir auch hier davon aus, dass die Kante
gewählt wird, die von dem kleineren Knoten ausgeht. Abbildung 3.42 repräsentiert den
Graphen nach dem Ablauf des zweiten Teilschritts des zweiten Durchlaufs. Auch hier
sind wieder alle Baumkanten dick dargestellt und es ist ersichtlich, dass der minimale
72

aufspannende Baum gefunden wurde. Da der Graph am Ende des zweiten Durchlaufs
auch nur noch über eine Komponente verfügt, wird sich im dritten und finalen Durchlauf
nichts mehr ändern. Es werden also keine Kanten mehr in den minimalen aufspannenden
Baum aufgenommen und Abbildung 3.42 repräsentiert das Endergbnis des Algorithmus,
wobei nur die dicken Kanten die Ausgabe darstellen.
Abbildung 3.42.: Dieser Graph repräsentiert nicht nur das Teilergebnis nach dem zweiten
Schritt des zweiten Durchlaufs, sondern er stellt auch gleichzeitig
das Endergebnis dar. Alle dick dargestellten Kanten gehören zum minimal
aufspannenden Baum und werden als Ergebnis zurückgegeben.
3.2.2.1. Realisierung auf dem GCA
Der erste Schritt zur Modifikation ist die Eingabe eines gewichteten Graphen, was aber
kein Problem darstellt, da man nur innerhalb der Matrix auch Werte größer eins erlauben
muss. Der GCA unterliegt in dieser Richtung keinerlei Beschränkung und diese
Modifikation kann einfach übernommen werden. Jede Zelle (außer der Speicherzelle)
beinhaltet weiterhin eine Zeile der Matrix. Eine weitere Modifikation ist, dass nicht
mehr nach der Kante zu dem Nachbarn mit dem kleinsten Knoten, sondern nach der
Kante mit der kleinsten Wertung zur anderen Komponente gesucht wird. Dies ist eine
algorithmische Änderung, die keine Veränderungen im Aufbau des GCA, sondern nur
im darauf ablaufenden Programm, bedingt.
Des weiteren muss im ersten Schritt gespeichert werden, wohin die gewählte Kante führt.
Dieser Wert kann ohne Anfrage bei der Speicherzelle gefunden werden, da einfach die
Stelle des gewählten Werts in der Zeile gespeichert werden muss. Im vorher vorgestellten
Beispiel wird dabei von 0 beginnend gezählt (also 0,1,...,i-1). Zusätzlich sollte gespeichert
werden, welche Kosten die gewählte Kante hat. Um im zweiten Schritt auf diese Werte
zugreifen zu können, werden sie mit in die Speicherzelle übernommen.
Auch im zweiten Schritt darf nicht mehr nach der kleinsten Knotennummer ausgewählt
werden, sondern es muss eine Selektion nach der kleinsten Kantenwertung geschehen.
73

Dabei muss wieder mitgespeichert werden, welcher Knoten eigentlich die Kante ausgewählt
hat. Ist dies geschehen, so kann die Kante in den minimal aufspannenden Baum
aufgenommen werden. Stellt man sich nun vor, dass die Speicherzelle am Ende den minimal
aufspannenden Baum enthält, so erscheint es sinnvoll, dort die Kanten entweder
als Tripel (i,j,k) mit i = Startknoten, j = Zielknoten und k = Kantenwertung oder als
Matrix zu speichern. Für den Fall, dass die Tripel verwendet werden, sollte das Ergebnis
als Menge von ungerichteten Kanten interpretiert werden. Eine Zelle kann nun mit dem
Wissen, welcher Knoten die Kante ausgewählt hat, bei der Speicherzelle sowohl das Ziel
der Kante als auch deren Wert abfragen. Anschließend kann das Ergebnis von der Speicherzelle
ausgelesen und geeignet abgespeichert werden. Bei diesem Algorithmus wird
beibehalten, dass der Knoten mit der kleinsten Nummer der Repräsentant der Gruppe
ist. Die Kante, die von dem Repräsentanten der neu entstandenen Komponente ausgeht,
muss nun noch entfernt werden, damit keine Zyklen entstehen. Dieser Schritt erspart
die Zyklendetektion, bewirkt aber, dass die Kanten erst nach dem fünften Teilschritt
endgültig feststehen. Um zu sehen, dass dieses Vorgehen auch zum Erfolg führt, muss
man sich verdeutlichen, dass am Ende des zweiten Schritts immer der neue Repräsentant
der nach dem fünften Schritt entstehenden Komponente in den Zyklus involviert ist.
Die Modifikationen, die am Algorithmus vorgenommen wurden, ändern weder etwas an
der Laufzeitkomplexität noch an der Anzahl der benötigten Zellen. Es ist also möglich,
den minimal aufspannenden Baum eines ungerichteten, gewerteten Graphen in O(log(n) 2 )
mit O(
n 2
log(n) 2 ) Zellen finden.
Auch bei dem modifizierten Algorithmus von Hirschberg ändert sich (wie beim Floyd-
Warshall-Algorithmus gegenüber dem Warshall-Algorithmus) nichts an der Einordnung
in das Schema aus Kapitel 2.3.4. Die Abhängigkeit der Funktionen lässt sich also weiterhin
ausdrücken mit: d’ = f(d,d*) und p’ = g().
3.2.3. Derzeitiger Forschungsstand
Momentan gibt es zwei Algorithmen, welche die benötigte Laufzeitkomplexität zum Auffinden
des minimalen aufspannenden Baum noch weiter verbessern. Dabei ist anzumerken,
dass alle vorgestellten Algorithmen auf einer EREW P-RAM laufen und deshalb
größeren Restriktionen als auf einer CRCW P-RAM unterliegen. Da das EREW und
das CREW Prinzip eher die Möglichkeiten des GCA widerspiegeln, wird hier darauf
verzichtet, Algorithmen auf der CRCW P-RAM vorzustellen.
Donald Johnson und Panagiotis Metaxas stellen in [JM92] einen Algorithmus vor, der
mit einer Laufzeit von O(log(|E|) 3 2 ) bei einer Verwendung von |E|+|V | Prozessoren auskommt.
Dieser Algorithmus wird als bahnbrechend betrachtet, da vorher die Meinung
vertreten wurde, dass der minimale aufspannende Baum auf einer EREW P-RAM in
schnellstens O(log(|E|) 2 ) gefunden werden kann. Mit dem Algorithmus wurde das Gegenteil
bewiesen und Ka Wong Chong, Yijie Han und Tak Wah Lam schafften es sogar
in [CHL99] einen Algorithmus anzugeben, der in O(log(|E|)) das Ergebnis findet und
dabei nur O(|E| + |V |) Prozessoren verwendet.
74

Bei beiden Algorithmen ist die Angabe der Laufzeit kritisch zu betrachten, da die Autoren
mehr Sorgfalt darauf verwendet haben, die Korrektheit der Algorithmen als die
Korrektheit der Laufzeit zu beweisen 15 . Davon abgesehen, bieten die Algorithmen gute
Ansätze zum Bestimmen des minimal aufspannenden Baums, weshalb sie kurz in ihrer
Funktionalität vorgestellt werden sollen.
Der Algorithmus von Johnson und Metaxas startet wie der Kruskal und der Hirschberg
mit einer Menge von Wäldern, die jeweils aus genau einem Knoten bestehen. Im
Gegensatz zum Hirschberg arbeitet der Algorithmus allerdings nicht mit einer Adjazenzmatrix,
sondern mit Adjazenzlisten, d. h. jeder Knoten kennt explizit seine Nachfolger.
Damit entfällt die Suche nach Nachbarn. Entweder ist die Liste leer, dann existiert kein
Nachbar√mehr, oder man entnimmt das erste Element der Liste. Der Algorithmus setzt
sich aus log(n) Phasen zusammen. Jede Phase fasst dabei Wälder weiter zusammen, so
√
log(n)∗(i+1)
dass nach Beendigung der i-ten Phase jeder Wald, falls möglich, mindestens 2
Knoten beinhaltet. Beim Zusammenfügen von zwei Wäldern werden zwei wichtige Operationen
durchgeführt:
• Die Adjazenzlisten der beiden zusammengefassten Wälder werden zusammengefasst.
Verwendet man hierfür Mergesort 16 , so erhält man am Ende wieder eine
sortierte Adjazenzliste.
• Jede Kante (u,v) innerhalb der Adjazenzliste wird umbenannt in (p(u),p(v)), wobei
p(u) und p(v) den Repräsentanten der Gruppen von u bzw. v bezeichnet. Interne
Kanten (gleicher Start- und Endknoten) werden entfernt.
Aufgrund dieser Verwaltungsarbeiten gelingt es, dass der Algorithmus schneller abläuft
als die bis dahin bekannten Algorithmen auf der EREW P-RAM.
Die Autoren von [CHL99] erweitern diesen Algorithmus noch in der Weise, dass die
Phasen parallel ablaufen. Dazu startet Phase i, sobald Phase ⌈ i ⌉ abgeschlossen ist und
2
beginnt, schon einmal eine Vorauswahl zu treffen. Jede Phase, die danach beendet wird,
sorgt dafür, dass diese Vorauswahl verfeinert und an das Endergebnis angenähert werden
kann. Mit Hilfe dieser Parallelisierung schaffen es die Autoren, dass der Algorithmus
einen minimal aufspannenden Baum in O(⌊log(n)⌋) bestimmt.
3.3. NP-vollständige Probleme
In die Klasse NP fallen diejenigen Probleme, für die man zwar auf einer nichtdeterministischen
Turingmaschine einen Lösungsalgorithmus in polynomieller Zeit gefunden
15 Die Autoren schätzen z. B. an einer Stelle den Aufwand einer Aktion in einem Baum mit n Knoten
und m Kanten mit O(log(m)) ab und fassen dies dann in O(log(n)) zusammen. Diese Aussage ist
richtig, wenn man betrachtet, dass ein Graph mit n Knoten maximal n 2 Kanten hat, allerdings
werden die Aussagen dadurch schwerer nachvollziehbar.
16 Mergesort kann in O(log(n)) Zeit mit n Prozessoren zwei sortierte Listen zu einer sortierten Liste
zusammenfügen.
75

hat, deren beste bislang gefundene Lösung auf einer deterministischen Turingmaschine
jedoch exponentiell viel Zeit benötigt. Die Klasse P umfasst die Algorithmen, die auf
einer deterministischen Turingmaschine in polynomieller Zeit laufen. Die Frage, ob NP
= P gilt, ist zur Zeit noch ungeklärt, es wird aber vermutet, dass diese Gleichung nicht
gilt. Die Theorie zu diesen Klassen ist in vielen (Lehr-) Büchern zu finden, u. a. auch in
[Sch01].
Die Klasse der NP-vollständigen Probleme ist eine Unterklasse der Klasse NP. Dabei
lässt sich jedes NP-vollständige Problem auf jedes andere NP-vollständige Problem reduzieren.
Mit anderen Worten, findet man eine effiziente Lösung für eines der Probleme
dieser Klasse, so kann man auch alle anderen Probleme effizient lösen.
Auch in der Graphentheorie existieren einige NP-vollständige Probleme, z. B. das Graphenfärbbarkeitsproblem,
das ”
Travelling-Salesman“-Problem und die Bestimmung der
maximalen Clique eines Graphen. In der Regel lassen sich solche NP-vollständige Probleme
nur durch Backtracking 17 lösen und sind somit bezüglich der Laufzeit ineffizient.
Auch die Möglichkeiten, die parallele Automaten und Rechenmodelle bieten, ändern
wenig an dieser Problematik. Trotzdem gibt es einige Unterklassen der Probleme, für
die es effiziente Lösungen gibt. Für andere Probleme existieren Approximationsalgorithmen,
die zwar kein optimales Ergebnis liefern, aber dem optimalen Ergebnis sehr nahe
kommen.
Die Möglichkeiten, für einige Spezialfälle eine effiziente Lösung zu finden, wird im Folgenden
exemplarisch am Beispiel des Graphenfärbbarkeitsproblem erläutert.
3.3.1. Das Graphenfärbbarkeitsproblem
Das Graphenfärbbarkeitsproblem besteht darin, dass man versucht, einen Graphen mit
einer minimalen Anzahl an Farben einzufärben. Dabei kann man entweder die Knoten
oder die Kanten färben, wobei darauf zu achten ist, dass keine benachbarten Knoten
(Kanten) die gleiche Farbe haben.
Für allgemeine Graphen ist dieses Problem nur mittels Backtracking zu lösen, was zu
einer exponentiellen Laufzeit führt. Das Backtracking-Verfahren ist in Kapitel A.1 des
Anhangs beschrieben.
Allerdings existieren Graphenklassen, für die sich das Graphenfärbungsproblem effizient
lösen lassen, dazu gehören u. a. die bipartiten, outerplanaren und Halin-Graphen.
Bipartite Graphen sind solche Graphen, deren Knotenmenge V sich derart in zwei Mengen
zerlegen lässt, dass V 1 ∪ V 2 = V und V 1 ∩ V 2 = ∅ gilt und es zudem nur Kanten
gibt, die V 1 und V 2 verbinden. Das heißt es existieren keine Kanten, die von V 1 nach V 1
oder von V 2 nach V 2 gehen. Diese Graphen sind bezüglich der Knoten zweifärbar (alle
17 Backtracking beschreibt eine strukturierte Art und Weise, Probleme per Austesten zu lösen und
falsche Annahmen wieder zurückzunehmen. Da dieses Verfahren im worst-case alle Möglichkeiten
austestet, kann es keine effiziente Laufzeit haben. Eine Beschreibung des Verfahrens ist in Kapitel
A.1 zu finden.
76

Knoten aus V 1 werden in einer gemeinsamen Farbe gefärbt und alle Knoten aus V 2 in
einer anderen Farbe), weshalb die Betrachtung der Kanten hier interessanter ist. Die
Definition von bipartiten Graphen wird in Abbildung 3.43 verdeutlicht. Abbildungsteil
a) zeigt einen bipartiten Graph, in b) ist nur eine Kante zusätzlich vorhanden, dennoch
ist es kein bipartiter Graph mehr.
Abbildung 3.43.: Der Graph in a) ist bipartit, da seine Knotenmenge in zwei Teilmengen
zerlegen lässt, so dass alle Kanten eine Verbindung zwischen diesen
Mengen schaffen und keine Kanten zwei Knoten innerhalb einer Menge
verbinden. Aus diesem Grund ist der Graph aus b) nicht bipartit, seine
Knotenmenge lässt sich nicht in zwei Teilengen mit dieser Eigenschaft
zerlegen.
Outerplanare Graphen sind planare Graphen, bei denen alle Knoten an einer gemeinsamen
Fläche liegen. Planare Graphen lassen sich so darstellen, dass keine Kantenüberschneidungen
existieren. Ohne Einschränkung der Allgemeinheit wird angenommen, dass
die gemeinsame Fläche der outerplanaren Kanten die äußere Fläche ist 18 . Ein outerplanarer
Graph ist in Abbildung 3.44 gegeben.
Abbildung 3.44.: Der angegebene Graph ist planar (es existieren keine Kantenüberschneidungen)
und alle Knoten liegen an der Außenfläche. Damit ist
der Graph outerplanar.
Halin-Graphen sind planare Graphen mit der folgenden Eigenschaft: Der Graph setzt sich
aus einem Baum zusammen, der keine Knoten mit dem Grad zwei enthält. Es existiert
zudem ein Zyklus, der alle Blätter des Baums und keine inneren Knoten beinhaltet. Ein
möglicher Halin-Graph ist in Abbildung 3.45 abgebildet.
18 Es existieren Theoreme, dass jeder planare Graph, dessen Knoten eine gemeinsame Fläche haben, so
dargestellt werden kann, dass diese Fläche die Außenfläche ist.
77

Abbildung 3.45.: Die Baumkanten sind hervorgehoben. Der Baum beinhaltet keine Knoten
mit dem Grad 2. Zudem sind in dem Graphen alle Blätter des
Baums durch einen Zyklus verbunden. Zusammen sorgen diese Eigenschaften
dafür, dass dieser Graph ein Halin-Graph ist.
Nachfolgend wird ein Algorithmus angegeben, mit dessen Hilfe die Kanten von bipartiten
Graphen gefärbt werden können.
3.3.1.1. Kantenfärbung von bipartiten Graphen
Im diesem Abschnitt sei ∆ definiert als der maximale Grad eines Knotens des zu untersuchenden
Graphen. Da es also mindestens einen Knoten gibt, dessen Grad ∆ ist, werden
mindestens ∆ Farben benötigt, um die Kanten des Graphen zu färben. In [GR98] wird
zuerst ein Algorithmus angegeben, der den Graphen einfärbt für den Fall, dass ∆ eine
Zweierpotenz ist. Darauf aufbauend wurde dann erst ein Algorithmus vorgestellt, der
die Kantenfärbung für bipartite Graphen mit beliebigem ∆ ermöglicht. Im Folgenden
soll gezeigt werden, wie der Algorithmus zur Färbung von bipartiten Graphen mit maximalem
Knotengrad ∆ = 2 x auf dem GCA implementiert werden kann. Der Algorithmus
zum Kantenfärben allgemeiner bipartiter Graphen hingegen wird in dieser Arbeit nicht
auf dem GCA modelliert. An dem Algorithmus interessierte Leser werden an dieser Stelle
auf [GR98] verwiesen.
Der Algorithmus zur Färbung bipartiter Graphen mit einer Zweierpotenz als maximalen
Grad (Euler-Färbung) verwendet das parallele Divide-and-Conquer-Prinzip (siehe A.2
und B.3). Da vorausgesetzt wurde, dass ∆ eine Zweierpotenz ist, kann der Graph in zwei
Teilgraphen zerlegt werden, die dann auch wieder ein ∆ haben, welches eine Zweierpotenz
darstellt. Der Ausgangsgraph war bipartit, daher sind auch die Teilgraphen bipartit, da
keine neuen Kanten hinzukommen, welche die Bedingungen verletzen könnten.
Entscheidend ist zunächst, wie diese Zerlegung gefunden werden kann. Die Euler-Zerlegung
erlaubt es dem Algorithmus, den Graphen so zu teilen, dass beide Teilgraphen
eigenständig bearbeitet werden können und am Ende das korrekte Ergebnis ohne großen
Aufwand aus den Teilergebnissen ermittelt werden kann. Unter der Euler-Zerlegung
versteht man die Aufteilung des Graphen in mehrere kantendisjunkte Zyklen und Wege.
Dabei ist jeder Knoten mit ungeradem Grad Endpunkt genau eines Wegs. Diese
Euler-Zerlegung bildet die Grundlage für die anschließend vorgenommenen Zerlegung,
die darauf beruht, dass die Kanten alternierend mit 0 und 1 beschriftet werden. Alle
78

Kanten mit der Beschriftung 0 sind im Teilgraphen G 1 , alle mit 1 im Teilgraphen G 2
enthalten. Da die Euler-Zerlegung also den Startpunkt und die Reihenfolge bestimmt, in
der die Kanten betrachtet werden, wird im nächsten Absatz näher darauf eingegangen,
wie die Euler-Zerlegung gefunden werden kann.
Abbildung 3.46.: In a) ist der Graph zu sehen, Knoten 2 hat Grad 4, somit ist ∆ eine
Zweierpotenz. Teil b) zeigt die Zerlegung in die Wege und Zyklen. In
Teil c) sind alle Kanten des Graphen G 1 gestrichelt, die Kanten von
G 2 sind wie gewohnt abgebildet.
Bei einem Eulerschem Graphen 19 gibt es genau einen Zyklus, der bestimmt werden kann.
Ist der Graph nicht eulersch, so wird ein Zusatzknoten und von jedem Knoten mit ungeradem
Knotengrad eine Kante zu diesem eingeführt. Dann wird die Euler-Zerlegung für
diesen Graphen G ∗ gesucht. Die Euler-Zerlegung von G erhält man, indem der Zusatzknoten
und alle zu ihm führenden Kanten gelöscht werden. Dadurch kann es passieren,
dass Zyklen zu Wegen zerfallen, aber auch diese sind in der Euler-Zerlegung erlaubt.
Betrachtet man den Graphen aus Abbildung 3.46.a, so sieht dessen Euler-Zerlegung wie
in 3.46.b aus. Der Graph wird dann in die zwei Teilgraphen G 1 und G 2 zerlegt, indem
alle Kanten mit einer 0 als Markierung in G 1 und alle Kanten mit der Markierung 1 in
G 2 enthalten sind.
Diese Zerlegung wird solange fortgesetzt, bis ∆=1 gilt. Dann können alle Kanten mit
einer Farbe eingefärbt werden. Jeder der Teilgraphen färbt die Kanten mit einer Nummer
von 1 bis ∆ . Beim Zusammenfassen der Teilgraphen werden dann die Farben im
2
Teilgraphen G 2 umbenannt, indem man ∆ hinzuaddiert. Damit hat man insgesamt alle
2
Kanten mit einer Nummer versehen und da in G 1 und G 2 nach der Umbenennung keine
19 Man spricht davon, dass ein Graph eulersch ist oder von einem Eulerschem Graphen, wenn es in
dem Graphen einen Eulerschen Kreis gibt. Dieser Eulersche Kreis beschreibt einen Zyklus, der jede
Kante des Graphen genau einmal benutzt. Ein ungerichteter Graph kann nur dann eulersch sein,
wenn alle Knoten einen geraden Grad haben.
79

gemeinsamen Farben (die Nummern entsprechen Farben) mehr existieren, ist das Gesamtergebnis
eine korrekte Färbung, wenn beide Teilgraphen korrekt gefärbt waren. In
Pseudocode wird der Algorithmus wie folgt formuliert:
Listing 3.6: Eulerfärbung für bipartite Graphen
1 procedure Euler−colour (G)
2 begin
3 /∗ G hat maximalen Grad ∆ ∗/
4 if ∆ = 1 then
5 markiere a l l e Kanten in G mit der Farbe 1
6 else
7 begin
8 finde eine Euler−Zerlegung von G
9 mit Hilfe der Euler−Zerlegung bilde die zwei Graphen G 1
und G 2 , beide mit maximalen Grad ∆ 2
10 for G = G 1 und G = G 2 in parallel do Euler−colour (G)
11 s t e l l e G aus G 1 und G 2 wieder her , indem die Farben aus
G 2 umbenannt werden , damit G 1 und G 2 disjunkte
Farbmengen benutzen .
12 end
13 end
Für die Modellierung auf dem GCA ist es notwendig, die einzelnen Schritte genauer zu
betrachten. Kann man jeden Schritt auf dem GCA modellieren, so ist auch der gesamte
Algorithmus auf dem GCA modellierbar. Nachfolgend sollen die Pseudo-Befehle aus dem
obigen Programm näher erläutert und auf dem GCA modelliert werden:
• In Zeile 4 des Programms findet sich die Abbruchbedingung des rekursiven Algorithmus.
Um parallel testen zu können, ob alle Knoten einen maximalen Grad von
eins haben, braucht man auf dem GCA für jeden Knoten eine Zelle. Jede Zelle
kennt ihren eigenen Grad, der von anderen Zellen abgefragt werden kann. Sinnvoll
ist an dieser Stelle auch eine Master-Zelle, die von allen Knoten-Zellen den Grad
abfragt und aufgrund der Daten entscheided, ob das Abbruchkriterium erfüllt ist
oder nicht. Dies kann unter anderem dadurch geschehen, dass die Master-Zelle alle
Knotengrade verodert und, wenn das Ergebnis größer als eins ist, entscheidet, dass
das Kriterium noch nicht erfüllt ist.
Ist das Abbruchkriterium erfüllt, so müssen alle im Graphen enthaltenen Kanten
mit der Farbe 1 gefärbt werden. Eine Färbung kann als Label an der Kante
dargestellt werden.
In Bezug auf den weiteren Algorithmus ist es sinnvoll, die Kanten auch als Zellen
zu modellieren. Da aber eine Kante immer zwei Knoten verbindet, ist es im
Weiteren notwendig, für jede Kanten-Zelle die Knoten-Zelle zu bestimmen, welche
im weiteren Verlauf des Algorithmus regelt, ob und wie umgefärbt werden muss.
80

Deswegen wird hier festgelegt, dass jede Kanten-Zelle, die (i,j) repräsentiert, lesend
auf die Knoten-Zelle i zugreift.
Die Knoten-Zellen haben lesenden Zugriff auf alle Kanten-Zellen, die sie berühren,
und können somit anhand ihrer Verbindungen feststellen, welchen Grad sie haben.
Das Färben einer Kante gestaltet sich dann so, dass die Knoten-Zellen alle die
Farbe 1 in den Ausgabeport schreiben und die Kanten-Zellen diese lesen und ihre
Kanten labeln.
• In Zeile 8 findet sich die nächste interessante Anweisung. Diese Anweisung wird
immer dann ausgeführt, wenn das Abbruchkriterium nicht erfüllt ist. Sie besteht
aus mehreren Schritten, die im Pseudo-Code nicht deutlich werden. Die Schritte
um eine Euler-Zerlegung zu finden werden in der folgenden Aufzählung benannt
und gleich deren Modellierung auf dem GCA erläutert.
Zur Verdeutlichung der Schritte werden auch immer die Auswirkungen auf den
Beispielgraphen 3.47 anhand von Graphiken aufgezeigt. Wichtig ist hierbei, dass
der Graph für diesen Schritt eulersch sein muss; wie er angepasst werden kann,
wurde bereits weiter vorne beschrieben.
Da eine Dummy-Zelle nicht zur Laufzeit erzeugt werden kann, muss diese Zelle
von vornherein vorhanden sein. Die Dummy-Knoten-Zelle übernimmt es, jeden
Knoten auf seinen Grad zu überprüfen. Haben alle Knoten einen geraden Grad,
so deaktiviert sie sich. Ansonsten geht sie in einen Zustand, welche den Dummy-
Kanten-Zellen anzeigt, dass diese sich mit einem Wert zu initialisieren haben (auch
die Dummy-Kanten-Zellen müssen aktiv nach einer nötigen Verbindung suchen, da
beim GCA nicht schreibend auf Zellen zugegriffen werden darf).
Da somit eine große Anzahl eventuell unbeschäftigter Zellen nötig ist, erscheint es
sinnvoller, entweder nur eulersche Graphen mit Hilfe des GCA zu bearbeiten oder
die Speicherzellen-Konstruktion zu verwenden. Bei der zweiten Variante würde die
Speicherzelle alle relevanten Daten abspeichern (u. a. die Kanten) und könnte einfach
bei sich feststellen, wenn ein neuer Knoten und dazugehörige Kanten eingefügt
werden müssen. Auch dieses Konstrukt ist nicht einfach, da die Knoten dann bei
der Speicherzelle abfragen müssen, ob neue Kanten für sie hinzugekommen sind
oder nicht, aber es entsteht kein so hoher Prozessorbedarf wie bei der anderen
Möglichkeit.
– Um die Euler-Zerlegung zu finden wird ein Teil des Algorithmus verwendet,
der den Euler-Kreis eines eulerschen Graphen bestimmt. Da dieser Algorithmus
einen gerichteten Graphen als Eingabe erhält und der bislang behandelte
Graph ungerichtet ist, müssen alle Kanten durch gerichtete Kanten in beide
Richtungen ersetzt werden. Dies könnte dadurch modelliert werden, dass jede
Kante (i,j) repräsentierende Zelle zusätzlich die Kante (j,i) speichert und
somit eine ungerichtete Kante durch zwei gerichtete ersetzt.
Allerdings ist es für die folgenden Schritte besser, wenn jede gerichtete Kante
durch eine eigene Zelle repräsentiert wird. Dazu werden |E| zusätzliche Zellen
81

Abbildung 3.47.: Ein einfacher bipartiter Graph, der in den folgenden Schritten dazu
verwendet werden soll, den Algorithmus zu verdeutlichen.
Abbildung 3.48.: Die Kanten des Graphen wurden alle durch zwei gerichtete Kanten ersetzt.
Dieser Vorgang ist auch noch einmal anhand der Zellen verdeutlicht.
Für jede Kante und jeden Knoten existiert eine repräsentierende
Zelle.
benötigt, die jeweils die Knoten einer Kante abfragen und sie in umgekehrter
Reihenfolge speichern. Wichtig ist, dass dies strukturiert geschieht, damit die
Knoten-Zellen auch lesend auf diese Zellen zugreifen können.
Zudem muss jede neue Kanten-Zelle eine lesende Verbindung zu beiden Knoten-
Zellen, die sie berührt, aufbauen. Das ist eine Abweichung zu der vorher getroffenen
Aussage, ist aber für diesen Schritt sehr hilfreich und kann ohne
weiteres realisiert werden. Die für den vorhergehenden Schritt unnötige lesende
Verbindung wird dort einfach deaktiviert (nicht genutzt). Das Ergebnis
dieses Schritts ist in Abbildung 3.48 graphisch dargestellt.
– Damit eine Kante des Original-Graphen auch nur ein Label erhält und damit
der Euler-Algorithmus erfolgreich ist, muss nun eine der beiden gerichteten
Kanten eliminiert werden. Die Auswahl, welche der beiden gerichteten Kanten
eliminiert werden muss, geschieht in diesem und den nächsten Schritten.
Zunächst wird die Liste der Kanten sortiert. In vorangehenden Abschnitten
wurde bereits der Heap-Sort als ein möglicher Sortier-Algorithmus vorgestellt,
82

Abbildung 3.49.: Die Kanten wurden in diesem Schritt sortiert. An den Verbindungen
zu den Knoten ändert sich nichts.
allerdings hat dieser auch in der parallelen Variante eine Laufzeit von O(n).
In [GR98] werden parallele Sortieralgorithmen vorgestellt, die in O(log(n))
sortieren. Da dies ein deutlich besseres Laufzeitverhalten ist, sollte ein entsprechender
Sortieralgorithmus gewählt werden.
Zum Sortieren wird in [GR98] Coles Sortieralgorithmus vorgeschlagen. Allerdings
wird in [Nat90] sehr anschaulich illustriert, dass dieser Sortieralgorithmus
zwar eine Laufzeitkomplexität von O(log(n)) hat, aber in der konkreten
Implementierung eine schlechtere Laufzeit aufweist als das bitonische Sortieren
mit einer Laufzeit von O(log 2 (n)). Da sich dort der Sortieralgorithmus
von Cole bis zu einer Eingabegröße von n = 2 69 schlechter als das bitonische
Sortieren verhält (dabei wurden manche Verbesserungsmöglichkeiten des bitonischen
Sortierens bewusst nicht genutzt), wird hier darauf verzichtet, den
Algorithmus von Cole auf dem GCA zu implementieren. Dies erscheint vor
allem deswegen sinnvoll, da das bitonische Sortieren bereits in [Hee01] sehr
anschaulich und effizient auf dem GCA modelliert wurde.
Die einzige Aufgabe besteht nun darin, den Komperator dergestalt anzupassen,
dass eine Kante (i,j) genau dann als kleiner als eine Kante (k,l) definiert
wird, wenn i < k∨(i = k∧j < l) gilt. In Abbildung 3.49 wurde die Sortierung
der Kanten für den Beispielgraph vorgenommen.
– Mit Hilfe der Sortierung werden nun die Successoren (Nachfolger) der Kanten
bestimmt. Da die Kanten untereinander über keine Verbindungen verfügen,
muss die Zuweisung des Successors von den Knoten-Zellen aus erfolgen. Jede
Knoten-Zelle bestimmt anhand der von ihr ausgehenden Kanten die Successoren
der in sie eingehenden Kanten (momentan wird auf einem gerichteten
Graphen gearbeitet, deswegen sind die Kanten so am einfachsten zu
beschreiben). Die Kanten-Zellen, welche die eingehenden Kanten repräsentieren,
können dann nach der Berechnung ihren Successor bei der Knoten-Zelle
auslesen und abspeichern.
Um auszurechnen, welche eingehende Kante welche ausgehende Kante zugewiesen
bekommt, werden die sortierten Kanten betrachtet. Alle Kanten, die
vom Knoten i ausgehen, sind in dieser sortierten Kantenfolge hintereinander
angeordnet. Da der Knoten lesenden Zugriff auf alle an ihm anliegenden Kanten
hat, kann davon ausgegangen werden, dass seine Verweise auch in einer
Art abgespeichert sind, dass sie der Sortierung entsprechen.
83

Abbildung 3.50.: Für jede Kantenzelle wurde der Successor bestimmt. Die Zelle hat sich
ihren Successor nicht nur gespeichert, sondern auch eine Verbindung
zu ihm aufgebaut.
Da der Graph eulersch ist, hat jeder Knoten i eine gerade Anzahl ausgehender
Kanten, welche mit (i,v 0 )...(i,v k ) bezeichnet werden. Die v l (die Durchnummerierung
folgt der Sortierung und jedes v l bezeichnet einen Endknoten
einer Kante) sind wichtig, da sie bestimmen, welche eingehende Kante
und welche ausgehende Kante ein Successor-Paar bilden. Für jedes ungerade
l berechnet der Knoten i nun SUCCESSOR((v l ,i)) ← (i,v l+1 ) und
SUCCESSOR((v l+1 ,i)) ← (i,v l ).
Dabei bilden die letzte Kante der Liste und die erste Kante der Liste ein Paar
(dies geschieht in der Berechnung, indem einfach modulo der Anzahl der
ausgehenden Kanten gerechnet wird). Sinnvoll ist bei diesem Schritt, dass die
Kanten-Zellen sich nicht nur den Wert ihres Successors abspeichern, sondern
auch eine Verbindung zu der entsprechenden Zelle herstellen. Betrachtet man
nur die Zellen nach dem Ablauf des Schritts, so ergibt sich Abbildung 3.50.
– Nun wird die Doubling-Technik auf die Kanten-Zellen angewendet und gleichzeitig
speichert die Kanten-Zelle einen Wert. Dieser Wert gibt am Ende des
Schritts die kleinste Kante des Zyklusses an, zu dem die Kanten-Zelle gehört.
Jede Kanten-Zelle berechnet deswegen:
V alue ← min{eigener V alue,V alue des Successors}.
Initialwert der Kanten-Zelle ist die eigene Kante. Nachdem der neue Value
ausgerechnet wurde, wird die Successor-Verbindung auf den Successor des
Successors gesetzt. Somit ist nach log(n) Schritten der gesamte Zyklus durchlaufen
und jede Kanten-Zelle enthält als Value die kleinste Kante des eigenen
Zyklusses. Die Kanten-Zellen nach Beenden der Doubling-Technik sind in
Abbildung 3.51 dargestellt.
– Um nun die gerichteten Kanten auszuwählen, die die Kantenfärbung bestimmen,
wird zwischen einem Kantenpaar (i,j) und (j,i) immer diejenige ausgewählt,
deren Value kleiner ist. Dabei wird die oben beschriebene Vergleichsoperation
verwendet.
Dieser Vergleich kann entweder durch die Kanten-Zellen erfolgen, falls sie
lesenden Zugriff auf die jeweils andere Kanten-Zelle haben, oder durch die
Knoten-Zellen. Da Knoten-Zellen lesenden Zugriff auf alle sie berührende
84

Abbildung 3.51.: Nachdem die Doubling-Technik auf die Kanten-Zellen angewendet wurde,
hat jede Zelle sich selber als Successor und der Value steht auf der
kleinsten Kante des Zyklusses, zu dem die Kante gehört.
Abbildung 3.52.: Anhand des Values wurde jetzt für jede Kanten-Zelle entschieden, ob
sie aktiv oder inaktiv ist. Grau hinterlegte Kanten sind inaktiv, die
anderen aktiv.
Kanten-Zellen haben, können sie den Vergleich ohne weiteren Verbindungsaufwand
durchführen. Wichtig ist, dass die Kanten-Zellen mit dem größeren
Value deaktiviert werden und somit für die nachfolgenden Schritte nicht mehr
zur Verfügung stehen. Auch die Knoten-Zellen merken, welche Kanten-Zellen
deaktiviert wurden und ignorieren eine Verbindung dorthin. Die deaktivierten
Kanten-Zellen sind in Abbildung 3.52 durch eine graue Hinterlegung gekennzeichnet.
– Der letzte Schritt besteht nun darin, für die aktiven Kanten-Zellen einen
Nachfolger zu finden, so dass die Kanten mit 0 oder 1 gelabelt werden können.
Hierbei ist anzumerken, dass bei diesem Beispiel zwar ein Zyklus entsteht, dies
aber nicht immer so sein muss. Die einzige Garantie, die der Algorithmus an
dieser Stelle liefert, ist, dass der Graph in kantendisjunkte Kreise und Wege
zerlegt wurde. Da ein Euler-Kreis aber auch nicht für den weiteren Verlauf
des Algorithmus notwendig ist, reicht diese Garantie.
Um nun die Nachfolger zu bestimmen, müssen im Original-P-RAM-Algorithmus
der Kantenvektor und der Successorvektor (die P-RAM arbeitet auf
Vektoren) jeweils sortiert werden. Der Successorvektor nimmt dafür den schon
bekannten Komperator. Bei dem Kantenvektor ist eine Kante (i,j) kleiner als
(k,l), wenn j < l ∨ (j = l ∧ i < k). Mit anderen Worten, der Kantenvektor
wird nach der zweiten Komponente jeder Kante sortiert.
Auf dem GCA lässt sich dieser Schritt folgendermaßen realisieren: jede Knoten-
Zelle kennt die an sie angrenzenden Kanten-Zellen. Außerdem hat jedes Kante-
85

Abbildung 3.53.: Jede Kanten-Zelle kennt nun ihren Successor (explizit in der Kanten-
Zelle gespeichert und als Link).
Successor-Paar genau einen Knoten gemeinsam: die zweite Komponente der
Kante und die erste Komponente des Successors. Da beide Kanten also der
Knoten-Zelle bekannt sind, kann diese auch die Zuordnung übernehmen. Dazu
muss sie intern ihre Kanten aufspalten in die Hälfte der von ihr ausgehenden
Kanten (erste Komponente ist gleich der Zell-ID des Knotens) und der eingehenden
Kanten (zweite Komponente ist gleich der Zell-ID des Knotens).
Die ausgehenden Kanten werden wie der Successorvektor sortiert. Da hierbei
die erste Komponente immer gleich ist, reduziert sich der Vergleich nun
darauf, ob die zweite Komponente kleiner ist.
Die eingehenden Kanten werden wie der Kantenvektor sortiert. Auch hier
reicht es, nach der ersten Komponente zu sortieren, da die zweite Komponente
bei allen ausgehenden Kanten gleich der Zell-ID des Knotens ist.
Nun wird der i-ten eingehenden Kante (aus der sortierten eingehenden Kanten-
Liste) die i-te ausgehende Kante (aus der sortierten ausgehenden Kanten-
Liste) als Successor zugewiesen und die Kanten fragen wieder bei der entsprechenden
Knoten-Zelle ihren Successor ab.
In dem hier gewählten Beispiel hat jeder Knoten nur eine eingehende und
eine ausgehende Kante, das Sortieren ist also nicht notwendig. In Abbildung
3.53 wurde jeder in den Knoten eingehenden Kante die aus dem Knoten
ausgehende als Successor zugewiesen.
• In Zeile 9 wird nun gefordert, dass mit Hilfe der eben gefundenen Zerlegung der
Graph in zwei Teilgraphen zerlegt wird. Dies geschieht dadurch, dass alle noch aktiven
Kanten-Zellen (ab diesem Schritt werden sie wieder als ungerichtete Kanten
betrachtet) entweder eine 0 oder eine 1 als Label erhalten. Anschließend werden
die Kanten, die mit dem Dummy verbunden sind, entfernt.
Die Kanten können mit Hilfe der Doubling-Technik mit dem Label versehen werden.
Wichtig dafür ist, dass eine Zelle mit einem Label initialisiert wird. Bereits
in den vorangehenden Schritten benötigten die Kanten einen lesenden Zugriff auf
den Master, also kann dieser die Initialisierung der Kante veranlassen. Dies geschieht,
indem er die Kante und den Label, auf den sie zu setzen ist, in seinen
86

Zustand kodiert. Die Kanten-Zellen lesen diesen Zustand und diejenige, die ihre
Werte liest (Start- und Endpunkt sind gleich) initialisiert sich auf das angegebene
Label. Anschließend entfernt sie ihre Verbindung zum Nachfolger.
Die Kanten-Zellen fragen nun das Label ihres Nachbarn ab. Ist das Label weder
0 noch 1, so setzen sie ihre Nachfolgerverbindung auf die ihres Nachbarn. Dieser
Schritt wird solange wiederholt, bis der Nachbar ein gültiges Label besitzt (nach
maximal O(log(n)) Schritten).
Mit Hilfe dieses Labels wird nun das eigene Label gesetzt. Wurde das andere Label
im ersten Schritt gefunden, so ist das gefundene Label zu negieren, ansonsten ist
der Wert einfach zu übernehmen.
• In Zeile 10 findet der rekursive Aufruf statt. Es gibt die Möglichkeit, beide Aufrufe
nacheinander abzuarbeiten (auch das liefert schon eine Laufzeitverbesserung
gegenüber anderen Algorithmen) oder beide Aufrufe parallel zu bearbeiten. Das
bedeutet allerdings, dass die Knoten-Zellen bei jedem Aufruf dupliziert werden
müssen. Sinnvoller ist es, der Master-Zelle die Koordination zu überlassen und
einen Aufruf nach dem anderen zu bearbeiten.
• Als letzter Schritt (Zeile 11) müssen nun die Farben im Ergebnis des zweiten
Aufrufs umbenannt werden. Auch dies kann die Master-Zelle erledigen. Sie muss
lediglich für die Kanten-Zellen lesbar hinterlegen, ob es sich um den ersten oder
den zweiten Aufruf handelt und wie groß das ∆ auf dieser Aufruf-Ebene war. Die
Kanten addieren dann alle ∆ zu ihrer Farbe und die Umbenennung ist abgeschlossen.
2
Insgesamt werden also für diesen Algorithmus die Master-Zelle, |V | Knoten-Zellen und
|2E| Kanten-Zellen benötigt. Zusätzlich wird entweder eine Speicherzelle oder eine Dummy-Knoten-Zelle
und maximal 2(|V |−1) Dummy-Kanten-Zellen benötigt. Daraus ergibt
sich ein Zellenaufwand von O(|V |+|E|), was deutlich schlechter ist als der Aufwand von
O(|V |) auf der P-RAM. Auch die Laufzeitkomplexität ist mit O(log 3 (n)) schlechter als
auf der P-RAM. Dies liegt aber an der bewussten Entscheidung, nicht Coles Algorithmus
zum Sortieren zu verwenden.
Auch die Euler-Färbung soll mit Hilfe des Schemas aus Kapitel 2.3.4 klassifiziert werden.
Als erstes soll dabei die Abhängigkeit der Daten untersucht werden. Anschließend werden
die Abhängigkeiten der Verbindungen beleuchtet.
In diesem Algorithmus existieren drei Arten von Zellen: Die Kanten-Zellen, die Knoten-
Zellen und die Master-Zelle (sowie eventuell eine Speicherzelle). Die Zellen verhalten sich
unterschiedlich je nachdem, welcher Art sie angehören. Ordnet man die Zellen gemäß
ihrer Art an, so kann man dieses Verhalten durch ihren Ort im GCA bestimmen. Es
besteht dann also eine Ortsabhängigkeit der Daten.
Die Kanten-Zellen ändern ihr Label, wenn sie dies von der Master-Zelle oder ihrer
Knoten-Zelle vorgegeben bekommen. Die Daten der Zellen sind also abhängig von den
Daten der Nachbarzellen. Da das eigene Label durch hinzuaddieren des gelesenen Werts
87

aus der Nachbarzelle gewonnen wird, sind die Daten auch abhängig von den eigenen
Daten.
Es ergibt sich keine ersichtliche Veränderung der Daten aufgrund der Zeit, weshalb dafür
keine Abhängigkeit besteht. Auch eine Abhängigkeit von den Verbindungen ist nicht
festzustellen.
Bereits bei der Betrachtung der Abhängigkeiten der Daten wurde festgestellt, dass sich
Zellen unterschiedlicher Arten verschieden verhalten. Auch hier wird dies als eine Ortsabhängigkeit
beschrieben.
Die Verbindungen werden innerhalb des Algorithmus dynamisch gehandhabt. So wird u.
a. die Doubling-Technik mehrfach angewendet. Da diesmal die Doubling-Technik ohne
die Zuhilfenahme einer Speicherzelle angewendet wird, sind die Verbindungen abhängig
von den Verbindungen der Nachbar-Zelle.
Im Laufe des Algorithmus werden Successoren bestimmt und auch eine Verbindung zu
diesen hergestellt. Die Successoren werden aber aufgrund der Daten der Nachbar-Zelle
(der Knoten) gebildet und deswegen ist die Verbindung abhängig von den Daten der
Nachbar-Zelle.
Die oben festgestellten Abhängigkeiten treten in dem Algorithmus mehrfach auf und
die angeführten Argumente sind nur als Beispiele zu sehen, weshalb die Abhängigkeit
besteht. Andere Abhängigkeiten wurden nicht festgestellt.
3.4. Zusammenfassung
In diesem Kapitel wurden einige Graphen-Algorithmen vorgestellt. Da die Graphentheorie
ein sehr weites und umfangreiches Feld ist, wurden hier drei Problematiken exemplarisch
beleuchtet: die Bestimmung zusammenhängender Komponenten, die Bestimmung
eines minimal aufspannenden Baums und die Färbung bipartiter Graphen.
Für die Bestimmung zusammenhängender Komponenten und die Berechnung des minimal
aufspannenden Baums wurden zuerst klassische sequentielle Algorithmen vorgestellt.
Diese wurden dann anschließend auf dem GCA modeliert und es wurde versucht,
eine Laufzeitverbesserung zu erreichen.
Im Falle des Warshall-Algorithmus (zusammenhängende Komponenten) ist es gelungen,
die Laufzeitkomplexität von O(n 3 ) auf O(n) zu reduzieren. Allerdings wurde dies nur
dadurch erreicht, dass ein hoher Aufwand in der Hardware betrieben wurde (O(n) Zellen
und O(n) Leitungen).
Es hat sich herausgestellt, dass die sequentiellen Algorithmen durch die parallelen Möglichkeiten
des GCA beschleunigt werden können. Allerdings schneiden sie in der Laufzeitanalyse
schlechter ab als Algorithmen, die bereits für parallele Systeme entwickelt wurden.
Es wurden einige Algorithmen, die für die P-RAM entwickelt wurden auf dem GCA
modelliert und eine Laufzeitanalyse betrieben. Im Laufe dieser Analyse wurde das Mo-
88

Algorithmus Sequentiell Zeit P-RAM Proz. P-RAM Zeit GCA Zellen GCA
Warshall O(n 3 ) - - O(n) O(n)
Floyd-Warshall O(n 3 ) - - O(n) O(n)
Hirschberg - O(log 2 (n)) O( n2
log(n) ) O(log2 (n)) O( n2
log(n) )
Heapsort O(n log(n)) - - O(n) O(log(n))
Kruskal O(|E|) - - O(|E|) O(|V |)
mod. Hirschberg - O(log 2 (n)) O( n2
log(n) ) O(log2 (n)) O( n2
log(n) )
Euler-Färbung - O(log 2 (n)) O(m) O(n log(n)) O(m + n)
Tabelle 3.1.: Eine Betrachtung der Laufzeit der behandelten Algorithmen. Falls vorhanden
sind die sequentielle oder die P-RAM-Laufzeit angegeben. Wurde der
Algorithmus ursprünglich auf der P-RAM angegeben und eine Abschätzung
der benötigten Prozessoren gegeben, so ist diese auch hier angegeben. Abschließend
sind die Laufzeit und die benötigte Anzahl an Zellen angegeben.
dell einer Speicherzelle entwickelt, welche ermöglicht, dass alle betrachteten P-RAM-
Algorithmen auf dem GCA modelliert werden können.
Eine Zusammenfassung der betrachteten Algorithmen zusammen mit ihrer Laufzeit im
sequentiellen Fall, auf der P-RAM und dem GCA ist in Tabelle 3.1 gegeben. Es erscheint
immer interessant, bei parallelen Algorithmen nicht nur die Laufzeit sondern auch die
Anzahl der benötigten Prozessoren (bzw. Zellen) zu betrachten. In [GR98] findet sich
auf S. 1 folgendes Zitat:
A subclass of problems of particular interst are those which have optimal
parallel algorithms. An optimal parallel algorithm is an algorithm for which
the product of the parallel time t with the number of processors p used is
linear in the problem size n. That is, pt = O(n). Optimality may also mean
that the product pt is equal to the computation time of the fastest known
sequential-time algorithm for the problem. Here we specifically refer to the
problem as having optimal speed-up.
Das Produkt pt wird an anderen Stellen (u. a. in [KKT01]) auch als work bezeichnet.
Alle betrachteten Algorithmen wurden in das in Kapitel 2.3.4 vorgestellte Schema eingeordnet.
Dabei wurden die Abhängigkeiten der Daten und der Verbindungen der nächsten
Generationen von den momentanen Gegebenenheiten untersucht. Das Ergebnis dieser
Untersuchungen ist in Tabelle 3.2 (Daten) und 3.3 (Verbindungen) gegeben. Dabei stehen
die Abkürzungen für folgende Werte:
• t = Zeit: kennzeichnet eine Veränderung des betrachteten Werts (Daten / Verbindung)
abhängig von der Zeit.
• l = Eigener Ort: kennzeichnet eine Veränderung des betrachteten Werts abhängig
von dem Ort der eigenen Zelle.
89

t l l* d d* p p*
Warshall - - - + + - -
Floyd-Warshall - - - + + - -
Hirschberg - - - + + - -
Heapsort + - - + + + -
Kruskal + - - + + - -
mod. Hirschberg - - - + + - -
Euler-Färbung - + - + + + -
Tabelle 3.2.: Abhängigkeit der Daten einer Zelle in dem jeweils links stehenden Algorithmus.
Ein + steht für eine Abhängigkeit, ein - für keine Abhängigkeit. Die
Bedeutung der Abkürzungen ist dem Text zu entnehmen.
t l l* d d* p p*
Warshall + - - + - - -
Floyd-Warshall + - - + - - -
Hirschberg - - - - - - -
Heapsort - + - + - - +
Kruskal - - - - - - -
mod. Hirschberg - - - - - - -
Euler-Färbung - + - - + - +
Tabelle 3.3.: Abhängigkeit der Verbindungen einer Zelle in dem jeweils links stehenden
Algorithmus. Ein + steht für eine Abhängigkeit, ein - für keine Abhängigkeit.
Die Bedeutung der Abkürzungen ist dem Text zu entnehmen.
• l* = Ort der Nachbarn: kennzeichnet eine Veränderung des betrachteten Werts
abhängig von dem Ort der Nachbar-Zellen.
• d = Eigene Daten: kennzeichnet eine Veränderung des betrachteten Werts abhängig
von den eigenen Daten einer Zelle.
• d* = Daten der Nachbarn: kennzeichnet eine Veränderung des betrachteten Werts
abhängig von den Daten der Nachbar-Zellen.
• p = Eigene Verbindung (Pointer): kennzeichnet eine Veränderung des betrachteten
Werts abhängig von den eigenen Verbindungen (nicht den Werten, auf die sie
zeigen).
• p* = Verbindungen der Nachbarn: kennzeichnet eine Veränderung des betrachteten
Werts abhängig von den Verbindungen der Nachbar-Zellen.
90

4. Die Modellierung von
Krypto-Algorithmen auf dem GCA
In der heutigen Zeit werden die meisten Dokumente elektronisch verwaltet und Nachrichten
werden elektronisch verschickt. Daher ist es wichtig, dass die Daten vor fremden
Zugriff geschützt werden können. Die Kryptographie ist eine Disziplin, die Methoden
der Mathematik und Informatik kombiniert, um u. a. zu verhindern, dass Unbefugte,
die in Besitz von Daten gelangen, daraus Informationen gewinnen können. Gerade da
der Briefverkehr sich immer mehr in die elektronische Variante, die E-Mail, verlagert,
ist es wichtig, diese Informationen vor unbefugten Zugriff zu schützen.
Viele in der Kryptographie genutzte Algorithmen lassen sich leicht parallelisieren. Meist
werden mehrere Berechnungen der gleichen Art benötigt, um am Ende das Gesamtergebnis
zu erhalten. Diese Berechnungen können (falls sie nicht voneinander abhängig sind)
parallel ausgeführt werden und somit kann eine Laufzeitverringerung erreicht werden.
Ein solcher Algorithmus ist der Chinesische Restsatz. Mit Hilfe des Chinesischen Restsatzes
ist es u. a. möglich, simultane Kongruenzen zu lösen. Um n Kongruenzen zu
lösen, muss unabhängig voneinander n mal der erweiterte euklidische Algorithmus ausgeführt
werden. Der erweiterte euklidische Algorithmus (EEA) selber eignet sich leider
nicht zur Parallelisierung. Da er aber nötig ist, um den Chinesischen Restsatz anwenden
zu können, wird im folgenden erst der EEA erklärt. Erst danach wird die Anwendung
des Chinesischen Restsatzes erläutert und auf dem GCA simuliert. Beide Algorithmen
verwenden Grundlagen der Gruppentheorie, auf die in dieser Arbeit aber nicht näher eingegangen
wird. Eine gute Zusammenfassung der Gruppentheorie und eine Beschreibung
der Algorithmen liefert [Buc01].
4.1. Der erweiterte euklidische Algorithmus
Der Euklidische Algorithmus dient dazu, den größten gemeinsamen Teiler (ggT) zweier
Zahlen a und b zu berechnen. Der erweiterte euklidische Algorithmus nutzt die Einzelschritte
des euklidischen Algorithmuses, um zusätzlich das Inverse von a mod b und
von b mod a zu berechnen. Für den Chinesischen Restsatz ist es notwendig, genau diese
Inversen zu bestimmen, weshalb der erweiterte euklidische Algorithmus so wichtig ist.
Der euklidische Algorithmus benötigt maximal log(b)/log( 1+√ 5
2
) + 1 Schritte.
Um den ggT zweier ganzer Zahlen a und b mit a > b zu berechnen, wird a zerlegt in
a = q × b + r. Dabei ist q das Ergebnis der Ganzzahldivision ohne Rest von a durch b
91

und r der dabei anfallende Rest. Im Algorithmus wird deshalb a durch b und b durch r
ersetzt. Dieser Schritt wird solange wiederholt, bis b = 0 ist. Ist dies der Fall, so wird a
als Ergebnis zurückgegeben.
Die Schritte des euklidischen Algorithmus können sehr anschaulich in einer Tabelle dargestellt
werden. Die erste Zeile beinhaltet die Werte aus denen der ggT berechnet werden
soll (die Werte des ersten Durchlaufs stehen in der ersten und zweiten Spalte, die Werte
des zweiten Durchlaufs stehen in der zweiten und dritten Spalte usw.). Die zweite Zeile
gibt das q an (also die Anzahl, wie oft b in a passt).
k 0 1 2 3
r k 27 6 3 0
q k 4 2
Tabelle 4.1.: Beispiel: Der euklidische Algorithmus wird verwendet um den ggT von 27
und 6 zu berechnen.
Der erweiterte euklidische Algorithmus nutzt nun die q k , um ein x und ein y zu berechnen,
so dass gilt: ggT(a,b) = ax + by. Dies gelingt mit Hilfe der Erkenntnis, dass r n =
(−1) n x n a + (−1) n+1 y n b, d. h. es wird lediglich eine Berechnungsvorschrift benötigt, um
die x k und y k (für alle 1 ≤ k ≤ n) zu berechnen. Durch die oben genannte Endbedingung
ergeben sich die Berechnungsvorschriften: x k+1 = q k x k + x k−1 und y k+1 = q k y k + y k−1 .
Da die oben genannte Erkenntnis für alle n ≤ k (also insbesondere auch für r 0 = a und
r 1 = b) gilt, ergeben sich folgende Initialisierungen: x 0 = 1, x 1 = 0, y 0 = 0 und y 1 = 1.
Wendet man den erweiterten euklidischen Algorithmus auf das vorherige Beispiel an, so
muss die Tabelle um die Einträge x k und y k erweitert werden. Die Tabelle 4.2 berechnet
neben dem ggT auch noch das x und das y.
Da in der Tabelle der letzte Wert von r k ≠ 0 den ggT angibt, kann man aus der Tabelle
folgendes entnehmen:
ggT(27, 6) = 3 = 1 × 27 + (−4) × 6 = 27 − 24 = 3.
Für Werte a und b, die teilerfremd sind (d. h. ggT(a,b) = 1), ist der Wert x gleichzeitig
auch das Inverse von a modulo b. Da modulo b gerechnet wird gilt:
k 0 1 2 3
r k 27 6 3 0
q k 4 2
x k (+)1 (-)0 (+)1 (-)2
y k (-)0 (+)1 (-)4 (+)9
Tabelle 4.2.: Beispiel: Der erweiterte euklidische Algorithmus wird verwendet um den
ggT von 27 und 6 zu berechnen. Gleichzeitig werden das x und das y bestimmt,
für die gilt: ggT(27, 6) = 27 × x + 6 × y. In den Klammern ist das
alternierende Vorzeichen gegeben, welches aber lediglich für die endgültigen
Werte von x und y benötigt werden.
92

1 mod b = ggT(a,b) mod b = (a × x + b × y) mod b = a × x mod b. Somit liefert
der erweiterte euklidische Algorithmus für teilerfremde Zahlen eine einfache Methode
zur Bestimmung von Inversen in einem Modulo-Ring. Der Source-Code in C sieht im
Prinzip folgendermaßen aus:
Listing 4.1: Der erweiterte euklidische Algorithmus in C
1 int euklid ( int a , int b , int ∗x , int ∗y){
2 int xPrev , xCur , yPrev , yCur , xNext , yNext , r , q ;
3 int sign = 1;
4 xPrev = 1;
5 xCur = 0;
6 yPrev = 0;
7 yCur = 1;
8 while (b != 0) {
9 r = a%b ;
10 q = a/b ;
11 a = b ;
12 b = r ;
13 xNext = q∗xCur + xPrev ;
14 xPrev = xCur ;
15 xCur = xNext ;
16 yNext = q∗yCur + yPrev ;
17 yPrev = yCur ;
18 yCur = yNext ;
19 sign = −sign ;
20 }
21 ∗x = sign ∗ xCur ;
22 ∗y = −sign ∗ yCur ;
23 return a ;
24 }
Da in der Anwendung des Chinesischen Restsatzes nur Kongruenzen der Form
yM ≡ 1 mod m nach der Verwendung des erweiterten euklidischen Algorithmus verlangen
(es wird das Inverse von M modulo m gesucht) und dabei i. A. gilt, dass M > m,
wird nur die Berechnung des Wertes x benötigt.
4.2. Die Anwendung des Chinesische Restsatzes
Der Chinesische Restsatz lautet: Seien m,n teilerfremd. Dann hat das Gleichungssystem
∣
x = a mod m
x = b mod n
∣
93

eine eindeutige Lösung modulo m × n.
Der Chinesische Restsatz wird u. a. angewendet, um simultane Kongruenzen zu lösen.
Dabei müssen die Faktoren, nach denen modularisiert wird paarweise teilerfremd sein.
Betrachtet man nun das Beispiel aus [Buc01] S. 41, so stehen dort mehrere Kongruenzen,
die ein gemeinsames Ergebnis x haben. Diese allgemeinen Kongruenzen möchte man
dann mit Hilfe des Chinesischen Restsatzes lösen:
x ≡ a 1 mod m 1 ,x ≡ a 2 mod m 2 , · · · ,x ≡ a n mod m n .
Alle m i (1 ≤ i ≤ n) sind untereinander teilerfremd. Dann setzt man m = ∏ n
i=1 m i und
berechnet anschließend für jedes i ein eigenes M i = m m i
. Dann wird für jedes M i sein
Inverses modulo m i gesucht, es muss also die Gleichung y i M i ≡ 1 mod m i für jedes
i größer 1 und kleiner n gelöst werden. Um die y i zu berechnen, wird der erweiterte
euklidische Algorithmus verwendet.
Mit Hilfe dieser Ergebnisse kann nun das Gesamtergebnis x der simultanen Kongruenz
bestimmt werden, da x = ( ∑ n
i=1 a i y i M i ) mod m gilt.
Interessant ist diese Methode, wenn entweder bekannt ist, dass mehrere Kongruenzen
das gleiche (noch unbekannte) Ergebnis haben, oder wenn man quadratische Gleichungen
modulo einer Zahl m berechnen muss.
Betrachtet man das Beispiel x 2 = 1 mod 30, so kann diese Gleichung in die drei Kongruenzen
x 2 = 1 mod 2, x 2 = 1 mod 3 und x 2 = 1 mod 5 zerlegt werden (man zerlegt
die 30 in seine Primfaktoren).
Der Chinesische Restsatz gilt zwar nur für lineare Gleichungen, es gestaltet sich jedoch
einfacher, quadratische Gleichungen für die Primfaktoren zu lösen als für m. So kann
die Gleichung x 2 = 1 mod 2 gelöst werden, indem alle Werte i mit 0 ≤ i ≤ überprüft
werden, ob sie die Gleichung erfüllen.
Die 0 wird für keine der Gleichungen eine Lösung sein, also müssen pro Gleichung maximal
4 Werte (für m i = 5) eingesetzt und geprüft werden. Die erste Gleichung ist eindeutig
mit x = 1 mod 2 bestimmt, bei der zweiten und dritten gibt es jedoch jeweils zwei Lösungen.
Die zwei Lösungen der zweiten Gleichung sind x = 1 mod 3 und x = 2 mod 3. Die
dritte Gleichung dagegen hat die Lösungen x = 1 mod 5 und x = 4 mod 5.
Es gibt vier Möglichkeiten, diese Gleichungen zu kombinieren, also vier verschiedene
” Sets“ an a i:
• a 1 = 1, a 2 = 1, a 3 = 1
• a 1 = 1, a 2 = 2, a 3 = 1
• a 1 = 1, a 2 = 1, a 3 = 4
• a 1 = 1, a 2 = 2, a 3 = 4
Die Inversen können unabhängig von den a i berechnet werden, aber beim Bestimmen
der Lösung für die ursprüngliche Gleichung muss jedes ”
Set“ eingesetzt werden. Es gibt
also vier Lösungen für das Gleichungssystem.
94

Für die Anwendung des Chinesischen Restsatzes gelten folgende Werte: m 1 = 2, m 2 = 3,
m 3 = 5 und m = 30. Daraus berechnen sich nun die M i : M 1 = 15, M 2 = 10 und M 3 = 6.
Anschließend muss für jedes M i sein Inverses modulo m i bestimmt werden. Dies geschieht
mit dem erweiterten euklidischen Algorithmus:
k 0 1 2 3
r k 15 2 1 0
q k 7 2
x k (+)1 (-)0 (+)1 (-)2
y k (-)0 (+)1 (-)7 (+)15
Tabelle 4.3.: Zur Berechnung des Inversen von M 1 modulo m 1 wird der erweiterte euklidische
Algorithmus verwendet.
Aus den Tabellen 4.3, 4.4 und 4.5 lassen sich nun die y i nun jeweils in der Spalte k = 2
und Zeile x k ablesen. Daraus ergeben sich die folgenden y i : y 1 = y 2 = y 3 = 1.
Setzt man nun dieses Ergebnis ein, so erhält man die Lösungen:
• x = 1 × 1 × 15 + 1 × 1 × 10 + 1 × 1 × 6 mod 30 = 1 mod 30
• x = 1 × 1 × 15 + 1 × 2 × 10 + 1 × 1 × 6 mod 30 = 41 mod 30 = 11 mod 30
• x = 1 × 1 × 15 + 1 × 1 × 10 + 1 × 4 × 6 mod 30 = 49 mod 30 = 19 mod 30
• x = 1 × 1 × 15 + 1 × 2 × 10 + 1 × 4 × 6 mod 30 = 59 mod 30 = 29 mod 30
k 0 1 2 3
r k 10 3 1 0
q k 3 3
x k (+)1 (-)0 (+)1 (-)3
y k (-)0 (+)1 (-)3 (+)9
Tabelle 4.4.: Auch zur Berechnung des Inversen von M 2 modulo m 2 wird der erweiterte
euklidische Algorithmus verwendet.
k 0 1 2 3
r k 6 5 1 0
q k 1 5
x k (+)1 (-)0 (+)1 (-)5
y k (-)0 (+)1 (-)1 (+)6
Tabelle 4.5.: Das letzte benötigte Inverse (von M 3 modulo m 3 ) wird auch mit Hilfe des
erweiterten euklidischen Algorithmus berechnet.
95

Abbildung 4.1.: Jede Zelle des GCA wird mit einem a i und einem m i initialisiert. Daraufhin
setzt die Zelle m auf m i damit die Doubling-Technik erfolgreich
angewendet werden kann. Die letzte Zelle hat eine inaktive Verbindung,
dies ist dadurch dargestellt, dass die Zelle grau hinterlegt wurde.
Abbildung 4.2.: Nach log(n) (hier zwei) Schritten steht das korrekte Ergebnis in der ersten
Zelle. Die anderen Zellen haben eine deaktivierte Verbindung. Dies
wurde auch hier wieder durch eine graue Hinterlegung gekennzeichnet.
Wie anhand des Beispiels ersichtlich wird, gibt es Lösungen für das Gleichungssystem,
welche man ohne den Chinesischen Restsatz nicht so einfach erkannt hätte.
Für die Implementierung der Anwendung des Chinesischen Restsatzes wird angenommen,
dass bereits die linearen Kongruenzen vorhanden sind. Dann wird jede Zelle mit
einer Kongruenz initialisiert, d. h. sie erhält ein a i und ein m i (s. Abbildung 4.1).
Als ersten Schritt muss m berechnet werden. Dazu wird wieder die Doubling-Technik
verwendet. Jede Zelle überprüft, ob die Verbindung der Nachbar-Zelle noch aktiv ist.
Falls dies nicht der Fall ist, so multipliziert die Zelle ihren eigenen Wert m mit dem
Wert m ihrer Nachbar-Zelle und deaktiviert seine Verbindung. Ist die Verbindung der
Nachbar-Zelle nicht deaktiviert, so multipliziert die Zelle ihren eigenen Wert m mit dem
Wert m ihrer Nachbar-Zelle und setzt seine Verbindung auf die Verbindung der Nachbar-
Zelle. Alle Zellen mit einer deaktivierten Verbindung warten, bis die log(n) Schritte der
Ausrechenphase beendet sind, bevor sie wieder etwas machen.
Nach log(n) Schritten hat nur die erste Zelle einen korrekten Wert (s. Abbildung 4.2),
also müssen alle Zellen eine Verbindung zu der ersten Zelle aufbauen. In 4.3 haben alle
Zellen außer der ersten eine Verbindung zu der ersten Zelle aufgebaut und deren Wert
von m übernommen.
In den nachfolgenden Schritten ist keinerlei Kommunikationsaufwand nötig. Die Zellen
berechnen ihr eigenes M i indem sie m durch m i teilen. Anschließend wird der erweiterte
euklidische Algorithmus verwendet, um das y i zu berechnen. Nachdem die Zelle y i , a i
und M i kennt, kann sie diese miteinander multiplizieren und schreibt sie in den x-Wert.
96

Abbildung 4.3.: Alle Zellen haben eine Verbindung zu der ersten Zelle aufgebaut. Anschließend
wurde der Wert m bei der ersten Zelle ausgelesen und in die
eigene Variable m geschrieben.
Nachfolgend wird wieder eine Kommunikation notwendig, denn zum Abschluss des Algorithmus
müssen die gefundenen Werte x aller Zellen aufaddiert werden. Dies kann
wie das initiale Berechnen des Wertes m mit der Doubling-Technik geschehen. Dazu
addieren die Zellen ihren eigenen x-Wert und den x-Wert ihres Nachbarn falls die eigene
Verbindung aktiv ist. Ist die eigene Verbindung und die Verbindung des Nachbarn aktiv,
so wird anschließend die eigene Verbindung auf die Verbindung des Nachbarn gesetzt.
Die Lösung der simultanen Kongruenz steht dann in der ersten Zelle und kann dort
ausgelesen werden.
Da die Kongruenzen alle parallel gelöst werden, ist die Laufzeit der Anwendung des Chinesischen
Restsatzes von der Laufzeit des erweiterten euklidischen Algorithmus abhängig.
Wie bereits bei der Beschreibung des erweiterten euklidischen Algorithmus erwähnt
wurde, sind maximal log(b)/log( 1+√ 5) + 1 Schritte nötig. Allerdings fallen in dem erweiterten
euklidischen Algorithmus auch zwei Multiplikationen an, welche in [Buc01]
2
als der zeitkritische Faktor angesehen werden und deswegen die Laufzeit dominieren.
Es ergibt sich deshalb eine Laufzeit für den erweiterten euklidischen Algorithmus von
O(log(a) × log(b)). Betrachte man die Anwendung des Chinesischen Restsatzes unter
diesen Gesichtspunkten, so hat die Initialisierung auf das gemeinsame m anfangs trotz
der benötigten log(m) Schritte die gleiche Laufzeitkomplexität wie der erweiterte euklidische
Algorithmus. Insgesamt benötigt die Anwendung des Chinesischen Restsatzes
also eine Laufzeit von O(log(m) × log(n)) wobei m das größte und n das zweitgrößte
Ausgangsmodul ist.
4.3. Einordnung der Anwendung des Chinesischen
Restsatzes
In diesem Abschnitt wird die Anwendung des Chinesischen Restsatzes in das in Kapitel
2.3.4 vorgestellte Schema eingeordnet. Da die Kommunikation innerhalb dieses Algorithmus
auf die Initialisierung und das Zusammenrechnen am Ende beschränkt, reicht eine
Betrachtung dieser beiden Abläufe.
Betrachtet man diese beiden Abläufe genauer, so erkennt man, dass es sich beide Male
um eine Doubling-Technik handelt. Bei der Initialisierung müssen die Werte der Zellen
97

t l l* d d* p p*
Daten - - - + + + -
Verbindungen + - - - - + +
Tabelle 4.6.: Abhängigkeit der Verbindungen und der Daten einer Zelle für die Anwendung
des Chinesischen Restsatzes. Ein + steht für eine Abhängigkeit, ein
- für keine Abhängigkeit. Die Bedeutung der Abkürzungen ist entsprechend
denen in Kapitel 3.4.
multipliziert, am Ende muss addiert werden. Ansonsten sind beide Abläufe gleich und
können somit gemeinsam betrachtet werden.
Die Daten sind abhängig von den eigenen Daten und den Daten der Nachbarn.
Eine Abhängigkeit der Daten von der Zeit ist nicht feststellbar.
Auch von dem eigenen Ort sind die Daten nicht abhängig, außer dass das Ergebnis der
Rechnung am Ende in der ersten Zelle steht.
Interessant ist, dass sich die Daten in Abhängigkeit der eigenen Verbindung ändern. Nur
wenn die eigene Verbindung aktiv ist, werden die eigenen Daten geändert.
Die Verbindungen sind abhängig von der Verbindung des Nachbarn. Ist die Verbindung
des Nachbarn aktiv, so wird die eigene Verbindung auf diese Verbindung geändert, ansonsten
wird die eigene Verbindung deaktiviert. Außerdem sind sie abhängig von den
eigenen Verbindungen, da auf den Nachbar nur zugegriffen wird, wenn die eigene Verbindung
aktiv ist.
Da nach der Doubling-Technik alle Zellen eine Verbindung zu der ersten Zelle aufbauen,
ist die Verbindung auch abhängig von der Zeit. Es ist vorhersehbar, dass zu diesem
Zeitpunkt genau diese Verbindungen existieren.
Die Abhängigkeit vom Ort bedarf der Interpretation. Man kann sich einerseits auf den
Standpunkt stellen, dass alle Zellen, die nicht an der ersten Stelle sind, eine Verbindung
zu der ersten Zelle aufbauen. Mit dieser Betrachtung ist die Verbindung ortsabhängig.
Andererseits kann man die Auffassung vertreten, dass jede Zelle eine Verbindung zu
der ersten Zelle aufbaut (also auch die erste Zelle). In diesem Fall ist die Verbindung
ortsunabhängig. Da sich die Abhängigkeit hier sehr leicht vermeiden lässt und keine
Fehler dadurch entstehen, wird der zweite Ansatz vertreten.
Es ergeben sich also die Funktionen: d’ = f(d,d*,p) und p’ = g(t,p,p*).
98

5. Implementierungseigenheiten
Die in Kapitel 3 und Kapitel 4 vorgestellten Algorithmen wurden nicht nur in der Theorie
auf dem GCA modelliert, sondern auch in C implementiert. Allerdings besteht bei der
Programmierung in C das Problem, dass diese Sprache selbst nicht parallel ist. Die
einzige Möglichkeit, Parallelität in C zu programmieren, sind Threads.
Threads bieten die Möglichkeit, mehrere Prozesse zur gleichen Zeit aufzurufen. Auf einem
Single-Prozessor-System ergibt sich dadurch keine Laufzeitbeschleunigung. Da der
Prozessor versucht, alle Prozesse möglichst gleich zu behandeln, schaltet er nach gewissen
Zeitspannen zwischen den Prozessen um (Scheduling).
Durch dieses Verhalten wird ein Programm mit Threads auf einem Einprozessor-System
eher langsamer laufen als das gleiche Programm ohne Threads.
Aus Vergleichsgründen wurde der Warshall-Algorithmus mit und ohne Threads implementiert.
Es stellte sich heraus, dass der Warshall-Algorithmus mit Threads auch auf
einem Multiprozessor-System langsamer ist als ohne Threads. Ein Grund dafür ist die
Synchronisation, die für den Ablauf des Warshall-Algorithmus notwendig ist. Außerdem
stellte sich heraus, dass die Problemgröße zu gering ist, als dass sich die Verwendung
von Threads positiv auf die Laufzeit auswirken könnte.
Um zu überprüfen, ob dies die einzigen Gründe sind, wurde ein Testprogramm geschrieben,
welches keiner Kommunikation bedarf. Das Programm besteht aus zwei Prozessen,
die 1000000000 mal eine Random-Variable bestimmen, sie aufaddiert und modulo rechnet.
Das charakteristische Programmfragment ist im Folgendem gegeben.
Listing 5.1: Effizienztest für Threads in C
1 #define ANZAHL WIEDERHOLUNGEN 100000000
2
3 void some thread (void∗ some){
4 int i , x1 , x2 ;
5 for ( i =0; i

Es stellte sich heraus, dass sich mit Threads eine Laufzeitverbesserung erreichen lässt
(siehe Tabelle 5.1). Allerdings stellte sich auch heraus, dass Programme mit hohem
Kommunikationsaufwand und geringen Problemgrößen nicht dazu geeignet sind, mit
Threads parallelisiert zu werden.
Prozessoren Intel ohne Threads mit Threads
Singleprozessor P4 Hyperthreading 3,2 GHz 94 s 80 s
Dualprozessor Xeon Hyperthreading 3,0 GHz 80 s 41 s
Tabelle 5.1.: Ausführungszeiten ohne Threads und mit Threads
Die in Kapitel 3 betrachteten Algorithmen haben alle einen hohen Kommunikationsaufwand
und sind zudem auf ein synchrones System ausgelegt. Aus diesem Grund sind
diese Algorithmen nicht geeignet, um mit Hilfe von Threads parallelisiert zu werden.
Der kryptographische Algorithmus aus Kapitel 4 hat einen geringeren Kommunikationsaufwand,
allerdings sind die Berechnungen nicht sehr aufwendig. Eine Parallelisierung
ist hier also möglich aber nicht sinnvoll. Außerdem bedarf die beschriebene Initialisierung
und Endberechnung wieder eines synchronen Systems. Ein Thread kann also nur
sinnvoll zwischen Initialisierung und Endrechnung betrieben werden.
Der Warshall-Algorithmus wurde auf verschiedene Arten implementiert, um zu testen, ob
eine geeignete Implementierung die Laufzeit verbessert. Die meisten Implementierungen
benötigten ungefähr die gleiche Laufzeit, außer dem modularen Warshall-Algorithmus.
Dieser stellte sich als sehr laufzeitineffizient heraus. Es wurde bei den weiteren Algorithmen
deswegen auf eine Modularisierung und Kapselung verzichtet.
Der Hirschberg wurde mit Hilfe von structs implementiert. Dabei gab es ein Array (den
GCA) von structs (den Zeilen), welche die Eingabe bildeten. Alle weiteren Schritte wurden
sequentiell abgearbeitet. Programmiert man einen parallelen Algorithmus sequentiell,
so muss jede parallele Anweisung durch eine Schleife ersetzt werden.
Um Datenkonflikte (die bei synchroner Parallelität im Programm nicht auftreten) zu vermeiden,
müssen Variablen doppelt gehalten werden. Im Schritt der parallelen Veränderung
wird die Änderung nicht in die eigentliche Variable geschrieben, sondern in deren
Kopie. Nach Durchlauf der Schleife muss dann das Ergebnis in die Variable zurückgespeichert
werden.
Im konkreten Fall wurde mit Pointern gearbeitet und nach einem Durchlauf der Pointer
auf die aktuelle Variable umgebogen.
Dieses Verfahren wurde nicht nur bei dem Algorithmus von Hirschberg angewendet, sondern
auch bei den anderen Algorithmen. Eine Ausnahme bildete dabei die Anwendung
des Chinesischen Restsatzes, da dieser keine Kommunikation bedarf. Soll das Programm
für die Anwendung des Chinesischen Restsatzes parallelisiert werden, muss lediglich die
Schleife durch eine parallele Anweisung ersetzt werden.
100

6. Zusammenfassung und Ausblick
In dieser Arbeit wurde anfangs ein Überblick über momentan verwendete parallele Modelle
geliefert. Die Auswahl umfasst hierbei die P-RAM, die parallelen Pointer-Maschinen
und die Zellularautomaten. Innerhalb der Zellularautomaten wurde der ”
Global Cellular
Automata “ (GCA) als Modell vorgestellt. Dieser wurde im weiteren verwendet.
In Kapitel 3 und Kapitel 4 wurden dann Algorithmen auf dem GCA modelliert. Im
Rahmen der Modellierungen der Graphen-Algorithmen in Kapitel 3 wurde auch eine
Speicherzelle entwickelt. Diese ist als Konstrukt portabel und erlaubt es dem GCA,
einen gemeinsamen Speicher zu simulieren. Es können allerdings keine Daten in den
Speicher geschrieben werden, sondern die Speicherzelle muss sich aktiv die Daten bei
den Zellen holen und an den von den Zellen vorgeschriebenen Platz schreiben. Auch
gestaltet sich ein Lese-Zugriff auf den Speicher schwerer, da eine Zelle erst die Stelle
angeben muss, von der sie lesen möchte, bevor die Speicherzelle den Wert bereitstellt.
Trotzdem ermöglicht die Speicherzelle eine Modellierung von P-RAM-Programmen auf
dem GCA. Der Autorin sind momentan keine Fälle bekannt, in denen ein sofortiger
wahlfreier Zugriff auf die Daten des Speichers nötig ist.
Ein weiteres neu entwickeltes Konstrukt ist die Bus-Zelle. Erscheint es in einer Anwendung
als sinnvoll, einen Bus zu verwenden, ist dies aber aus diversen Gründen nicht
möglich, so kann die Bus-Zelle verwendet werden. Allerdings ist bei der Bus-Zelle eine
geeignete Verwaltung notwendig, damit die Bus-Zelle weiß, bei welcher Zelle sie momentan
lesen muss. Im Falle des Warshall-Algorithmus ist das einfach, allerdings gestaltet
sich die Verwendung des Busses nicht immer einfach.
Für eine Entscheidung, ob die Bus-Zelle sinnvoll verwendbar ist oder nicht, kann das
in Kapitel 2.3.4 vorgestellte Schema verwendet werden. Es eignen sich vor allem solche
Algorithmen, deren Verbindungen möglichst von nichts oder nur der Zeit (und eventuell
wie beim Warshall-Algorithmus von den Daten) abhängen.
Im weiteren sind die in Kapitel 3 gegebenen Algorithmen ein gutes Beispiel dafür, dass
parallel entwickelte Algorithmen meist effizienter sind als parallelisierte sequentielle Algorithmen.
Die zeigt sich u. a. in dem Vergleich zwischen Warshall-Algorithmus (O(n))
und dem Algorithmus von Hirschberg (O(log 2 (n))).
Allerdings ist die Laufzeitkomplexität meist trügerisch. Die Algorithmen der Klasse O(n)
beispielsweise müssen erst ab einem Wert n 0 langsamer oder gleich schnell wie n wachsen.
Dieses n 0 wird in der Laufzeitkomplexität allerdings nicht angegeben.
Betrachtet man laufzeiteffiziente Algorithmen genauer, kann man also u. U. feststellen,
dass dieses n 0 größer als normale Problemgrößen ist. Ein Beispiel hierfür ist Coles Al-
101

gorithmus, der erst ab einem n 0 ≥ 2 70 genauso langsam wie log(n) wächst. Es erscheint
in solchen Fällen sinnvoller, einen langsameren Algorithmus (statt Coles Algorithmus z.
B. das Bitonische Mischen) zu verwenden, der innerhalb der gewünschten Problemgröße
ein besseres Laufzeitverhalten aufweist.
Auch in Zukunft wird es interessant sein, parallele Algorithmen zu entwickeln. Da zur
heutigen Zeit wieder vermehrt parallele Architekturen entworfen und gebaut werden,
erscheint es auch sinnvoll, die Möglichkeiten dieser Architekturen genauer zu studieren.
Ein Algorithmus, der sich optimal an die Gegebenheiten der Architektur anpasst und für
sie entwickelt wurde, wird in den meisten Fällen um einiges besser sein als ein allgemeiner
Algorithmus. Da solche Algorithmen jedoch nicht mehr portabel sind, ist zu bezweifeln,
dass eine Architektur es schafft, einen so großen Ausbreitungsgrad zu erreichen, dass
sich solch ein Aufwand lohnt.
Bis zu dem Zeitpunkt an dem es eine ”
universelle“ Architektur gibt, die mehr als 50%
des Marktanteils ausmacht, werden nur teure Speziallösungen wirklich auf die Architektur
angepasst werden. Es ist zu erwarten, dass solange es keine solche Architektur gibt,
auch weiterhin Algorithmen auf Automatenmodellen entwickelt werden. Denn Automatenmodelle
erlauben es, dass man einen Algorithmus entwickeln kann, ohne die genaue
Architektur zu kennen, auf dem das Programm später läuft. Wer den Algorithmus dann
implementieren will, kann sich immer noch entscheiden, ob er dies sehr architekturnah
oder so abstrakt wie möglich realisieren möchte.
102

A. Traversierungsstrategien
Im folgenden sollen einige Traversierungsstrategien angegeben werden, die verwendet
werden, um schwierige Probleme zu lösen.
A.1. Backtracking
Backtracking liefert einen Algorithmus, um strukturiert alle möglichen Lösungen durchzutesten.
Dabei wird immer versucht, auf der bislang erzielten Teillösung aufbauend, dem
Endergebnis näher zu kommen. Entsteht dabei ein Konflikt, so wird die vorhergehende
Entscheidung zurückgenommen und somit die Ausgangslage verändert. Das Verfahren
soll anhand des Acht-Damen-Problems erläutert werden. Aufgabe ist es dabei, auf einem
8x8-Schachbrett acht Damen so zu positionieren, dass keine Dame eine andere schlagen
kann.
Die erste Dame wird in die obere linke Ecke gesetzt, Abb. A.1 verdeutlicht zudem auch
noch alle Felder, auf die keine Dame mehr gestellt werden kann.
Die zweite Dame kann nun weder auf dem ersten noch dem zweiten Feld positioniert
werden, also landet sie auf dem dritten Feld der zweiten Zeile. In Abb. A.2 ist die Dame
schon positioniert und es wurde wieder zum Verständnis markiert, welche Felder alle
für die zukünftige Positionierung von Damen gesperrt ist. Die dritte Dame kann jetzt
erst an die vierte Stelle der dritten Zeile positioniert werden, auch dies wird wieder mit
einer Abbildung verdeutlicht. Abb. A.3 zeigt das Schachbrett nach der Positionierung
Abbildung A.1.: Die erste Dame wurde in die obere linke Ecke positioniert. Da Damen
geradeaus und diagonal gehen können, ist die restliche Zeile sowie die
Spalte und die Diagonale als gesperrt markiert. Diese Markierung dient
nur dem Verständnis, der Algorithmus liefert sie nicht.
103

Abbildung A.2.: Die zweite Dame wurde an die dritte Position der zweiten Zeile positioniert.
Da Damen geradeaus und diagonal gehen können, ist die restliche
Zeile sowie die Spalte und die Diagonale als gesperrt markiert.
Abbildung A.3.: Die dritte Dame wurde auf das erste Feld in der dritten Zeile gesetzt,
welches keinen Konflikt auslöst. Es wurden wieder alle Felder markiert,
die von der dritten Dame geschlagen werden.
der dritten Dame. Im nächsten Schritt wird dann die vierte Dame in der vierten Zeile
positioniert.
Das Schachbrett nach dem positionieren der vierten Dame zeigt Abb. A.4.
Nachdem die fünfte Dame positioniert wurde, sieht das Feld wie in Abb. A.5 aus. Durch
die Markierung wird deutlich, dass die sechste Dame nicht mehr gesetzt werden kann,
ohne dass sie sofort geschlagen wird. Eine korrekte Lösung ist also bei der vorher getroffenen
Annahme nicht möglich.
Da die sechste Dame also nicht positioniert werden kann, muss die Positionierung der
fünften Dame falsch sein. Also wird die fünfte Dame wieder vom Brett genommen und
neu positioniert. Dabei wird darauf geachtet, dass die fünfte Dame nicht mehr an die
Stelle kommen kann, an der sie davor saß. Dieses Zurücknehmen einer Entscheidung
kennzeichnet das Backtracking. Allerdings wird auch durch die Neupositionierung der
fünften Dame (s. Abb. A.6) kein Feld in der sechsten Zeile frei, weshalb die fünfte Dame
komplett vom Feld genommen wird und die vierte Dame neu positioniert wird. Die neue
Situation ist in Abb. A.7 dargestellt.
Diese Schritte des Setzens und Zurücknehmens von Damen wird solange wiederholt, bis
104

Abbildung A.4.: Die vierte Dame wurde auf das erste Feld in der dritten Zeile gesetzt,
welches keinen Konflikt auslöst. Es wurden wieder alle Felder markiert,
die von der dritten Dame geschlagen werden.
Abbildung A.5.: Die fünfte Dame ist auf dem Feld positioniert worden und es ist ersichtlich,
dass die sechste Dame nicht mehr positioniert werden kann.
Abbildung A.6.: Die fünfte Dame ist auf dem Feld reposiotioniert worden, in der sechsten
Zeile kann trotzdem keine Dame positioniert werden. Es ist also
ein weiterer Backtracking-Schritt notwendig.
105

Abbildung A.7.: Nachdem die vierte Dame auf dem Feld repositioniert wurde, gibt es
zwei interessante Stellen, an die die fünfte Dame positioniert werden
kann.
die achte Dame positioniert wurde, dann ist eine Lösung für das Problem gefunden.
Anzumerken ist, dass der Algorithmus auch die Stellen, die in den Abbildungen mit
einem * gekennzeichnet sind, abtestet und somit viele Tests vonnöten sind. Beim Acht-
Damen-Problem ist die Laufzeit aus zwei Gründen erträglich:
1. Die Anzahl der Damen ist begrenzt und sehr klein.
2. Es existiert mehr als eine Lösung, jede Lösung wird als gleichwertig angesehen,
weshalb nach dem Finden einer Lösung der Algorithmus beendet ist.
Diese zwei Punkte gelten nicht für alle Probleme, die mittels Backtracking gelöst werden
müssen, so dass das exponentielle Verhalten des Backtrackings die meisten Lösungen
uninteressant machen.
A.2. Divide and Conquer
Für das Divide-and-Conquer-Verfahren eignen sich solche Problemstellungen, die sich in
unabhängige Teilprobleme zerlegen lassen. Der bekannteste Algorithmus, der nach dem
Divide-and-Conquer-Verfahren arbeitet, ist der Quicksort.
Quicksort macht eine Vorsortierung auf der gegebenen Liste und teilt diese dann in
zwei Teillisten. Jede der Teillisten kann für sich allein sortiert werden, und am Schluss
müssen die Teillisten nur noch zusammengehängt werden, um das korrekte Gesamtergebnis
zu erhalten. Divide-and-Conquer wird in der Regel rekursiv verwendet, da die
Lösung so verständlicher ist 1 . Im Falle des Quicksorts bedeutet dies, dass jede Liste vorsortiert
wird und dann auf die Teillisten wieder der Quicksort angewendet wird. Dabei
1 Sequentielle rekursive Lösungen weisen meist ein schlechteres Laufzeitverhalten auf als iterative
Lösungen. Trotzdem verzichtet man meist darauf, die Algorithmen iterativ zu programmieren, da
rekursive Programme übersichtlicher und somit für den Fachmann leichter lesbar sind. Grundsätzlich
können alle rekursiven Programme in iterative Programme umgearbeitet werden, allerdings ist
oft der Aufwand dafür recht groß und das Programm wird unleserlich.
106

Abbildung A.8.: Die Startinitialisierung des Quicksorts. Das Pivot ist durch einen
dicken Kasten markiert, die ersten zu vergleichenden Elemente durch
die Zeiger i und j. Das Pivot-Element wird anfangs nicht verglichen
sondern am Ende des Vorsortierens an den korrekten Platz getauscht.
Abbildung A.9.: Die Vorsortierung wurde beendet. Da j links von i steht, wird die Vorsortierung
abgeschlossen.
wird eine einelementige Liste als sortiert betrachtet. Die Länge der Liste bietet also das
Abbruchkriterium, mit dem die Rekursion kontrolliert beendet wird.
Zur Veranschaulichung soll die Liste (7, 5, 10, 1, 3, 4, 9, 6, 12, 15, 2, 20, 22, 14) sortiert werden.
Dazu wird ein Vergleichselement, das sogenannte Pivot, gewählt und alle Werte
mit diesem verglichen. Werte die kleiner als das Pivot sind, werden nach links, größere
Werte nach rechts sortiert. Wie dies genau geschieht hängt von der jeweiligen Implementierung
ab, hier werden zwei Zeiger i und j verwendet, die den Vergleich kleinergleich
(i) bzw. größer (j) durchführen und dazu am linken Ende (i) bzw. rechten Ende (j) der
Liste starten. Als Pivot wird hier das linke Element der Liste gewählt. Die Ausgangssituation
ist in Abbildung A.8 dargestellt. Das Pivot-Element ist dick umrandet, i zeigt
auf das zweite Feld von links (da das linke Element das Pivot ist, erübrigt sich hier ein
Vergleich), j auf das letzte Element der Liste.
Im Laufe des Algorithmus wird der linke Zeiger i immer eine Stelle nach rechts gerückt,
wenn der Wert auf den i momentan zeigt kleinergleich dem Pivot-Element ist. Ist der
Vergleich nicht erfolgreich (ist also der Wert an der Stelle i größer als das Pivot-Element),
so bleibt i stehen und der Zeiger j wird solange nach links gerückt, bis entweder ein Wert
gefunden wird, der kleinergleich dem Pivot ist oder bis der Zeiger j links vom Zeiger i
steht. Bleibt j auf einem Feld stehen, dessen Inhalt kleinergleich dem Pivot ist, so wird
getauscht, ansonsten kann der rekursive Aufruf erfolgen.
Für den rekursiven Aufruf wird zuerst das Pivot-Element mit dem Wert an der j-ten
Stelle getauscht. Dann wird Quicksort auf die Liste von der ersten Stelle bis zur Stelle j-1
und von der j+1-ten Stelle bis zur letzten Stelle der Liste aufgerufen. Abbildung A.9 zeigt
die Liste nach der Vorsortierung, wobei das Pivot-Element noch nicht getauscht wurde.
In Abbildung A.10 wurde der Tausch des Pivots bereits durchgeführt, das Pivot-Element
steht an der korrekten Stelle. Zudem wurde die Liste aufgeteilt, dies wird durch die Zeiger
i1, j1, i2 und j2 verdeutlicht, welche für die linke bzw. rechte Teilliste die Grenzen mar-
107

kieren. Für beide Teillisten wurde das Pivot dick umrandet. Für diese beiden Teillisten
wird wieder wie beschrieben die Vorsortierung ausgeführt und wieder geteilt. Dabei wird
bei jeder Vorsortierung mindestens ein Element (das Pivot-Element) endgültig sortiert.
Abbildung A.10.: Das Pivot wurde an seine endgültige Stelle getauscht und die Liste in
zwei Teillisten zerlegt. Die umrandeten Felder geben die Pivots für die
Teillisten an, i1,j1,i2 und j2 bezeichnen die Grenzen der Teillisten.
Der Quicksort wird mit diesen Teillisten rekursiv ausgeführt.
108

B. Parallele Algorithmische Techniken
Bei parallelen Systemen gibt es zusätzlich zu den bekannten sequentiellen Techniken
(s. vorheriges Kapitel) noch die Möglichkeit, die Kommunikation der Prozessoren nach
bestimmten Prinzipien aufzubauen und dadurch schnelle Lösungen zu erhalten. In den
nachfolgenden Abschnitten sollen einige der Techniken, die im Rahmen dieser Ausarbeitung
verwendet oder erwähnt werden, näher erklärt werden. Meist findet sich bereits
im Text eine kurze Erläuterung zu den Methoden, allerdings werden hier noch einmal
andere Beispiele angeführt, um die Methoden weiter zu verdeutlichen. Die benötigte Anzahl
an Prozessoren kann bei den meisten Methoden verringert werden, aber in diesem
Anhang wird nicht näher auf diese Möglichkeiten eingegangen, der interessierte Leser sei
an [GR98] verwiesen.
B.1. Die Balanced-Binary-Tree-Technik
Grundlage der Balanced-Binary-Tree-Technik ist ein vollständiger Binärbaum. Dieser
Baum wird dermaßen belegt, dass in die Blätter die Werte geschrieben werden, die bearbeitet
werden sollen. Die inneren Knoten werden durch Prozessoren dargestellt, die
auf den Werten ihrer Söhne einen Teil der geforderten Berechnung ausführen. Dementsprechend
arbeiten zuerst die Prozessoren, die in der untersten Ebene angeordnet sind,
und erst wenn diese ihr Ergebnis haben, können die Prozessoren der Ebene darüber
ihre Berechnung ausführen. Probleme, die sich effizient mit der Balanced-Binary-Tree-
Technik lösen lassen, sind das Finden des Minimums, des Maximums oder der Summe
einer gegebenen Menge von Zahlen.
Das erfolgreiche Auffinden des Minimums der Liste mit Hilfe der Technik wurde bereits
in Kapitel 3.1.3.2 vorgestellt, ein Beispiel für das Maximum findet sich u. a. in [GR98].
Aus diesem Grund soll hier das Beispiel zur Bestimmung der Summe anhand der Abbildung
B.1 veranschaulicht werden. Die zu untersuchenden Werte stehen in den Blättern
des Baums und jeder Knoten addiert seine Söhne. Damit ist die Summe des Knotens berechnet
und sein Vater kann mit diesem Teilergebnis weiterrechnen. Die Wurzel enthält
am Ende das Gesamtergebnis. Möchte man die Summe einer Liste bestimmen, deren
Länge keine Zweierpotenz ist, so müssen die freien Blätter mit dem Wert 0 gefüllt werden,
damit das Ergebnis nicht verfälscht wird.
109

Abbildung B.1.: In den Blättern stehen die Werte deren Summe gebildet werden soll.
Jeder Prozessor (innerer Knoten) berechnet die Summe für seine Nachfolger.
Das Ergebnis steht nach log(n) Schritten in der Wurzel.
Der Pseudocode zur Bestimmung der Summe lautet:
Listing B.1: Berechnung der Summe mit der Balanced-Binary-Tree-Technik
1 for k

Abbildung B.2.: Jeder Prozessor repräsentiert einen Wert der Liste. Für jedes Listenelement
wird nacheinander der Abstand zum Listenende bestimmt. Die
Graphik zeigt die einzelnen Schleifendurchläufe der Doubling-Technik,
die unterste Abbildung entspricht dem Endergebnis.
B.3. Die Divide-and-Conquer-Technik
Die parallele Divide-and-Conquer-Technik ist der seriellen sehr ähnlich, allerdings wird
bei der parallelen gefordert, dass die Teilprobleme einer Rekursionsebene sich vollständig
unabhängig voneinander lösen lassen 1 . Die Balanced-Binary-Tree-Technik kann als ein
Spezialfall der Divide-and-Conquer-Technik angesehen werden, da auch dort die Knoten
einer Ebene die Berechnungen unabhängig voneinander ausführen. Allerdings verfolgt
die Balanced-Binary-Tree-Technik die Bottom-up-Methode 2 , während die Divide-and-
Conquer-Technik die Top-down-Methode 3 verwendet. Die Divide-and-Conquer-Technik
kann für alle Probleme angewendet werden, die auch bei der Balanced-Binary-Tree-
Technik angeführt wurden (natürlich sind dies nicht die einzigen Probleme, für die die
beiden Techniken sich eignen, allerdings sind sie einfach und damit leicht nachvollziehbar).
So kann das Minimum einer Liste z. B. dadurch bestimmt werden, dass man das
Minimum in der linken Hälfte und in der rechten Hälfte der Liste bestimmt. Danach
muss aus diesen beiden Werten nur noch das Minimum bestimmt werden und das Gesamtergebnis
ist gefunden.
1 Meist wird diese Bedingung auch im sequentiellen Fall erfüllt, da die Probleme dadurch überschaubarer
bleiben
2 Bei der Bottom-up-Methode werden zuerst die Teilprobleme gelöst und diese nach und nach zu der
Gesamtlösung zusammengesetzt.
3 Bei der Top-down-Methode wird das zu lösende Problem solange weiter zerlegt, bis die gefundenen
Teilprobleme leicht lösbar sind.
111

C. Implementierungen der Algorithmen
C.1. Warshall-Algorithmus
Listing C.1: Implementierung des Warshall-Algorithmus
1
2 #include
3 #include
4 #include
5 #include
6 #define N 30
7 #define DATEI ”Matrix0 . dat”
8 #define ANZAHL WIEDERHOLUNGEN 1
9 #define Debug 1
10 FILE ∗ f i l e ;
11 struct handle {
12 int row [N] ;
13 int ID ;
14 };
15
16 int takt [N] ;
17 int currentID ;
18 int done ;
19 int Bus [N] ;
20 int aktual ;
21 int NumReady;
22 int Result [N] [N] ;
23
24 void c e l l ( struct handle ∗ give ) {
25 int i ;
26 int ownRow[N] ;
27 int ownID=(∗give ) . ID ;
28 for ( i =0; i

67 void main () {
68 struct handle give [N] ;
69 int i , j , k ;
70 char datum ;
71 LARGE INTEGER start ticks , ende ticks , frequenz ;
72 double t i c k d i f f = 0;
73 for ( i =0; i

24
25 void hirschberg ( int GCA[N] [N] ) {
26 int i , j , k , l ;
27 int Thelp [N] ;
28 int ∗ aktual ;
29 int ∗ start ;
30 int ∗ old ;
31 int found ; /∗ z e i g t an , ob der gesuchte Eintrag gefunden wurde ∗/
32
33 for ( l =1; l

114 int complete [N]={0 ,0 ,0 ,0 ,0 ,0 ,0 ,0};
115 LARGE INTEGER start ticks , ende ticks , frequenz ;
116 double t i c k d i f f = 0;
117 QueryPerformanceFrequency(&frequenz ) ;
118 printf (”Beginne mit der Messung der benoetigten Zeit des Hirschbergalgorithmus \n”) ;
119 /∗ I n i t i a l i s i e r u n g Zeitmessung ∗/
120 s t a r t t i c k s . QuadPart = 0;
121 ende ticks . QuadPart = 0;
122 QueryPerformanceCounter(& s t a r t t i c k s ) ;
123 hirschberg (GCA) ;
124 /∗ Abschliessen der Zeitmessung ∗/
125 QueryPerformanceCounter(&ende ticks ) ;
126 t i c k d i f f = ((double) ende ticks . QuadPart − (double) s t a r t t i c k s . QuadPart) /
127 frequenz . QuadPart ;
128 printf (” Benoetigte Zeit in Sekunden %f \n” , t i c k d i f f ) ;
129 printf (”Ergebnis : ”) ;
130 /∗Ausgabe der Komponenten ∗/
131 for ( i =0; i

51 Graph [ last ]=Graph [ 0 ] ;
52 last −−;
53 heap (0 , last ) ;
54 return ret ;
55 }
56
57 void main () {
58 int tree [N] ;
59 int number ;
60 int in , i , j , tested , trunc , keep ;
61 struct vector edge ;
62 struct vector spanntree [N−1];
63 for ( i =0; i

141 number++;
142 in = 1;
143
144 /∗Die Teilbaeume zusammenfuegen . ∗/
145 if ( in==1){
146 for ( j =0; j

56 }
57 Tglobal [ i ] = Cglobal [ to [ i ] ] ;
58 value [ i ] = GCA[ i ] [ to [ i ] ] ;
59 }/∗Ende erster T e i l s c h r i t t
60 / ∗2. T e i l s c h r i t t von Schritt 1. Auch hier i s t die s e r i e l l e Loesung wieder schlechter
61 als die parallele , das Minimum muss e x p l i z i t gesucht werden und es muss gespeichert werden , von
62 wo die Kante kam. ∗/
63 for ( i =0; i 0) ) {
66 doppelt [ i ]= to [ i ] ;
67 }
68 else doppelt [ i ]=N;
69 }
70 for ( i =0; i

146 /∗ Abschliessen der Zeitmessung ∗/
147 QueryPerformanceCounter(&ende ticks ) ;
148 t i c k d i f f = ((double) ende ticks . QuadPart − (double) s t a r t t i c k s . QuadPart) /
149 frequenz . QuadPart ;
150 printf (” Benoetigte Zeit in Sekunden %f \n” , t i c k d i f f ) ;
151 printf (”Ergebnis : ”) ;
152 /∗Ausgabe der Komponenten ∗/
153 for ( i =0; ikey . points [ 1 ] != key2 . points [ 1 ] ) ) {
42 actual = actual −>next ;
43 }
44 if ( actual == NULL | | actual −>next == NULL && ( actual −>key . points [ 0 ] != key2 . points [ 0 ] | | actual
−>key . points [ 1 ] != key2 . points [ 1 ] ) ) {
45 help = malloc ( sizeof ( struct list element ) ) ;
46 (∗ help ) . key = key2 ;
47 help−>value = value ;
48 help−>next = NULL;
49 if ( Liste == NULL) Liste = help ;
50 else actual −>next = help ;
51 }
52 else {
53 actual −>value = value ;
119

54 }
55 return Liste ;
56 }
57
58 /∗Die Funktion get l i e f e r t zu einem Key den zugehoerigen Value einer Kante . Die Liste b l e i b t dabei
59 unveraendert . ∗/
60 struct EDGE get ( struct list element ∗Liste , struct EDGE key ) {
61 struct list element ∗actual ;
62 struct EDGE err ;
63 int finished ;
64 actual = Liste ;
65 finished = 0;
66 err . points [0]= 0;
67 err . points [1]= 0;
68 while( actual != NULL && finished == 0) {
69 if ( actual −>key . points [ 0 ] == key . points [ 0 ] && actual −>key . points [ 1 ] == key . points [ 1 ] ) {
70 finished = 1;
71 return actual −>value ;
72 }
73 else actual= actual −>next ;
74 }
75 return err ;
76 }
77
78 /∗Die Funktion doubling succ fuehrt einen Durchlauf der Doubling −Technik fuer die Successor −Liste
aus . ∗/
79 struct list element ∗ doubling succ ( struct list element ∗ Liste ) {
80 struct list element ∗ actual , ∗ start ;
81
82 actual = Liste ;
83 start = NULL;
84 while( actual != NULL) {
85 start = set ( start , actual −>key , get ( Liste , actual −>value ) ) ;
86 actual = actual −>next ;
87 }
88 return start ;
89 }
90
91 /∗Fuehrt einen Schritt der doubling −Technik fuer die Kanten aus , dabei wird die Edge−Liste
a k t u a l i s i e r t .
92 Im Laufe des Schritts wird eine modifizierte Kopie der Edge−Liste angelegt und die uebergebene
Liste dann geloescht . ∗/
93
94 struct list element ∗ doubling edge ( struct list element ∗ Liste , struct list element ∗Successor ) {
95 struct list element ∗actual , ∗ start ;
96 struct EDGE kante , vergleich ;
97
98 actual = Liste ;
99 start = NULL;
100 while( actual != NULL) {
101 kante = actual −>value ;
102 vergleich = get ( Liste , get ( Successor , actual −>key ) ) ;
103 if ( kante . points [ 0 ] < vergleich . points [ 0 ] | | ( kante . points [ 0 ] == vergleich . points [ 0 ] && kante .
points [ 1 ] < vergleich . points [ 1 ] ) ) {
104 start = set ( start , actual −>key , kante ) ;
105 }
106 else start = set ( start , actual −>key , vergleich ) ;
107 actual = actual −>next ;
108 }
109 return start ;
110 }
111
112 /∗Die Funktion size l i e f e r t die Anzahl der Elemente der Liste zurueck . ∗/
113 int size ( struct list element ∗ Liste ) {
114 int i ;
115 struct list element ∗actual ;
116 actual = Liste ;
117 i= 0;
118 if ( Liste == NULL) return 0;
119 else {
120 while( actual != NULL ) {
121 i++;
122 actual = actual −>next ;
123 }
124 return i ;
125 }
126 }
127
128 /∗Die Funktion s o r t l i s t l i e f e r t die s o r t i e r t e Liste zurueck . Als Sortieralgorithmus dient hier
129 Bubblesort . ∗/
130 struct list element ∗ s o r t l i s t ( struct list element ∗ Liste ) {
131 struct list element ∗switcher , ∗actual , ∗previous ;
132 struct EDGE help ;
133 int i , j ;
134
135 for ( i = 0; i< size ( Liste ) ; i++){
136 actual = Liste ;
137 previous = Liste ;
138 for ( j =0; j< size ( Liste ) −1; j++){
139 if ( actual != NULL && actual −>next != NULL) {
120

140 if (( actual −>key . points [ 0 ] > actual −>next−>key . points [ 0 ] ) | | ( actual −>key . points [ 0 ] ==
actual −>next−>key . points [ 0 ] && actual −>key . points [ 1 ] > actual −>next−>key . points [ 1 ] ) ) {
141 if ( j==0){
142 switcher = actual −>next ;
143 actual −>next = switcher −>next ;
144 switcher −>next = actual ;
145 Liste = switcher ;
146 }
147 else {
148 switcher = actual −>next ;
149 actual −>next = switcher −>next ;
150 switcher −>next = actual ;
151 previous −>next = switcher ;
152 help=get ( Liste , actual −>key ) ;
153 previous = previous −>next ;
154 }
155 }
156 else {
157 if ( j != 0) previous = previous −>next ;
158 actual = actual −>next ;
159 }
160 }
161 }
162 }
163 return Liste ;
164 }
165 /∗Die Funktion strange sort l i e f e r t die s o r t i e r t e Liste zurueck . Als Sortieralgorithmus dient hier
166 Bubblesort . ∗/
167 struct list element ∗ strange sort ( struct list element ∗ Liste ) {
168 struct list element ∗switcher , ∗actual , ∗previous ;
169 struct EDGE help ;
170 int i , j ;
171
172 for ( i = 0; i< size ( Liste ) ; i++){
173 actual = Liste ;
174 previous = Liste ;
175 for ( j =0; j< size ( Liste ) −1; j++){
176 if ( actual != NULL && actual −>next != NULL) {
177 if (( actual −>key . points [ 1 ] > actual −>next−>key . points [ 1 ] ) | | ( actual −>key . points [ 1 ] ==
actual −>next−>key . points [ 1 ] && actual −>key . points [ 0 ] > actual −>next−>key . points [ 0 ] ) ) {
178 if ( j==0){
179 switcher = actual −>next ;
180 actual −>next = switcher −>next ;
181 switcher −>next = actual ;
182 Liste = switcher ;
183 }
184 else {
185 switcher = actual −>next ;
186 actual −>next = switcher −>next ;
187 switcher −>next = actual ;
188 previous −>next = switcher ;
189 help=get ( Liste , actual −>key ) ;
190 previous = previous −>next ;
191 }
192 }
193 else {
194 if ( j != 0) previous = previous −>next ;
195 actual = actual −>next ;
196 }
197 }
198 }
199 }
200 return Liste ;
201 }
202
203 /∗Die Funktion d e f i n e s t a r t s d e f i n i e r t fuer jeden Knoten das Element der Linked−List , welches als
204 erstes eine ausgehende Kante des Knotens repraesentiert . ∗/
205 void define starts ( struct list element ∗ Liste ) {
206 int i ;
207 struct list element ∗pos ;
208
209 pos= Liste ;
210 for ( i =0; ikey . points [ 0 ] == i +1){
212 if ( pos−>key . points [ 0 ] == i+1 && Cells [ i ] . f i r s t == NULL) {
213 Cells [ i ] . f i r s t = pos ;
214 }
215 pos = pos−>next ;
216 }
217 }
218 }
219
220 /∗Die Funktion c o p y l i s t l i e f e r t eine Copie der uebergebenen Liste zurueck . ∗/
221 struct list element ∗ copy list ( struct list element ∗ Liste ) {
222 struct list element ∗actual , ∗neustart ;
223 neustart = NULL;
224 actual = Liste ;
225 while( actual != NULL) {
226 neustart=set ( neustart , actual −>key , actual −>value ) ;
227 actual = actual −>next ;
121

228 }
229 return neustart ;
230 }
231
232 /∗Die Funktion define successor bestimmt fuer jede Kante ihre Successor −Kante . ∗/
233 struct list element ∗ define successor ( struct list element ∗ Liste ) {
234 struct list element ∗actual , ∗ start ;
235 struct EDGE kante ;
236 int i ;
237
238 start = copy list ( Liste ) ;
239 actual = start ;
240 i =0;
241 while( actual != NULL) {
242 i++;
243 if ( actual −>key . points [ 0 ] == Cells [ i −1]. f i r s t −>key . points [ 0 ] && actual −>key . points [ 1 ] == Cells [
i −1]. f i r s t −>key . points [ 1 ] ) {
244 actual = actual −>next ;
245 }
246 while( actual != NULL && actual −>key . points [ 0 ] == i ) {
247 if ( actual −>next != NULL && actual −>next−>key . points [ 0 ] ==i ) {
248 kante . points [0]= actual −>key . points [ 1 ] ;
249 kante . points [1]= i ;
250 start = set ( start , kante , actual −>next−>key ) ;
251 kante . points [ 0 ] = actual −>next−>key . points [ 1 ] ;
252 kante . points [ 1 ] = i ;
253 start = set ( start , kante , actual −>key ) ;
254 actual = actual −>next−>next ;
255 }
256 else {
257 kante . points [ 0 ] = actual −>key . points [ 1 ] ;
258 kante . points [ 1 ] = i ;
259 start = set ( start , kante , Cells [ i −1]. f i r s t −>key ) ;
260 kante . points [ 0 ] = Cells [ i −1]. f i r s t −>key . points [ 1 ] ;
261 kante . points [ 1 ] = i ;
262 start = set ( start , kante , actual −>key ) ;
263 actual = actual −>next ;
264 }
265 }
266 }
267 return start ;
268 }
269
270 struct list element ∗ select elements ( struct list element ∗ Liste ) {
271 struct list element ∗ actual , ∗ start ;
272 struct EDGE kante , vergleich ;
273 actual = Liste ;
274 start = NULL;
275 while( actual != NULL) {
276 kante . points [ 0 ] = actual −>key . points [ 1 ] ;
277 kante . points [ 1 ] = actual −>key . points [ 0 ] ;
278 vergleich = get ( Liste , kante ) ;
279 kante= actual −>value ;
280 if ( kante . points [ 0 ] < vergleich . points [ 0 ] | | ( kante . points [ 0 ] == vergleich . points [ 0 ] && kante .
points [ 1 ] < vergleich . points [ 1 ] ) ) {
281 start = set ( start , actual −>key , actual −>key ) ;
282 }
283
284 actual = actual −>next ;
285 }
286 d e s t r o y l i s t ( Liste ) ;
287 return start ;
288 }
289
290 struct list element ∗ rearange ( struct list element ∗Liste , struct list element ∗Successor ) {
291 struct list element ∗actualEdge , ∗actualSucc , ∗ start ;
292 struct EDGE succ ;
293 int i ;
294 actualEdge = Liste ;
295 actualSucc = Successor ;
296 start = NULL;
297 for ( i =0; i < size ( Liste ) ; i++){
298 start = set ( start , actualEdge−>key , actualSucc −>key ) ;
299 succ = actualSucc −>key ;
300 actualEdge = Liste ;
301 actualSucc = Successor ;
302 while (( actualEdge−>key . points [ 0 ] != succ . points [ 0 ] | | actualEdge−>key . points [ 1 ] != succ . points
[ 1 ] ) && actualEdge != NULL) {
303 actualEdge = actualEdge−>next ;
304 actualSucc = actualSucc −>next ;
305 }
306 }
307 d e s t r o y l i s t ( Liste ) ;
308 return start ;
309 }
310
311 /∗Damit der Speicher auch nach mehrmaligem Ausfuehren des Programms nicht zu v o l l ist , wird der
312 r e s e r v i e r t e Speicherbereich hier wieder freigegeben . ∗/
313
314 void d e s t r o y l i s t ( struct list element ∗ Liste ) {
122

315 struct list element ∗help ;
316 while( Liste != NULL && Liste −>next != NULL) {
317 help = Liste −>next ;
318 free ( Liste ) ;
319 Liste = help ;
320 }
321 free ( Liste ) ;
322 }
323
324 struct list element ∗ Euler partition ( struct list element ∗ Liste ) {
325 struct list element ∗ EDGES ,∗SUCCESSORS, ∗help ;
326 int i ;
327 EDGES = Liste ;
328 EDGES = s o r t l i s t (EDGES) ;
329 help = EDGES;
330 define starts (EDGES) ;
331 SUCCESSORS = NULL;
332 SUCCESSORS = define successor (EDGES) ;
333 for ( i =0; i < LOGN; i++){
334 EDGES = doubling edge (EDGES,SUCCESSORS) ;
335 SUCCESSORS = doubling succ (SUCCESSORS) ;
336 }
337 EDGES = select elements (EDGES) ;
338 d e s t r o y l i s t (SUCCESSORS) ;
339 SUCCESSORS = copy list (EDGES) ;
340 EDGES = strange sort (EDGES) ;
341 SUCCESSORS = s o r t l i s t (SUCCESSORS) ;
342 EDGES = rearange (EDGES,SUCCESSORS) ;
343 help = EDGES;
344 i =0;
345 while( help != NULL) {
346 help−>key . label=i ;
347 i = ( i == 0) ;
348 help = help−>next ;
349 }
350 d e s t r o y l i s t (SUCCESSORS) ;
351 return EDGES;
352 }
353
354 int NodeDegree ( int knoten , struct list element ∗ Liste ) {
355 int i ;
356 struct list element ∗actual ;
357 i= 0;
358 actual = Liste ;
359
360 while( actual != NULL) {
361 if ( actual −>key . points [ 0 ] == knoten | | actual −>key . points [ 1 ] == knoten ) i++;
362 actual= actual −>next ;
363 }
364 return i ;
365 }
366
367 int MaxDegree( struct list element ∗ Liste ) {
368 int i , degree , temp ;
369 degree = 0;
370 for ( i =0; i degree ) degree = temp ;
373 }
374 return degree ;
375 }
376
377 struct list element ∗ directEdges ( struct list element ∗ Liste ) {
378 struct list element ∗actual , ∗ start ;
379 struct EDGE other ;
380 actual = Liste ;
381 start = NULL;
382 while( actual != NULL) {
383 start = set ( start , actual −>key , actual −>value ) ;
384 other . points [ 0 ] = actual −>key . points [ 1 ] ;
385 other . points [ 1 ] = actual −>key . points [ 0 ] ;
386 other . label = actual −>key . label ;
387 start = set ( start , other , other ) ;
388 actual = actual −>next ;
389 }
390 d e s t r o y l i s t ( Liste ) ;
391 return start ;
392 }
393
394 struct list element ∗ Euler colour ( struct list element ∗ Liste ) {
395 struct list element ∗actual , ∗one , ∗two ;
396 int degree ;
397 actual = Liste ;
398 degree = MaxDegree( Liste ) ;
399 if ( degree == 1) {
400 while( actual != NULL) {
401 actual −>key . label = 1;
402 actual = actual −>next ;
403 }
404 return Liste ;
123

405 }
406 else {
407 Liste = addDummy( Liste ) ;
408 actual = directEdges ( Liste ) ;
409 actual = Euler partition ( actual ) ;
410 actual = removeDummy( actual ) ;
411 one = NULL;
412 two = NULL;
413 while( actual != NULL) {
414 if ( actual −>key . label == 0) one = set (one , actual −>key , actual −>value ) ;
415 else two = set (two , actual −>key , actual −>value ) ;
416 actual = actual −>next ;
417 }
418 one = Euler colour ( one ) ;
419 two = Euler colour (two) ;
420 actual = two ;
421 degree = degree /2;
422 while( actual != NULL) {
423 actual −>key . label = actual −>key . label + degree ;
424 one = set (one , actual −>key , actual −>value ) ;
425 actual = actual −>next ;
426 }
427 d e s t r o y l i s t (two) ;
428 return one ;
429 }
430 }
431
432 struct list element ∗ addDummy( struct list element ∗ Liste ) {
433 int i ;
434 struct list element ∗ intern ;
435 struct EDGE kante ;
436 intern=Liste ;
437
438 for ( i =0; ikey . points [ 0 ] != (N+1)) && ( actual −>key . points [ 1 ] != (N+1)) ) {
454 start = set ( start , actual −>key , actual −>value ) ;
455 }
456 actual = actual −>next ;
457 }
458 d e s t r o y l i s t ( Liste ) ;
459 return start ;
460 }
461
462 /∗In der Funktion main e r f o l g t die I n i t i a l i s i e r u n g des Graphen und die Koordination des Ablaufs
463 des Algorithmus . ∗/
464 void main () {
465 int i ;
466 struct EDGE key , value ;
467 struct list element ∗help , ∗EDGES;
468 EDGES = NULL;
469 for ( i =0; i

495 EDGES= Euler colour (EDGES) ;
496 d e s t r o y l i s t (EDGES) ;
497 }
C.6. Chinesischer Restsatz
Listing C.6: Implementierung des Chinesischen Restsatzes
1 #include
2 #include
3 #include
4 #include
5
6 struct list element {
7 int x ;
8 int mi ;
9 int Mi;
10 int m;
11 int a ;
12 struct list element ∗next ;
13 struct list element ∗ link ;
14 };
15
16 int euklid ( int a , int b , int ∗x , int ∗y){
17 int xPrev , xCur , yPrev , yCur , xNext , yNext , r , q ;
18 int sign = 1;
19 int Sa , Sb ;
20
21 xPrev = 1;
22 xCur = 0;
23 yPrev = 0;
24 yCur = 1;
25 Sa = a ;
26 Sb = b ;
27 while(b != 0) {
28 r = a%b ;
29 q = a/b ;
30 a = b ;
31 b = r ;
32 xNext = q∗xCur + xPrev ;
33 xPrev = xCur ;
34 xCur = xNext ;
35 yNext = q∗yCur + yPrev ;
36 yPrev = yCur ;
37 yCur = yNext ;
38 sign = −sign ;
39 }
40 ∗x = sign ∗ xPrev ;
41 if (∗x < 0) ∗x= Sb + ∗x ;
42 ∗y = −sign ∗ yPrev ;
43 return a ;
44 }
45
46 int chin ( int a , int Mi, int mi){
47 int y , x , help ;
48 help = euklid (Mi,mi,&y,&x) ;
49 printf (”Ergebnis des erweiterten Euklid : %i \n” ,y) ;
50 x = Mi ∗ y ∗ a ;
51 return x ;
52 }
53
54 int size ( struct list element ∗ Liste ) {
55 struct list element ∗actual ;
56 int i ;
57 actual = Liste ;
58 i = 0;
59 while( actual != NULL) {
60 i++;
61 actual = actual −>next ;
62 }
63 return i ;
64 }
65
66 void calc ( struct list element ∗ Liste ) {
67 double logm ;
68 int i ;
69 struct list element ∗actual ;
70 actual = Liste ;
71 while( actual != NULL && actual −>next != NULL) {
72 actual −>link = actual −>next ;
73 (∗ actual ) .m = actual −>mi ;
74 actual = actual −>next ;
75 }
76 actual −>m = actual −>mi ;
77 actual −>link = NULL;
125

78 logm = log ((double) size ( Liste ) ) ;
79 for ( i =0; ilink != NULL) {
83 actual −>m= ( actual −>m) ∗ ( actual −>link −>m) ;
84 actual −>link = actual −>link −>link ;
85 }
86 actual = actual −>next ;
87 }
88 }
89 actual = Liste ;
90 while( actual != NULL) {
91 actual −>m = Liste −>m;
92 actual −>Mi = actual −>m /actual −>mi ;
93 actual = actual −>next ;
94 }
95 actual = Liste ;
96 while( actual != NULL) {
97 actual −>x = chin ( actual −>a , actual −>Mi, actual −>mi) ;
98 actual = actual −>next ;
99 }
100 actual = Liste ;
101 while( actual != NULL && actual −>next != NULL) {
102 actual −>link = actual −>next ;
103 actual = actual −>next ;
104 }
105 actual −>link = NULL;
106 for ( i =0; ilink != NULL) {
110 actual −>x= ( actual −>x + actual −>link −>x)%(Liste −>m) ;
111 actual −>link = actual −>link −>link ;
112 }
113 actual = actual −>next ;
114 }
115 }
116 printf (”Das Ergebnis der simultanen Kongruenz i s t : %i \n” , Liste −>x) ;
117 }
118
119 struct list element ∗ set ( struct list element ∗Liste , struct list element item ) {
120 struct list element ∗help , ∗actual ;
121 actual = Liste ;
122 while( actual != NULL && actual −>next !=NULL ) {
123 actual = actual −>next ;
124 }
125 help = malloc ( sizeof ( struct list element ) ) ;
126 (∗ help ) = item ;
127 help−>next = NULL;
128 if ( Liste == NULL) Liste = help ;
129 else actual −>next = help ;
130 return Liste ;
131 }
132
133 void destroyList ( struct list element ∗ Liste ) {
134 struct list element ∗actual ;
135 while ( Liste != NULL) {
136 actual = Liste −>next ;
137 free ( Liste ) ;
138 Liste = actual ;
139 }
140 }
141
142 void main () {
143 struct list element value ;
144 struct list element ∗gca , ∗actual ;
145 gca = NULL;
146
147 value . mi= 6;
148 value . a = 2;
149 gca = set ( gca , value ) ;
150
151 value . mi = 19;
152 value . a = 12;
153 gca = set ( gca , value ) ;
154
155 value . mi = 23;
156 value . a = 12;
157 gca = set ( gca , value ) ;
158
159 value . mi = 7;
160 value . a = 4;
161 gca = set ( gca , value ) ;
162
163 actual = gca ;
164 calc ( gca ) ;
165 destroyList ( gca ) ;
166 }
126

Literaturverzeichnis
[ARS71] Alvy Ray Smith, III: Simple Computation-Universal Cellular Spaces. J.
ACM, 18(3):339–353, 1971.
[BA95]
[Buc01]
[CHL99]
[CLC82]
Ben-Amram, Amir M.: What is a ”
Pointer Machine“ ? In: SIGACTN: SI-
GACT News (ACM Special Interest Group on Automata and Computability
Theory), 1995.
Buchmann, Johannes: Einführung in die Kryptographie
2., erweiterte Auflage. Springer, 2001.
Chong, Ka Wong, Yijie Han und Tak Wah Lam: On the parallel time complexity
of undirected connectivity and minimum spanning trees. In: SODA ’99:
Proceedings of the tenth annual ACM-SIAM symposium on Discrete algorithms,
Seiten 225–234, Philadelphia, PA, USA, 1999. Society for Industrial
and Applied Mathematics.
Chin, Francis Y., John Lam und I-Ngo Chen: Efficient parallel algorithms for
some graph problems. Commun. ACM, 25(9):659–665, 1982.
[CLRS01] Cormen, Thomas H., Charles E. Leiserson, Ronald L. Rivest und Clifford
Stein: Introduction to Algorithms, Second Edition. The MIT Press, Cambridge,
London, 2001.
[CNG + 01] Calidonna, Claudia R., Claudia Di Napoli, Maurizio Giordano, Mario Mango
Furnari und Salvatore Di Gregorio: A network of cellular automata for
a landslide simulation. In: ICS ’01: Proceedings of the 15th international
conference on Supercomputing, Seiten 419–426, New York, NY, USA, 2001.
ACM Press.
[DR86]
[GK96]
Dymond, Patrick W. und Walter L. Ruzzo: Parallel RAMs with Owned Global
Memory and Deterministic Context-Free Language Recognition (Extended
Abstract). In: Automata, Languages and Programming, Seiten 95–104, 1986.
Goodrich, Michael T. und S. Rao Kosaraju: Sorting on a Parallel Pointer
Machine with Applications to Set Expression Evaluation. In: Journal of the
ACM, 1996.
127

[GR98]
[Gü92]
[Hee01]
[Hoc98]
[HVH03]
[JM92]
[KKT01]
Gibbons, Alan und Woiciech Ritter: Efficient Parallel Algorithms. Cambridge
University Press, New York, Port Chester, Melbourne, Sidney, 1998.
Güting, Ralf Hartmut: Datenstrukturen und Algorithmen. B. G. Teubner,
1992.
Heenes, Wolfgang: Globaler Zellularer Automat: Algorithmen und Strukturen.
Diplomarbeit, Technische Universität Darmstadt, 2001.
Hochberger, Christian: CDL - Eine Sprache für die Zellularverarbeitung auf
verschiedenen Zielplattformen. Doktorarbeit, Technische Universität Darmstadt,
1998.
Hoffmann, Rolf, Klaus-Peter Völkmann und Wolfgang Heenes: GCA: A Massively
Parallel Model. In: IPDPS ’03: Proceedings of the 17th International
Symposium on Parallel and Distributed Processing, Seite 270.2, Washington,
DC, USA, 2003. IEEE Computer Society.
Johnson, Donald B. und Panagiotis Metaxas: A parallel algorithm for computing
minimum spanning trees. In: SPAA ’92: Proceedings of the fourth annual
ACM symposium on Parallel algorithms and architectures, Seiten 363–372,
New York, NY, USA, 1992. ACM Press.
Keller, Jörg, Christoph W. Keßler und Jesper Larsson Träff: Practical PRAM
Programming. John Wiley & Sons, INC., New York, Chichester, Weinheim,
Brisbane, Singapore, Toronto, 2001.
[Kru05] Kruthoff, Bernd: Ausarbeitung Graph-Algorithmen, 2005.
http://www-wi.uni-muenster.de/pi/lehre/SS03/Seminar/Graph
Bernd Kruthoff.pdf.
[Maj94]
Majercik, Stephen Michael: Structurally Dynamic Cellular Automata. Diplomarbeit,
The University of Southern Maine School of Applied Science,
1994.
[MWIS02] Muzy, Alexandre, Gabriel Wainer, Eric Innocenti und Antoine Aiello Jean-
Franšois Santucci: Comparing Simulation Methods For Fire Spreading Across
A Fuel Bed. In: Proceedings of AIS’2002, Lisbon, Portugal, 2002.
[Nat90]
[Sar00]
Natvig, Lasse: Logarithmic time cost optimal parallel sorting is not yet fast
in practice! In: Supercomputing ’90: Proceedings of the 1990 ACM/IEEE
conference on Supercomputing, Seiten 486–494, Washington, DC, USA, 1990.
IEEE Computer Society.
Sarkar, Palash: A brief history of cellular automata. ACM Comput. Surv.,
32(1):80–107, 2000.
128

[Sch01]
[Sig89]
Schöning, Uwe: Theoretische Informatik - kurzgefasst. Spektrum Akademischer
Verlag, 2001.
Signorini, J.: How a SIMD machine can implement a complex cellular automata?
a case study: von Neumann’s 29-state cellular automaton. In: Supercomputing
’89: Proceedings of the 1989 ACM/IEEE conference on Supercomputing,
Seiten 175–186, New York, NY, USA, 1989. ACM Press.
[Web05] Webseite über den Cell-Prozessor: 2005.
http://www.blachford.info/computer/Cell/Cell0 v2.html.
129