Masterkurs Parallele und Verteilte Systeme: Grundlagen und Programmierung von Multicoreprozessoren, Multiprozessoren, Cluster und Grid

Günther Bengel | Christian Baun | Marcel Kunze | Karl-Uwe Stucky Masterkurs Parallele und Verteilte Systeme

Günther Bengel | Christian Baun | Marcel Kunze | Karl-Uwe Stucky

Masterkurs Parallele und Verteilte Systeme Grundlagen und Programmierung von Multicoreprozessoren, Multiprozessoren, Cluster und Grid Mit 103 Abbildungen STUDIUM

Bibliografische Information der Deutschen Nationalbibliothek Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über abrufbar.

Das in diesem Werk enthaltene Programm-Material ist mit keiner Verpflichtung oder Garantie irgendeiner Art verbunden. Der Autor übernimmt infolgedessen keine Verantwortung und wird keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der Benutzung dieses Programm-Materials oder Teilen davon entsteht. Höchste inhaltliche und technische Qualität unserer Produkte ist unser Ziel. Bei der Produktion und Auslieferung unserer Bücher wollen wir die Umwelt schonen: Dieses Buch ist auf säurefreiem und chlorfrei gebleichtem Papier gedruckt. Die Einschweißfolie besteht aus Polyäthylen und damit aus organischen Grundstoffen, die weder bei der Herstellung noch bei der Verbrennung Schadstoffe freisetzen.

1. Auflage 2008 Alle Rechte vorbehalten © Vieweg+Teubner | GWV Fachverlage GmbH, Wiesbaden 2008 Lektorat: Sybille Thelen | Andrea Broßler Vieweg+Teubner ist Teil der Fachverlagsgruppe Springer Science+Business Media. www.viewegteubner.de Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Jede Verwertung außerhalb der engen Grenzen des Urheberrechtsgesetzes ist ohne Zustimmung des Verlags unzulässig und strafbar. Das gilt insbesondere für Vervielfältigungen, Übersetzungen, Mikroverfilmungen und die Einspeicherung und Verarbeitung in elektronischen Systemen. Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk berechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften. Umschlaggestaltung: KünkelLopka Medienentwicklung, Heidelberg Druck und buchbinderische Verarbeitung: Wilhelm & Adam, Heußenstamm Gedruckt auf säurefreiem und chlorfrei gebleichtem Papier. Printed in Germany ISBN 978-3-8348-0394-8

Vorwort Die Entwicklung von Computern steht heute an einem Wendepunkt. Nach Jahrzehnten stetiger Steigerung der Rechengeschwindigkeit baut heute kein Hardware-Hersteller mehr schnellere sequentielle Prozessoren. Ein klarer Trend zu Computer-Architekturen, die parallele Abläufe unterstützen, und zur Parallelisierung von Programmen ist erkennbar. So sind beispielsweise Multicore-Chips zu erwarten, die bis 2009 bis zu 64 und bis 2015 bis zu 128 integrierte Prozessoren aufweisen. Zusammen mit der Weiterentwicklung von Cluster-Architekturen in homogener und heterogener Rechnerlandschaft sowie mit dem rasch voranschreitenden Ausbau von Grids mit heterogener Zusammensetzung ist hier eine klare Richtung vorgegeben. Die neuen Architekturen können aber nur dann sinnvoll genutzt werden, wenn die Software den angebotenen Parallelismus auch nutzt, wobei heute noch die Hardware die Entwicklungsgeschwindigkeit vorgibt und der Softwareentwicklung vorauseilt. Parallele Architekturen und deren Programmierung verlassen damit ihre bisherige Nische des Hochleistungsrechnens und werden zukünftig zum Standard. Sie erweitern unsere vernetzte Welt und bieten etwa Wissenschaftlern Zugriff auf nahezu unbegrenzte Rechenleistung und Speicherkapazität. Im kommerziellen Bereich, um mit IBM’s Zauberformel “Business on demand“ zu argumentieren, wird IT-Dienstleistung an jedem Ort und zu jeder Zeit mit beliebig großen Rechen- und Speicheranforderungen verfügbar. Kaum ein Bereich, in dem heute schon Rechner eingesetzt werden, wird von der allgegenwärtigen Vielfalt an Rechenressourcen ausgenommen bleiben. Derzeit bahnt sich High Performance Computing (HPC) rasch einen Weg über die Grenzen von Hochschulen und Forschungseinrichtungen hinaus. Die neuen, schlüsselfertigen HPC-Systeme ermöglichen nun auch (fast) jeder Forschungseinrichtung und jedem Unternehmen den Betrieb von enorm leistungsstarken Rechnersystemen. Diese besitzen eine offene Architektur, die sich von einzelnen Racks auf Cluster im Petascale-Bereich ausdehnen lässt. In Grids erfolgt der Rechnerverbund sogar domänenübergreifend, also mit Ressourcen, die verschiedenen Organisationen zugeordnet sind. Ein weltweites Supercomputing in einer zuvor nie gekannten Größenordnung wird Realität.

V

Vorwort Peer-to-Peer-Computing (P2P) spielt im Bereich des Hochleistungsrechnens und der Leistungssteigerung durch Parallelität kaum eine Rolle und hat nur wenig Einfluss auf das Cluster- und GridComputing. Der ursprüngliche Plan, das P2P-Computing mit in dieses Werk aufzunehmen, wurde aus diesem Grund und zu Gunsten einer größeren Tiefe des übrigen Stoffes aufgegeben. Der Aufbau des Buches orientiert sich nach einer Einleitung mit Historie und einem allgemeinen Überblick zunächst an der führenden Rolle der Hardwareentwicklung, die der Software-Entwicklung in der Regel immer vorauseilt. Schon 1987 hat Greg Papadopoulos, heute Chief Technology Officer und Executive Vice President of Research and Development bei Sun Microsystems, Inc., das Hinterherhinken der Software gegenüber der parallelen Hardware folgendermaßen charakterisiert: „It appears to be easier to build parallel machines than to use them.”1 Und Sutter und Larus äußern sich folgendermaßen: „The concurrency revolution is primarily a software revolution. The difficult problem is not building multicore hardware, but programming it in a way that lets mainstream application benefit from the continued exponential growth in CPU performance.” 2 Kapitel 2 beschreibt zunächst die Grundlagen der parallelen Hardware für Einprozessorsysteme und die Rechnerarchitekturen für den Aufbau von Multiprozessoren. Wir starten mit dem Instruction Level Parallelismus und Thread-Level Parallelismus und führen hin zum Simultaneous Multithreading. Bei Multiprozessoren unterscheiden wir zwischen Architekturen mit gemeinsamem Speicher (eng gekoppelten Multiprozessoren) und verteiltem Speicher (lose gekoppelten Multiprozessoren). Bei den eng gekoppelten Multiprozessoren betrachten wir die Cachekohärenzprotokolle, die Architektur und die Thread-Programmierung von Multicoreprozessoren. Anschließend gehen wir auf die Organisation von Multiprozessorbetriebssystemen und hauptsächlich auf das

VI

1

Papadopoulos G.: The new dataflow architecture being built at MIT. In: Proceedings of the MIT-ZTI-Symposium on Very High Parallel Architectures, November 1987.

2

Sutter H., Larus J.: Software and the concurreny revolution. ACM Queue, Vol. 3, No. 7, 2005.

Vorwort Symmetrische Multiprocessing ein. Schwergewicht bei den Multiprozessorbetriebssystemen sind die parallelen Prozesse und deren Synchronisation. Die Synchronisationsverfahren umfassen die hardwarenahen Locksynchronisationsverfahren bis hin zu den klassischen Semaphoren, aber auch das neuere Verfahren des Transactional Memory. Bei den lose gekoppelten Multiprozessoren zeigen wir, nach der Darstellung von deren Architektur, wie durch die Implementierung eines verteilten gemeinsamen Speichers die lose gekoppelte Architektur in die eng gekoppelte Architektur überführbar ist. Als Beispiel für ein lose gekoppeltes System dient das Load Balancing und High Throughput Cluster Google. Gemäß der zuvor gemachten Aussage, dass die Software der parallelen Hardware hinterherhinkt und bei der Software ein Nachholbedarf besteht, sind die Programmiermodelle für parallele Architekturen von zentraler Bedeutung und nehmen mit Kapitel 3 den größten Umfang des Werkes ein. Die Unterteilung von Kapitel 2 in eng gekoppelte und lose gekoppelte Multiprozessoren gibt die Unterteilung der Programmiermodelle in Kapitel 3 vor. Der erste Teil befasst sich mit dem Client-Server-Modell, das auf die Hardwarearchitektur keine Rücksicht zu nehmen braucht. Eine Einführung in service-orientierte Architekturen, die hauptsächlich auf verteilten Rechnern basieren, enthält der zweite Teil. Der dritte Teil behandelt die Programmiermodelle für gemeinsamen Speicher und der vierte Teil die Modelle und Programmierverfahren für verteilten Speicher. Es wurde versucht, nicht nur die beiden vorherrschenden Modelle OpenMP für gemeinsamen Speicher und das Message Passing Interface (MPI) für verteilten Speicher zu besprechen, sondern auch die älteren Verfahren und ganz neue Entwicklungen zu behandeln, die gerade im Entstehen und in der Entwicklung sind. Ältere Programmiermodelle für gemeinsamen Speicher sind Unix mit den fork- und join-Systemaufrufen, Threads und das Ada-Rendezvous. Neuere Modelle sind in Programmiersprachen wie Unified Parallel C und Fortress realisiert. Ältere Programmiermodelle für verteilten Speicher sind bei den nebenläufigen Modellen Occam und der Parallel Virtual Machine (PVM) zu finden. Weitere ältere kooperative Modelle sind die TCP/IP-Sockets. Nicht ganz so alt sind der Java Message Service (JMS) und für die entfernten Aufrufe der Remote Procedure Call (RPC), die Common Object Request Broker Architecture (CORBA) und die Remote Method Invocation (RMI). Neuere Entwicklungen sind das .NET-Remoting und die

VII

Vorwort Service Oriented Architecture (SOA) und deren Implementierungsbasis, die Web-Services und der XML-RPC. Zur Illustration der Programmierverfahren wurde, wo es vom Umfang her möglich und für das Programmiermodell angepasst war, das Erzeuger-Verbraucher-Problem gewählt. Kapitel 4 beschreibt den parallelen Softwareentwurf und definiert die Leistungsmaße und Metriken für Parallele Programme. Die eingeführten Leistungsmaße führen zu einer Bewertung der nachfolgend besprochenen Parallelisierungstechniken und -verfahren. Das Werk legt den Schwerpunkt auf die Darstellung der Parallelität und der parallelen Prozesse. Dass die parallelen Prozesse weltweit auf die Rechner verteilt werden ist dabei nur ein Nebenaspekt. Deshalb erläutert Kapitel 5 (Verteilte Algorithmen) nur die mit den verteilten Algorithmen auftretende Problematik des Fehlens von Gemeinsamkeiten. Zur Lösung oder Umgehung dieser Problematik werden die grundlegenden und somit wichtigsten verteilten Basisalgorithmen vorgestellt. Besonderes Gewicht legen wir mit Kapitel 6 auf das Thema Rechenlastverteilung. Die Beschreibung der statischen Lastverteilung erläutert das Scheduling-Problem, gibt einen Überblick über verschiedene Jobmodelle einschließlich Workflows und diskutiert Beispiele für Verfahren. Der Abschnitt zur dynamischen Lastverteilung unterscheidet zwischen zentralen und dezentralen Verfahren und erläutert die Migration, die Unterbrechung und Verschiebung bereits laufender Prozesse. Den Abschluss bildet eine Einführung in das Grid Scheduling, das auf Besonderheiten der domänenübergreifenden Architektur Rücksicht nehmen muss und für das erste Lösungen verfügbar sind. Kapitel 7 geht auf Virtualisierungstechniken ein, mit denen das Problem des Ressourcenmanagements in verteilten Systemen elegant gelöst werden kann. Oftmals werden Ressourcen wie CPU und Speicher nicht optimal genutzt, und die Virtualisierung bietet hier ein großes Potenzial zur Effizienzsteigerung. Alle modernen Prozessoren bieten heute entsprechende Funktionen. Anwendungsvirtualisierung hilft darüber hinaus bei der Verwaltung von Software und bei der aus Kostengründen immer häufiger diskutierten Rezentralisierung von IT-Services. Kapitel 8 beschreibt die Entwicklung des Cluster-Computing. Besonderes Gewicht hat die Klassifikation der unterschiedlichen Arten von Clustern mit ihren typischen Einsatzgebieten, sowie die Beschreibung der eingesetzten Technologien.

VIII

Vorwort Kapitel 9 definiert den Begriff des Grid-Computing und klassifiziert die Unterscheidungsmöglichkeit von verschiedenen Grid-Systemen. Die populärsten Grid Middleware-Systeme mit ihren notwendigen Protokollen und Diensten werden vorgestellt. Zusätzlich beschreibt Kapitel 9 die Grid-Softwarepakete, welche die Verwaltung eines Grid und die Arbeit damit vereinfachen. Von Kapitel 1 bis 6.1 ist Prof. Bengel der Autor, Abschnitt 6.1.1.3 bis zum Ende von Kapitel 6 verfasste Dr. Stucky, Kapitel 7 hat sich Dr. Kunze vorgenommen, Abschnitt 8 hat C. Baun erstellt und Kapitel 9 wurde in Zusammenarbeit von C. Baun und M. Kunze erstellt. Der Stoff wurde so umfassend wie möglich dargestellt. Dies betrifft besonders die parallelen Programmiermodelle in Kapitel 3, dem vom Umfang her mächtigsten Abschnitt des Werkes. Dadurch eignet sich das Buch sehr gut als Einstiegs- und Nachschlagewerk. Die tiefe Untergliederung der einzelnen Abschnitte und die systematische Darstellung des Stoffes unterstützen dies. Die Vielzahl von Literaturhinweisen erleichtert dem Leser den noch tieferen Einstieg in die Thematik und die selbstständige Vertiefung des Stoffes. Dadurch ist das Werk auch sehr gut zum Selbststudium geeignet. Das Buch ist eher forschungsorientiert ausgelegt, und die einzelnen Abschnitte sind in sich abgeschlossen. Durch das Umfassende und den großen Umfang des Werkes konnte in den einzelnen Abschnitten eine große Tiefe erreicht werden. Dadurch lassen sich prinzipiell wie aus einem Modulkasten auch mehrere Masterkurse mit verschiedener Ausrichtung auf dem Gebiet der Parallelen und Verteilten Systeme zusammenstellen und konzipieren. Einzelne Abschnitte oder Teile davon können aber auch in Vorlesungen oder Seminare im BachelorStudiengang einfließen. Vom Forschungszentrum Karlsruhe vom Institut für wissenschaftliches Rechnen danken wir Frau Dr. Jie Tao für die kritische Durchsicht der Hardwarerealisierung von Client-Server-Systemen und die Verbesserung und Richtigstellung des MESI-Protokolls. Hr. Dipl.-Phys. Klaus-Peter Mickel (komm. Leiter des Instituts für Wissenschaftliches Rechnen) danken wir für die Bereitstellung von Ressourcen und Unterstützung während der Erstellung des Werkes. Herr Prof. Dr. Georg Winterstein, Dekan der Fakultät für Informatik, Hochschule Mannheim und dem Rektor Prof. Dr. Dietmar v. Hoyningen-Huene dankt Prof. Bengel für die Genehmigung eines Forschungsfreisemesters im Sommersemester 2007 am Forschungszentrum Karls-

IX

Vorwort ruhe. Ohne dieses Forschungssemester und der Unterstützung durch Herrn Klaus-Peter Mickel wäre dieses Werk in solchem Umfang und Tiefe nicht möglich gewesen. Vielen Dank an Anja Langner, die das Zeichnen einiger Abbildungen in diesem Buch übernommen hat und den Abbildungen ein professionelleres Aussehen gegeben hat. Frau Dipl.-Bibl. Maria Klein von der Hochschulbibliothek der Hochschule Mannheim möchten wir unseren Dank aussprechen für die schnelle Beschaffung der aktuellsten Neuerscheinungen, sowie der für dieses Werk notwendigen großen Anzahl von Literatur. Mit dem Buch steht auch ein kostenloser Online-Service zur Verfügung. Die Internet-Adresse der Web-Seiten ist http://www.pvs.hs-mannheim.de Die folgenden Informationen können auf den Web-Seiten gefunden werden: •

Informationen über die Autoren mit Email-Adresse, die zum Senden von Anmerkungen, Kommentaren und Berichtigungen verwendet werden kann.

•

Alle Abbildungen des Buches zum Herunterladen; sie lassen sich in der Lehre einsetzen und wieder verwenden.

•

Alle Programmbeispiele des Buches zum Herunterladen. Sie sollen den Leser ermuntern, die Programme auszuprobieren, und dienen zur Gewinnung von praktischer Erfahrung mit den Techniken der parallelen und verteilten Programmierung.

•

Ein Erratum, d.h. Korrekturen zu Fehlern, die erst nach der Drucklegung des Buches gefunden wurden.

•

Aktuelle Informationen zu Weiter- und Neuentwicklungen bzgl. der im Buch beschriebenen Technologien.

Die Web-Seiten werden kontinuierlich weiterentwickelt und ausgebaut. Zum Schluss noch eine Zukunftsvision: In einer total vernetzten Welt sind Rechenleistung, Speicherkapazität und andere Ressourcen als Dienste von jedem Computer aus zugreifbar. Der Einsatz von Rech-

X

Vorwort nern in täglich genutzten Geräten sowie die mobile Verfügbarkeit von Internetzugängen ermöglichen sogar den Zugriff von buchstäblich jedem beliebigen Ort aus3. Durch diese Technologien erhält der Mensch eine nahezu unbegrenzte Vielfalt von Möglichkeiten, sein Leben, seine Arbeit und Freizeit sowie seine Umgebung zu gestalten. Gleichzeitig sind sie aber auch eine Herausforderung, da sie in völlig neuer Art und Weise und in bisher unbekanntem Umfang in das Leben jedes Einzelnen eingreifen. Wir hoffen, dieses Werk hilft Ihnen bei der aktiven und verantwortungsvollen Mitgestaltung dieser Zukunftsvision. Altrip, Mannheim, Karlsruhe im Dezember 2007 Günther Bengel Christian Baun Marcel Kunze Karl-Uwe Stucky

3

Siehe hierzu auch Mattern F. (Hrsg.): Total vernetzt. Szenarien einer informatisierten Welt. Springer Verlag 2003.

XI

Inhaltsverzeichnis 1 Einführung und Grundlagen..................................................................1 1.1 Historische Entwicklung der Rechensysteme ..................................1 1.2 Technologiefortschritte........................................................................5 1.2.1 Leistungsexplosion und Preisverfall der Hardware ................6 1.2.2 Fortschritte bei lokalen Netzen ...................................................6 1.2.3 Aufkommen von Funkverbindungen und mobilen Geräten..9 1.2.4 Übernetzwerk Internet ...............................................................11 1.3 World Wide Web (WWW) ................................................................12 1.3.1 Web 2.0 .........................................................................................12 1.3.2 Web 3.0 .........................................................................................15 1.3.3 Web 4.0 .........................................................................................16 1.3.4 E-World ........................................................................................17 1.3.4.1 E-Business..............................................................................17 1.3.4.2 Weitere E-Applikationen.....................................................19 1.4 Selbstorganisierende Systeme ..........................................................20 1.4.1 On Demand Computing.............................................................20 1.4.2 Autonomic Computing ..............................................................22 1.4.3 Organic Computing ....................................................................22 1.5 Parallele versus Verteilte Verarbeitung ..........................................23 1.5.1 Parallele Verarbeitung................................................................23 1.5.1.1 Nebenläufige Prozesse.........................................................25 1.5.1.2 Kooperierende Prozesse ......................................................25 1.5.2 Verteilte Verarbeitung ................................................................26 1.5.2.1 Beispiele für Verteilte Systeme ...........................................27

XIII

Inhaltsverzeichnis 1.5.2.2 Positive Eigenschaften der verteilten Verarbeitung ....... 27 1.5.2.3 Eigenschaften eines Verteilten Systems............................ 28 2 Rechnerarchitekturen für Parallele und Verteilte Systeme............ 33 2.1 Simultaneous Multithreading.......................................................... 34 2.1.1 Instruction Level Parallelism .................................................... 34 2.1.2 Thread Level Parallelismus....................................................... 37 2.1.3 Arbeitsweise des Simultaneous Multithreading .................... 38 2.2 Eng gekoppelte Multiprozessoren und Multicore-Prozessoren . 39 2.2.1 Architektur von eng gekoppelten Multiprozessoren ............ 39 2.2.2 Cachekohärenzprotokolle ......................................................... 41 2.2.2.1 MESI Cachekohärenz-Protokoll ........................................ 42 2.2.2.2 Verzeichnis-basierte Cachekohärenz-Protokolle............. 51 2.2.3 Kreuzschienenschalter-basierte Multiprozessoren ................ 52 2.2.4 Mehrebenennetzwerke-basierte Multiprozessoren ............... 53 2.2.5 Multicore-Prozessoren ............................................................... 55 2.2.5.1 Programmierung von Multicore-Architekturen.............. 59 2.2.6 Multiprozessorbetriebssysteme................................................ 61 2.2.6.1 Master Slave Multiprocessing............................................ 62 2.2.6.2 Asymmetrisches Multiprocessing ..................................... 63 2.2.6.3 Symmetrisches Multiprocessing (SMP)............................ 64 2.2.6.3.1 Floating Master ............................................................. 65 2.2.6.4 Lock-Synchronisation.......................................................... 67 2.2.6.4.1 Test and Set (TAS) ........................................................ 68 2.2.6.4.2 Exchange (XCHG)......................................................... 69 2.2.6.4.3 Spinlocking .................................................................... 69 2.2.6.4.4 Semaphore ..................................................................... 70 2.2.6.4.5 Compare and Swap (CAS)........................................... 71 2.2.6.5 Transactional Memory (TM) .............................................. 74

XIV

Inhaltsverzeichnis 2.2.6.5.1 Programmsprachliche Realisierung des TM..............75 2.2.6.5.2 Software Transactional Memory (STM) .....................77 2.2.6.5.3 Hardware Transactional Memory (HTM)..................78 2.3 Lose gekoppelte Multiprozessoren und Multicomputer ..............79 2.3.1 Architektur von lose gekoppelten Multiprozessoren ............79 2.3.2 Verteilter gemeinsamer Speicher ..............................................81 2.3.2.1 Implementierungsebenen....................................................82 2.3.2.2 Speicher Konsistenzmodelle...............................................83 2.3.2.3 Implementierung der Sequenziellen Konsistenz .............86 2.3.3 Multicomputer.............................................................................95 2.3.4 Leistungs-Effizenzmetriken.......................................................96 2.4 Load Balancing und High Throughput Cluster Google ...............97 2.4.1 Leistungsmaße und Ausstattung des Google-Clusters..........97 2.4.2 Google Server-Aufbau und -Architektur.................................99 3 Programmiermodelle für parallele und verteilte Systeme .............105 3.1 Client-Server-Modell .......................................................................106 3.1.1 Fehlersemantik ..........................................................................108 3.1.2 Serverzustände ..........................................................................115 3.1.3 Client-Server versus Verteilt....................................................118 3.2 Service-orientierte Architekturen (SOA).......................................120 3.2.1 Bestandteile eines Service ........................................................121 3.2.2 Eigenschaften eines Service .....................................................122 3.2.3 Servicekomposition, -management und -überwachung......125 3.2.4 Enterprise Service Bus ..............................................................127 3.3 Programmiermodelle für gemeinsamen Speicher .......................130 3.3.1 Parallelisierende Compiler.......................................................136 3.3.2 Unix.............................................................................................137

XV

Inhaltsverzeichnis 3.3.2.1 fork, join .............................................................................. 137 3.3.2.2 Erzeuger-Verbraucher (Pipe) .......................................... 140 3.3.2.3 Warteschlange (Queue) ................................................... 142 3.3.3 Threads ...................................................................................... 143 3.3.3.1 Threads versus Prozesse................................................... 143 3.3.3.2 Implementierung von Threads ........................................ 145 3.3.3.3 Pthreads .............................................................................. 150 3.3.3.3.1 Thread Verwaltungsroutinen.................................... 150 3.3.3.3.2 Wechselseitiger Ausschluss....................................... 153 3.3.3.3.3 Bedingungsvariable.................................................... 156 3.3.3.3.4 Erzeuger-Verbraucher (Pipe) mit Threads .............. 158 3.3.4 OpenMP..................................................................................... 160 3.3.4.1 Parallel Pragma .................................................................. 162 3.3.4.2 Gültigkeitsbereiche von Daten ........................................ 163 3.3.4.3 Lastverteilung unter Threads........................................... 164 3.3.4.3.1 for Pragma ................................................................... 164 3.3.4.3.2 section Pragma ............................................................ 165 3.3.4.3.3 single Pragma .............................................................. 165 3.3.4.3.4 master Pragma ............................................................ 166 3.3.4.4 Synchronisation ................................................................. 166 3.3.4.4.1 Kritische Abschnitte ................................................... 166 3.3.4.4.2 Sperrfunktionen .......................................................... 167 3.3.4.4.3 Barrieresynchronisation............................................. 167 3.3.5 Unified Parallel C (UPC) ......................................................... 168 3.3.5.1 Identifier THREADS und MYTHREAD ......................... 168 3.3.5.2 Private und Shared Data................................................... 169 3.3.5.3 Shared Arrays..................................................................... 169 3.3.5.4 Zeiger .................................................................................. 170 3.3.5.5 Lastverteilung unter Threads, upc_forall....................... 170

XVI

Inhaltsverzeichnis 3.3.5.6 Sperrfunktionen..................................................................171 3.3.5.7 Barrieresynchronisation ....................................................172 3.3.5.7.1 Barrieren .......................................................................172 3.3.5.7.2 Split Phase Barrieren ...................................................172 3.3.6 Fortress .......................................................................................173 3.3.6.1 Datentypen..........................................................................173 3.3.6.2 Ausdrücke und Anweisungen ........................................174 3.3.6.3 Juxtaposition Operator ......................................................176 3.3.6.4 Objekte, Traits, Top-level-Funktionen und Komponenten .................................................................................176 3.3.6.4.1 Objekte ..........................................................................176 3.3.6.4.2 Traits..............................................................................177 3.3.6.4.3 Komponenten und APIs.............................................178 3.3.6.5 Parallelität............................................................................179 3.3.6.5.1 Schleifen und sonstige Konstrukte............................179 3.3.6.5.2 Datenverteilung ...........................................................180 3.3.6.5.3 Explizite Threads.........................................................180 3.3.6.5.4 Atomic-Block................................................................181 3.3.7 Ada ..............................................................................................182 3.3.7.1 Ada-Rendezvous ................................................................182 3.3.7.2 Selektive Ada-Rendezvous ...............................................185 3.3.7.2.1 Erzeuger-Verbraucher (Pipe) mit selektivem Rendezvous.................................................................................186 3.3.7.3 Geschützte Objekte ............................................................188 3.4 Programmiermodelle für verteilten Speicher...............................189 3.4.1 Überblick nebenläufige Modelle .............................................190 3.4.1.1 Nachrichtenbasierte Modelle............................................190 3.4.1.2 Datenparallelität ausnutzende Modelle ..........................192 3.4.2 Überblick kooperative Modelle...............................................194

XVII

Inhaltsverzeichnis 3.4.2.1 Lokalisierung des Kooperationspartners (Broker)........ 194 3.4.2.2 Datenrepräsentation auf unterschiedlichen Maschinen196 3.4.2.3 Nachrichtenbasierte Modelle ........................................... 199 3.4.2.4 Entfernte Aufruf-Modelle................................................. 201 3.4.3 Nebenläufige und nachrichtenbasierte Modelle .................. 204 3.4.3.1 Message Passing Interface (MPI)..................................... 204 3.4.3.1.1 Initialisieren und Beenden von Prozessen .............. 206 3.4.3.1.2 Kommunikator und Rang.......................................... 208 3.4.3.1.3 Blockierendes Senden und Empfangen ................... 209 3.4.3.1.4 Nichtblockierendes Senden und Empfangen ......... 212 3.4.3.1.5 Persistente Kommunikation...................................... 214 3.4.3.1.6 Broadcast...................................................................... 216 3.4.3.1.7 Weitere kollektive Kommunikationsfunktionen.... 217 3.4.3.1.8 Kommunikator und Gruppenmanagement............ 217 3.4.3.2 Occam.................................................................................. 221 3.4.3.2.1 SEQ- versus PAR-Konstrukt ..................................... 221 3.4.3.2.2 ALT-Konstrukt............................................................ 222 3.4.3.2.3 IF- WHILE- Konstrukt, SEQ- und PAR-Zählschleifen..................................................................... 223 3.4.3.2.4 Prozeduren .................................................................. 224 3.4.3.2.5 Konfiguration .............................................................. 225 3.4.3.3 Parallel Virtual Machine (PVM) ...................................... 226 3.4.3.3.1 Dämon-Prozesse ......................................................... 226 3.4.3.3.2 Task Erzeugung und Start ......................................... 227 3.4.3.3.3 Hinzufügen und Entfernen von Rechnern.............. 228 3.4.3.3.4 Taskkommunikation .................................................. 229 3.4.3.3.5 Gruppen ....................................................................... 232 3.4.3.3.6 Barrieresynchronisation und Broadcast .................. 233 3.4.4 Kooperative und nachrichtenbasierte Modelle .................... 233

XVIII

Inhaltsverzeichnis 3.4.4.1 TCP/IP-Sockets ...................................................................233 3.3.4.1.1 Datagram Sockets ........................................................237 3.4.4.1.2 Anwendungsbeispiel echo-serving..........................241 3.4.4.1.3 Stream-Sockets.............................................................245 3.4.4.1.4 Anwendungsbeispiel rlogin.......................................248 3.4.4.2 Java Message Service (JMS)...............................................251 3.4.4.2.1 Message API.................................................................252 3.4.4.2.2 Producer Consumer API ............................................255 3.4.4.2.3 Anwendungsbeispiel Erzeuger-VerbraucherProblem (Pipe) ............................................................................264 3.4.4.2.4 JMS-Provider................................................................269 3.4.5 Kooperative Modelle mit entfernten Aufrufen .....................270 3.4.5.1 Ablauf von entfernten Aufrufen ......................................270 3.4.5.2 Abbildung des entfernten Aufrufes auf Nachrichten ...271 3.4.5.3 Stubs.....................................................................................272 3.4.5.4 Parameter- und Ergebnisübertragung.............................273 3.4.5.5 Remote Procedure Calls (ONC RPCs, DCE RPCs, DCOM) ............................................................................................275 3.4.5.6 Entfernte Methodenaufrufe (CORBA).............................276 3.4.5.6.1 Object Management Architecture (OMA)................277 3.4.5.6.2 Object Request Broker (ORB).....................................279 3.4.5.6.3 CORBA Component Model (CCM) ..........................284 3.4.5.7 Remote Method Invocation (RMI) ...................................285 3.4.5.7.1 Package java.rmi..........................................................286 3.4.5.7.2 Package java.rmi.registry ...........................................288 3.4.5.7.3 Package java.rmi.server ..............................................290 3.4.5.7.4 Serialisieren von Objekten..........................................292 3.4.5.7.5 RMI-Programmierung ................................................293 3.4.5.8 Entfernte Komponentenaufrufe .......................................297

XIX

Inhaltsverzeichnis 3.4.5.8.1 .NET Plattform ............................................................ 297 3.4.5.8.2 .NET Framework ........................................................ 299 3.4.5.8.3 .NET-Remoting ........................................................... 301 3.4.5.8.4 .NET 3.0........................................................................ 303 3.4.5.9 Entfernte Serviceaufrufe (Web Services) ........................ 303 3.4.5.9.1 Web Service-Architektur ........................................... 304 3.4.5.10 XML-RPC.......................................................................... 306 4 Parallelisierung..................................................................................... 313 4.1 Leistungsmaße für parallele Programme ..................................... 313 4.1.1 Laufzeit ...................................................................................... 313 4.1.2 Speedup ..................................................................................... 314 4.1.3 Kosten und Overhead .............................................................. 315 4.1.4 Effizienz ..................................................................................... 316 4.1.5 Amdahls Gesetz........................................................................ 317 4.1.6 Gustafsons Gesetz .................................................................... 319 4.1.7 Karp-Flatt-Metrik...................................................................... 320 4.2 Parallelisierungstechniken ............................................................. 321 4.2.1 Inhärenter Parallelismus......................................................... 321 4.2.2 Zerlegungsmethoden ............................................................... 322 4.2.2.1 Funktionale Zerlegung ..................................................... 324 4.2.2.2 Datenzerlegung.................................................................. 325 4.2.2.2.1 Master Worker-Schema.............................................. 326 4.2.2.2.2 Berechnungsbäume .................................................... 327 4.2.2.3 Funktions- und Datenzerlegung...................................... 328 4.2.2.3.1 Methodisches Vorgehen ............................................ 328 4.2.2.3.2 Dynamische Allokation ............................................. 331 4.2.3 Weitere parallele Verfahren und Algorithmen .................... 332

XX

Inhaltsverzeichnis 5 Verteilte Algorithmen ..........................................................................333 5.1 Verteilt versus zentralisiert .............................................................333 5.2 Logische Ordnung von Ereignissen...............................................336 5.2.1 Lamport-Zeit..............................................................................336 5.2.2 Vektoruhren ...............................................................................339 5.3 Auswahlalgorithmen .......................................................................342 5.3.1 Bully-Algorithmus ....................................................................342 5.3.2 Ring-Algorithmus .....................................................................345 5.4 Übereinstimmungsalgorithmen ....................................................346 5.4.1 Unzuverlässige Kommunikation ............................................348 5.4.2 Byzantinische fehlerhafte Prozesse.........................................349 6 Rechenlastverteilung............................................................................353 6.1 Statische Lastverteilung...................................................................356 6.1.1 Jobmodelle..................................................................................358 6.1.1.1 Task-Präzedenz-Graphen..................................................359 6.1.1.2 Task-Interaktionsgraphen .................................................360 6.1.1.3 Workflows ...........................................................................362 6.1.2 Lösungsverfahren .....................................................................364 6.2 Dynamische Lastverteilung ............................................................368 6.2.1 Zentrale Lastverteilungssysteme ............................................376 6.2.2 Dezentrale Lastverteilungssysteme ........................................379 6.2.2.1 Lastausgleich ohne Migration ..........................................382 6.2.2.2 Lastausgleich mit Migration .............................................382 6.3 Grid Scheduling................................................................................389 7 Virtualisierungstechniken...................................................................395 7.1 Betriebssystemvirtualisierung ........................................................396 7.1.1 Vollvirtualisierung ....................................................................398

XXI

Inhaltsverzeichnis 7.1.2 Containervirtualisierung ......................................................... 400 7.1.3 Paravirtualisierung................................................................... 400 7.2 Virtuelle Maschine........................................................................... 401 7.2.1 Java Virtuelle Maschine (JVM) ............................................... 401 7.2.2 Common Language Runtime (CLR) ...................................... 403 7.3 Softwarevirtualisierung .................................................................. 403 7.3.1 Services ...................................................................................... 403 7.3.2 Anwendungen .......................................................................... 405 7.4 Hardware-Virtualisierung.............................................................. 405 7.4.1 Prozessor.................................................................................... 406 7.4.2 Hauptspeicher........................................................................... 407 7.4.3 Datenspeicher............................................................................ 408 7.4.3.1 In-Band-Virtualisierung.................................................... 411 7.4.3.2 Out-of-Band-Virtualisierung............................................ 412 7.4.4 Netzwerke ................................................................................. 412 7.4.4.1 Virtual Local Area Network............................................. 413 7.4.4.2 Virtual Private Network ................................................... 413 8 Cluster..................................................................................................... 415 8.1 Definition Cluster ............................................................................ 416 8.1.1 Vor- und Nachteile von Clustern ........................................... 417 8.1.2 Single System Image ................................................................ 417 8.1.3 Aufstellungskonzepte von Clustern ...................................... 419 8.2 Klassifikationen von Clustern........................................................ 420 8.2.1 Hochverfügbarkeits-Cluster ................................................... 422 8.2.2 High Performance-Cluster ...................................................... 427 8.2.2.1 Beowulf ............................................................................... 428 8.2.2.2 Wolfpack............................................................................. 430

XXII

Inhaltsverzeichnis 8.2.3 Cluster für hohen Datendurchsatz .........................................430 8.2.4 Skalierbare-Cluster....................................................................431 8.3 Zugangs-Konzepte ...........................................................................432 9 Grid-Computing....................................................................................435 9.1 Definition Grid .................................................................................435 9.2 Unterscheidung von Grids..............................................................437 9.3 Grid Middleware-Systeme..............................................................438 9.3.1 Globus Toolkit ...........................................................................439 9.3.2 gLite ............................................................................................440 9.3.3 Unicore .......................................................................................440 9.4 Weitere Grid Software .....................................................................444 9.4.1 GridSphere .................................................................................444 9.4.2 Shibboleth...................................................................................444 9.4.3 VOMS..........................................................................................445 9.4.4 SRB ..............................................................................................445 9.4.5 SRM/dCache ..............................................................................445 9.4.6 OGSA-DAI .................................................................................446 9.4.7 GAT.............................................................................................446 Literatur.......................................................................................................447 Schlagwortverzeichnis .............................................................................481

XXIII

1 Einführung und Grundlagen 1.1 Historische Entwicklung der Rechensysteme Rechensysteme,ȱihrȱEinsatzȱundȱBetriebȱhabenȱsichȱinȱdenȱletztenȱJahrȬ zehntenȱ radikalȱ geändert.ȱ Ihreȱ historischeȱ Entwicklungȱ lässtȱ sichȱ inȱ folgendenȱSchrittenȱgrobȱskizzieren:ȱ 1970ȱ–ȱBatchȱProcessingȬSysteme:ȱMitȱEinlesenȱvonȱJobsȱ(oderȱAufträȬ gen)ȱ undȱ Bearbeitungȱ derȱ Jobsȱ durchȱ denȱ Rechnerȱ (Mainframe).ȱ Zurȱ ReihenfolgeȱderȱBearbeitungȱderȱJobsȱnachȱeinerȱbestimmtenȱStrategieȱ stehtȱeinȱJobȱSchedulerȱzurȱVerfügung.ȱȱ

Batchȱ Processingȱ

1975ȱ –ȱ TimesharingȬSysteme:ȱ ȱ Einzelneȱ Aufträgeȱ wickeltȱ derȱ Rechnerȱ (Mainframeȱ undȱ Minicomputer)ȱ imȱ Dialogȱ mitȱ demȱ Benutzerȱ ab.ȱ Einȱ Benutzerȱ übergibtȱ überȱ eineȱ Kommandooberfläche,ȱ beiȱ UnixȱShellȱ geȬ nannt,ȱ einenȱAuftragȱ zurȱBearbeitung.ȱMehrereȱ Benutzerȱ (MultiȱUserȬȱ Betrieb)ȱ teilenȱ sichȱ dabeiȱ dieȱ CPU.ȱ Diesȱ geschiehtȱ dadurch,ȱ dassȱ denȱ einzelnenȱProzesseȱdieȱaufȱderȱCPUȱabgearbeitetȱwerden,ȱZeitscheibenȱ zurȱVerfügungȱgestelltȱwerden.ȱNachȱdemȱAblaufenȱeinerȱZeitscheibeȱ kommtȱ durchȱ eineȱ Prozessumschaltungȱ (Dispatcher)ȱ einȱ andererȱ ProȬ zessȱ zumȱ Zuge.ȱ Dadurchȱ hatȱ derȱ Benutzerȱ denȱ Eindruck,ȱ alsȱ stündeȱ derȱRechnerȱihmȱalleineȱzurȱVerfügungȱ(virtuellerȱProzessor).ȱ

Timesharing

1980ȱ –ȱ Personalȱ Computerȱ undȱ Workstation:ȱ Dieȱ Rechenleistungȱ PCsȱ kommtȱanȱdenȱArbeitsplatzȱundȱstehtȱjedemȱeinzelnenȱBenutzerȱ(Singleȱ Userȱ Betrieb)ȱ zurȱ Verfügung.ȱ Überȱ eineȱ Kommandooberflächeȱ undȱ späterȱ durchȱ eineȱ Windowsoberflächeȱ übergibtȱ derȱ Benutzerȱ einenȱ Auftragȱ zurȱ Bearbeitungȱ oderȱ erȱ ruftȱ einȱ Anwendungsprogrammȱ z.B.ȱ einȱTextverarbeitungsprogrammȱauf.ȱDadurchȱentstandenȱInsellösungen,ȱ dieȱ keinenȱ Zugriffȱ aufȱ gemeinsameȱ Betriebsmittelȱ erlaubten.ȱ BetriebsȬ mittelȱkönnenȱdabeiȱHardwarebetriebsmittel,ȱwieȱz.B.ȱDrucker,ȱPlotter,ȱ Modemȱ oderȱ Softwarebetriebsmittel,ȱ wieȱ z.ȱ B.ȱ Daten,ȱ Filesȱ oderȱ ProȬ gramme,ȱ sein.ȱ Diesenȱ Nachteilȱ versuchteȱ manȱ zuȱ umgehen,ȱ indemȱ manȱ mehrereȱ Rechnerȱ überȱ einȱ Netzȱ verband.ȱ Jederȱ Rechnerȱ imȱ Netzȱ stelltȱdabeiȱBetriebsmittelȱzurȱVerfügungȱundȱkannȱaufȱdieȱBetriebsmitȬ telȱeinesȱanderenȱRechnersȱzugreifen.ȱDaȱalleȱRechnerȱimȱNetzȱgleichȬ berechtigtȱsindȱundȱihreȱDienstȱundȱihreȱBetriebsmittelȱundȱdieȱdamitȱ verbundenenȱDiensteȱanbietenȱundȱandererseitsȱauchȱdieȱDiensteȱvonȱ anderenȱRechnernȱ inȱ Anspruchȱ nehmen,ȱ sprichtȱ manȱ vonȱ einemȱ peerȬ toȬpeerȬNetz.ȱDadurch,ȱdassȱjederȱRechnerȱallesȱanbietenȱkannȱundȱallesȱ

1ȱ

1ȱȱEinführungȱundȱGrundlagenȱ vonȱ jedemȱ anderenȱ Rechnerȱ nutzenȱ kann,ȱ mussȱ aufȱ jedemȱ Rechnerȱ festgehaltenȱ werden,ȱ werȱ welcheȱ Ressourcenȱ (Drucker,ȱ Dateienȱ etc.)ȱ nutzenȱ darf.ȱ Diesȱ führtȱ zuȱ einemȱ hohenȱ Verwaltungsaufwandȱ aufȱ jeȬ demȱRechner.ȱȱ ClientȬServerȱ

1985ȱ–ȱȱClientȬServerȬSysteme:ȱȱZurȱVerwaltungsvereinfachungȱzentraȬ lisiertȱ manȱ denȱ Dienstȱ (Service)ȱ aufȱ einemȱ bestimmtenȱ Rechner,ȱ undȱ dieserȱRechnerȱwurdeȱzumȱServerȱimȱNetz,ȱz.B.ȱzumȱPrintȬServerȱoderȱ zumȱFileȬServer.ȱDieȱanderenȱMaschinenȱwurdenȱzuȱClients,ȱdieȱdiesenȱ zentralisiertenȱ Dienstȱ inȱ Anspruchȱ nehmenȱ konnten.ȱ Dieȱ AnwendunȬ gen,ȱdieȱaufȱsolchemȱClientȬServerȬSystemȱablaufen,ȱsindȱClients,ȱundȱ sieȱhabenȱüberȱdasȱBetriebssystemȱZugriffȱaufȱdieȱDiensteȱdesȱServers.ȱ DieȱBetriebssysteme,ȱdieȱsolchȱeinenȱClientȬServerȬBetriebȱermöglichen,ȱ sindȱaufȱderȱClientȬSeiteȱAufsätzeȱaufȱbestehendeȱBetriebssysteme,ȱdieȱ denȱZugriffȱaufȱentfernteȱRessourcenȱermöglichen,ȱundȱaufȱderȱServerȬ Seiteȱ organisierenȱ sieȱ denȱ ServerȬBetrieb.ȱ Solcheȱ Betriebssystemeȱ heiȬ ßenȱNetzwerkbetriebssysteme.ȱȱ

Clusterȱ

1990ȱ –ȱ ClusterȬSysteme:ȱ Daȱ Serverȱ hoheȱ Anforderungenȱ anȱ dasȱ LeisȬ tungsvermögenȱ undȱ dieȱ Ausfallsicherheitȱ derȱ Rechnerȱ stellen,ȱ setztȱ manȱ alsȱ ServerȬMaschinenȱ Multiprozessorenȱ einȱ oderȱ manȱ verbindetȱ zweiȱ oderȱ mehrereȱ Rechnerȱ zuȱ einemȱ Clusterȱ (Traube,ȱ Bündel,ȱ Schwarm),ȱsoȱdassȱsieȱwieȱeineȱeinzigeȱvirtuelleȱMaschineȱagieren.ȱȱ Einȱ Loadȱ Balancingȱ Clusterȱ verteiltȱ durchȱ einȱ LastausgleichȬFrontendȱ dieȱ Arbeitslastȱ aufȱ mehrereȱ BackendȬServer.ȱ Solchȱ einȱ Clusterȱ vonȱ ComputernȱwirdȱauchȱalsȱServerȬFarmȱbezeichnet.ȱȱ Beiȱ einemȱ Highȱ Performanceȱ Computingȱ (HPC)ȱ Clusterȱ parallelisiertȱ undȱ partioniertȱ manȱ dieȱ Aufgabenȱ undȱ verteiltȱ sieȱ aufȱ dieȱ mehrerenȱ Knotenȱ einesȱ Clustersȱ undȱ erreichtȱ durchȱ dieȱ paralleleȱ Abarbeitungȱ eineȱschnellereȱBearbeitungȱderȱGesamtaufgabe.ȱ ZurȱErhöhungȱderȱAusfallsicherheitȱundȱSteigerungȱderȱVerfügbarkeitȱ vonȱServerȱdienenȱHighȱAvailabilityȱ(HA)ȱCluster.ȱEinȱHAȬClusterȱistȱ einȱ Systemȱ ausȱ mehrerenȱ Computern,ȱ dieȱ sichȱ überȱ spezielleȱ VerbinȬ dungenȱ überȱ ihreȱ Einsatzbereitschaftȱ verständigen.ȱ Fälltȱ einȱ Systemȱ aus,ȱsoȱwerdenȱalleȱProzesseȱanȱdasȱandereȱSystemȱübergeben.ȱImȱeinȬ fachstenȱFallȱstehtȱeinȱkompletterȱzweiterȱRechnerȱalsȱReserveȱzurȱVerȬ fügung,ȱwasȱnatürlichȱdoppelteȱHardwareȬȱundȱSoftwareinvestitionenȱ verursacht.ȱȱ

PeerȬtoȬPeerȱ

2ȱ

1995ȱ–ȱPeerȬtoȬPeerȬSysteme:ȱDasȱGegenteilȱzumȱClientȬServerȬPrinzipȱ istȱ dasȱ PeerȬtoȬPeerȬPrinzip.ȱ Beimȱ ClientȬServerȬBetriebȱ bietetȱ derȱ SerȬ verȱ Diensteȱ an,ȱ undȱ derȱ Clientȱ nutztȱ diesenȱ Dienst.ȱ Inȱ PeerȬtoȬPeerȬ

1.1ȱHistorischeȱEntwicklungȱderȱRechensystemeȱ NetzenȱistȱdieseȱRollenverteilungȱaufgehoben.ȱJederȱRechnerȱinȱeinemȱ Netzȱ istȱ einȱ peer,ȱ dennȱ erȱ kannȱ gleichzeitigȱ Clientȱ undȱ Serverȱ sein.ȱ PeerȬtoȬPeerȱ (Gleichgestellter,ȱ Ebenbürtigerȱ oderȱ Altersgenosse)ȱ beȬ zeichnetȱ dieȱ Kommunikationȱ unterȱ Gleichen.ȱ Dadurchȱ dassȱ esȱ nurȱ Gleicheȱ inȱ PeerȬtoȬPeerȬNetzenȱ gibt,ȱ sindȱ derȱ Leistungsengpassȱ oderȱȱȱȱȱ Ȭflaschenhalsȱ undȱ derȱ einzelneȱ Ausfallpunktȱ vonȱ ClientȬServerȬ SystemenȱinȱPeerȬtoȬPeerȬNetzenȱeliminiertȱ[SWȱ04].ȱȱ Derȱ Begriffȱ PeerȬtoȬPeerȱ oderȱ P2Pȱ hatȱ sichȱ durchȱ dieȱ MusikȬ TauschbörseȱNapsterȱeingebürgert,ȱobwohlȱNapsterȱnochȱeinenȱzentraȬ lenȱ Serverȱ besaß.ȱ Erstȱ derȱ Nachfolgerȱ Gnutellaȱ besaßȱ eineȱ dezentraleȱ Strukturȱ undȱ verdienteȱ denȱ Namenȱ P2P.ȱ Besondersȱ dieȱ Vielzahlȱ vonȱ Applikationenȱ wieȱ FastTrack,ȱ GnutellaȬ2,ȱ eDonkey,ȱ Overnetȱ undȱ KaȬ demlia,ȱ BitTorrent,ȱ undȱ Skype,ȱ treibenȱ dieȱ Entwicklungenȱ aufȱ demȱ P2PȬGebietȱvoranȱ[Dȱ02]ȱ[SFTȱ02].ȱȱȱ DieȱPeer–toȬPeerȬNetzwerkeȱsindȱdenȱKinderschuhenȱentwachsen,ȱundȱ langsamȱkristallisiertȱsichȱheraus,ȱwasȱdieȱStandardtechnikenȱsindȱundȱ welcheȱArtȱvonȱProblemenȱrelevantȱsindȱ[MSȱ07],ȱ[ASȱ04],ȱ[SWȱ05].ȱ 2000ȱ –ȱ GridȬSysteme:ȱ Dasȱ GridȬComputingȱ (Gitterrechnen)ȱ hatȱ zumȱ Ziel,ȱverschiedeneȱITȬRessourcenȱinȱeinemȱNetzwerkȱzusammenzufasȬ sen.ȱ Anwender,ȱ dieȱ inȱ soȱ genanntenȱ virtuellenȱ Organisationenȱ zuȬ sammengeschlossenȱ seinȱ können,ȱ nutzenȱ dieseȱ Ressourcenȱ überȱ eineȱ GridȱMiddleware,ȱ dieȱ zentraleȱ Funktionenȱ inȱ einerȱserviceorientiertenȱ Strukturȱ(SOA)ȱbereitstellt.ȱȱȱ

Gridȱ

Einȱ Rechengridȱ (Computingȱ Grid)ȱ mitȱ Zugriffȱ aufȱ verteilteȱ RechenresȬ sourcenȱistȱvergleichbarȱmitȱdemȱPowerȱGridȱ(daherȱauchȱderȱName),ȱ alsoȱ demȱ Stromnetz:ȱ Dazuȱ stelltȱ derȱ Verbraucherȱ vonȱ Rechenleistungȱ eineȱVerbindungȱzumȱRechennetzȱher,ȱähnlichȱwieȱderȱStromverbrauȬ cherȱ zumȱ Stromversorgungsnetz.ȱ Dortȱ istȱ alles,ȱ wasȱ hinterȱ derȱ SteckȬ doseȱ passiert,ȱ fürȱ denȱ Konsumentenȱ verborgen,ȱ erȱ nutztȱ einfachȱ dieȱ angeboteneȱLeistung.ȱ

Computingȱ Gridȱ

EinȱDatengridȱ(DataȱGrid),ȱmitȱZugriffȱaufȱverteilteȱDatenbanken,ȱkoȬ operiertȱ nichtȱ nurȱ dieȱ einzelnenȱ (HochleistungsȬ)ȱ Computer,ȱ umȱ ReȬ chenleistungȱ zurȱ Verfügungȱ zuȱ stellen,ȱ sondernȱ auchȱ Datenbeständeȱ werdenȱ verknüpft.ȱ Zugangȱ zuȱ solchenȱ Gridsȱ bietetȱ meistȱ einȱ GridȬ Portal.ȱ

DataȱGridȱ

ZusammenfassendȱzeigtȱAbbildungȱ1Ȭ1ȱRealisierungenȱdesȱClientȱSerȬ verȬȱ undȱ Distributedȱ Computingȱ (Parallelesȱ undȱ Verteiltesȱ Rechnen)ȱ undȱ klassifiziertȱ diese.ȱ Sieheȱ auchȱ dieȱ umfangreichereȱ Klassifikationȱ vonȱBaunȱ[B1ȱ06]ȱundȱ[B2ȱ06].ȱ

3ȱ

1ȱȱEinführungȱundȱGrundlagenȱ Abb.ȱ1Ȭ1:ȱ Realisierungȱ desȱClientȱ ServerȬȱundȱ Distributedȱ Computingȱ

ȱ

ȱ

ȱ

ȱ ȱ ȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ Mobileȱ Systemeȱ

2000ȱ –ȱ Mobileȱ Computingȱ [Rȱ 05]:ȱ Funkverbindungenȱ ergänzenȱ undȱ verdrängenȱ teilweiseȱ dieȱ klassischenȱ leitungsgebundenenȱ Netzwerke.ȱ Funkverbindungenȱ ermöglichenȱ denȱ selbstständigenȱ Aufbauȱ undȱ dieȱ KonfigurationȱvonȱNetzenȱmitȱmobilenȱEndgerätenȱwieȱMobiltelefone,ȱ PersonalȱDigitalȱAssistantsȱ(PDAs),ȱNotebooksȱundȱHandheldȬRechnerȱ oderȱSpezialgeräteȱwieȱDigitalkamerasȱundȱGPSȬEmpfängerȱbisȱhinȱzuȱ diversenȱ mobilenȱ Mikrogeräten,ȱ wieȱ sieȱ beimȱ Wearableȱ Computingȱ oderȱUbiquitousȱComputingȱzumȱEinsatzȱkommen.ȱȱ

MANetȱ

DaȱdieȱProtokolleȱundȱAnwendungenȱmitȱkommendenȱundȱgehendenȱ oderȱ ausgefallenenȱ Gerätenȱ umgehenȱ müssen,ȱ bauenȱ sichȱ dieȱ Netzeȱ dynamischȱ durchȱ kommendeȱ oderȱ gehendeȱ Knotenȱ aufȱ undȱ abȱ undȱ passenȱ sichȱ dynamischȱ denȱ sichȱ bewegendenȱ Gerätenȱ an.ȱ Deshalbȱ sprichtȱmanȱbeiȱdiesenȱNetzenȱvonȱmobilenȱAdȬhocȬNetzenȱ(mobileȱadȱ hocȱnetwork,ȱMANet).ȱDaȱinȱdenȱNetzenȱkeineȱzentralenȱInstanzenȱundȱ keineȱzentralenȱRouterȱvorhandenȱsind,ȱbesitzenȱdieȱProtokolleȱundȱdieȱ aufȱ denȱ Gerätenȱ ablaufendenȱ Algorithmenȱ eineȱ PeerȬtoȬPeerȬ Architektur.ȱȱ

Sicherheitȱbeiȱ MANetȱ

Funkverbindungenȱ sindȱ schlechterȱ gegenȱ Abhörungȱ undȱ Angriffeȱ zuȱ sichernȱalsȱeinȱFestnetz.ȱEinȱweitererȱNachteilȱist,ȱdassȱdieȱausȱFestnetȬ zenȱ bekanntenȱ Sicherheitsalgorithmenȱ meistȱ eineȱ ClientȬServerȬ Strukturȱ besitzen.ȱ Sicherheitssystemeȱ fürȱ Funknetzeȱ müssenȱ deshalbȱ

4ȱ

1.2ȱTechnologiefortschritteȱ dieȱ erhöhtenȱSicherheitsanforderungenȱfürȱFunknetzeȱ berücksichtigenȱ undȱinȱeineȱpeerȬtoȬpeerȬArchitekturȱübergeführtȱwerdenȱ[MDMȱ07].ȱ

1.2 Technologiefortschritte DieȱEntwicklungȱderȱletztenȱfünfȱGenerationenȱwurdeȱdurchȱdasȱAufȬ kommenȱderȱfolgendenȱTechnologienȱermöglicht:ȱ 1.

Mächtigeȱ Mikroprozessoren,ȱ zuerstȱ 8,ȱ dannȱ 16,ȱ 32ȱ undȱ inȱ denȱ neunzigerȱJahrenȱ64ȬbitȱCPUsȱ(z.B.ȱDEC’sȱAlphaȱChip)ȱstehenȱzurȱ Verfügung.ȱAusȱhistorischerȱSichtȱübertreffenȱdabeiȱdieȱMikroproȬ zessorenȱdieȱRechenleistungȱeinesȱGroßrechnersȱzumȱBruchteilȱdesȱ PreisesȱeinesȱGroßrechners.ȱWeiterhinȱführteȱdieȱKoppelungȱdieserȱ Prozessorenȱ hinȱ zuȱ Multiprozessoren,ȱ welcheȱ dieȱ Möglichkeitȱ derȱ inkrementellenȱLeistungssteigerungȱbieten.ȱ

2.

Dasȱ Aufkommenȱ vonȱ lokalenȱ Netzwerkenȱ (localȱ areaȱ networksȱ –ȱȱ LANs).ȱLokaleȱNetzwerkeȱerlauben,ȱDutzendeȱoderȱsogarȱHunderȬ teȱvonȱRechnernȱüberȱeinȱNetzȱzuȱkoppeln,ȱsoȱdassȱkleineȱMengenȱ vonȱ Informationenȱ innerhalbȱ vonȱ Millisekundenȱ transferiertȱ werȬ denȱ können.ȱ Größereȱ Datenmengenȱ lassenȱ sichȱ inȱ Ratenȱ vonȱ 10ȱ Millionenȱbits/secȱ(Ethernetȱ10ȱMBitȱbisȱzuȱFastȱEthernetȱ100ȱMBit),ȱ TokenȱRingȱ4ȱoderȱ16ȱMBit,ȱTokenȱBusȱ5ȱMBitȱoderȱ10ȱMBit),ȱüberȱ 100ȱ Millionenȱ bits/secȱ (optischeȱ Netzeȱ –ȱ FDDIȱ (Fiberȱ Distributedȱ Dataȱ Interconnect)ȱ undȱ FastȬEthernet)ȱ bisȱ zuȱ GigabitȬEthernetȱ (1GBit)ȱ undȱ10ȱ GbitȬEthernetȱ transferieren.ȱ Netzwerktechnologienȱ wieȱ Asynchronousȱ Transferȱ Modeȱ (ATM)ȱ erlaubenȱ DatenübertraȬ gungsgeschwindigkeitenȱvonȱ155ȱMbps,ȱ622ȱMbpsȱundȱ2,5ȱGbps.ȱ

3.

Vonȱ verschiedenenȱ Funkverbindungenȱ undȱ derȱ technologischenȱ Entwicklungȱ derȱ mobilenȱ Endgeräteȱ erwartetȱ dieȱ Industrieȱ einenȱ starkȱ wachsendenȱ Markt,ȱ undȱ damitȱ gewinnenȱ dieȱ Technologienȱ derȱmobilenȱNetzeȱheuteȱundȱzukünftigȱimmerȱmehrȱanȱBedeutung.ȱ Szenarienȱ einerȱ totalȱ vernetztenȱ informatisiertenȱ Weltȱ stelltȱ MatȬ ternȱvorȱinȱ„Totalȱvernetzt“ȱ[Mȱ03].ȱȱ

4.

DieȱVerbindungȱmehrererȱphysischerȱNetzeȱzuȱeinemȱeinheitlichenȱ KommunikationssystemȱundȱdasȱAnbietenȱeinesȱUniversaldienstesȱ fürȱ heterogeneȱ Netzwerke,ȱ demȱ Internetworking,ȱ undȱ dasȱ darausȱ resultierendeȱSystem,ȱdemȱInternet.ȱȱ

5ȱ

1ȱȱEinführungȱundȱGrundlagenȱ

1.2.1 Leistungsexplosion und Preisverfall der Hardware Gesetzȱvonȱ Mooreȱ

Derȱ Gründerȱ vonȱ INTEL,ȱ Gordonȱ Moore,ȱ sagteȱ 1965ȱ eineȱ VerdoppeȬ lungȱ vonȱ Transistorenȱ aufȱ einemȱ Chipȱ alleȱ 18ȱ Monateȱ vorausȱ –ȱ wasȱ sichȱ bisȱ heuteȱ bewahrheitete.ȱ 1971ȱ stellteȱ derȱ amerikanischeȱ ChipherȬ stellerȱ denȱ 4004ȬProzessorȱ mitȱ 2300ȱ Transistorenȱ undȱ einerȱ Taktrateȱ vonȱ108ȱKilohertzȱvor;ȱeinȱPentiumȱIIIȱvonȱ1999ȱverfügtȱüberȱ9,5ȱMilliȬ onenȱTransistorenȱundȱwirdȱmitȱ650ȱbisȱ1.2ȱGigahertzȱgetaktet,ȱundȱeinȱ Pentiumȱ4ȱProzessorȱbesitztȱ42ȱMillionenȱTransistorenȱundȱkannȱbisȱzuȱ 3,2ȱGigahertzȱgetaktetȱwerden.ȱ Speicherchipsȱ(TypȱDRAM)ȱkonntenȱzuȱBeginnȱderȱ70erȱJahreȱeinȱKiloȬ bitȱspeichern,ȱheutigeȱTypenȱschaffenȱeinȱGigabit,ȱdasȱMillionenfache.ȱ Dieȱ Strukturenȱ inȱ demȱ Siliziumȱ verringertenȱ sichȱ vonȱ 10ȱ Mikrometerȱ aufȱ0,25ȱMikrometerȱBreite.ȱȱ

Fallendeȱ MIPSȬPreiseȱ

Dabeiȱ fallenȱ beiȱ dieserȱ Entwicklungȱ nochȱ dieȱ Preise!ȱ 1991ȱ kosteteȱ dieȱ Leistungȱ vonȱ einerȱ Millionȱ Instruktionenȱ proȱ Sekundeȱ (MIPS),ȱ erȬ brachtȱdurchȱdenȱIntelȱ486ȬProzessor,ȱnochȱ225ȱDollar.ȱBeiȱeinemȱPenȬ tiumȱIIȱvonȱ1997ȱsindȱesȱnochȱvierȱDollarȱproȱMIPS.ȱEinȱȱPentiumȱ4ȱvonȱ 2004,ȱderȱmitȱ3ȱGigahertzȱgetaktetȱist,ȱerbringtȱ9075ȱMIPS,ȱsoȱdassȱderȱ Preisȱ fürȱ einȱ MIPSȱ unterȱ 5ȱ Centȱ liegt.ȱ Derȱ mitȱ zweiȱ Kernenȱ bestückteȱ ProzessorȱCoreȱ2ȱDuoȱvonȱIntelȱvonȱ2007ȱerbringtȱ22000ȱMIPS,ȱsoȱdassȱ derȱPreisȱfürȱeinȱMIPSȱbeiȱetwaȱ1,6ȱCentȱliegt.ȱȱ KosteteȱbeiȱFestplattenȱ1991ȱeinȱSpeichervolumenȱvonȱeinemȱMegabyteȱ nochȱ fünfȱ Dollar,ȱ liegtȱ derȱ Preisȱ 1999ȱ hierfürȱ nochȱ beiȱ zweiȱ bisȱ fünfȱ Cents,ȱundȱerȱistȱheuteȱunterȱ0,1ȱCentȱgefallen.ȱDieseȱEntwicklungȱkannȱ nochȱmindestensȱzehnȱJahreȱweitergehen!ȱ

Fortschritteȱ MikroȬ prozessorȬ Architekturenȱȱ

DieȱMikroprozessortechnologieȱerreichteȱrasanteȱFortschritteȱundȱgehtȱ überȱ dieȱ superskalareȱ Architektur,ȱ demȱ Simultanousȱ Multithreadingȱ bisȱhinȱzuȱdenȱMulticoreȬMultiprozessoren,ȱdieȱmehrereȱRechnerkerneȱ besitzenȱundȱdamitȱeinȱMultiprozessorȱaufȱeinemȱChipȱsind.ȱȱ

1.2.2 Fortschritte bei lokalen Netzen Ethernetȱȱ

6ȱ

Endeȱ 1972ȱ entwickelteȱ Bobȱ Metcalfeȱ beiȱ Xeroxȱ einȱ experimentellesȱ Netzwerk.ȱ 1976ȱ veröffentlichtenȱ Bobȱ Metcalfeȱ undȱ Davidȱ Boggsȱ ihrȱ Paperȱ „Ethernet:ȱ Distributedȱ Packetȱ Switchesȱ forȱ Localȱ Computerȱ Networks“ȱ [MBȱ 76].ȱ Ethernetȱ wurdeȱ imȱ Laufeȱ derȱ folgendenȱ Jahreȱ soȱ erfolgreich,ȱ dassȱ Xeroxȱ mitȱ Intelȱ undȱ DECȱ denȱ QuasiȬStandardȱ DIXȬ Ethernetȱveröffentlichte.ȱ1983ȱwurdeȱderȱEthernetȱStandardȱIEEEȱ802.3ȱ veröffentlicht.ȱSeitȱdieserȱZeitȱentwickeltȱsichȱderȱStandardȱkontinuierȬ lichȱweiter:ȱ1995ȱwurdeȱderȱFastȱEthernetȱStandardȱverabschiedet,ȱ1998ȱ GigabitȬEthernetȱundȱimȱJahrȱ2002ȱ10ȱGigabitȬEthernet.ȱ

1.2ȱTechnologiefortschritteȱ DieȱFunktionenȱdesȱEthernetsȱwerdenȱüberȱdasȱSocketȬInterfaceȱangeȬ sprochen,ȱdasȱalsȱPOSIXȬStandardȱverfügbarȱundȱBestandteilȱallerȱakȬ tuellenȱBetriebssystemeȱist.ȱDieȱKommunikationȱunterstütztȱeineȱ x

verbindungsorientierteȱ(stream)ȱKommunikation,ȱdieȱmitȱHilfeȱdesȱ TCPȬProtokollsȱrealisiertȱist.ȱTCPȱgewährleistetȱeineȱfehlerfreiȱDaȬ tenübertragungȱ zwischenȱ zweiȱ Endpunkten,ȱ dieȱ alsȱ StreamȬ Socketsȱ bezeichnetȱ werden.ȱ Multicastȱ undȱ Broadcastȱ sindȱ hierbeiȱ nichtȱ möglich.ȱ Dieȱ Datenübertragungȱ istȱ sehrȱ effizient,ȱ daȱ Datenȱ gepuffertȱundȱvomȱBetriebssystemȱparallelȱzurȱAbarbeitungȱeinerȱ Applikationȱgesendetȱundȱempfangenȱwerden;ȱȱ

x

verbindungsloseȱoderȱpaketorientierteȱ(datagram)ȱKommunikation,ȱ dieȱmitȱHilfeȱdesȱUDPȬProtokollsȱrealisiertȱist.ȱDaȱjedesȱNachrichȬ tenpaketȱ eineȱ ZielȬAdresseȱ enthält,ȱ brauchtȱ manȱ keineȱ expliziteȱ Verbindungȱ zwischenȱ Senderȱ undȱ Empfängerȱ aufzubauen.ȱ DaȬ tagramȱSocketsȱbietenȱdieȱMöglichkeit,ȱPaketeȱgleichzeitigȱanȱvieleȱ Empfängerȱ zuȱ verteilen.ȱ Broadcastȱ undȱ Multicastȱ werdenȱ dabeiȱ überȱreservierteȱAdressbereicheȱangesprochen.ȱDieȱKommunikatiȬ onȱ zwischenȱDatagramȬSocketsȱ istȱ schnellerȱ alsȱ zwischenȱ StreamȬ Sockets,ȱdaȱderȱProtokollȬOverheadȱfürȱdieȱsichereȱKommunikatiȬ onȱentfällt.ȱȱȱ

Socketsȱ

Fürȱ denȱ Einsatzȱ inȱ ClusterȬComputernȱ kommtȱ oftȱ undȱ meistensȱ nurȱ GigabitȬEthernetȱ inȱ Frage,ȱ dasȱ preiswerteȱ Kupferkabelȱ oderȱ robusteȱ Glasfaserkabelȱbenutzt.ȱEthernetȬTechnologieȱistȱpreiswertȱundȱfürȱjedeȱ HardwareȬȱundȱSoftwareȬPlattformȱverfügbar.ȱEthernetȱbietetȱdieȱMögȬ lichkeiten,ȱ perȱ Broadcastȱ undȱ Multicastȱ Datenȱ vonȱ einemȱ Senderȱ anȱ mehrereȱEmpfängerȱzuȱversenden.ȱȱ AnȱHochgeschwindigkeitsȬNetzwerktechnologieȱstehenȱnochȱ x

dasȱ vonȱ derȱ Firmaȱ Myriconȱ [Mȱ 06]ȱ angeboteneȱ Myrinetȱ 2000ȱ zurȱ Verfügungȱ [BCFȱ 95].ȱ Knotenȱ einesȱ Myrinetȱ Clusterȱ sindȱ durchȱ MyrinetȬSwitchesȱ undȱ Glasfaserȱ miteinanderȱ verbunden.ȱ Beiȱ denȱ MyrinetȬSwitchesȱ handeltȱesȱ sichȱumȱ Crossbarȱ Switch.ȱ (sieheȱ AbȬ schnittȱ 2.2.3)ȱ Myrinetȱ verwendetȱ dasȱ properitäreȱ GMȬProtokollȱ (grandȱ message)ȱ aufȱ demȱ aufsetzend,ȱ wieȱ beiȱ Ethernet,ȱ auchȱ einȱ TCP/IPȬProtokollȱgefahrenȱwerdenȱkann;ȱ

x

dasȱ vonȱ derȱ internenȱ Vernetzungȱ vonȱ Großrechnernȱ abgeleiteteȱ IEEEȬStandardȱ Scalableȱ Coherentȱ Interconnectȱ (SCI)ȱ ȱ zurȱ VerfüȬ gung.ȱ Dieȱ Firmaȱ Dolphinȱ Interconnectȱ Solutionsȱ [Dȱ 06]ȱ bietetȱ aufȱ dieserȱTechnologieȱbasierendeȱPCIȬKartenȱnebstȱLinuxȬTreibernȱan.ȱ Andersȱ alsȱ beiȱ Ethernetȱ undȱ Myrinetȱ erfolgtȱ dieȱ Kommunikationȱ inȱ einemȱ SCIȬNetzwerkȱ nichtȱ überȱ einenȱ Switchȱ sondernȱ vonȱ

7ȱ

1ȱȱEinführungȱundȱGrundlagenȱ Punktȱ zuȱ Punkt.ȱ Dadurchȱ bedingtȱ könnenȱ dieȱ Knotenȱ nurȱ linearȱ miteinanderȱ verbundenȱ werdenȱ undȱ dieȱ Netzwerkeȱ nehmenȱ ToȬ rusformȱan;ȱȱ x

dasȱvonȱderȱFirmaȱInfiniBandȱTradeȬAssociationȱ[Iȱ06]ȱentwickelteȱ InfiniBandȱ zurȱ Verfügung.ȱ Dieȱ InfinibandȬArchitekturȱ definiertȱ einenȱ Industriestandardȱ fürȱ einȱ allgemeinesȱ HochgeschwindigȬ keitsnetzwerk.ȱDieȱArchitekturȱistȱausȱvielenȱSchichtenȱaufgebautȱ undȱ kannȱ sowohlȱ innerhalbȱ einesȱ Computersȱ alsȱ auchȱ zwischenȱ verschiedenenȱ Computernȱ fungieren.ȱ Sieȱ erlaubtȱ einenȱ direktenȱ ZugriffȱaufȱdenȱHauptspeicher,ȱsoȱdassȱderȱDatentransferȱohneȱBeȬ lastungȱ derȱ CPUȱ vonȱ stattenȱ geht.ȱ Verbindungenȱ zwischenȱ ComȬ puternȱerfolgenȱPunktȱzuȱPunktȱinȱeinemȱmitȱSwitchȱausgestatteȬ tenȱNetzwerk;ȱȱ

x

dasȱ vonȱ derȱ Firmaȱ Quadricsȱ [Qȱ 06]ȱ entwickelteȱ QsNetȱ undȱ QsNet11ȱ zurȱ Verfügung.ȱ QsNetȱ wurdeȱ aufȱ dieȱ Verwendungȱ inȱ SymmetrischenȱMultiprozessorenȱhinȱentwickelt.ȱMehrereȱparalleȬ leȱProzesseȱkönnenȱgleichzeitigȱaufȱeinȱNetzwerkinterfaceȱzugreiȬ fen,ȱohneȱsichȱdabeiȱgegenseitigȱzuȱbehindern.ȱDieȱDatenȱkönnenȱ zwischenȱ Interfaceȱ undȱ Speicherȱ transportiertȱ werden,ȱ ohneȱ denȱ Speicherȱ zuȱ belasten.ȱ QsNetȬȱ undȱ QsNet11ȬInterfacesȱ werdenȱ durchȱ Switchesȱ undȱ KupferȬȱ beiȱ QsNet11ȱ Glasfaserkabelȱ verbunȬ den.ȱ Soȱ lassenȱ sichȱ mitȱ bisȱ zuȱ 1024ȱ (QsNet)ȱ bzw.ȱ 4096ȱ (QsNet11)ȱ KnotenȱbeiȱkonstanterȱBisektionsbandbreiteȱjeȱKnotenȱaufbauenȱȱ

Dieȱ Charakteristikaȱ verschiedenerȱ Netzwerktechnologienȱ undȱ DatenȬ austauschȱimȱComputerȱüberȱdenȱBusȱmitȱdemȱHauptspeicherȱzeigtȱdieȱ nachfolgendeȱTabelleȱ1Ȭ1ȱ[BMȱ06]ȱimȱVergleich.ȱȱ DatenüberȬ tragungsrateȱ

Dieȱ Bandbreiteȱ oderȱ Datenübertragungsrateȱ gibtȱ dasȱ Verhältnisȱ zwiȬ schenȱ Datenmengeȱ undȱ Zeitȱ an,ȱ dieȱ inȱ einerȱ Datenübertragungȱ zurȱ Verfügungȱ steht.ȱ Beiȱ einerȱ parallelenȱ Datenübertragungȱ (vorȱ allemȱ beimȱZugriffȱaufȱeinȱSpeichermediumȱüberȱeinenȱDatenbus),ȱwirdȱdieȱ ÜbertragungsrateȱauchȱhäufigȱinȱByteȱproȱSekundeȱangegeben,ȱalsoȱinȱ 8ȱ Bitsȱ proȱ Sekunde.ȱ Manȱ mussȱ alsoȱ daraufȱ achten,ȱ obȱ eineȱ ÜbertraȬ gungsrateȱz.B.ȱmitȱ1ȱMByte/sȱoderȱmitȱ1ȱMbit/sȱangegebenȱwirdȱ(letzteȬ reȱAngabeȱentsprichtȱnurȱetwaȱeinemȱAchtelȱderȱGeschwindigkeitȱderȱ ersten).ȱ

Latenzȱ

DieȱLatenzȱistȱdabeiȱdieȱZeitspanne,ȱdieȱeinȱDatenpaketȱinȱComputerȬ netzwerkenȱvomȱSenderȱzumȱEmpfängerȱbenötigt.ȱDieseȱkommtȱdurchȱ dieȱLaufzeitȱimȱÜbertragungsmediumȱundȱdurchȱdieȱVerarbeitungszeitȱ aktiverȱKomponentenȱ(z.ȱB.ȱSwitch,ȱimȱGegensatzȱzuȱpassivenȱKompoȬ

8ȱ

1.2ȱTechnologiefortschritteȱ nentenȱwieȱz.B.ȱeinemȱHub)ȱzustande.ȱInȱdiesemȱZusammenhangȱwirdȱ dieȱLatenzȱauchȱalsȱPingȱbezeichnetȱ Tab.ȱ1Ȭ1:ȱ CharakteȬ ristikaȱverȬ schiedenerȱ NetzwerkȬ technologienȱ imȱVergleichȱ zumȱBusȱ

ȱ Technologie

Typȱȱ

Bandbreite in MByte/s

Latenz in Psec

Hauptspeicherȱȱ

Bus ȱ

> 1000

< 0.01

ȱ

Fast Ethernet

switchȱ

ȱ

GBit Ethernet

ȱ

ȱ ȱ ȱ

ȱ

11

70

switcheȱ d

110

30

Myrinet-ȱ2 ȱ 000

switcheȱ dȱȱ

248

6,3

ȱ

SCI

point-tȱo-ȱp ȱ oint

326

2,7

ȱ

InfiniBand

switchedȱȱ

805

7,5

ȱ

QsNet, QsNet11 ȱ

switchedȱȱ

340 bzw. 900

4ȱ

ȱ ȱ

ȱ

1.2.3 Aufkommen von Funkverbindungen und mobilen Geräten DieȱdrahtlosenȱNetzeȱundȱderenȱmobileȱEndgeräteȱlassenȱsichȱwieȱfolgtȱ unterteilen:ȱ x

Wirelessȱ Personalȱ Areaȱ Networksȱ (WPANs)ȱ sindȱ Netzwerkeȱ fürȱ dieȱVernetzungȱkleinererȱGeräte.ȱEinsatzgebieteȱsindȱz.B.ȱAusdruȬ ckenȱ vonȱ Fotosȱ vonȱ einerȱ Digitalkameraȱ aufȱ einenȱ Fotodrucker.ȱ AnschlussȱeinesȱdrahtlosenȱHeadsetsȱanȱeinȱ(MobilȬ)ȱTelefon,ȱAnȬ schlussȱ vonȱ Rechnerperipherieȱ (Maus,ȱ Tastatur,ȱ Joysticks,ȱ BildȬ schirm),ȱAnschlussȱvonȱHerzfrequenzȬPulsuhrenȱzurȱÜbertragungȱ vonȱ Datenȱ aufȱ einenȱ Rechner,ȱ Vernetzungȱ vonȱ Haushaltsgeräten,ȱ VernetzungȱvonȱPDAsȱzumȱAustauschȱvonȱDaten.ȱRealisiertȱwerȬ denȱWPANsȱmitȱ x Infrarotȱ Verbindungen:ȱ Sieȱ sindȱ nurȱ innerhalbȱ vonȱ Gebäudenȱ einsetzbar,ȱundȱesȱmussȱeineȱSichtverbindungȱzwischenȱSenderȱ undȱEmpfängerȱbestehen,ȱd.h.ȱzwischenȱSenderȱundȱEmpfängerȱ dürfenȱsichȱkeineȱGegenständeȱ(Wände)ȱbefinden.ȱDieȱInfraredȱ Dataȱ Associationȱ (IrDA)ȱ legtȱ dieȱ Standardsȱ fest.ȱ Veryȱ Fastȱ Infraredȱ (VFIR)ȱ ermöglichtȱ Datenratenȱ bisȱ zuȱ 16ȱ MBit/sȱ undȱ Reichweitenȱvonȱbisȱzuȱ5ȱm.ȱInfrarotȱVerbindungenȱunterliegenȱ keinenȱhoheitlichenȱBeschränkungen.ȱȱ

9ȱ

1ȱȱEinführungȱundȱGrundlagenȱ x FunkverbindungȱBluetooth:ȱEinsatzszenarienȱfürȱBluetoothȱsindȱ einȱ DreiȬinȬeinsȬTelefonȱ (Verbindungȱ insȱ Mobilfunknetz,ȱ VerȬ bindungȱ inȱ dasȱ Festnetz,ȱ Verbindungȱ zuȱ einemȱ weiterenȱ BlueȬ toothȬTelefon).ȱBeiȱeinerȱVerbindungȱzuȱeinemȱRechnerȱoderȱeiȬ nemȱ Mobiltelefonȱ erhältȱ manȱ Zugangȱ zumȱ Internet.ȱ Beiȱ einerȱ Verbindungȱ zuȱ einemȱ Mobiltelefonȱ undȱ einemȱ SpracheingabeȬȱ undȱ Ausgabesystemȱ oderȱ einemȱ Headsetȱ könnenȱ Audiodatenȱ übertragenȱwerden.ȱDiesȱistȱbesondersȱinȱPkwsȱnützlichȱ(Handyȱ imȱ Kofferraumȱ undȱ Telefonierenȱ amȱ Lenkrad).ȱ Weiterhinȱ werȬ denȱ Funkmäuseȱ undȱ Funktastaturenȱ mitȱ Bluetoothȱ anȱ einenȱ Rechnerȱangeschlossen.ȱEinȱFirmenkonsortiumȱ(Ericsson,ȱNokia,ȱ IBM,ȱIntelȱundȱToshiba),ȱgenanntȱdieȱBluetoothȱSpecialȱInterestȱ Groupȱ (Bluetoothȱ SIG),ȱ legtȱ denȱ Standardȱ fest.ȱ Esȱ werdenȱ DaȬ tenratenȱ vonȱ 1ȱ MBit/sȱ bisȱ zuȱ 3ȱ MBit/sȱ erreicht.ȱ Abhängigȱ vonȱ derȱ Sendeleistungȱ undȱ damitȱ vomȱ Stromverbrauchȱ sindȱ dieȱ Reichweitenȱ10ȱmȱ(beiȱMobiltelefonen)ȱbisȱzuȱ200ȱmȱmöglich.ȱ x SchnurloseȱTelefoneȱerlaubenȱmeistȱimȱBereichȱeinesȱGebäudes,ȱ drahtlosȱzuȱtelefonieren,ȱwährendȱderȱeigentlicheȱZugangȱzumȱ TelefonnetzȱeinȱtraditionellerȱFestnetzanschlussȱist.ȱAlsȱZugangȱ zumȱFestnetzȱdientȱeineȱBasisstation.ȱAlsȱStandardȱhatȱsichȱDiȬ gitalȱ Enhancedȱ Cordlessȱ Telecommunicationsȱ DECTȱ weltweitȱ etabliert.ȱDieȱBasisstationȱbeschränktȱdieȱReichweite,ȱdieȱbeiȱ50ȱ mȱinȱGebäudenȱundȱbeiȱ300ȱmȱimȱFreienȱliegt.ȱDaȱDECTȱeinȱdiȬ gitalesȱNetzȱist,ȱkannȱesȱauchȱzurȱÜbertragungȱvonȱDatenȱeingeȬ setztȱ werden.ȱ DECTȱ istȱ nahtlosȱ inȱ denȱ UMTSȬStandardȱ IMTȬ 2000ȱeingebunden.ȱSomitȱkannȱmanȱzukünftigȱmitȱeinemȱGerätȱ imȱ Heimbereichȱ kostengünstigȱ überȱ dasȱ Festnetzȱ telefonieren,ȱ währendȱmanȱaußerhalbȱdesȱHausesȱundȱunterwegsȱmobilȱteleȬ fonierenȱkann.ȱȱ x Mobiltelefonieȱhatȱsichȱseitȱdenȱ90erȱJahreȱnachȱdemȱÜbergangȱ vonȱ analogenȱ Netzenȱ inȱ dieȱ digitalenȱ DȬNetze,ȱ basierendȱ aufȱ demȱStandardȱGlobalȱSystemȱforȱMobileȱCommunicationȱGSMȱ 900ȱ (Frequenzbereichȱ 900ȱ MHz)ȱ undȱ weiterentwickeltenȱ EȬ Netze,ȱ basierendȱ aufȱ GSMȱ 1800ȱ (Frequenzbereichȱ 1800ȱ MHz)ȱ rasantȱ bisȱ zurȱ drittenȱ Generation,ȱ derȱ UMTSȬNetzeȱ (Universalȱ MobileȱTelecomunicationsȱSystem)ȱentwickelt.ȱDieȱInfrastrukturȱ fürȱ UMTSȬNetzeȱ befindetȱ sichȱ imȱ Aufbauȱ undȱ mussȱ gegenȱ dieȱ funktionsfähigenȱ undȱ bestehendenȱ Mobilfunknetzeȱ mitȱ GSMȱ ankämpfen.ȱ Derȱ Übergangȱ vonȱ GSMȬNetzenȱ aufȱ UMTSȬNetzeȱ sollȱ durchȱ DualȬModeȬHandysȱ (kannȱ beideȱ Netzeȱ benutzen)ȱ undȱerweiterteȱDienstangeboteȱattraktiverȱgemachtȱwerden.ȱ

10ȱ

1.2ȱTechnologiefortschritteȱ x

Wirelessȱ Localȱ Areaȱ Networkȱ (WLAN)ȱ habenȱ imȱ Gegensatzȱ zuȱ WPANȱ größereȱ Sendeleistungȱ undȱ damitȱ Reichweitenȱ vonȱ 30ȱ bisȱ 100ȱMeterȱaufȱfreierȱFläche.ȱDieȱBetriebsartenȱimȱWLANȱsind:ȱ 1.ȱ Derȱ Infrastructureȱ Mode,ȱ derȱ imȱ Aufbauȱ denȱ Mobilfunknetzenȱ ähnelt,ȱ mitȱ einerȱ Basisstation,ȱ demȱ soȱ genanntenȱ AccessȬPoint.ȱ EinȱAccessȬPointȱverbindetȱdasȱkabelloseȱNetzȱmitȱdemȱkabelgeȬ bundenenȱLAN–Netz.ȱDerȱAccessȬPointȱempfängt,ȱspeichertȱundȱ überträgtȱ dieȱ Datenȱ zwischenȱ WLANȱundȱ LAN.ȱ Jederȱ EndknoȬ tenȱimȱWLANȱbesitztȱeinenȱWLANȬAdapter,ȱderȱalsȱPCȬKarteȱinȱ demȱGerätȱsteckt.ȱȱ 2.ȱDerȱAdȱhocȱMode,ȱbeiȱdemȱzweiȱoderȱmehrereȱmobileȱFunkstaȬ tionenȱ inȱ Reichweiteȱ untereinanderȱ Datenȱ austauschen.ȱ Dieseȱ Adȱ hocȬNetzeȱ sindȱ PeerȬtoȬPeerȬNetzeȱ undȱ jedeȱ Funkstationȱ kommuniziertȱ mitȱ jederȱ anderenȱ ohneȱ einenȱ Serverȱ oderȱ einenȱ LANȬAnschluss.ȱȱ Derȱ WLANȬStandardȱ IEEEȱ 802.11ȱ definiertȱ aufȱ demȱ physikaliȬ schenȱLayerȱundȱderȱMACȬSchichtȱÜbertragungenȱvonȱeinemȱoderȱ zweiȱ MBit/sȱ imȱ 2,4ȱ GHzȬBand.ȱ WLANȱ nachȱ 802.11aȱ (maximalȱ 54ȱ Mbit/sȱ brutto)ȱ arbeitetȱ imȱ 5ȬGHzȬBandȱ undȱ stelltȱ 455ȱ MHzȱ zurȱ Verfügung.ȱȱ Derȱ IEEEȱ 802.11ȱ Standardȱ verwendetȱ wieȱ derȱ EthernetȬStandardȱ 802.3ȱdieselbeȱAdressierung.ȱMitȱeinemȱWirelessȱAccessȬPointȱmitȱ EthernetȬAnschlussȱlässtȱsichȱdadurchȱleichtȱeineȱVerbindungȱmitȱ einemȱkabelgebundenenȱLANȱherstellen.ȱAllerdingsȱmussȱderȱAcȬ cessȬPointȱ zwischenȱ demȱ 802.11ȱ WLANȬStandardȱ undȱ demȱ 802.3ȱ EthernetȬStandardȱkonvertieren.ȱȱ

1.2.4 Übernetzwerk Internet Dasȱ Internetȱ istȱ einȱ weltweitesȱ Netzwerkȱ voneinanderȱ unabhängigerȱ Netzwerkeȱ (Firmennetzwerke,ȱ Providernetzwerke,ȱ HochschulnetzȬ werke,ȱ öffentlichenȱ Netzenȱ sowieȱ privatenȱ lokalenȱ Netzen).ȱ Spezielleȱ Koppelungselemente,ȱ soȱ genannteȱ Routerȱ verbindenȱ dieseȱ Teilnetzeȱ untereinanderȱundȱermöglichenȱsoȱdieȱKommunikationȱundȱdenȱAusȬ tauschȱ vonȱ Information.ȱ Jederȱ Rechnerȱ einesȱ Netzwerkesȱ kannȱ dabeiȱ prinzipiellȱ mitȱ jedemȱ anderenȱ Rechnerȱ kommunizierenȱ undȱ Datenȱ austauschen.ȱEsȱbasiertȱaufȱderȱeinheitlichenȱTCP/IPȬProtokollfamilieȱ (Transmissionȱ Controlȱ Protocol/Internetȱ Protocol),ȱ welcheȱ dieȱ AdresȬ sierungȱundȱdenȱDatenaustauschȱzwischenȱverschiedenenȱComputernȱ undȱ Netzwerkenȱ standardisiert.ȱ Dieȱ Kommunikationȱ istȱ dabeiȱ völligȱ unabhängigȱvonȱdemȱverwendetenȱBetriebssystemȱundȱderȱNetzwerkȬ

Basisȱdesȱ Internetȱ TCP/IPȱ

11ȱ

1ȱȱEinführungȱundȱGrundlagenȱ technologie.ȱDieȱnetzartigeȱStrukturȱsowieȱdieȱHeterogenitätȱsorgenȱfürȱ eineȱ sehrȱ hoheȱ Ausfallsicherheit.ȱ Dieȱ Kommunikationȱ zwischenȱ zweiȱ BenutzerȱexistierenȱmeistensȱmehrereȱKommunikationswege,ȱundȱerstȱ beiȱderȱtatsächlichenȱDatenübertragungȱwirdȱeinȱentsprechenderȱWegȱ gewählt.ȱȱ Dasȱ Internetȱ mitȱ demȱ TCP/IPȬProtokollȱ istȱ dieȱ Netzwerktechnologieȱ undȱ Basisȱ fürȱ alleȱ ClientȬServerȬ,ȱ ClusterȬ,ȱ PeerȬtoȬPeerȬȱ undȱ GridȬ Netze.ȱ Dasȱ Internetȱ selbstȱ stelltȱ lediglichȱ dieȱ Infrastrukturȱ zurȱ Verfügung.ȱ DemȱDurchbruchȱundȱweitenȱVerbreitungȱverdanktȱdasȱInternet,ȱdassȱ esȱ demȱAnwenderȱ verschiedeneȱ Diensteȱ zurȱVerfügungȱ stellt.ȱ Dieȱ beȬ kanntestenȱDiensteȱsind:ȱ Internetȱ Diensteȱ

x

Worldȱ Wideȱ Webȱ (WWW)ȱ oderȱ kurzȱ Webȱ mitȱ demȱ Hypertextȱ TransferȱProtocolȱ(HTTP)ȱundȱdemȱWebbrowser,ȱ

x

EȬMailȱmitȱdemȱSimpleȱMailȱTransferȱProtocolȱ(SMTP),ȱPostȱOfficeȱ ProtocolȱVersionȱ3ȱ(POP3)ȱundȱdemȱInternetȱMessageȱAccessȱProȬ tocolȱ(IMAP)ȱundȱdemȱEȬMailȱClientȱz.B.ȱMicrosoftȱOutlook,ȱȱ

x

InternetȱRelayȱChatȱ(IRC)ȱmitȱdemȱIRCȬProtokollȱundȱdenȱClientȬ programmenȱmIRCȱoderȱXChat,ȱ

x

Dateitransfer(ftp)ȱmitȱdemȱFileȱTransferȱProtocolȱundȱClientsȱwieȱ z.B.ȱFileZilla,ȱ

x

InternetȱTelefonieȱVoiceȱoverȱIPȱ(VoIP)ȱmitȱdenȱProtokollenȱH.323ȱ undȱSessionȱInitiationȱProtocolȱ(SIP)ȱȱundȱȱȱ

x

Tauschbörsenȱ BitTorrent,ȱ eDonkey,ȱ Gnutella,ȱ FastTrack,ȱ dieȱ alsȱ PeerȬtoȬpeerȬSystemeȱausgelegtȱsindȱundȱdamitȱkeineȱZentraleȱbeȬ sitzen.ȱ

1.3 World Wide Web (WWW) NebenȱEȬMailȱistȱdasȱWorldȱWideȱWebȱoderȱkurzȱWebȱdieȱKillerappliȬ kationȱfürȱdasȱInternet.ȱȱ

1.3.1 Web 2.0 Derȱ Begriffȱ Webȱ 2.0ȱ wurdeȱ 2005ȱ vonȱ Timȱ O`ȱ Reillyȱ inȱ seinemȱ Artikelȱ „Whatȱ isȱ Webȱ 2.0“ȱ [ORȱ 05]ȱ geprägt.ȱ Erȱ bezeichnetȱ mitȱ Webȱ 2.0ȱ dieȱ zweiteȱPhaseȱderȱEntwicklungȱdesȱWebs,ȱdieȱeinhergehtȱmitȱdenȱsoziaȬ len,ȱ ökonomischenȱ undȱ technischenȱ Veränderungenȱ desȱ Websȱ [Aȱ 06],ȱ

12ȱ

1.3 World Wide Web (WWW) [A 07]. Web 2.0 lässt sich durch die drei folgenden Themen charakterisieren: 1.

Collaboration-, Participation Social-, oder Read/Write-Web, bei dem das Web als ein Zwei-Wege-Medium gesehen wird, wobei die Nutzer Leser und Schreiber sein können. Im Gegensatz zu Web 1.0, wo ein Nutzer nur statische HTML-Seiten lesen konnte. Dies ermöglicht dann Kommunikation und Kollaboration zwischen mehreren Nutzer und das Netz wird somit zu einem sozialen Netz. Von der dazugehörigeren Software spricht man von sozialer Software [Br 06] [A 07]. Beispiele dafür sind:

Read/WriteWeb

x Instant Messaging (IM) oder Nachrichtensofortversand ist ein Dienst, der es ermöglicht, mittels eines Client, dem Instant Messenger, in Echtzeit mit anderen Teilnehmern zu kommunizieren (chatten). Dabei werden kurze Text-Mitteilungen im Push oder Publish-Verfahren an den Server geschickt, der sie im Subscribe-Verfahren an die Empfänger verschickt (für Push, Publish und Subscribe siehe Abschnitt 3.3.4.2). Der Empfänger kann dann unmittelbar darauf antworten. Auf diesem Weg lassen sich meist auch Dateien austauschen. Zusätzlich bieten zahlreiche Messaging-Programme Video- oder Telefonkonferenzen an.

Instant Messaging

x Web Logs oder kurz Blogs sind Websites, auf der jeder fortlaufend Beiträge schreiben kann. Dieses Schreiben wird als Bloggen bezeichnet. Neue Beiträge stehen ganz oben und werden von anderen zuerst gelesen. Anschließend schreiben diese einen Kommentar dazu, verlinken darauf oder schicken vielleicht eine E-Mail. Viele Menschen nutzen ein Blog einfach nur, um ihre Gedanken zu ordnen, um sich Gehör zu verschaffen und um mit anderen in Verbindung zu treten, während andere weltweit die Aufmerksamkeit Tausender suchen. Journalisten benutzen Blogs, um durchschlagende Nachrichten zu veröffentlichen, während private Tagebuchschreiber ihre innersten Gedanken darlegen. Weitere Motivationen für das Blogging sind in [NSG 04] und die segensreiche Auswirkungen von Blogs auf unsere Demokratie sind in [S 04] beschrieben. Struktur und Entwicklung das Webdienstes Blog beschreiben Kumar et.al. in [KNR 04]. x Wikipedia ist eine von ehrenamtlichen Autoren (zurzeit etwa 285.000 angemeldete Benutzer und mehr als 7.000 Autoren für die deutschsprachige Ausgabe) verfasste, mehrsprachige, freie Online-Enzyklopädie [WW 07]. Der Begriff setzt sich aus „En-

Blogs

Wikipedia

13

1 Einführung und Grundlagen cyclopedia“ für Enzyklopädie und „Wiki“ [EG 05] zusammen. Der Name Wiki stammt von wikiwiki, dem hawaiischen Wort für „schnell“. Ein Wiki, auch WikiWiki und WikiWeb genannt, ist eine im Web verfügbare Seitensammlung, die von jedem Benutzer nicht nur gelesen, sondern auch online geändert werden kann. Wikis ähneln damit Content Management-Systemen. Mit der Änderbarkeit der Seiten durch jedermann erfüllt Wikipedia eine wichtige Anforderung an soziale Software. Flickr

Google, Ebay, Amazon, Google Maps

2.

x Flickr (von „to flick through something“ etwas durchblättern) bietet jedem die Möglichkeit, digitale Fotos in Kategorien (auch Tags genannt) zu sortieren, in so genannte Pools aufzunehmen, nach Stichworten zu suchen, so genannte Photostreams (Photoblogs) anderer Benutzer anzuschauen und Bilder mit Bildausschnitten zu kommentieren. Neben dem herkömmlichen Upload über die Website können die Bilder auch per E-Mail oder vom Fotohandy aus übertragen und später von anderen Webauftritten aus verlinkt werden. Web-Services oder Dienstleistungsservices stellen Services zur Verfügung, durch deren Nutzung Geld verdient wird, z.B. Google, Ebay und Amazon. Ein Service ist für den Benutzer umso wertvoller, je größer und breiter die Datenbasis ist, auf denen er basiert. Damit werden Inhalte der Websites wichtiger als das Aussehen der Inhalte im Vergleich zu Web 1.0. Durch Verknüpfung vorhandener Daten oder der Services lassen sich neue Services generieren. Google Maps [G 07] ist ein exzellentes Beispiel für die Erstellung neuer Services auf Basis bestehender Suchmaschinenfunktionalitäten, und geographische Daten werden verknüpft, um z.B. die Pizzerien einer Stadt auf einer Karte darzustellen. Die Verknüpfung der Daten, der Wiederfindung mit DataminingMethoden und deren Vertrauenswürdigkeit am Beispiel Google und Wikipedia und die daraus resultierenden Auswirkungen stellt Maurer in [M 07] zur Diskussion. Zur Programmierung von Web-Services stehen Frameworks zur Verfügung. Die populärsten sind Struts, Tapestry, Cocoon, ASP.NET und Ruby On Rails. Ein kurzer und weiterführender Überblick der Web 2.0 Frameworks ist in [BK 07] enthalten.

Web Service

14

3.

Das Web als Programmierplattform erlaubt die Erstellung von neuen Software-Applikationen, welche Service-orientierte Architekturen (SOA) realisieren. Die SOA ist eine Menge voneinander unabhängiger, lose gekoppelter Dienste, die meist mit WebServices [KW 02], [ACK 03], [DJM 05] [WCL 05] implementiert

1.3 World Wide Web (WWW) sind. Ein Web-Service erlaubt normalerweise nicht die Kommunikation mit einem Benutzer, sondern zwischen zwei oder mehreren Software Applikationen. Web-Services sind also nicht für Clientanfragen von einem Browser gedacht, sondern für Softwaresysteme, die automatisiert XML-basierte Nachrichten (Daten) austauschen und/oder Funktionen auf entfernten Rechnern aufrufen.

1.3.2 Web 3.0 Die Zusammenführung der Web 2.0-Technologien mit dem semantischen Web bezeichnet man als Web 3.0. Das semantische Web (Semantic Web) erweitert die Inhalte des Webs um semantische Informationen, so dass daraus maschinenlesbare und verarbeitbare Daten werden. Damit sind die Daten durch Software-Agenten verstehbar, interpretierbar, analysierbar und benutzbar. Die Agenten können dann, gemäß der Bedeutung der im Web abgelegten Dokumente, neue Dokumente zusammenstellen.

Semantic Web

Das Konzept beruht auf einer Vision [B 01], des W3C Direktors Tim Berners-Lee, der das Web als ein universales Medium für Daten-, Informations- und Wissensaustausch sieht. Sollen Agenten oder Automaten Such-, Kommunikations- und Entscheidungsaufgaben auf das in den Webseiten gespeicherte Wissen übernehmen oder Daten austauschen, so müssen die Webseiten Information darüber enthalten, wie sie strukturiert sind und wie sie zu interpretieren sind. Zur Darstellung komplexer Wissensbeziehungen verwendet die Informatik den Begriff Ontologie. Eine Ontologie beschreibt also einen Wissensbereich (knowledge domain) mit Hilfe einer standardisierenden Terminologie sowie Beziehungen und ggf. Ableitungsregeln zwischen den dort definierten Begriffen [H 02]. Das gemeinsame Vokabular ist in der Regel in Form einer Taxonomie gegeben, die als Ausgangselemente (modelling primitives) Klassen, Relationen, Funktionen und Axiome enthält. Eine Ontologie stellt ein Netzwerk von Informationen dar, während die Taxonomie nur eine hierarchische Untergliederung bildet.

Ontologie

Vergleichbar ist eine Ontologie mit einem UML-Klassendiagramm: Bei einem UML-Klassendiagramm modelliert man einzelne Klassen, deren Eigenschaften, sowie die Beziehungen zwischen den Klassen. Der Unterschied besteht nur darin, dass Ontologien Begriffe modellieren und keine Klassen. Das semantische Web setzt sich aus folgenden Standards und Tools zusammen:

15

1ȱȱEinführungȱundȱGrundlagenȱ

SoftwareȬ Agentenȱ

x

XMLȱ istȱ dieȱ Beschreibungsspracheȱ fürȱ strukturierteȱ Elementeȱ enthältȱ jedochȱ keineȱ semantischeȱ Beschreibungenȱ fürȱ BedeuȬ tungenȱdesȱDokuments.ȱ

x

XMLȱ Schemaȱ istȱ eineȱ Spracheȱ zurȱ Einschränkungȱ derȱ Strukturȱ undȱderȱElementeȱeinesȱXMLȱDokuments.ȱ

x

RDFȱ (Resourceȱ Descriptionȱ FrameworkȬModell)ȱ istȱ einȱ DatenȬ modellȱfürȱObjekteȱ(Ressourcen)ȱundȱwieȱsieȱmiteinanderȱinȱBeȬ ziehungȱstehen.ȱ

x

RDFȱ Schemaȱ istȱ einȱ Vokabularȱ zurȱ Beschreibungȱ vonȱ EigenȬ schaftenȱundȱKlassenȱvonȱRDFȱRessourcen.ȱ

x

OWLȱ (Webȱ Ontologyȱ Language)ȱ istȱ dieȱ zurzeitȱ populärsteȱ Spracheȱ fürȱ dieȱ Modellierungȱ vonȱ Ontologienȱ undȱ damitȱ zurȱ EntwicklungȱdesȱSemantischenȱWebs.ȱ

x

SPARQLȱ(SPARQLȱProtocolȱandȱRDFȱQueryȱLanguage)ȱistȱeinȱ ProtokollȱundȱeineȱAbfragespracheȱfürȱdasȱSemantischeȱWeb.ȱȱ

SoftwareȬAgentenȱ[Gȱ06]ȱsindȱdieȱBenutzerschnittstellenȱzumȱSemanticȱ Web.ȱAlsȱvirtuelleȱHandlungsreisendeȱbevölkernȱsieȱdasȱSemanticȱWebȱ undȱ führenȱ fürȱ ihreȱ menschlichenȱ Benutzerȱ Aufträgeȱ aus.ȱ Dazuȱ müsȬ senȱsieȱmitȱanderenȱSoftwareȬAgentenȱkommunizierenȱundȱihreȱDiensȬ teȱansprechen,ȱdasȱheißt,ȱmitȱihnenȱinteragierenȱkönnen.ȱ

1.3.3 Web 4.0 Webȱ Intelligenceȱ (WI)ȱ

16ȱ

Webȱ Intelligenceȱ (WI)ȱ untersuchtȱ dieȱ fundamentalenȱ Grundlagen,ȱ Auswirkungenȱ undȱ praktischenȱ Effekteȱ vonȱ Künstlicherȱ Intelligenzȱ undȱ fortgeschrittenenȱ InformationsȬTechnologienȱ aufȱ webbasierteȱ Produkte,ȱ Servicesȱ undȱ Aktivitäten.ȱ Dieȱ betreffendenȱ Gebieteȱ derȱ Künstlichenȱ Intelligenzȱ sindȱ z.B.ȱ Knowledgeȱ Representation,ȱ KnowȬ ledgeȱ Planning,ȱ Knowledgeȱ Discoveryȱ undȱ Dataȱ Mining,ȱ Intelligentȱ Agentsȱ undȱ Socialȱ Networkȱ Intelligence.ȱ Fortgeschritteneȱ InformatiȬ onstechnologienȱ sindȱ z.B.ȱ Wirelessȱ Networks,ȱ Ubiquitousȱ Devices,ȱ SocialȱNetworksȱundȱData/KnowledgeȱGrids.ȱWIȱlässtȱsichȱalsȱWeiterȬ entwicklungȱ oderȱ Erweiterungȱ vonȱ Künstlicherȱ Intelligenzȱ und/oderȱ Informationstechnologienȱ betrachten.ȱ Mitȱ derȱ Verknüpfungȱ vonȱ WIȱ mitȱ MultiȬPhasenȬProzessen,ȱ undȱ verteiltenȱ undȱ parallelenȱ Prozessen,ȱ leistetȱ dasȱ WIȱ wertvolleȱ Beiträgeȱ zurȱ Fortentwicklungȱ vonȱ webȬ basiertenȱTechnologienȱ[ZLYȱ07].ȱȱ

1.3ȱWorldȱWideȱWebȱ(WWW)ȱ DiesȱergibtȱeineȱzukünftigeȱVerlagerungȱdesȱWebȱhinȱzumȱWorldȱWideȱ WisdomȱWebȱoderȱkurzȱW4ȱ[ZLYȱ07]ȱundȱwirdȱhierȱalsȱeineȱvielleichtȱ neueȱzukünftigeȱVersionȱdesȱWebȱmitȱWebȱ4.0ȱbezeichnet.ȱDasȱWebȱ4.0ȱ beeinflusstȱ dieȱ folgendenȱ beschriebenenȱ EȬApplikationenȱ undȱ wirdȱ dieseȱweiterȱvorantreibenȱundȱmitȱmehrȱIntelligenzȱversehen.ȱȱ

W4ȱȱ Webȱ4.0ȱ

1.3.4 E-World Dieȱ Fortschritteȱ undȱ Entwicklungenȱ derȱ Telekommunikationȱ undȱ derȱ Informatik,ȱ derȱ Telematikȱ zusammenȱ mitȱ derȱ Entwicklungȱ derȱ InforȬ mationstechnik,ȱ hinȱ zuȱ mobilenȱ undȱ allgegenwärtigenȱ (ubiquitous)ȱ Endgeräten,ȱȱführteȱzurȱNeugestaltungȱvonȱApplikationenȱaufȱallȱunseȬ rerȱLebensgebieten,ȱhinȱzuȱEȬApplikationen,ȱoderȱwieȱKuhlenȱ[Kȱ05]ȱesȱ nennt,ȱaufȱunsereȱzukünftigeȱEȬWorld.ȱDasȱ„e“ȱstehtȱdabeiȱfürȱelectroȬ nicȱoderȱenhanced.ȱȱ

EȬApplikaȬ tionenȱ

Anfangsȱ wurdeȱ zwischenȱMenschenȱundȱ Menschenȱperȱ Telefonȱ komȬ muniziert.ȱDasȱInternetȱundȱdasȱWebȱ1.0ȱerlaubteȱeineȱKommunikationȱ zwischenȱ demȱ Menschenȱ undȱ derȱ Maschine.ȱ Dieȱ Maschineȱ stelltȱ InȬ formationȱoderȱWebseitenȱzurȱVerfügung,ȱdieȱderȱMenschȱabrufenȱundȱ einsehenȱ kann.ȱ Erȱ kannȱ weltweitȱ aufȱ Informationȱ zugreifen,ȱ undȱ Schlagworteȱ „Informationȱ atȱ yourȱ fingertipps“ȱ charakterisierenȱ denȱ Informationszugriff.ȱ Anȱ brauchbarenȱ undȱ aktuellenȱ Informationenȱ stehenȱ beispielsweiseȱ Cityȱ Guides,ȱ Travelȱ Information,ȱ elektronischesȱ TelefonbuchȱundȱHotelauskunftsverzeichnisseȱzurȱVerfügung.ȱȱ

Entwicklungȱ derȱKomȬ munikationȱ undȱdesȱWebȱ

Webȱ2.0ȱerlaubtȱmitȱdenȱWebȬServicesȱzusätzlichȱeineȱKommunikationȱ vonȱMaschinenȱmitȱanderenȱMaschinen.ȱDiesȱerlaubtȱdannȱzusammenȬ gesetzteȱundȱkomplexereȱServicesȱabzuwickeln,ȱdieȱaufȱverschiedenenȱ MaschinenȱzurȱVerfügungȱstehen.ȱDieseȱbildetȱheuteȱundȱzukünftigȱdieȱ Grundlageȱ undȱ Basisȱ vielerȱ EȬApplikationen.ȱ Gelingtȱ es,ȱ dieȱ Servicesȱ mitȱ semantischerȱ Informationȱ auszustattenȱ (Webȱ 3.0),ȱ soȱ könnenȱ dieȱ ServicesȱihremȱInhaltȱundȱihrerȱFunktionȱgemäßȱgesuchtȱundȱaufgeruȬ fenȱ undȱ ausgeführtȱ werden.ȱ Diesȱ erlaubtȱ dannȱ dieȱ komfortableȱ AbȬ wicklungȱ komplexerȱ EȬApplikationen.ȱ Mitȱ Webȱ 4.0ȱ könnenȱ dannȱ aufȱ Wissenȱ basierteȱ Servicesȱ abgewickeltȱ undȱ damitȱ intelligenteȱ EȬ Applikationenȱaufgebautȱwerden.ȱȱ

1.3.4.1 E-Business EȬBusinessȱumfasstȱdieȱbeidenȱheuteȱundȱzukünftigȱmeistensȱüberȱdasȱ InternetȱabgewickeltenȱGeschäftstätigkeitenȱdesȱ

17ȱ

1 Einführung und Grundlagen E-Commerce

x

Elektronischen Handels (E-Commerce oder andere Begriffe dafür sind Internetverkauf, Elektronischer Marktplatz und Virtueller Marktplatz), also das Handeln mit Gütern und Dienstleistungen und die

E-Procurement

x

elektronische Beschaffung (E-Procurement), also die Beschaffung von Gütern und Dienstleistungen.

Der Elektronische Handel lässt sich nach der Art der Teilnehmer unterteilen in [WE 07] Unterteilung des Elektronischen Handels

x

Consumer (Kunde): x C2C – Consumer-To-Consumer, Verbraucher an Verbraucher. Auktionshandel z.B. über Ebay. x C2B – Consumer-To-Business, Verbraucher an Unternehmen. Dienstleistungsangebote der Verbraucher an Unternehmen z.B. My-Hammer. x C2A – Consumer-To-Administration, Verbraucher an Regierung.

Definition E-Business

x

Business (Verkäufer, Unternehmen): x B2C – Business-To-Consumer, Unternehmen an Verbraucher. Versandhandel z.B. Amazon, eBay, Express, Otto etc. x B2B – Business-To-Business, Unternehmen an Unternehmen. Handel zwischen Unternehmen und Lieferanten z.B. ExportPages, Wer liefert was? x B2A – Business-To-Administration, Unternehmen an öffentl. Verwaltung. Durchführung der Leistung von Unternehmen an den Staat/öffentliche Stellen. x B2E – Business-To-Employee, Unternehmen an Mitarbeiter.

x

Administration (Regierung): x A2C – Administration-To-Consumer, Regierung an Verbraucher, elektronisch gestützte Steuererklärung z.B. Elster. x A2B – Adminstration-To-Business, Regierung an Unternehmen, Leistungsangebot öffentlicher Stellen an Unternehmen. x A2A – Administration-To-Administration, Regierung an Regierung. Elektronischer Verkehr zwischen Behörden, Austausch von Informationen.

Der Begriff E-Business wurde in den 1990er Jahren von IBM durch Werbekampagnen populär gemacht. E-Business ist die integrierte Aus-

18

1.3ȱWorldȱWideȱWebȱ(WWW)ȱ führungȱ allerȱ digitalenȱ Bestandteileȱ ökonomischerȱ Prozesseȱ [Tȱ 02].ȱ Alsoȱ dieȱ medienbruchfreie,ȱ rechnerbasierteȱ undȱ automatisierteȱ VerarȬ beitungȱ vonȱ Informationȱ inȱ ökonomischenȱ Prozessen.ȱ Beiȱ denȱ ökonoȬ mischenȱProzessenȱwerdenȱvolkswirtschaftlicheȱProzesseȱausgeschlosȬ sen.ȱ

1.3.4.2 Weitere E-Applikationen Applikationen,ȱdieȱsichȱgrößtenteilsȱaufȱdieȱInternetȬInfrastrukturȱoderȱ Ȭtechnikȱ stützenȱ undȱ dieȱ früherȱ gebrauchtenȱ TeleȬXȬBegriffeȱ oderȱ CyȬ berȬXȬBegriffeȱersetzen,ȱwerdenȱheuteȱmeistȱunterȱdemȱOberbegriffȱEȬXȱ zusammengefasst.ȱ Dieȱ prägnantestenȱ undȱ gebräuchlichtestenȱ EȬ BegriffeȱsindȱFolgende:ȱ x

Vonȱ EȬBusinessȱ Intelligenceȱ [KMUȱ 06]ȱ sprichtȱ manȱ beiȱ derȱ elektȬ ronischenȱÜberwachungȱundȱAnalyseȱderȱGeschäftstätigkeiten.ȱȱ

x

EȬFinanceȱbefasstȱsichȱmitȱgrundlegendenȱundȱaktuellenȱFragestelȬ lungenȱ derȱ elektronischenȱ Finanzdienstleistungen,ȱ z.B.ȱ desȱ elektȬ ronischenȱWertpapierhandels.ȱ

x

EȬScienceȱ bezeichnetȱ denȱ Einsatzȱ derȱ elektronischenȱ Netze,ȱ unterȱ Verwendungȱ derȱ Methodenȱ desȱ Distributedȱ Computing,ȱ insbeȬ sondereȱvonȱGridȬTechnologienȱimȱwissenschaftlichenȱUmfeld.ȱȱ

x

Unterȱ EȬLearningȱ verstehtȱ manȱ alleȱ Formenȱ desȱ Lernens,ȱ beiȱ deȬ nenȱ digitaleȱ Medienȱ fürȱ dieȱ Präsentationȱ undȱ Distributionȱ vonȱ Lernmaterialienȱ und/oderȱ elektronischeȱ Netzeȱ zurȱ Unterstützungȱ zwischenmenschlicherȱ Kommunikationȱ zumȱ Einsatzȱ kommen.ȱ BeimȱWebȬBasedȱTrainingȱ(WBT)ȱwerdenȱLerneinheitenȱnichtȱaufȱ einemȱDatenträgerȱverbreitet,ȱsondernȱvonȱeinemȱWebserverȱonliȬ neȱmittelsȱdesȱInternetsȱoderȱeinesȱIntranetsȱabgerufen.ȱDieȱEinbetȬ tungȱ insȱ Netzȱ bietetȱ vielfältigeȱ weiterführendeȱ Möglichkeitenȱ derȱ Kommunikationȱ undȱ Interaktionȱ desȱ Lernendenȱ mitȱ demȱ DozenȬ tenȱ bzw.ȱ seinenȱ Mitlernern.ȱ Soȱ könnenȱ Mails,ȱ News,ȱ Chatsȱ undȱ Diskussionsforenȱ mitȱ demȱ WBTȱ verknüpftȱ undȱ AudioȬȱ undȱ ViȬ deosignaleȱliveȱgestreamtȱwerden.ȱ

x

EȬServiceȱ umfasstȱ alleȱ Formenȱ undȱ Möglichkeiten,ȱ aufȱ elektroniȬ schemȱWegeȱdenȱServiceȱzuȱverbessern.ȱZ.ȱB.ȱbeiȱBankenȱinteraktiȬ veȱ Finanzdienstleistungenȱ (EȬBanking).ȱ Beimȱ Marketing,ȱ speziellȱ beiȱAutoherstellern,ȱeinȱ„CarȬKonfigurator“,ȱȱmitȱdessenȱHilfeȱmanȱ sichȱseinȱWunschautoȱzusammenstellenȱkann.ȱBeiȱVersicherungenȱ dieȱ interaktivenȱ Beratungsangeboteȱ zumȱ Durchspielenȱ unterȬ schiedlicherȱTarife.ȱ

19ȱ

1ȱȱEinführungȱundȱGrundlagenȱ x

UnterȱEȬGovernmentȱverstehtȱmanȱdieȱVereinfachungȱundȱDurchȬ führungȱ vonȱ Prozessenȱ zurȱ Information,ȱ Kommunikationȱ undȱ TransaktionȱinnerhalbȱundȱzwischenȱstaatlichenȱInstitutionenȱundȱ Behördenȱ sowieȱ zwischenȱ diesenȱ Institutionenȱ undȱ Bürgernȱ bzw.ȱ Unternehmenȱ durchȱ denȱ Einsatzȱ vonȱ Informationstechnologienȱ undȱ elektronischenȱ Netzen.ȱ EȬGovernmentȱ istȱ somitȱ derȱ ÜberbeȬ griffȱ fürȱ EȬAdministration,ȱ EȬJusticeȱ undȱ EȬDemocracy.ȱ EȬ DemocracyȱumfasstȱEȬParticipationȱundȱEȬVoting.ȱȱ

x

EȬCommunityȱ ermöglichtȱ dieȱ Bildungȱ vonȱ Gemeinschaften.ȱ EȬ CommunityȱstelltȱeineȱunterstützendeȱundȱproduktiveȱUmgebungȱ zumȱ Zusammenarbeiten,ȱ Lernenȱ undȱ Kommunizierenȱ zurȱ VerfüȬ gung.ȱȱ

x

EȬHealthȱ bezeichnetȱ dieȱ Vernetzungsbestrebungenȱ imȱ GesundȬ heitswesenȱ(z.ȱB.ȱelektronischeȱPatientenakten)ȱoderȱgenerellȱelektȬ ronischeȱ Infrastrukturinitiativenȱ (z.B.ȱ elektronischeȱ Beschaffungȱ vonȱGesundheitsinformationenȱundȱDienstleistungenȱviaȱInternet).ȱ Mitunterȱ sindȱ mitȱ EȬHealthȱ Anwendungenȱ derȱ Telemedizinȱ geȬ meint,ȱ z.B.ȱ Expertenkonzileȱ oderȱ dasȱ FernȬMonitoringȱ derȱ VitalȬ werteȱvonȱPatienten.ȱ

1.4 Selbstorganisierende Systeme Dieȱ verteiltenȱ Rechensystemeȱ müssenȱ installiert,ȱ konfiguriert,ȱ überȬ wachtȱ (Monitoring),ȱ Sicherheitsanforderungenȱ realisiert,ȱ umkonfiguȬ riertȱ undȱ beiȱ auftretendenȱ Fehlernȱ repariertȱ werden.ȱ Diesȱ verursachtȱ imȱlaufendenȱBetriebȱderȱSystemeȱhoheȱKosten,ȱdieȱsoȱgenanntenȱTotalȱ Costȱ ofȱ Ownershipȱ (TCO).ȱ Zurȱ Senkungȱ derȱ Kostenȱ gehtȱ manȱ entweȬ derȱdenȱWegȱȱ x

desȱAuslagernsȱderȱRechenressourcenȱȱanȱexterneȱDienstleistungsȬ unternehmenȱ(Outsourcing),ȱoderȱ

x

durchȱ Virtualisierungstechniken,ȱ besondersȱ beiȱ derȱ ServerȬ Konsolidierungȱ versuchtȱ manȱ durchȱ Reduktionȱ derȱ Anzahlȱ derȱ ServerȱdieȱlaufendenȱKostenȱzuȱreduzieren,ȱoderȱ

x

durchȱ selbstlaufende,ȱ selbstkonfigurierende,ȱ fehlertoleranteȱ undȱ somitȱsichȱselbstorganisierendeȱSystemeȱversuchtȱmanȱdieȱKostenȱ inȱdenȱGriffȱzuȱbekommen.ȱȱ

1.4.1 On Demand Computing 2002ȱ prägteȱ IBMȱ denȱ Begriffȱ desȱ Businessȱ onȱ Demand.ȱ Businessȱ onȱ DemandȱerlaubtȱgeänderteȱMarktbedingungenȱoderȱveränderteȱAnforȬ

20ȱ

1.4ȱSelbstorganisierendeȱSystemeȱ derungenȱ–ȱdieȱzumȱTeilȱdurchȱdieȱGlobalisierungȱderȱMärkteȱbedingtȱ sindȱ –ȱzuȱ erkennenȱundȱ mitȱ einerȱ flexiblenȱ ITȬInfrastrukturȱ daraufȱzuȱ reagieren.ȱȱ Heuteȱ wirdȱ derȱ Begriffȱ Businessȱ onȱ Demandȱ weiterȱ ausgelegtȱ undȱ schließtȱ dasȱ Computingȱ onȱ Demandȱ mitȱ ein.ȱ Onȱ Demandȱ Computingȱ (ODC)ȱistȱeinȱComputingȬModellȱaufȱUnternehmensebene,ȱbeiȱdemȱdieȱ Technologienȱ undȱ Rechenressourcenȱ Organisationenȱ undȱ individuelȬ lenȱBenutzernȱsobaldȱundȱsoweitȱerȱsieȱbenötigtȱzurȱVerfügungȱgestelltȱ werden.ȱ Rechenressourcenȱ sindȱ dabeiȱ CPUȬZyklen,ȱ Bandbreite,ȱ SpeiȬ cherȱundȱneuerdingsȱauchȱApplikationenȱundȱServices.ȱDieȱRechenresȬ sourcenȱwerdenȱdenȱTasksȱoderȱdenȱApplikationenȱderȱBenutzerȱzugeȬ teilt,ȱsoȱwieȱerȱsieȱbenötigt.ȱDiesȱführtȱaufȱeineȱbessereȱAuslastungȱderȱ Rechenressourcen,ȱdaȱverschiedeneȱBenutzerȱzuȱeinerȱZeitȱunterschiedȬ licheȱ Ressourcenȱ belegen.ȱ Weiterhinȱ könnenȱ dadurchȱ SpitzenleistunȬ genȱbesserȱbewältigtȱwerden,ȱdaȱnichtȱalleȱBenutzerȱzurȱgleichenȱZeit,ȱ sondernȱzuȱverschiedenenȱZeitenȱdieȱSpitzenleistungȱbenötigen.

OnȱDemandȱ Computingȱ (ODC)ȱ

Mitȱ Virtualisierungstechnikenȱ (sieheȱ Kapitelȱ 7)ȱ unterteiltȱ manȱ denȱ geȬ meinsamȱ genutztenȱ Rechnerpoolȱ inȱ logischeȱ Ressourcenȱ anstelleȱ derȱ physikalischȱvorhandenenȱRessourcen.ȱEinerȱTaskȱoderȱeinerȱApplikaȬ tionȱ wirdȱ keineȱ bestimmte,ȱ vorabȱ festgelegteȱ Ressourceȱ zugeordnet,ȱ sondernȱeineȱbeliebige,ȱzurȱLaufzeitȱfreieȱvirtuelleȱRessourceȱausȱdemȱ PoolȱderȱRessourcen.ȱȱ

VirtualisieȬ rungȱ

Dieȱ Ressourcenȱ werdenȱ dabeiȱ durchȱ dieȱ eigeneȱ ITȬInfrastrukturȱ desȱ payȬperȬuse Benutzersȱ oderȱ durchȱ ServiceȬProviderȱ zurȱ Verfügungȱ gestellt.ȱ Dieȱ ServiceȬProviderȱrechnenȱdannȱihreȱLeistungenȱbeiȱpayȬperȬuseȱab.ȱEsȱ müssenȱalsoȱnurȱdieȱLeistungenȱfürȱInanspruchnahmeȱderȱRessourcenȱ bezahltȱwerden,ȱdieȱauchȱtatsächlichȱbenutztȱwurden.ȱServiceȬProviderȱ bietenȱ einenȱ Katalogȱ vonȱ standardisiertenȱ Servicesȱ an.ȱ Dieseȱ könnenȱ unterschiedlicheȱ Serviceȱ Levelȱ Agreementsȱ (Vereinbarungȱ überȱ dieȱ QualitätȱundȱdenȱPreisȱeinerȱITȬDienstleistung)ȱhaben.ȱDerȱKundeȱhatȱ keinenȱEinflussȱmehrȱaufȱdieȱzugrundeȱliegendenȱTechnologienȱwieȱz.B.ȱ dieȱServerȬPlattform.ȱ Unterȱ Utilityȱ Computingȱ verstehtȱ manȱ Technologienȱ undȱ GeschäftsȬ modelle,ȱmitȱdenenȱeinȱServiceȬProviderȱseinenȱKundenȱITȬLeistungenȱ inȱ Formȱ vonȱ Servicesȱ zurȱ Verfügungȱ stelltȱ undȱ dieseȱ nachȱ Verbrauchȱ abrechnet.ȱ Beispieleȱ fürȱ solcheȱ ITȬServicesȱ sindȱ Serverkapazität,ȱ SpeiȬ cherplatzȱoderȱApplikationen.ȱȱ

Utilityȱ Computingȱ

UtilityȱComputingȱlässtȱsichȱunterteilenȱinȱ

21ȱ

1ȱȱEinführungȱundȱGrundlagenȱ x

Internalȱ Utility,ȱ dasȱ Rechnernetzȱ undȱ dieȱ Rechnerȱ werdenȱ nurȱ innerhalbȱeinesȱUnternehmensȱgemeinsamȱgenutzt.ȱInȱdiesemȱFallȱ sindȱ dieȱ Kundenȱ dieȱ einzelnenȱ Spartenȱ oderȱ Abteilungenȱ diesesȱ Unternehmens.ȱȱȱ

x

ExternalȱUtility,ȱbeiȱdemȱmehrereȱverschiedeneȱUnternehmenȱdenȱ RechnerpoolȱeinesȱServiceprovidersȱgemeinsamȱnutzen.ȱȱ

x

MischformenȱzwischenȱInternalȱundȱExternalȱsindȱmöglich.ȱ

SunȱMicrosystemsȱbietetȱmitȱSunȱGridȱ{Sȱ07]ȱeineȱExternalȱUtilityȱoder,ȱ wieȱ Sunȱ esȱ nennt,ȱ einȱ OnȬdemandȱ Gridȱ Computingȱ Serviceȱ an.ȱ Sunȱ Gridȱ bietetȱ dabeiȱ Rechenleistungȱ undȱ Rechenressourcenȱ überȱ dasȱ InȬ ternetȱan.ȱGrundlageȱdesȱSunȱGridȱistȱdieȱSunȱGridȱEngine,ȱdieȱalsȱOȬ penȱSourceȱzurȱVerfügungȱsteht.ȱȱ

1.4.2 Autonomic Computing Autonomicȱ Computingȱ

Inȱ2001ȱstarteteȱIBMȱdieȱInitiativeȱdesȱAutonomicȱComputing.ȱ{KCȱ03].ȱ DasȱendgültigeȱZielȱistȱdasȱselbstorganisierendeȱautonomeȱComputerȬ System.ȱIBMȱ[KCȱ03]ȱhatȱdazuȱdieȱvierȱfolgendenȱZieleȱfestgelegt:ȱ 1.ȱSelbstȬKonfigurationȱ(SelfȬConfiguration):ȱAutomatischeȱKonfiguraȬ tionȱundȱManagementȱderȱKomponenten;ȱ 2.ȱ SelbstȬHeilendȱ (SelfȬHealing):ȱ Automatischeȱ Entdeckungȱ vonȱ FehȬ lernȱundȱKorrekturȱderȱFehler;ȱȱ 3.ȱ SelbstȬOptimierendȱ (SelfȬOptimization):ȱ Automatischeȱ ÜberwaȬ chungȱundȱKontrolleȱderȱRessourcenȱzurȱSicherstellungȱderȱoptimaȬ lenȱ Funktionstüchtigkeitȱ inȱ Bezugȱ aufȱ dieȱ vorgegebenenȱ AnfordeȬ rungen;ȱȱ 4.ȱ SelbstȬSchützendȱ (SelfȬProtection):ȱ Aufȱ Eigeninitiativeȱ basierendeȱ IdentifikationȱundȱSchutzȱvorȱwillkürlichenȱAngriffen.ȱȱȱ InȱeinemȱselbstorganisierendenȱSystemȱnimmtȱderȱmenschlicheȱOperaȬ torȱ eineȱ neueȱ Rolleȱ ein:ȱ Erȱ kontrolliertȱ nichtȱ dasȱ Systemȱ direkt,ȱ stattȬ dessenȱdefiniertȱerȱStrategienȱundȱRegeln,ȱdieȱdannȱalsȱEingabeȱdienenȱ undȱVorgabenȱsindȱfürȱdasȱsichȱselbstorganisierendeȱSystem.ȱ DieȱIBMȱSelfȬManagingȱAutonomicȱTechnologyȱundȱdieȱIBMȱITȱServiceȱ Managementȱ Visionȱ sindȱ aufȱ denȱ Webseitenȱ vonȱ IBMȱ [IBMȱ 07]ȱ beȬ schrieben.ȱ

1.4.3 Organic Computing Aufbauendȱ aufȱ demȱ Autonomenȱ Computingȱ mitȱ denȱ SelbstȬ Eigenschaftenȱ entstehtȱ einȱ Netzwerkȱ vonȱ autonomerenȱ intelligentenȱ

22ȱ

1.5ȱParalleleȱversusȱVerteilteȱVerarbeitungȱ Systemen.ȱDieȱtechnischenȱSystemeȱmüssenȱdazuȱunabhängigȱvoneinȬ anderȱarbeiten,ȱflexibelȱaufeinanderȱreagieren,ȱundȱjedesȱSystemȱmussȱ autonomȱarbeiten,ȱd.h.ȱsieȱmüssenȱlebensähnlicheȱEigenschaftenȱzeigen.ȱ SolcheȱSystemeȱheißenȱorganisch.ȱEinȱ“organischesȱComputerȬSystem”ȱ istȱeinȱtechnischesȱSystem,ȱwelchesȱsichȱdynamischȱaufȱdieȱgegenwärȬ tigenȱ Bedingungenȱ seinerȱ Umgebungȱ anpasst.ȱ Esȱ istȱ selbstȬ organisierend,ȱ selbstȬkonfigurierend,ȱ selbstȬoptimierend,ȱ selbstȬ heilend,ȱselbstȬschützend,ȱselbstȬerklärendȱundȱkontextbewusstȱ[MMWȱ 04].ȱȱ Organicȱ Computingȱ undȱ dessenȱ fundamentaleȱ Konzepteȱ tretenȱ unabȬ hängigȱ voneinanderȱ inȱ verschiedenenȱ Forschungsgebietenȱ aufȱ (z.B.ȱ inȱ denȱNeurowissenschaften,ȱinȱderȱMolekularbiologieȱundȱinȱComputerȱ Engineering).ȱȱ DasȱGebietȱOrganicȱComputingȱbearbeitenȱMathematiker,ȱSoziologen,ȱ Physiker,ȱÖkonomenȱundȱInformatiker.ȱLetztereȱbetrachtenȱjedochȱdieȱ SystemeȱnurȱunterȱdemȱAspektȱvonȱvereinfachtenȱModellenȱderȱKünstȬ lichenȱ Intelligenz.ȱ Zentralesȱ Anliegenȱ vonȱ Organicȱ ComputerȬ Systemenȱ istȱ dieȱ Analyseȱ vonȱ Informationsverarbeitungȱ inȱ biologiȬ schenȱSystemen.ȱȱȱ Dieȱ Organicȱ Computingȱ Initiativeȱ istȱ inȱ [OCIȱ 07]ȱ enthalten,ȱ undȱ dasȱ Projektȱ Organicȱ Computingȱ derȱ Deutschenȱ Forschungsgemeinschaftȱ (DFG)ȱ istȱ beschriebenȱ inȱ [DFGȱ 07].ȱ Visionenȱ desȱ Organicȱ Computingȱ undȱ Anwendungsszenarienȱ beschreibtȱ dasȱ Positionspapierȱ [VIGȱ 07]ȱ derȱ Gesellschaftȱ fürȱ Informatikȱ (GI)ȱ undȱ derȱ Informationstechnischenȱ GesellschaftȱimȱVDEȱ(ITG).ȱ Zurȱ Beherrschungȱ undȱ fürȱ denȱ laufendenȱ Betriebȱ vonȱ Clusterȱ oderȱ Gridsȱ mitȱ Hundertenȱ bisȱ Tausendenȱ Prozessorenȱ sindȱ dieȱ SelbstȬ Eigenschaftenȱ desȱ Organicȱ Computingȱ eineȱ Grundvoraussetzungȱ undȱ einȱMuss.ȱȱȱ

1.5 Parallele versus Verteilte Verarbeitung 1.5.1 Parallele Verarbeitung Zielȱ derȱ parallelenȱ Verarbeitungȱ istȱ hauptsächlich,ȱ eineȱ GeschwindigȬ keitssteigerungȱ derȱ Anwendungȱ herbeizuführen.ȱ Besondersȱ beiȱ denȱ echtȱparallelenȱ(trueȱparallel)ȱ[HPȱ06]ȱProgrammenȱfürȱwissenschaftliȬ cheȱApplikationen,ȱdieȱaufȱmächtigȱausgelegtenȱMultiprozessorenȱ(SuȬ percomputer)ȱ oderȱ Highȱ Performanceȱ Computingȱ Clusterȱ undȱ Gridsȱ ablaufen,ȱ stehtȱ dieȱ Parallelitätȱ zumȱ Erzielenȱ einerȱ Lösungȱ innerhalbȱ einerȱakzeptierbarerȱZeitspanneȱimȱVordergrund.ȱȱ

Zieleȱderȱ ParallelverȬ arbeitungȱȱ

23ȱ

1ȱȱEinführungȱundȱGrundlagenȱ Tasks,ȱ Prozesseȱ

Zurȱ Ereichungȱ derȱ Parallelitätȱ zerlegtȱ manȱ dieȱ Applikationȱ oderȱ dasȱ ProgrammȱinȱEinheiten,ȱdieȱparallelȱausgeführtȱwerden,ȱinȱsog.ȱTasks,ȱ oderȱausȱBetriebssystemsichtȱbetrachtetȱinȱProzesse.ȱZurȱReduktionȱderȱ Prozessumschaltzeiten,ȱ fallsȱ dasȱ Programmȱ quasiparallel,ȱ alsoȱ aufȱ einemȱ Prozessorȱ ausgeführtȱ wird,ȱ oderȱ zurȱ effizientenȱ ImplementieȬ rungȱvonȱServer,ȱkönnenȱdieȱProzesseȱweiterzerlegtȱwerdenȱinȱBerechȬ nungsfädenȱ oderȱ Threads.ȱ Dieȱ Prozesseȱ oderȱ Threadsȱ verteiltȱ manȱ dannȱ aufȱ mehrereȱ Prozessorenȱ undȱ führtȱ sieȱ somitȱ gleichzeitigȱ undȱ parallelȱ aus.ȱ Dieȱ Verteilungȱ nimmtȱ einȱ Ablaufplanerȱ oderȱ Schedulerȱ vor.ȱȱ

Vorteileȱderȱ quasiȬ parallelenȱ Abarbeitungȱȱ

Verschiedeneȱ Prozesseȱ stellenȱ unterschiedlicheȱ Anforderungenȱ anȱ dieȱ Betriebsmittelȱ oderȱ Ressourcenȱ einesȱ Rechners.ȱ Liegtȱ nurȱ einȱ Rechnerȱ oderȱ Prozessorȱ vor,ȱ soȱ erreichtȱ manȱ durchȱ Umschaltenȱ (Dispatching)ȱ derȱ Prozesseȱ aufȱ demȱ Prozessor,ȱ undȱ somitȱ einerȱ quasiparallelenȱ AbȬ arbeitung,ȱ eineȱ bessereȱ Auslastungȱ derȱ Betriebsmittelȱ einesȱ Rechners.ȱ Diesȱistȱdadurchȱbedingt,ȱdassȱunterschiedlicheȱProzesseȱunterschiedliȬ cheȱ Betriebsmittelȱ desȱ Rechnersȱ belegen.ȱ Rechenintensiveȱ Prozesseȱ benötigenȱ vielȱ CPUȬZeit,ȱ ȱ undȱ E/AȬintensiveȱ Prozesseȱ belastenȱ dasȱ E/AȬSystemȱ stark.ȱ Eineȱ guteȱ Mischungȱ vonȱ beidenȱ Prozessartenȱ undȱ mitȱ demȱ Umschaltenȱ derȱ Prozesseȱ führtȱ diesȱ dannȱ aufȱ kürzereȱ VerȬ weilzeitenȱderȱProzesseȱimȱSystem.ȱGemäßȱdenȱBetriebsȬȱundȱEinsatzȬ artenȱdesȱRechnersȱverkürztȱdiesȱdieȱfolgendȱbeschriebenenȱZeiten:ȱȱ x

Sindȱ dieȱ Prozesseȱ Batchjobs,ȱ soȱ erreichtȱ manȱ dadurchȱ kürzereȱ Durchlaufzeitenȱ(TurnaroundȱTime)ȱderȱJobs.ȱ

x

Imȱ TimesharingȬBetriebȱ führtȱ dieȱ Prozessumschaltungȱ aufȱ eineȱ bessereȱAuslastungȱderȱCPUȬȱundȱI/OȬRessourcenȱundȱaufȱkürzereȱ Antwortzeitenȱ(ResponseȱTime)ȱfürȱdenȱBenutzer.ȱ

x

Beimȱ RealzeitȬBetriebȱ erlaubtȱ eineȱ Zerlegungȱ desȱ Programmsȱ inȱ Tasksȱ dieȱ bessereȱ Nachbildungȱ derȱ externenȱ Parallelitäten.ȱ WeiȬ terhinȱ könnenȱ dannȱ durchȱ dieȱ Zuordnungȱ einerȱ Prioritätȱ anȱ dieȱ TasksȱundȱeinemȱprioritätsorientiertenȱSchedulerȱdieȱexternenȱpaȬ rallelenȱAbläufeȱbeiȱderȱBearbeitungȱbesserȱgewichtetȱwerden.ȱȱȱ

x

BeimȱServerȬBetriebȱreagiertȱeinȱparallelerȱServerȱ{Bȱ04],ȱderȱmeistȱ multithreadedȱ ist,ȱschnellerȱ aufȱ dieȱ Anfragenȱ derȱ Clients.ȱ Einȱ paȬ rallelerȱ Serverȱ ermöglichtȱ dieȱ Anforderungenȱ vonȱ mehrerenȱ Clientsȱparallelȱzuȱbearbeiten.ȱȱ

VerteilteȱProgrammeȱlaufenȱimmerȱaufȱmehrerenȱProzessorenȱab,ȱwähȬ rendȱparalleleȱProgrammeȱauchȱquasiparallel,ȱalsoȱaufȱeinemȱProzessorȱ ausgeführtȱwerdenȱkönnen.ȱȱ

24ȱ

1.5ȱParalleleȱversusȱVerteilteȱVerarbeitungȱ DerȱParallelitätsbegriffȱlässtȱsichȱweiterȱuntergliedernȱinȱ x

nebenläufigeȱundȱȱ

x

kooperierendeȱProzesse.ȱ

1.5.1.1 Nebenläufige Prozesse Nebenläufigȱ (concurrent)ȱ [HHȱ 98]ȱ bedeutet,ȱ dassȱ zweiȱ AktionsȬȱ oderȱ AktivitätensträngeȱoderȱProzesseȱgleichzeitigȱablaufen,ȱdieseȱaberȱnichtȱ notwendigerweiseȱetwasȱmiteinanderȱzuȱtunȱhaben.ȱDieȱAktionenȱsindȱ kausalȱ voneinanderȱ unabhängigȱ undȱ könnenȱ somitȱ unabhängigȱ vonȬ einanderȱausgeführtȱwerden.ȱ[PFȱ06].ȱȱ

Nebenläufigȱ

BeiȱderȱAusführungȱderȱnebenläufigenȱProzesseȱstehenȱsieȱinȱKonkurȬ renzȱzueinanderȱbeiȱderȱBelegungȱundȱanschließendenȱBenutzungȱderȱ Betriebsmittelȱ einesȱ Rechners,ȱ Multiprozessors,ȱ MultiȬComputers,ȱ ClustersȱoderȱGrids.ȱȱ

Konkurrenz

1.5.1.2 Kooperierende Prozesse Vonȱkooperierendenȱ(cooperating)ȱProzessenȱsprichtȱman,ȱȱ

Kooperierendȱ

1.ȱwennȱdieȱnebenläufigenȱAbläufeȱ(Prozesse)ȱzuȱeinemȱübergeordneȬ tenȱ Programmȱ gehörenȱ oderȱ dieȱ verschiedenenȱ Aktivitätensträngeȱ undȱsomitȱdieȱProzesseȱeineȱgemeinsameȱAufgabeȱlösenȱundȱ 2.ȱ dieȱ Abläufeȱ soȱ logischȱ miteinanderȱ verknüpftȱ sind,ȱ dassȱ eineȱ SynȬ chronisationȱzwischenȱdenȱAbläufenȱerfolgenȱmuss.ȱȱ EinȱBeispielȱvonȱkooperierendenȱProzessenȱistȱdasȱErzeugerȬȱundȱVerȬ braucherproblem,ȱ beiȱ demȱ einȱ Erzeugerȱ überȱ eineȱ Röhreȱ (Pipeȱ unterȱ Unix)ȱ einemȱVerbraucherȱNachrichtenȱzusendet.ȱ Einȱ weiteresȱBeispielȱ sindȱdieȱWarteschlangenȱ(QueuesȱunterȱUnix).ȱMehrereȱErzeugerȱkönȬ nenȱeineȱNachrichtȱanȱdieȱQueueȱsenden,ȱdieȱdannȱvonȱmehrerenȱunȬ terschiedlichenȱ Empfängernȱ ausȱ derȱ Warteschlangeȱ entnommenȱ werȬ denȱkönnen.ȱDa,ȱwieȱbeiȱderȱPipe,ȱderȱEmpfängerȱnichtȱfestliegt,ȱmussȱ beiȱ derȱ Queueȱ derȱ Senderȱderȱ Nachrichtȱ dieȱ Adresseȱ desȱ Empfängersȱ mitgeben.ȱȱ

Pipe,ȱQueue

Schränktȱ manȱ dieȱ Interaktionȱ derȱ kooperierendenȱ Prozesseȱ aufȱ NachȬ richtenaustauschȱmitȱsend-ȱundȱreceiveȬAnweisungenȱein,ȱsoȱkönnȬ teȱ manȱ inȱ Anlehnungȱ anȱ dieȱ Communicatingȱ Sequentialȱ Processesȱ (CSP)ȱvonȱHoareȱ[Hoȱ78]ȱdieȱkooperierendenȱProzesseȱauchȱkommuniȬ zierendeȱProzesseȱnennen.ȱȱ

KommunizieȬ rendeȱ Prozesseȱ (CSP)ȱ

Abbildungȱ 1Ȭ2ȱ zeigtȱ dieȱ Gemeinsamkeitenȱ vonȱ Parallelȱ undȱ Verteiltȱ ausȱSichtȱderȱparallelenȱVerarbeitungȱ[Lȱ01].ȱ

25ȱ

1ȱȱEinführungȱundȱGrundlagenȱ Abb.ȱ1Ȭ2:ȱ Parallelȱundȱ Verteiltȱausȱ Sichtȱderȱ parallelenȱ Verarbeitungȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

1.5.2 Verteilte Verarbeitung Definitionȱ Distributedȱ Computingȱȱ

Verteiltesȱ Rechnenȱ oderȱ Verteilteȱ Verarbeitungȱ (Distributedȱ CompuȬ ting)ȱbefasstȱsichȱmitȱderȱKoordinationȱvonȱvielenȱComputernȱinȱmögȬ licherweiseȱ entferntenȱ physikalischenȱ Lokationen,ȱ dieȱ eineȱ gemeinsaȬ meȱAufgabeȱerledigen.ȱDieȱHardware,ȱBetriebssysteme,ȱProgrammierȬ sprachenȱundȱRessourcenȱderȱeinzelnenȱComputerȱkönnenȱdabeiȱstarkȱ variierenȱundȱunterschiedlichȱsein.ȱVonȱdenȱMaschinen,ȱdieȱzusammenȱ arbeiten,ȱ mussȱ jedeȱ Maschineȱ überȱ einȱ Netzwerkȱ vonȱ jederȱ anderenȱ Maschineȱ zugreifbarȱ sein.ȱ Diesȱ istȱ meistensȱ gegebenȱ durchȱ dasȱ zuȬ grundeȱliegendeȱTCP/IPȬProtokoll.ȱ

Interaktionȱ

Dieȱ Möglichkeitȱ zurȱ Benutzungȱ ganzȱ unterschiedlicherȱ Computerȱ hatȱ aufȱdasȱProtokollȱAuswirkungen:ȱDasȱProtokollȱoderȱderȱKommunikaȬ tionskanalȱdarfȱkeineȱInformationȱenthaltenȱoderȱbenutzen,ȱdasȱgewisȬ seȱ Maschinenȱ nichtȱ verstehen.ȱ Dieȱ Nachrichtenȱ müssenȱ korrektȱ abgeȬ liefertȱ undȱ ungültigeȱ Nachrichtenȱ abgewiesenȱ werden.ȱ Besondersȱ beiȱ ungültigenȱ Nachrichtenȱ bestehtȱ dieȱ Gefahr,ȱ dassȱ dasȱ Systemȱ abstürztȱ undȱmöglicherweiseȱdenȱRestȱdesȱNetzwerkesȱlahmȱlegt.ȱȱ

HerunterȬ ladenȱvonȱ Codeȱ

Dasȱ Sendenȱ vonȱ Softwareȱ oderȱ Codeȱ zuȱ einemȱ anderenȱ Computerȱ mussȱ gegebenȱ sein.ȱ Derȱ andereȱ Computerȱ kannȱ dannȱ diesenȱ Codeȱ ausführenȱ undȱ mitȱ demȱ bestehendenȱ Netzwerkȱ interagieren.ȱ Dieseȱ Möglichkeitȱ istȱ durchȱ Javaȱ gegeben,ȱ wennȱ aufȱ allenȱ Maschinenȱ dieȱ Javaȱ Virtualȱ Machineȱ (JVM)ȱ läuft.ȱ Stehtȱ dieȱ Javaȱ virtuelleȱ Maschineȱ nichtȱ zurȱ Verfügung,ȱ daȱ unterschiedlicheȱ Hardware,ȱ Betriebssystemeȱ undȱProgrammiersprachenȱbenutztȱwerden,ȱsoȱmussȱCrossȬCompilingȱ bisȱhinȱzurȱmanuellenȱPortierungȱdesȱCodesȱeingesetztȱwerden.ȱȱ

26ȱ

1.5ȱParalleleȱversusȱVerteilteȱVerarbeitungȱ DasȱPackageȱSerializationȱȱinȱJavaȱȱserialisiertȱObjekteȱ(ObjectȱSerialiȬ zation).ȱ Damitȱ könnenȱ Objekteȱ undȱ somitȱ Datenȱ überȱ dasȱ Netzȱ zumȱ Codeȱwandern.ȱȱDiesȱerlaubtȱdieȱlokaleȱVerarbeitungȱderȱDaten,ȱundȱesȱ mussȱnichtȱmehrȱderȱCodeȱzuȱdenȱDatenȱkopiertȱoderȱherunterȱgeladenȱ werden,ȱȱd.h.ȱüberȱdasȱNetzȱtransportiertȱwerden.ȱȱ

Mobileȱ Objekteȱ

1.5.2.1 Beispiele für Verteilte Systeme EinȱBeispielȱfürȱeinȱVerteiltesȱSystemȱistȱdasȱWorldȱWideȱWebȱ(WWW)ȱ (sieheȱ Abschnittȱ 1.3).ȱ Liestȱ einȱ Benutzerȱ eineȱ Webseite,ȱ soȱ benutztȱ erȱ dazuȱ seineȱ eigeneȱ Komponenteȱ desȱ Verteiltenȱ Systems,ȱ nämlichȱ denȱ WebȬBrowser.ȱ Browstȱ einȱBenutzerȱ durchȱ dasȱ Web,ȱsoȱläuftȱ derȱWebȬ Browserȱ aufȱ seinenȱ eigenenȱ Rechnerȱ undȱ erȱ kommuniziertȱ mitȱ verȬ schiedenenȱWebȬServern,ȱwelcheȱdieȱSeiteȱzurȱVerfügungȱstellen.ȱMögȬ licherweiseȱ benutztȱ derȱ Browserȱ einenȱ Proxyȱ Serverȱ zumȱ schnellerenȱ Zugriffȱ aufȱ bisherȱ vorhandeneȱ Seiten.ȱ Zumȱ Findenȱ derȱ WebȬServerȱ stehtȱ dasȱ Domainȱ Nameȱ Systemȱ (DNS)ȱ zurȱ Verfügung.ȱ Derȱ WebȬ Browserȱ kommuniziertȱ mitȱ allȱ diesenȱ WebȬServernȱ überȱ dasȱ Internetȱ durchȱeinȱSystemȱvonȱRoutern,ȱwelcheȱselbstȱwiederȱTeilȱeinesȱgroßenȱ VerteiltenȱSystemsȱsind.ȱ

Beispiel:ȱ WWWȱundȱ DNSȱ

DasȱWebȱistȱeinȱVerteiltesȱSystemȱmitȱheterogenenȱRechnernȱmitȱunterȬ schiedlichemȱLeistungsspektrumȱ(vomȱPC,ȱMainframe,ȱMultiprozessoȬ renȱ bisȱ hinȱzuȱ Cluster).ȱ Imȱ Gegensatzȱ dazu,ȱundȱ einȱ weiteresȱ Beispielȱ fürȱeinȱVerteiltesȱSystem,ȱsindȱdieȱMikrogeräteȱoderȱdieȱmobilenȱEndȬ geräteȱ(MicroȱDevices),ȱdieȱüberȱdrahtloseȱNetzeȱmiteinanderȱverbunȬ denȱwerden.ȱ(sieheȱAbschnittȱ1.2.3).ȱȱȱ

Beispiel:ȱ Drahtloseȱ Netzeȱmitȱ MicroȱDevicesȱ

1.5.2.2 Positive Eigenschaften der verteilten Verarbeitung Ausȱ Sichtȱ derȱ verteiltenȱ Verarbeitungȱ habenȱ verteilteȱ Anwendungenȱ zusätzlichȱ zurȱ Geschwindigkeitssteigerung,ȱ dieȱ durchȱ dieȱ paralleleȱ Verarbeitungȱerreichtȱwird,ȱnochȱweitereȱpositiveȱEigenschaftenȱ[CDKȱ 02]:ȱ x Ausfalltoleranz:ȱAusfälleȱinȱVerteiltenȱSystemenȱsindȱpartiellȱ–ȱdasȱ bedeutet,ȱ einigeȱ Komponentenȱ fallenȱ aus,ȱ währendȱ andereȱ weiterȬ hinȱ funktionierenȱ undȱ eineȱ Weiterarbeitȱ garantieren.ȱ Imȱ Vergleichȱ zuȱanderenȱSystemenȱsindȱbeiȱeinemȱVerteiltenȱSystemȱkeineȱTotalȬ ausfälleȱmöglich.ȱȱ

Zieleȱvonȱ verteilterȱ Verarbeitungȱ

x Fehlertolerant:ȱDieȱmeistenȱDiensteȱweisenȱFehlerȱauf,ȱundȱinȱeinemȱ großenȱNetzwerkȱmitȱvielenȱKomponentenȱsindȱnichtȱalleȱFehlerȱzuȱ erkennenȱundȱzuȱkorrigieren.ȱDasȱIgnorierenȱeinesȱFehlers,ȱz.B.ȱdasȱ Verwerfenȱ einerȱ korrumpiertenȱ Nachricht,ȱ kannȱ beiȱ verteilterȱ VerȬ

27ȱ

1ȱȱEinführungȱundȱGrundlagenȱ arbeitungȱ toleriertȱ werden.ȱ Diesȱ bedingtȱ natürlich,ȱ dassȱ derȱ Clientȱ bzw.ȱderȱ Benutzerȱ sieȱ tolerierenȱ mussȱundȱüberȱdenȱ aufgetretenenȱ Fehlerȱinformiertȱwird.ȱȱȱ x Erhöhteȱ Verfügbarkeitȱ durchȱ Redundanzen:ȱ Diensteȱ könnenȱ fehlerȬ tolerantȱgemachtȱwerden,ȱundȱeineȱhöhereȱVerfügbarkeitȱlässtȱsichȱ erreichen,ȱ indemȱ manȱ dieȱ Komponentenȱ mehrfachȱ undȱ somitȱ reȬ dundantȱ ausgelegt.ȱ Dieseȱ Redundanzenȱ könnenȱ natürlichȱ auchȱ durchȱ paralleleȱ Verarbeitungȱ zurȱ Geschwindigkeitssteigerungȱ ausȬ genutztȱwerden.ȱȱ Kooperationȱ beiȱverteilterȱ Verarbeitungȱ

Beiȱ einemȱ Verteiltenȱ Programmsystemȱ nenntȱ manȱ dieȱ ZusammenarȬ beitȱ allerȱ beteiligtenȱ Komponentenȱ kooperativ,ȱ wennȱ dasȱ geregelteȱ Zusammenwirkenȱ allerȱ Komponentenȱ undȱ dieȱ Steuerungȱ desȱ zeitliȬ chenȱ Ablaufsȱ durchȱ synchronenȱ Nachrichtenversand,ȱ Request/Replyȱ Protokollȱ (ClientȬServerȬProtokoll)ȱ oderȱ Aufrufbeziehungenȱ geregeltȱ wird.ȱȱ Ausȱ Sichtȱ derȱ verteiltenȱ Verarbeitungȱ ergibtȱ sichȱ damitȱ dasȱ zuȱ AbbilȬ dungȱ1Ȭ3ȱentsprechendeȱDiagramm.ȱ ȱ

Abb.ȱ1Ȭ3:ȱ Parallelȱundȱ Verteiltȱausȱ Sichtȱderȱ Verteiltenȱ Verarbeitungȱ

ȱ

ȱ ȱ

1.5.2.3 Eigenschaften eines Verteilten Systems BetrachtetȱmanȱdasȱVerteilteȱSystemȱausȱBenutzerȬȱundȱEinsatzsicht,ȱsoȱ sindȱweitereȱZieleȱundȱEigenschaftenȱeinesȱVerteiltenȱSystemsȱdasȱVerȬ bindenȱvonȱBenutzernȱundȱRessourcenȱinȱȱ

28ȱ

1.5ȱParalleleȱversusȱVerteilteȱVerarbeitungȱ x

transparenter,ȱȱ

x

skalierbarerȱundȱȱ

x

offenerȱWeise.ȱ

ȱ Transparenzȱ bedeutet,ȱ dassȱ etwasȱ „durchsichtig“,ȱ alsoȱ nichtȱ direktȱ sichtbarȱist.ȱEigenschaftȱeinesȱVerteiltenȱSystemsȱist,ȱdieȱVerteilungȱvorȱ einemȱ Benutzerȱ oderȱ einerȱ Anwendungȱ zuȱ verbergen.ȱ Derȱ Benutzerȱ sollȱnurȱeinȱSystemȱsehen,ȱimȱIdealfallȱseinȱeigenes,ȱihmȱalleinȱzurȱVerȬ fügungȱ stehendeȱ System.ȱ Nebenȱ anderenȱ Transparenzenȱ fordertȱ manȱ vonȱeinemȱVerteiltenȱSystemȱdieȱfolgendenȱTransparenzen:ȱ x

Ortstransparenz:ȱ Derȱ Ortȱ einerȱ Ressourceȱ oderȱ einesȱ Dienstesȱ istȱ demȱ Benutzerȱ oderȱ derȱ Anwendungȱ nichtȱ bekannt.ȱ Einȱ Benutzerȱ greiftȱüberȱeinenȱNamenȱaufȱdieȱRessourceȱoderȱdenȱDienstȱzu.ȱDerȱ NameȱenthältȱdabeiȱkeineȱInformationȱüberȱdenȱAufenthaltsortȱderȱ RessourceȱoderȱdesȱDienstes.ȱ

x

Zugriffstransparenz:ȱAufȱ alleȱ Ressourcenȱ oderȱ Diensteȱ wirdȱ inȱ derȬ selbenȱ Weiseȱ zugegriffen.ȱ Esȱ spieltȱ dabeiȱ keineȱ Rolle,ȱ obȱ dieȱ ResȬ sourceȱ oderȱ derȱ Dienstȱ lokalȱ oderȱ aufȱ einemȱ entferntenȱ Rechnerȱ zurȱVerfügungȱsteht.ȱȱ

x

Nebenläufigkeitstransparenz:ȱ Beiȱ einemȱ Verteiltenȱ Systemȱ nutzenȱ mehrereȱBenutzer,ȱdieȱräumlichȱvoneinanderȱgetrenntȱseinȱkönnen,ȱ gleichzeitigȱdasȱSystem.ȱEsȱistȱökonomischȱsinnvoll,ȱdieȱvorhandeȬ nenȱRessourcenȱzwischenȱdenȱgleichzeitigȱlaufendenȱBenutzerproȬ zessenȱ aufzuteilen.ȱ Dabeiȱ kannȱ esȱ vorkommen,ȱ dassȱ aufȱ gemeinȬ sameȱ Ressourcenȱ undȱ Datenȱ gleichzeitigȱ zugegriffenȱ wird.ȱ Dasȱ Systemȱ sorgtȱ dannȱ dafür,ȱ dassȱ aufȱ dieȱ Ressourcenȱ exklusiv,ȱ alsoȱ unabhängigȱ vonȱ anderenȱ Benutzernȱ oderȱ Anwendungen,ȱ zugeȬ griffenȱwird.ȱDieȱparallelenȱZugriffeȱverschiedenerȱBenutzerȱoderȱ AnwendungenȱsindȱdabeiȱunsichtbarȱfürȱdenȱBenutzerȱsynchroniȬ siert.ȱ

Einȱ skalierbaresȱ Systemȱ lässtȱ sichȱ leichtȱ undȱ flexibelȱ ändernȱ inȱ derȱ AnzahlȱderȱBenutzer,ȱderȱBetriebsmittel,ȱderȱRechner,ȱderȱAnwendunȬ genȱ undȱ derȱ Größeȱ derȱ Datenspeicher.ȱ Fürȱ denȱ Benutzerȱ sindȱ dieseȱ Änderungenȱ transparentȱ (Skalierungstransparenz)ȱ undȱ derȱ BenutzerȬ betriebȱbleibtȱvonȱdiesenȱÄnderungenȱunbeeinflusst.ȱSkalierbarkeitȱtrittȱ inȱdreiȱDimensionenȱauf:ȱ x

TranspaȬ renzenȱ

Skalierbarkeit

Lastskalierbarkeit:ȱBeiȱeinemȱDistributedȱSystemȱkönnenȱdieȱResȬ sourcenȱhinzugefügtȱoderȱeingeschränktȱwerden,ȱjeȱnachȱdem,ȱobȱ großeȱ oderȱ geringeȱ Lastȱ vorliegt.ȱ Zurȱ gleichmäßigenȱ Auslastungȱ

29ȱ

1ȱȱEinführungȱundȱGrundlagenȱ allerȱRessourcenȱfordertȱmanȱdieȱMigrationstransparenz,ȱalsoȱdasȱ Verschiebenȱ vonȱ Prozessenȱ oderȱ Datenȱ vonȱ einerȱ Ressourceȱ aufȱ eineȱandere.ȱDasȱVerschiebenȱgeschiehtȱfürȱdenȱBenutzerȱoderȱdieȱ Anwendungȱ verdecktȱ undȱ unbemerkbar.ȱ Zurȱ erfolgreichenȱ DurchführungȱeinerȱMigrationȱsindȱfolgendeȱPunkteȱzuȱbeachten:ȱ Entscheidungen,ȱwelcherȱProzessȱoderȱwelcheȱDateiȱwohinȱverlaȬ gertȱwird,ȱnimmtȱdasȱSystemȱautomatischȱvor:ȱ

30ȱ

x

Wirdȱ einȱ Prozessȱ oderȱ einȱ Fileȱ vonȱ einemȱ Knotenȱ aufȱ einenȱ anderenȱ verschoben,ȱ soȱ sollteȱ derȱ Prozessȱ oderȱ dieȱ Dateiȱ seiȬ nenȱbzw.ȱihrenȱNamenȱbeibehaltenȱkönnenȱ(Ortstransparenz).ȱ

x

Wirdȱ anȱ denȱ Prozessȱ eineȱ Nachrichtȱ geschicktȱ oderȱ wirdȱ aufȱ eineȱ Dateiȱ zugegriffen,ȱ derȱ oderȱ dieȱ geradeȱ verschobenȱ wurȬ de,ȱsoȱsollteȱdieȱNachrichtȱoderȱderȱZugriffȱdenȱverschobenenȱ Prozessȱ bzw.ȱ dieȱ verschobeneȱ Dateiȱ direktȱ erreichen,ȱ ohneȱ dassȱderȱSendeȬȱoderȱZugriffsprozessȱdieȱNachrichtȱoderȱdenȱ ZugriffȱerneutȱanȱdenȱKnotenȱschickenȱmuss.ȱ

x

AlleȱBetriebsmittelȱstellenȱdieȱRechenleistungȱzurȱVerfügung;ȱ welcheȱ Betriebsmittelȱ dieȱ Leistungȱ erbringen,ȱ istȱ unsichtbarȱ (Leistungstransparenz).ȱ Dieȱ Aufgabenȱ undȱ dieȱ Lastȱ werdenȱ dabeiȱ dynamischȱundȱautomatischȱ vonȱ einemȱVerteiltenȱ SysȬ temȱ aufȱ dieȱ vorhandenenȱ Betriebsmittelȱ verteilt.ȱ Durchȱ dieȱ Verteilungȱ undȱ dasȱ damitȱ verbundeneȱ paralleleȱ Abarbeitenȱ derȱAufgabenȱerreichtȱmanȱeineȱbessereȱLeistungȱdesȱVerteilȬ tenȱSystems.ȱSoȱsollteȱesȱnichtȱvorkommen,ȱdassȱeinȱBetriebsȬ mittelȱ desȱ Systemsȱ mitȱ Aufgabenȱ überlastetȱ ist,ȱ währendȱ einȱ anderesȱ Betriebsmittelȱ imȱ Leerlaufȱ arbeitet.ȱ Dieȱ Aufgabenȱ solltenȱ alsoȱ gleichmäßigȱ aufȱ dieȱ vorhandenenȱ Betriebsmittelȱ desȱSystemsȱverteiltȱsein.ȱȱ

x

Liegenȱ ausȱ Verfügbarkeitsgründenȱ oderȱ zurȱ Erhöhungȱ derȱ Leistungȱ mehrereȱ Kopienȱ einerȱ Dateiȱ oderȱ andererȱ RessourȬ cenȱvor,ȱsoȱgreiftȱeinȱBenutzerȱoderȱeineȱAnwendungȱaufȱeinȱ repliziertesȱ Objektȱ soȱ zu,ȱ alsȱ wäreȱ esȱ nurȱ einmalȱ vorhandenȱ (Replikationstransparenz).ȱ Dasȱ Systemȱ sorgtȱ dannȱ automaȬ tischȱdafür,ȱdassȱalleȱKopienȱkonsistentȱbleiben.ȱ

x

FehlerȱoderȱAusfälleȱimȱSystem,ȱwieȱAusfallȱderȱKommunikaȬ tionsverbindung,ȱ Rechnerausfallȱ oderȱ Plattenausfälle,ȱ solltenȱ fürȱdenȱBenutzerȱoderȱdieȱAnwendungȱmaskiertȱwerden.ȱTrittȱ einȱFehlerȱ oderȱAusfallȱauf,ȱ soȱ sollteȱ dasȱVerteilteȱ Systemȱ inȬ taktȱ fürȱ denȱ Benutzerȱ weiterarbeiten,ȱ allerdingsȱ mitȱ verminȬ

1.5 Parallele versus Verteilte Verarbeitung derter Leistung. Tritt ein Rechnerausfall auf, so sollte der Knotenausfall nur lokal sichtbar sein, und das Restsystem bleibt intakt und kann weiterarbeiten (Fehler- und Ausfalltransparenz). x

Geographische Skalierbarkeit: Ein geographisch skalierbares System erhält seine Leistungsfähigkeit und schränkt seinen Gebrauch nicht ein, egal und unabhängig davon, wie weit die Benutzer oder Ressourcen geographisch entfernt sind.

x

Administrative Skalierbarkeit: Die Anzahl der verschiedenen Organisationen, die sich ein Paralleles und Verteiltes System teilen, ist nicht beschränkt und kann schwanken und variieren. Das Management, das Monitoring und der Gebrauch des Distributed Systems sollte einfach zu bewerkstelligen und von überall aus möglich sein.

Offenheit ist die Eigenschaft eines Verteilten Systems, jedes SubSystem ist fortwährend offen zur Interaktion mit anderen Systemen. Besonders bei Grids sind Web-Service-Protokolle (SOAP) der Standard, um das Verteilte System zu erweitern und zu skalieren. Ein offenes skalierbares System bietet den Vorteil der dynamischen Änderung, als ein in sich abgeschlossenes System, wie es meistens bei Clustern vorliegt.

Offenheit

Die Offenheit des Verteilten Systems birgt folgende Probleme, die Herausforderungen an deren Realisierung stellen: x

Verbreitungs-Monotonie: Ist Information oder eine Nachricht in einem offenen Verteilten System verbreitet, so kann sie nicht mehr zurückgenommen werden, sondern sie liegt vor.

x

Pluralismus: Verschiedene Sub-Systeme in einem offenen Verteilten System besitzen heterogene, überlappende und möglicherweise sogar in Konflikt stehende Information. Es gibt keine zentrale Instanz für die Wahrheit der Information in einem offenen Verteilten System.

x

Unbegrenzter Nichtdeterminismus: Verschiedene asynchrone SubSysteme können zu beliebigen Zeitpunkten kommen und gehen. Das gleiche gilt für die Kommunikationskanäle oder Verbindungen zwischen ihnen. Aus diesem Grund ist nicht vorhersehbar, wann eine Operation in einem Verteilten System abgeschlossen und somit beendet ist.

31

2 Rechnerarchitekturen für Parallele und Verteilte Systeme Zurȱ Erbringungȱ derȱ großenȱ Rechenlastȱ desȱ Serversȱ mussȱ derȱ Serverȱ parallelȱ mitȱ Prozessen,ȱ oderȱ durchȱ mehrereȱ Threads,ȱ dieȱ unterȱ demȱ Serverprozessȱ laufen,ȱ ausgelegtȱ werden.ȱ Zumȱ Ablaufȱ desȱ parallelenȱ ServersȱstehenȱmehrereȱMöglichkeitenȱoffen:ȱ 1.ȱȱ ParalleleȱAbarbeitungȱderȱThreadsȱaufȱHardwareebeneȱ(SimultaneȬ ousȱMultithreading).ȱ 2.ȱȱ Einsatzȱ einesȱ engȱ gekoppeltenȱ Multiprozessorsystemsȱ oderȱ einesȱ MulticoreȬProzessorsȱmitȱgemeinsamemȱSpeicher.ȱȱ

Architekturenȱ fürȱparalleleȱ Serverȱ

3.ȱȱ Einsatzȱ einesȱ loseȱ gekoppeltenȱ Multiprozessors,ȱ oderȱ auchȱ MultiȬ computerȱ[Tȱ06]ȱ genannt,ȱundȱ derȱRealisierungȱ einesȱ verteiltenȱgeȬ meinsamenȱSpeichers.ȱ 4.ȱȱ HPCȬClusterȱ zurȱ Erhöhungȱ derȱ Leistungȱ oderȱ HAȬClusterȱ zurȱ ErȬ höhungȱderȱVerfügbarkeitȱoderȱeineȱKombinationȱvonȱbeidem.ȱ

MultiprozessorenȱundȱMulticomputerȱ Eineȱ überȱ dasȱ Simultaneousȱ Multithreadingȱ gehendeȱ Möglichkeit,ȱ dieȱ Verarbeitungsgeschwindigkeitȱ vonȱ Prozessorenȱ zuȱ erhöhen,ȱ istȱ dieȱ KoppelungȱvonȱmehrerenȱProzessoren,ȱsoȱdassȱȱ x

einȱ erhöhterȱ Systemdurchsatzȱ erreichtȱ wird,ȱ indemȱ verschiedeneȱ Prozesseȱ oderȱ Threadsȱ echtȱ parallelȱ aufȱ verschiedenenȱ ProzessoȬ renȱ ausgeführtȱ werdenȱ undȱ nichtȱ quasiȱ parallelȱ (durchȱ ProzessȬ umschaltung),ȱwieȱbeiȱEinprozessorsystemen.ȱȱȱ

x

EinȱerhöhterȱSystemdurchsatzȱistȱvorȱallemȱbeiȱparallelenȱServernȱ erwünscht,ȱdieȱfürȱjedenȱeingehendenȱRequestȱeinenȱThreadȱstarȬ tenȱ zurȱ Bearbeitungȱ desȱ Request.ȱ Diesȱ bewirktȱ dannȱ beimȱ Serverȱ eineȱ Erhöhungȱ derȱ Anzahlȱ derȱ zuȱ verarbeitendenȱ Requestsȱ inȱ eiȬ nerȱZeiteinheit.ȱHierbeiȱistȱsogarȱnochȱdieȱZeitȱzumȱAnlegenȱeinesȱ Threadȱ einzusparen,ȱ wennȱ derȱ Serverȱ mehrereȱ Threadsȱ vorhältȱ undȱ soȱ derȱ Threadȱ fürȱ einenȱ neuenȱ Requestȱ zurȱ Bearbeitungȱ desȱ Requestȱschonȱbereitsteht.ȱȱ

x

Eineȱ Geschwindigkeitssteigerungȱ einerȱ einzelnenȱ Anwendungȱ istȱ ebenfallsȱmöglich,ȱindemȱmanȱparallelisierendeȱCompilerȱeinsetztȱ oderȱdieȱAnwendungȱinȱparalleleȱTasksȱoderȱThreadsȱaufteilt.ȱ

33ȱ

2ȱȱRechnerarchitekturenȱfürȱParalleleȱundȱVerteilteȱSystemeȱ ȱ Basierendȱ aufȱ derȱ Koppelungȱ zwischenȱ denȱ Prozessorenȱ undȱ demȱ SpeicherȱlassenȱsichȱMultiprozessorenȱunterteilenȱinȱȱ x

engȱ gekoppelteȱ Multiprozessorenȱ (tightlyȱ coupled),ȱ beiȱ demȱ alleȱ CPUsȱdenȱHauptspeicherȱgemeinsamȱnutzen.ȱDieȱSynchronisation,ȱ Koordinationȱ undȱ Kommunikationȱ derȱ parallelenȱ Prozesseȱ aufȱ denȱ verschiedenenȱ CPUsȱ geschiehtȱ überȱ denȱ gemeinsamenȱ SpeiȬ cher.ȱ Dieȱ einzelnenȱ Prozessorenȱ könnenȱ ganzȱ einfachȱ inȱ denȱ geȬ meinsamenȱSpeicherȱlesenȱundȱschreibenȱ(sieheȱAbschnittȱ2.2).ȱ

x

loseȱgekoppelteȱMultiprozessorenȱ(looslyȱcoupled),ȱbeiȱdenenȱjederȱ ProzessorȱseinenȱeignenȱSpeicherȱhatȱundȱkeinȱgemeinsamerȱSpeiȬ cherȱvorhandenȱist.ȱDieȱSynchronisation,ȱKoordinationȱundȱKomȬ munikationȱderȱparallelenȱProzesseȱaufȱdenȱverschiedenenȱProzesȬ sorenȱ istȱ nurȱ durchȱ Nachrichtenaustauschȱ zuȱ bewerkstelligen,ȱ daȱ keinȱgemeinsamerȱSpeicherȱexistiert.ȱ(sieheȱAbschnittȱ2.3).ȱ

2.1 Simultaneous Multithreading Hyperȱ Threadingȱ

Simultaneousȱ Multithreadingȱ [EELȱ 97]ȱ bezeichnetȱ dieȱ Fähigkeitȱ einesȱ Mikroprozessors,ȱ mittelsȱ getrennterȱ Pipelinesȱ undȱ zusätzlicherȱ RegisȬ tersätzeȱ mehrereȱ Threadsȱ gleichzeitigȱ auszuführen.ȱ Dieȱ wohlȱ bekannȬ testenȱ Prozessoren,ȱ dieȱ Simultaneousȱ Multithreadingȱ realisieren,ȱ sindȱ derȱ Intelȱ Pentiumȱ 4ȱ undȱ derȱ Intelȱ Xeon.ȱ Dieȱ vonȱ Intelȱ vergebeneȱ BeȬ zeichnungȱ lautetȱ HyperȬThreadingȱ Technologyȱ [Mȱ 02]ȱ mitȱ derȱ AbkürȬ zungȱHTȬTechȱoderȱHTT.ȱ Eineȱ Leistungssteigerungȱ einesȱ einzelnenȱ Prozessorsȱ lässtȱ sichȱ durchȱ paralleleȱAusführungȱderȱBefehleȱerreichen.ȱParallelisierungȱkannȱnunȱ aufȱfolgendenȱEbenenȱstattfinden:ȱ 1.ȱȱ AufȱInstruktionsȬȱoderȱBefehlsebeneȱ(InstructionȱLevelȱParallelism)ȱ durchȱAbarbeitungȱmehrererȱInstruktionenȱinȱeinemȱTakt.ȱȱ 2.ȱȱ AufȱThreadȬEbeneȱ(ThreadȱLevelȱParallelism)ȱdurchȱparallelesȱAbȬ arbeitenȱvonȱBefehlenȱausȱmehrerenȱThreads.ȱ 3.ȱȱ Durchȱ Zusammenfassungȱ derȱ InstruktionsȬEbeneȱ undȱ ThreadȬ EbeneȱzumȱSimultaneousȱMultithreading.ȱȱȱȱ

2.1.1 Instruction Level Parallelism Befehle,ȱ dieȱ voneinanderȱ unabhängigȱ sindȱ undȱ ausȱ einemȱ überschauȬ baren,ȱlogischȱsequenziellȱangeordnetenȱProgrammausschnittȱstammen,ȱ lassenȱ sichȱ parallelȱ ausführen,ȱ sofernȱ zusätzlicheȱ Funktionseinheitenȱ

34ȱ

2.1ȱSimultaneousȱMultithreadingȱ undȱ Datenregisterȱ zurȱ Verfügungȱ stehen.ȱ Dieseȱ Technikȱ heißtȱ SuȬ perskalarverarbeitungȱoderȱSuperskalarität.ȱȱ

Superskalar

DieȱInȬOrderȬExecutionȱ[Mȱ01]ȱstartetȱ(issue)ȱdieȱBefehleȱausȱmehrerenȱ nebenläufigenȱ Pipelinesȱ inȱ ihrerȱ logischenȱ Reihenfolge.ȱ Dieȱ PhasenpiȬ pelineȱ beginntȱ häufigȱ mitȱ einerȱ oderȱ mehrerenȱ gemeinsamenȱ Stufenȱ (z.B:ȱ Befehleȱ holen,ȱ Befehleȱ vordekodieren)ȱ undȱ gabeltȱ sichȱ anschlieȬ ßendȱ inȱ mehrereȱ nebenläufigeȱ Teilpipelinesȱ auf.ȱ Gleichzeitigȱ oderȱ nacheinanderȱgestarteteȱBefehleȱkönnenȱsichȱdabeiȱnichtȱüberholenȱ(inȬ Order).ȱ Datenabhängigkeitenȱ zwischenȱ denȱ Befehlen,ȱ dieȱ sichȱ gleichȬ zeitigȱ inȱ denȱ Pipelinesȱ befinden,ȱ werdenȱ dadurchȱ aufgelöst,ȱ dassȱ dieȱ PipelinesȱmitȱdenȱlogischȱspäterȱfolgendenȱBefehlenȱsoȱlangeȱangehalȬ tenȱ werden,ȱ bisȱ dieȱ logischȱ früherȱ ankommendenȱ Befehleȱ ihreȱ ErgebȬ nisseȱ zurückȱ geschriebenȱ haben.ȱ Ergebnisseȱ werdenȱ alsoȱ auchȱ immerȱ inȱderȱlogischenȱkorrektenȱReihenfolgeȱzurückȱgeschriebenȱ(InȬOrderȬ Completion).ȱȱ

InȬOrderȬ Executionȱ

Dieȱ OutȬofȬOrderȬBefehlsverarbeitungȱ ȱ [Mȱ 01]ȱ verändertȱ dieȱ AusfühȬ rungsreihenfolgeȱderȱBefehleȱdynamischȱzurȱLaufzeitȱdesȱBefehlsȱ(dyȬ namischesȱ Scheduling).ȱ Imȱ Gegensatzȱ zurȱ InȬorderȬ Befehlsverarbeitung,ȱbeiȱderȱstatischȱdurchȱeinenȱCompilerȱdieȱReihenȬ folgeȱ derȱ Abarbeitungȱ derȱ Befehleȱ undȱ Pipelineunterbrechungenȱ festȬ gelegtȱ wirdȱ (statischesȱ Scheduling),ȱ benutztȱ dasȱ OutȬofȬOrderȬ VerfahrenȱdenȱStatusȱderȱBefehlsverarbeitungȱzurȱLaufzeitȱdesȱBefehlsȱ zurȱFestlegungȱderȱBefehlsabarbeitungȱ(dynamischesȱScheduling).ȱȱ

OutȬofȬOrderȬ Executionȱ

MikroarchitekturenȱfürȱProzessoren,ȱdieȱihreȱProgrammbefehleȱoutȬofȬ orderȱbearbeiten,ȱerledigenȱdieȱTeilaufgabenȱinȱfolgendenȱEinheiten:ȱȱ 1.ȱ Dieȱ FetchȬUnitȱ holtȱ überȱ denȱ Busȱ eineȱ festeȱ oderȱ variableȱ Anzahlȱ vonȱBefehlenȱausȱdemȱCodeȬCacheȱundȱlädtȱsieȱinȱeinenȱBefehlspufȬ fer.ȱȱ 2.ȱDieȱDecodeȬUnitȱmitȱmehrerenȱnebenläufigenȱDekodierern,ȱholtȱsichȱ einenȱTeilȱdieserȱBefehleȱundȱversuchtȱproȱTaktzyklusȱdieseȱzuȱdeȬ kodieren.ȱ Fürȱ Sprungbefehleȱ wirdȱ mitȱ einemȱ VorhersagealgorithȬ musȱ eineȱ Sprungvorhersageȱ durchgeführt.ȱ Beiȱ Sprüngen,ȱ dieȱ vorȬ aussichtlichȱ ausgeführtȱ werden,ȱ kannȱ dadurchȱ dasȱ Sprungzielȱ inȱ denȱCodecacheȱgeladenȱwerden.ȱ 3.ȱ Dieȱ DispatchȬUnitȱ holtȱdieȱ Befehleȱmeistensȱinȱ ihrerȱ logischenȱ ReiȬ henfolgeȱausȱdemȱBefehlspuffer.ȱMeistensȱdeshalb,ȱdaȱdieȱstatischenȱ Datenabhängigkeitenȱ undȱ Ressourcenkonflikteȱ derȱ Compilerȱ beȬ reitsȱerkanntȱhatȱundȱdementsprechendȱdieȱReihenfolgeȱderȱBefehleȱ umgestelltȱhat.ȱHatȱerȱnichtȱgenügendȱunabhängigeȱBefehleȱgefunȬ den,ȱsoȱhatȱerȱNOȬOPȬBefehleȱ(NoȱOperation)ȱeingefügtȱ(Statischesȱ

35ȱ

2ȱȱRechnerarchitekturenȱfürȱParalleleȱundȱVerteilteȱSystemeȱ Scheduling).ȱ Dieȱ DispatchȬUnitȱ untersuchtȱ jedenȱ Befehlȱ aufȱ RegisȬ terabhängigkeitenȱbeiȱOperandenȱundȱErgebnisregisterȱundȱändertȱ dementsprechendȱ dieȱ Befehlsausführungsreihenfolgeȱ (DynamiȬ schesȱ Scheduling).ȱ Dieȱ Veränderungȱ derȱ Ausführungsreihenfolgeȱ erfordertȱzusätzlicheȱSchattenregister,ȱumȱErgebnisregisterkonflikteȱ undȱ darausȱ resultierendeȱ Pipelineunterbrechungenȱ zuȱ vermeiden.ȱ DieȱumgeordnetenȱBefehleȱlandenȱinȱeinemȱBefehlspool,ȱdemȱReorȬ derȱBuffer,ȱderȱdieȱOutȬofȬOrderȬBefehlsverarbeitungȱwiderspiegelt,ȱ undȱwerdenȱderȱExecutionȬUnitȱzugeführtȱȱȱ 4.ȱDieȱExecutionȬUnitȱbestehtȱausȱmehrerenȱnebenläufigenȱFunktionsȬ einheiten.ȱEineȱFunktionseinheitȱistȱtypischerweiseȱaufȱdieȱAusfühȬ rungȱ einerȱ bestimmtenȱ Teilmengeȱ derȱ möglichenȱ Befehlstypenȱ beȬ schränkt.ȱDieȱBefehleȱwerdenȱschließlichȱdurchȱdieȱmehrerenȱFunkȬ tionseinheitenȱ parallelȱausgeführtȱ undȱ dieȱErgebnisseȱ inȱdieȱ SchatȬ tenregisterȱgeschriebenȱȱ 5.ȱDieȱCompletionȬUnitȱschreibtȱdieȱErgebnisse,ȱdieȱinȱdenȱSchattenreȬ gisternȱ vorliegen,ȱ inȱ dieȱ Registerȱ zurückȱ undȱ überprüft,ȱ obȱ einȱ InȬ terruptȱaufgetretenȱistȱ(Abb.2Ȭ1).ȱȱ ȱ Abb.ȱ2Ȭ1:ȱ BefehlsȬ pipelineȱbeiȱ SuperskalaȬ ritätȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

Arbeitsweiseȱ superskalarȱ

36ȱ

Nachfolgendeȱ Abbildungȱ 2Ȭ2ȱ zeigtȱ eineȱ SuperskalarȬArchitekturȱ beȬ stehendȱausȱvierȱnebenläufigenȱFunktionseinheiten.ȱWieȱbeiȱSuperskaȬ larȱüblich,ȱführenȱdieȱFunktionseinheitenȱInstruktionenȱausȱeinemȱProȬ grammȱoderȱeinemȱThreadȱaus.ȱVonȱdiesemȱversuchtȱsieȱsovielȱmehreȬ reȱ Instruktionenȱ zuȱ finden,ȱ dieȱ inȱ einemȱ Zyklusȱ nebenläufigȱ ausführȬ barȱ sind.ȱ Findetȱ sieȱ nichtȱ genug,ȱ soȱ bleibtȱ dieȱ Funktionseinheitȱ unbeȬ

2.1ȱSimultaneousȱMultithreadingȱ nutzt,ȱwasȱinȱAbbildungȱ2Ȭ2ȱdurchȱeinȱleeresȱKästchenȱgekennzeichnetȱ ist.ȱDieȱbenutztenȱKästchenȱenthaltenȱeinȱT1ȱ(Instruktionenȱausȱeinemȱ Threadȱ oderȱ einemȱ Programm).ȱ Dieȱ leerenȱ Kästchenȱ resultierenȱ meisȬ tensȱ ausȱ nichtȱ genügendȱ vorhandenenȱ InstruktionsȬLevelȬ Parallelismus.ȱ Eineȱ horizontalȱ kompletteȱ Reiheȱ vonȱ leerenȱ Kästchenȱ kennzeichnetȱ einenȱ komplettȱ ungenutztenȱ Zyklus.ȱ Diesȱ wirdȱ durchȱ Instruktionenȱ mitȱ hoherȱ Latenzzeitȱ verursacht,ȱ dieȱ eineȱ weitereȱ InȬ struktionszufuhrȱ verhindern.ȱ Dieȱ hohenȱ Latenzzeitenȱ rührenȱ vonȱ InȬ struktionenȱmitȱSpeicherreferenzenȱaufȱdenȱL1ȬȱoderȱL2ȬCache.ȱLandetȱ eineȱSpeicherreferenzȱwederȱimȱL1ȬȱnochȱimȱL2ȬCache,ȱsoȱentstehtȱeineȱ langeȱWartezeit,ȱbisȱdasȱangeforderteȱWortȱinȱdenȱCacheȱgeladenȱistȱ–ȱ dieȱPipelineȱmussȱangehaltenȱwerden.ȱȱ ȱ ȱ ȱ ȱ ȱ

Abb.ȱ2Ȭ2:ȱ FunktionsȬ einheitenȱundȱ ihreȱAusȬ nutzungȱbeiȱ SuperskalarȬ Architekturenȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

2.1.2 Thread Level Parallelismus Multithreadedȱ Prozessorenȱ besitzenȱ Befehlszählerȱ undȱ Registerȱ fürȱ mehrereȱThreads.ȱProȱThreadȱeinenȱBefehlszählerȱundȱeinenȱkompletȬ tenȱ Registersatz.ȱ Inȱ jedemȱ Zyklusȱ führtȱ derȱ Prozessorȱ Instruktionenȱ vonȱ irgendeinemȱ Threadȱ aus.ȱ Imȱ nächstenȱ Zyklusȱ schaltetȱ erȱ umȱ aufȱ denȱ Hardwarekontextȱ (Befehlszählerȱ undȱ Registersatz)ȱ einesȱ anderenȱ Threadsȱ undȱ führtȱ inȱ superskalarerȱ Arbeitsweiseȱ dieȱ Instruktionenȱ diesesȱ neuenȱ Threadsȱ aus.ȱ Dadurchȱ vermeidetȱ manȱ dieȱ komplettȱ unȬ

37ȱ

2ȱȱRechnerarchitekturenȱfürȱParalleleȱundȱVerteilteȱSystemeȱ genutztenȱ Zyklen,ȱ dieȱ durchȱ dieȱ Latenzzeitenȱ verursachtȱ sind.ȱ NachȬ folgendeȱ Abbildungȱ 2Ȭ3ȱ zeigtȱ diesenȱ Sachverhalt,ȱ wobeiȱ dieȱ Stricheȱ zwischenȱ denȱ einzelnenȱ Prozessorzyklenȱ dasȱ Umschaltenȱ aufȱ einenȱ anderenȱThreadȱandeuten.ȱ Abb.ȱ2Ȭ3:ȱ FunktionsȬ einheitenȱundȱ ihreȱAusȬ nutzungȱbeiȱ MultiȬ threadedȬ Architekturenȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

2.1.3 Arbeitsweise des Simultaneous Multithreading Simultaneousȱ Multithreadingȱ benutztȱ Instructionȱ Levelȱ Parallelismȱ undȱThreadȱLevelȱParallelismȱundȱvermeidetȱsomitȱdieȱleerenȱKästchenȱ inȱvertikalerȱundȱhorizontalerȱRichtung.ȱSimultaneousȱMultithreadingȱ nutztȱ denȱ Instructionȱ Levelȱ Parallelismȱ vonȱ jedemȱ Threadȱ ausȱ undȱ startetȱ dynamischȱ dieȱ parallelȱ ausführbarenȱ Instruktionenȱ vonȱ einemȱ Thread.ȱBesitztȱalsoȱeinȱThreadȱinȱeinemȱZyklusȱeinenȱhohenȱInstructiȬ onsȱLevelȱParallelism,ȱsoȱkannȱdieseȱdurchȱdieȱSuperskalarȬArchitekturȱ befriedigtȱ werden.ȱ Habenȱ vieleȱ Threadsȱ einenȱ niederenȱ Instructionȱ LevelȱParallelismus,ȱsoȱkönnenȱsieȱinȱeinemȱZyklusȱzusammenȱparallelȱ abgearbeitetȱwerdenȱ(Abb.ȱ2Ȭ4).ȱȱȱ ȱ

38ȱ

2.2ȱEngȱgekoppelteȱMultiprozessorenȱundȱMulticoreȬProzessorenȱ ȱ ȱ ȱ ȱ ȱ

Abb.ȱ2Ȭ4:ȱ FunktionsȬ einheitenȱundȱ ihreȱAusȬ nutzungȱbeimȱ Simultanousȱ MultiȬ threadingȱȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ Simultaneousȱ Multithreadingȱ istȱ deshalbȱ attraktiv,ȱ weilȱ dadurchȱ mitȱ nurȱ geringfügigemȱ zusätzlichemȱ Steuerungsaufwandȱ dieȱ ProzessorȬ leistungȱ gegenüberȱ denȱ SuperskalarȬArchitekturenȱ deutlichȱ erhöhtȱ werdenȱ kann.ȱ Soȱ erzieltenȱ [TEEȱ 96]ȱ mitȱ einerȱ Simulationȱ fürȱ einenȱ siȬ multaneousȱ multithreadingȬfähigenȱ Prozessorȱ LeistungsverbesserunȬ genȱzwischenȱ1,8ȱundȱ2,5ȱgegenüberȱeinemȱSuperskalarȬRechner.ȱ

2.2 Eng gekoppelte Multiprozessoren und MulticoreProzessoren 2.2.1 Architektur von eng gekoppelten Multiprozessoren Alleȱ Prozessorenȱ beiȱ einemȱ engȱ gekoppeltenȱ Multiprozessorȱ könnenȱ denȱ Adressraumȱ desȱ gemeinsamenȱ Speichersȱ gemeinsamȱ benutzen.ȱ JederȱProzessorȱkannȱeinȱSpeicherwortȱlesenȱoderȱschreiben,ȱindemȱerȱ einfachȱeinenȱLOADȬȱoderȱStoreȬBefehlȱausführt.ȱDieȱüblichȱverwendeȬ teȱ Speichertechnologieȱ DRAMȱ (dynamicȱ randomȱ accessȱ memory)ȱ erȬ laubtȱZugriffszeitenȱvonȱungefährȱ10ȱns.ȱ[BMȱ06].ȱDiesȱentsprichtȱeinerȱ Frequenzȱ vonȱ 100ȱ MHz,ȱ alsoȱ nurȱ einemȱ Bruchteilȱ derȱ Taktfrequenzȱ modernerȱ Prozessoren.ȱ Derȱ Verkehrȱ zwischenȱ Prozessorȱ undȱ demȱ

vonȬ NeumannȬ Flaschenhalsȱ

39ȱ

2ȱȱRechnerarchitekturenȱfürȱParalleleȱundȱVerteilteȱSystemeȱ Hauptspeicherȱ bildetȱ einenȱ leistungsbegrenzendenȱ Flaschenhalsȱ inȱ einemȱ Rechner,ȱ derȱ vonȬNeumannȬFlaschenhalsȱ [Bȱ 78]ȱ heißt.ȱ Engȱ geȬ koppelteȱ Multiprozessorenȱ verengenȱ nochȱ zusätzlichȱ gegenüberȱ EinȬ prozessorsystemenȱ denȱ vonȬNeumannȱ Flaschenhalsȱ undȱ vergrößernȱ denȱ ProzessorenȬSpeicherȬVerkehr:ȱ Jederȱ hinzukommendeȱ weitereȱ Prozessorȱ greiftȱ aufȱ denȱ gemeinsamenȱ Speicherȱ zuȱ undȱ belastetȱ dieȱ gemeinsameȱ ProzessorȬSpeicherȬVerbindung.ȱ Ausȱ diesemȱ Grundȱ sindȱ beiȱengȱgekoppeltenȱMultiprozessorenȱdieȱAnzahlȱderȱProzessorenȱaufȱ 8ȱbisȱhöchstensȱ64ȱbeschränkt.ȱ ZurȱReduktionȱdiesesȱFlaschenhalsesȱbesitztȱjederȱProzessorȱeinenȱCaȬ che,ȱderȱKopienȱvonȱTeilenȱdesȱHauptspeichersȱenthält.ȱErȱbestehtȱausȱ SRAMȱ (staticȱ randomȱ accessȱ memory)ȱ undȱ ermöglichtȱ ZugriffsgeȬ schwindigkeiten,ȱdieȱderȱTaktfrequenzȱderȱProzessorenȱnaheȱkommen.ȱ Dieȱ Größeȱ desȱ Cachesȱ istȱ beschränkt,ȱ üblicherweiseȱ einȱ bisȱ mehrereȱ MBytes,ȱ undȱ dieȱ Zugriffeȱ aufȱ Befehleȱ undȱ Daten,ȱ dieȱ nichtȱ imȱ Cacheȱ liegen,ȱ undȱ zuȱ Cacheȱ Missesȱ führenȱ zuȱ Leistungseinbußenȱ desȱ RechȬ nersȱ[BMȱ06].ȱȱ Abb.ȱ2Ȭ5:ȱȱȱȱ Engȱ gekoppelterȱ MultiȬ prozessorȱ ȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

40ȱ

2.2ȱEngȱgekoppelteȱMultiprozessorenȱundȱMulticoreȬProzessorenȱ Dasȱ Zusammenhängenȱ derȱ Prozessorenȱ mitȱ demȱ gemeinsamenȱ SpeiȬ cherȱ bietetȱ beliebigeȱ LeistungsȬȱ undȱ Fehlertoleranzstufen.ȱ Durchȱ denȱ gemeinsamenȱ Busȱ undȱ somitȱ durchȱ denȱ vonȱ NeumannȬFlaschenhalsȱ sindȱ dieȱ LeistungsȬȱ undȱ Fehlertoleranzgrenzenȱ jedochȱ nachȱ obenȱ beȬ schränkt.ȱ Allerdingsȱ bietetȱ derȱ gemeinsameȱ globaleȱ Speicherȱ Vorteileȱ beiȱderȱProzesssynchronisationȱundȱȬkommunikation,ȱdieȱhierȱwieȱbeiȱ Einprozessorsystemenȱ überȱ denȱ gemeinsamenȱ Speicherȱ läuft.ȱ Somitȱ sindȱ beiȱ engȱ gekoppeltenȱ Multiprozessorenȱ dieȱ bekanntenȱ SynchroniȬ sationsverfahrenȱ wieȱ Locks,ȱ Semaphorenȱ undȱ Monitorenȱ einsetzbar.ȱ DieȱKommunikationȱverläuftȱlokal,ȱundȱbrauchtȱnichtȱüberȱeineȱNetzȬ werkverbindungȱzuȱlaufenȱundȱistȱsomitȱschneller.ȱȱȱ

Nachteil:ȱȱȱȱ Bus;ȱȱȱȱȱ Vorteil:ȱ gemeinsamerȱ Speicherȱ

Zurȱ Reduktionȱ desȱ ProzessorȬSpeicherȬVerkehrsȱ dientȱ einemȱ jedemȱ Prozessorȱȱȱ x

vorgelagerterȱCache,ȱȱȱ

x

undȱ zurȱ Erhöhungȱ derȱ Leistungȱ desȱ ProzessorȬSpeicherȬVerkehrsȱ dienenȱleistungsfähigereȱVerbindungseinrichtungen,ȱwieȱȱ x Kreuzschienenschalterȱoderȱ x Mehrebenennetzwerke.ȱ

ÜberȱeinenȱgemeinsamenȱBusȱlassenȱsichȱnurȱdurchȱZwischenschaltenȱ vonȱmehrfachȱgestuftenȱCaches,ȱwobeiȱeineȱausreichendeȱDatenlokaliȬ tätȱvorausgesetztȱwird,ȱmehrereȱProzessorenȱkoppeln.ȱEngȱgekoppelteȱ Multiprozessorenȱ mitȱ großerȱ Prozessoranzahlȱ sindȱ aufȱ einerȱ BustechȬ nologieȱ nichtȱ aufbaubarȱ [Rȱ 97].ȱ Derȱ Busengpassȱ lässtȱ sichȱ nurȱ durchȱ einȬȱ undȱ mehrstufigeȱ Verbindungsnetzeȱ wieȱ Kreuzschienenschalterȱ undȱMehrebenennetzwerkeȱeliminierenȱ[Dȱ90].ȱ

2.2.2 Cachekohärenzprotokolle Dieȱ Datenȱ imȱ Cacheȱ undȱ imȱ Hauptspeicherȱ werdenȱ zerlegtȱ inȱ gleichȱ großeȱBlöcke.ȱ Einȱ Blockȱ istȱ dieȱ Einheit,ȱdieȱzwischenȱ demȱ HauptspeiȬ cherȱundȱdemȱCacheȱtransferiertȱwird.ȱAlsȱTransferȬȱundȱSpeichereinȬ heitȱ fürȱ denȱ Cacheȱ dientȱ eineȱ CacheȬZeileȱ (Cacheȱ Line)ȱ mitȱ normalerȬ weiseȱ32ȱoderȱ64ȱByteȱ[Tȱ06].ȱOptimaleȱCacheȬȱundȱBlockgrößenȱsindȱinȱ [Pȱ90]ȱdiskutiert.ȱ

CacheȱLine

DieȱEinführungȱdesȱCachesȱbringtȱjedochȱProbleme,ȱwennȱgemeinsameȱ BlöckeȱinȱmehrerenȱverschiedenenȱCachesȱvorliegen.ȱNehmenȱwirȱdaȬ zuȱFolgendesȱan:ȱZweiȱProzessorenȱlesenȱausȱdemȱHauptspeicherȱdenȱ gleichenȱ Blockȱ inȱ ihreȱ Caches.ȱ Anschließendȱ überschreibtȱ einerȱ dieserȱ ProzessorenȱdiesenȱBlock.ȱLiestȱnunȱderȱandereȱProzessorȱdiesenȱBlockȱ ausȱ seinemȱ Cache,ȱ soȱ liestȱ erȱ denȱ altenȱ Wertȱ undȱ nichtȱ denȱ geradeȱ

Inkonsistenteȱ Datenȱinȱ Cacheȱundȱ HauptȬ speicherȱ

41ȱ

2 Rechnerarchitekturen für Parallele und Verteilte Systeme überschriebene Wert. Die Daten in den Caches sind inkonsistent, und weiterhin sind die Daten in einem der Caches und dem Hauptspeicher inkonsistent. Datenkonsistenz

Datenkonsistenz bedeutet, dass im Hauptspeicher und in den Caches zu keinem Zeitpunkt verschiedene Kopien desselben Blockes existieren.

Datenkohärenz

Zur Lösung des Konsistenzproblems bei Multiprozessoren genügt es, eine abgeschwächte Bedingung, nämlich die Datenkohärenz, zu fordern. Datenkohärenz liegt vor, wenn beim Lesen des Blockes, welcher mehrfach überschrieben wurde, immer der zuletzt geschriebene Wert gelesen wird. Die Datenkonsistenz schließt die Kohärenz ein, aber nicht umgekehrt.

2.2.2.1 MESI Cachekohärenz-Protokoll Datenkohärenzproblem

Datenkohärenz ist bei Multiprozessorsysteme gegeben, wenn 1. zwar jeder Prozessorcache über eine Kopie von Daten im Hauptspeicher verfügen darf, 2. aber nur ein Prozessorcache eine modifizierte Kopie der Daten besitzen darf, jedoch nur solange, wie kein anderer Prozessor dieselben Daten liest. Das Kohärenzproblem tritt nicht nur bei Caches von Multiprozessoren auf, sondern auch bei einem Cache bei einem Einprozessorsystem, wenn der andere Prozessor DMA-Hardware (DMA – Direct Memory Access) bzw. ein Ein/Ausgabe-Prozessor ist, der zusätzlich zur CPU vorhanden ist. Das obige unter 1. beschriebene Problem ist lösbar, wenn beim Schreiben neuer Werte in den Cache auch die entsprechenden Werte in den Hauptspeicher und in die anderen Caches (bei Multiprozessoren) überschrieben werden. Für dieses Vorgehen gibt es zwei Methoden:

write through

1.

deferred write

2.

Das Durchschreiben (write through oder store through), wo bei jedem Schreiben in den Cache gleichzeitig auch in den entsprechenden Hauptspeicher geschrieben wird. Das verzögerte Rückschreiben (deferred write), bei dem die korrespondierende Kopie im Hauptspeicher nicht sofort ersetzt wird, sondern erst beim Verdrängen der Daten aus dem Cache.

Verfahren eins gewährleistet nicht nur die Kohärenz, sondern auch die Konsistenz, und besticht durch seine Einfachheit. Bei write through Caches (Verfahren eins) ist jedoch nachteilig, dass jedes Schreiben einen Hauptspeicherzugriff bedingt, was bei einem Multiprozessorsys-

42

2.2ȱEngȱgekoppelteȱMultiprozessorenȱundȱMulticoreȬProzessorenȱ temȱ wiederȱ denȱ Busȱ belastet.ȱ Deshalbȱ wirdȱ diesesȱ Verfahrenȱ nurȱ beiȱ Einprozessorsystemenȱ zwischenȱ demȱ Primaryȱ Cacheȱ (Levelȱ 1ȱ Cache)ȱ undȱdemȱSecondaryȱCacheȱ(Levelȱ2ȱCache)ȱangewandt.ȱDieȱDatenȱoderȱ Instruktionenȱ werdenȱ dabeiȱ ausȱ demȱ Primaryȱ Cacheȱ geholt,ȱ undȱ dieȱ Ergebnisseȱ werdenȱ beiȱ demȱ Primaryȱ Cacheȱ durchgeschriebenȱ (writeȱ through)ȱinȱdenȱSecondaryȱCache.ȱBeiȱMultiprozessorenȱistȱzurȱRedukȬ tionȱ derȱ Hauptspeicherzugriffeȱ nurȱ dieȱ verzögerteȱ RückschreibemeȬ thodeȱangebrachtȱ(Verfahrenȱzwei).ȱȱ

Einsatzȱdesȱ writeȱthroughȱ beiȱL1ȱȬȱundȱ L2ȬCachesȱ

Zurȱ Realisierungȱ desȱ verzögertenȱ Rückschreibensȱ gibtȱ esȱ aufȱ derȱ HardwareebeneȱzweiȱverschiedeneȱStrategienȱbeimȱSchreibenȱ[Sȱ90]:ȱ 1.ȱȱWriteȱinvalidateȱundȱ 2.ȱȱWriteȱupdate.ȱȱ DieȱWriteȱinvalidateȬStrategieȱarbeitetȱfolgendermaßen:ȱ Leseanfragenȱ werdenȱ lokalȱ befriedigt,ȱ fallsȱ eineȱ Kopieȱ desȱ Blockesȱ existiert.ȱÜberschreibtȱeinȱProzessorȱeinenȱBlock,ȱwerdenȱalleȱanderenȱ Kopienȱ(imȱHauptspeicherȱundȱdenȱanderenȱCaches)ȱaufȱungültigȱgeȬ setztȱ(Invalidated).ȱEinȱweiteresȱÜberschreibenȱdesȱgleichenȱProzessorsȱ kannȱnurȱaufȱseinemȱihmȱgehörendemȱCacheȱdurchgeführtȱwerden,ȱdaȱ keineȱweiterenȱKopienȱmehrȱexistieren.ȱWillȱeinȱandererȱProzessorȱdenȱ überschriebenenȱBlockȱlesen,ȱsoȱmussȱerȱwarten,ȱbisȱderȱBlockȱwiederȱ gültigȱist.ȱȱ

Writeȱ invalidateȱȱ

Imȱ Gegensatzȱ zuȱ derȱ Writeȱ invalidateȬStrategieȱ ändertȱ (updated)ȱ dieȱ WriteȱupdateȬStrategieȱbeimȱSchreibenȱeinesȱProzessorsȱalleȱKopienȱinȱ denȱanderenȱCaches.ȱ

Writeȱupdate

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

43ȱ

2 Rechnerarchitekturen für Parallele und Verteilte Systeme Abb. 2-6: Vergleich: Write invalidate und Write update

Prozessor 1

Prozessor 2

Cache X

Cache X

...

Prozessor n Cache X

Verbindungseinrichtung (Speicherbus)

Speichermodul 1 X

...

Speichermodul n

a) Ausgangszustand: Hauptspeicher und alle Caches haben konsistente Kopien des Blockes X

Prozessor 1

Prozessor 2

Cache X’

Cache Inv

...

Prozessor n Cache Inv

Verbindungseinrichtung (Speicherbus)

Speichermodul 1 Inv

...

Speichermodul n

b) Write invalidate: Alle Kopien mit Ausnahme von Cache in Prozessor 1 sind ungültig (Inv), wenn Prozessor 1 den Block X überschreibt, angezeigt durch X´.

44

2.2 Eng gekoppelte Multiprozessoren und Multicore-Prozessoren Prozessor 1

Prozessor 2

Cache X’

Cache X’

...

Prozessor n Cache X’

Verbindungseinrichtung (Speicherbus)

Speichermodul 1

...

Speichermodul n

c) Write update: Alle Kopien (mit Ausnahme der Speicherkopie, was ignoriert wird) sind abgeändert

Die Write invalidate- und Write update-Strategie erfordert, dass die Konsistenzkommandos (Invalidation-Kommando und UpdateKommando) wenigstens diejenigen Caches erreichen, die Kopien des Blockes haben. Das bedeutet, dass jeder Cache die Konsistenzkommandos bearbeiten muss, um herauszufinden, ob es einen Block in seinem Cache betrifft. Deshalb heißen diese Protokolle Snoopy Cache Protocols, da jeder Cache am Bus nach eingehenden Inkonsistenzkommandos “schnüffeln“ muss.

Snoopy Cache

Ein Snoopy Cache Protocol, basierend auf der Write InvalidateStrategie, schreibt einen Block im Cache nur beim ersten Schreiben in den Hauptspeicher zurück (Write-once Protocol oder Write-first Protocol). Nachfolgendes Lesen und Schreiben geschieht dann auf dem lokalen Block im Cache und erfordert kein Rückschreiben in den Hauptspeicher. Dadurch bedingen nachfolgende Lese- und Schreiboperationen des Prozessors keinen Busverkehr mehr. Das Write-once Protocol entspricht beim ersten Schreiben dem write through. Dieser zusätzliche Hauptspeicherzugriff zum Durchschreiben wird hier in Kauf genommen, da der Prozessor warten muss, bis die restlichen Caches den Block invalidiert haben.

Write-once Protocol

45

2ȱȱRechnerarchitekturenȱfürȱParalleleȱundȱVerteilteȱSystemeȱ DasȱWriteȱInvalidateȱSnoopyȱCacheȱProtocolȱassoziiertȱeinenȱZustandȱ mitȱ jederȱ Kopieȱ einesȱ Blockesȱ imȱ Cache.ȱ Dieȱ Zuständeȱ fürȱ eineȱ Kopieȱ sind:ȱȱ MESIȱ

x

Modified:ȱDatenȱwurdenȱeinmalȱüberschrieben,ȱundȱdieȱKopieȱistȱ nichtȱkonsistentȱmitȱderȱKopieȱimȱHauptspeicherȱ(WriteȬonceȱProȬ tocol).ȱDieȱKopieȱimȱHauptspeicherȱistȱdieȱveralteteȱKopie.ȱȱ

x

Exclusiveȱ(unmodified):ȱDieȱDatenȱwurdenȱnichtȱmodifiziert,ȱundȱ dieȱKopieȱistȱdieȱeinzigeȱKopieȱimȱSystem,ȱdieȱimȱCacheȱliegt.ȱ

x

Sharedȱ (unmodified):ȱ Esȱ existierenȱ mehrereȱ gültigeȱ Kopien,ȱ dieȱ konsistentȱmitȱderȱKopieȱimȱHauptspeicherȱsind.ȱ

x

Invalid:ȱDieȱKopieȱistȱungültig.ȱ

GemäßȱdenȱAnfangsbuchstabenȱderȱNamenȱfürȱdieȱZuständeȱheißtȱdasȱ SnoopyȱCacheȱInvalidationȱProtocolȱauchȱMESIȬProtokollȱ[Hȱ93].ȱ ZusätzlichȱzuȱdenȱnormalenȱKommandosȱzumȱLesenȱeinesȱBlockesȱausȱ (Read-Block)ȱ undȱ Schreibenȱ einesȱ Blockesȱ (Write-Block)ȱ inȱ denȱ SpeicherȱbenötigtȱmanȱnochȱdieȱbeidenȱKonsistenzkommandosȱ x

Write-Inv:ȱSetztȱalleȱanderenȱKopienȱeinesȱBlockesȱaufȱungültigȱ (invalidate).ȱ

x

Shared-Signal:ȱzumȱAnzeigen,ȱdassȱeineȱweitereȱKopieȱexistiert.ȱȱ

Zustandsänderungenȱ werdenȱ entwederȱ durchȱ dieȱ LeseȬȱ undȱ SchreibȬ kommandosȱdesȱProzessorsȱ(Proc-Read,ȱProc-Write)ȱoderȱüberȱdieȱ Konsistenzkommandos,ȱ dieȱ überȱ denȱ Busȱ kommenȱ (Read-Block,ȱ Write-Block,ȱWrite-Inv,ȱShared-Signal)ȱbewirkt.ȱȱ Derȱ Ablaufȱ desȱ MESIȬProtokollsȱ lässtȱ sichȱ nunȱ angebenȱ durchȱ dieȱ Aktionen,ȱ welcheȱ durchgeführtȱ werden,ȱ wennȱ derȱ Prozessorȱ einenȱ Blockȱliestȱ(Proc-Read)ȱoderȱeinenȱBlockȱbeschreibtȱ(Proc-Write).ȱȱ BeiȱeinemȱProc-Read undȱProc-WriteȱkönnenȱdieȱfolgendenȱFälleȱ auftreten:ȱ Hitȱȱ

x

Einȱ Readȱ Hitȱ trittȱ auf,ȱ wennȱ derȱ Blockȱ imȱ Cacheȱ vorhandenȱ undȱ gültigȱist.ȱȱ

x

EinȱReadȱMissȱtrittȱauf,ȱwennȱderȱBlockȱimȱCacheȱnichtȱvorhandenȱ oderȱungültigȱistȱ(Invalid).ȱ

x

EinȱWriteȱHitȱtrittȱauf,ȱwennȱderȱBlockȱimȱCacheȱvorhandenȱundȱ gültigȱist.ȱ

ȱ Missȱ

46ȱ

2.2ȱEngȱgekoppelteȱMultiprozessorenȱundȱMulticoreȬProzessorenȱ x

Einȱ Writeȱ Missȱ trittȱ auf,ȱ wennȱ derȱ Blockȱ imȱ Cacheȱ nichtȱ vorhanȬ denȱoderȱungültigȱistȱ(Invalid).ȱ

DieȱbeiȱeinemȱHitȱoderȱMissȱoderȱeinerȱErsetzungȱ(Replacement)ȱeinesȱ BlocksȱimȱCacheȱdurchzuführendenȱAktionenȱsind:ȱ x

ReadȱHit:ȱBenutzeȱdieȱlokaleȱKopieȱausȱdemȱCache.ȱ

x

Readȱ Miss:ȱ Existiertȱ keineȱ oderȱ keineȱ Modifiedȱ Kopie,ȱ dannȱ hatȱ derȱHauptspeicherȱeineȱgültigeȱKopie.ȱKopiereȱBlockȱvomȱHauptȬ speicherȱinȱdenȱCacheȱundȱsetzeȱdenȱBlockȱaufȱExclusive.ȱExistiertȱ eineȱModifiedȬKopie,ȱdannȱistȱesȱdieȱeinzigeȱgültigeȱKopieȱimȱSysȬ temȱ undȱ dieȱ Kopieȱ imȱ Hauptspeicherȱ istȱ ungültig.ȱ Schreibeȱ dieȱ ModifiedȬKopieȱinȱdenȱHauptspeicher,ȱsoȱdassȱerȱeineȱgültigeȱKoȬ pieȱenthält.ȱLadeȱdieȱgültigeȱKopieȱvomȱHauptspeicherȱinȱdenȱCaȬ che.ȱSetzeȱmitȱdemȱSharedȬSignalȱbeideȱKopienȱaufȱShared.ȱȱȱ

x

Writeȱ Hit:ȱ Existiertȱ keineȱ ModifiedȬKopie,ȱ dannȱ kannȱ dasȱSchreiȬ benȱlokalȱausgeführtȱwerden.ȱIstȱdieȱKopieȱModified,ȱsoȱ mussȱsieȱ vorherȱ inȱ denȱ Speicherȱ zurückgeschriebenȱ werden.ȱ Derȱ neueȱ ZuȬ standȱ derȱ Kopieȱ istȱ Modified.ȱ Sendeȱ dasȱ Konsistenzkommandoȱ Write-InvȱzuȱallenȱanderenȱCaches,ȱsoȱdassȱdieȱCachesȱihreȱKoȬ pienȱaufȱInvalidȱsetzenȱkönnen.ȱȱ

x

Writeȱ Miss:ȱ Dieȱ Kopieȱ besitztȱ denȱ Zustandȱ Modified,ȱ dannȱ wirdȱ dieȱKopieȱinȱdenȱSpeicherȱzurückgeschrieben,ȱandernfallsȱkannȱeinȱ Zurückschreibenȱ unterbleibenȱ Dieȱ Kopieȱ wirdȱ vomȱ Speicherȱ geȬ holt,ȱ undȱ anschließendȱ wirdȱ dieȱ Kopieȱ überschrieben.ȱ Sendeȱ dasȱ Konsistenzkommandoȱ Write-Invȱ zuȱ allenȱ anderenȱ Caches,ȱ soȱ dassȱdieȱCachesȱihreȱKopienȱaufȱInvalidȱsetzenȱkönnen.ȱDerȱneueȱ ZustandȱderȱKopieȱistȱExclusive.ȱ

x

Replacement:ȱ Istȱ dieȱ Kopieȱ Dirtyȱ (d.h.ȱ derȱ Blockȱ istȱ imȱ Cacheȱ geȬ ändert),ȱ soȱ mussȱ sieȱ inȱ denȱ Hauptspeicherȱ zurückȱ geschriebenȱ werden.ȱAndernfallsȱistȱkeineȱAktionȱnotwendigȱȱ

MESIȬ Protokollȱ

NachfolgendeȱAbbildungȱ2Ȭ7ȱzeigtȱanȱeinemȱBeispielȱdieȱAuswirkungȱ desȱ MESIȬProtokollsȱ undȱ verdeutlicht,ȱ dassȱ einȱ mehrmaligesȱ Lesenȱ undȱ Schreibenȱ einesȱ Prozessorsȱ nurȱ beimȱ erstmaligenȱ Schreibenȱ BusȬ verkehrȱ erfordertȱ undȱ nachfolgendesȱ Schreibenȱ undȱ Lesenȱ nurȱ lokalȱ aufȱ derȱ Kopieȱ imȱ Cacheȱ ausgeführtȱ wird.ȱ Inȱ Abbildungȱ 2Ȭ7ȱ beziehenȱ sichȱalleȱSpeicherzugriffeȱaufȱdieselbeȱAdresse.ȱȱ ȱ ȱ ȱ

47ȱ

2 Rechnerarchitekturen für Parallele und Verteilte Systeme

Abb. 2-7: Beispiel für das Writeinvalidate snoopy cache protocol (MESIprotocol)

Prozessor 1

Prozessor 2

Prozessor 3

Cache

Cache X1

Cache

Exclusive

Speicher X1

a) Anfangszustand: X1 ist im Hauptspeicher und im Cache von Prozessor 2

Prozessor 1

Prozessor 2

Prozessor 3

Cache

Cache X1

Cache

Shared

Shared

SharedSignal

Speicher X1 Read-Block

b) Prozessor 1 liest X1 : Read Miss: Prozessor 2 reagiert auf das Lesen von Prozessor 1 mit neuem Zustand Shared. Der Block kommt vom Hauptspeicher. Beide Zustände sind Shared.

48

2.2 Eng gekoppelte Multiprozessoren und Multicore-Prozessoren

Prozessor 1

Prozessor 2

Prozessor 3

Cache X 2

Cache X1

Cache

Modified

Invalid

Write-Inv

Speicher X1 c) Prozessor 1 überschreibt X1 : Write Hit: Erstes Schreiben von Prozessor 1 macht die Kopie im Cache von Prozessor 2 ungültig

Prozessor 1

Prozessor 2

Prozessor 3

Cache X 3

Cache X1

Cache

Modified

Invalid

Speicher X1

d) Prozessor 1 überschreibt X2 : Write Hit: Nachfolgendes Schreiben und Lesen geschieht lokal im Cache von Prozessor 1. Kein Busverkehr!

49

2 Rechnerarchitekturen für Parallele und Verteilte Systeme Prozessor 1

Prozessor 2

Prozessor 3

Cache X 3

Cache X1

Cache X 4

Invalid

Invalid

Exclusive

Write-Inv

Write-Block

Speicher X3

Read-Block

e) Prozessor 3 überschreibt X2 : Write Miss: Prozessor 1 liefert den Block. Alle anderen Caches werden auf ungültig gesetzt. Write Invalidate oder Write Update?

Bus-Snooping mit dem MESI-Protokoll, und somit mit der Write Invalidate-Strategie, verwendet der Intel Pentium 4 und viele andere CPUs [T 06]. Ein Beispiel für ein Write update Snoopy Cache Protocol ist das Firefly Protocol, das für eine Firefly Multiprocessor Workstation von Digital Equipment implementiert wurde, und das Dragon Protocol für eine Dragon Multiprocessor Workstation von Xerox PARC. Eine Übersicht und Beschreibung dieser Protokolle gibt Archibald und Baer [AB 86]. Die Write Update- und Write Invalidate-Techniken sind unter verschiedenen Belastungen unterschiedlich leistungsfähig. UpdateNachrichten befördern Nutzdaten und sind daher umfangreicher als Invalidierungs-Nachrichten. Die Update-Strategie vermeidet jedoch zukünftige Cache-Fehler [T 06]. Performance-Messungen, gewonnen durch Simulation des Write Invalidate- und Write Update-Protokoll, sind in [L 93] enthalten.

Unterschied Snoopy Cache und Directorybasierte Cache

50

Die Hauptunterschiede zwischen einem Snoopy Cache und einem gewöhnlichen Cache für Einprozessorsysteme, oder den nachfolgend beschriebenen Verzeichnis-basierten Multiprozessor-Caches, liegen einmal im x

Cache Controller, der Information in der Cache-Zeile abspeichert über jeden Zustand eines Blockes. Bei Snoopy Caches kann der Cache-Controller als Zustandsautomat ausgelegt werden, der das Cache Kohärenz-Protokoll gemäß den Zustandsübergängen imp-

2.2ȱEngȱgekoppelteȱMultiprozessorenȱundȱMulticoreȬProzessorenȱ lementiert.ȱ Wieȱ beiȱ denȱ SnoopyȬProtokollenȱ benötigtȱ einȱ DirectoȬ ryȬbasierterȱ Cacheȱ zumȱ Abspeichernȱ desȱ Zustandesȱ mindestensȱ zweiȱBits.ȱZumȱanderenȱimȱ x

Busȱ Controller,ȱ derȱ beiȱ Snoopyȱ Cachesȱ denȱ SnoopingȬ Mechanismusȱ implementiertȱ undȱ alleȱ Busoperationenȱ überwachtȱ undȱEntscheidungenȱfällt,ȱobȱAktionenȱnötigȱsindȱoderȱnicht.ȱZumȱ Weiterenȱimȱ

x

Busȱselber,ȱderȱzurȱeffizientenȱUnterstützungȱderȱWriteȱinvalidateȬȱ oderȱWriteȱupdateȬProtokolleȱweitereȱBusleitungenȱbesitzenȱmuss.ȱ Z.ȱ B.ȱ istȱ eineȱ Sharedȱ Lineȱ beiȱ derȱ Writeȱ UpdateȬStrategieȱ angeȬ bracht.ȱȱȱ

2.2.2.2 Verzeichnis-basierte Cachekohärenz-Protokolle SnoopyȱCacheȬProtokolleȱpassenȱsehrȱgutȱmitȱdemȱBusȱzusammenȱundȱ sindȱ nichtȱ geeignetȱ fürȱ allgemeineȱ Verbindungsnetzwerke,ȱ wieȱ dieȱ nachfolgendȱ beschriebenenȱ Kreuzschienenschalterȱ undȱ MehrebenenȬ netzwerke.ȱDerȱGrundȱliegtȱdarin,ȱdassȱsieȱeinenȱBroadcastȱerfordern,ȱ derȱmitȱeinemȱBusȱoderȱsogarȱmitȱeinerȱdafürȱvorgesehenenȱBusleitungȱ einfacherȱ zuȱ bewerkstelligenȱ istȱ alsȱ mitȱ einemȱ Verbindungsnetzwerk.ȱ Anstattȱ einesȱ Broadcastȱ solltenȱ dieȱ Konsistenzkommandosȱ nurȱ dieȱ Cachesȱ erreichen,ȱ dieȱ eineȱ Kopieȱ desȱ Blockesȱ haben.ȱ Diesȱ bedingt,ȱ esȱ mussȱInformationȱvorhandenȱsein,ȱwelcheȱCachesȱKopienȱbesitzenȱvonȱ allenȱinȱdenȱCachesȱvorhandenenȱBlöcken.ȱCachekohärenzȬProtokolle,ȱ dieȱirgendwieȱInformationȱabspeichern,ȱwelcheȱCachesȱeineȱKopieȱdesȱ Blockesȱ besitzen,ȱ arbeitenȱ mitȱ einemȱ Verzeichnisȱ Schemaȱ (Directoryȱ Scheme)ȱ[Sȱ90].ȱȱ

Gründeȱfür einȱ Verzeichnisȱ

Einȱ Verzeichnisȱ (Directory)ȱ oderȱ eineȱ Datenbankȱ enthältȱ fürȱ jedenȱ Speicherblockȱ (memoryȬline)ȱ einenȱ Eintrag,ȱ welcherȱ denȱ Zustandȱ desȱ Blockesȱ undȱ einenȱ Bitvektorȱ mitȱ denȱ Prozessoren,ȱ welcheȱ Kopienȱ beȬ sitzen,ȱ speichert.ȱ Durchȱ Auswertungȱ dieserȱ Einträgeȱ kannȱ jederzeitȱ bestimmtȱwerden,ȱwelcherȱCache,ȱwoȱaktualisiertȱwerdenȱmuss.ȱȱ

Directoryȱ

Eineȱ Konkretisierungȱ desȱ Konzeptesȱ derȱ Verzeichnisseȱ anȱ einemȱ SysȬ temȱ mitȱ 256ȱ Knoten,ȱ wobeiȱ jederȱ Knotenȱ ausȱ einerȱ CPUȱ undȱ 16MBȱ RAMȱbesteht,ȱerläutertȱTanenbaumȱ[Tȱ06].ȱStenströmȱ[Sȱ90]ȱuntersuchtȱ dieȱAnzahlȱderȱBitsȱzurȱSpeicherungȱderȱInformationȱfürȱjedenȱCacheȬȱ BlockȱundȱbetrachtetȱdannȱdenȱNetzwerkverkehrȱfürȱdasȱWriteȱInvaliȬ dateȱCacheȬProtokoll.ȱFürȱverschiedeneȱDirectoryȬSchemasȱführtȱStensȬ trömȱdannȱeineȱLeistungsoptimierungȱdurch.ȱHennessyȱundȱPattersonȱ [HPȱ06]ȱgebenȱeinȱDirectoryȬbasedȱCacheȱCoherenceȱProtocolȱmitȱdenȱ Zuständenȱ Invalid,ȱ Modifiedȱ undȱ Sharedȱ an.ȱ Imȱ Anhangȱ Cȱ erläutertȱ

51ȱ

2ȱȱRechnerarchitekturenȱfürȱParalleleȱundȱVerteilteȱSystemeȱ [HPȱ 06]ȱ dieȱ Cacheȱ Performanceȱ undȱ dieȱ darausȱ resultierendeȱ CacheȬ Optimierung.ȱȱȱ

2.2.3 Kreuzschienenschalter-basierte Multiprozessoren Crossbarȱ Switchȱ

Abb.ȱ2Ȭ8:ȱ Verbindungȱ vonȱ Prozessorenȱ undȱSpeicherȬ moduleȱmitȱ KreuzschieȬ nenschalterȱ

Beiȱ engȱ gekoppeltenȱ Multiprozessorenȱ wächstȱ derȱ Busverkehrȱ linearȱ mitȱ derȱ Anzahlȱ derȱ Prozessorenȱ an.ȱ Derȱ einzigeȱ Weg,ȱ denȱ ProzessorȬ SpeicherȬEngpassȱ zuȱ beseitigen,ȱ bestehtȱ darin,ȱ denȱ Hauptspeicherȱ inȱ mehrereȱ Moduleȱ aufzuteilenȱ undȱ mehrereȱ Pfadeȱ zwischenȱ dieȱ CPUsȱ undȱdieȱSpeichermoduleȱzuȱlegen.ȱDiesȱerhöhtȱnichtȱnurȱdieȱBandbreiteȱ derȱZugriffe,ȱsondernȱerlaubtȱauchȱdieȱparalleleȱAbarbeitungȱderȱSpeiȬ cherzugriffeȱ vonȱ verschiedenenȱ CPUsȱ zuȱ verschiedenenȱ SpeichermoȬ dulen.ȱDieȱeinfachsteȱSchaltung,ȱumȱnȱCPUsȱmitȱkȱSpeichermoduleȱzuȱ verbinden,ȱ istȱ einȱ Kreuzschienenschalterȱ (Crossbarȱ Switch)ȱ mitȱ n*kȱ Schalter,ȱwieȱuntenstehendeȱAbbildungȱ2.8ȱzeigt:ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ Jederȱ Kreuzungspunktȱ enthältȱ einenȱ Schalter,ȱ umȱ entwederȱ dieȱ horiȬ zontaleȱ oderȱ vertikaleȱ Linieȱ zuȱ verbinden.ȱ Beimȱ Zugriffȱ einesȱ ProzesȬ sorsȱ aufȱ einȱ bestimmtesȱ Speichermodulȱ wirdȱ derȱ entsprechendeȱ Pfadȱ durchgeschaltet.ȱ

FunktionsȬ weiseȱderȱ SpeicherzuȬ griffeȱ

52ȱ

Derȱ Vorteilȱ einesȱ Kreuzschienenschaltersȱ liegtȱ darin,ȱ dassȱ sichȱ zwiȬ schenȱ denȱ CPUsȱ undȱ denȱ Speichermodulenȱ einȱ nichtȱ blockierendesȱ Netzwerkȱ befindet.ȱ Dasȱ bedeutet,ȱ dassȱ keineȱ CPUȱ verzögertȱ werdenȱ muss,ȱ weilȱ sieȱ einenȱ bestimmtenȱ Kreuzungspunktȱ benötigtȱ oderȱ weilȱ eineȱ Leitungȱ besetztȱ ist.ȱ Natürlichȱ vorausgesetztȱ istȱ hierbei,ȱ dassȱ dasȱ

2.2ȱEngȱgekoppelteȱMultiprozessorenȱundȱMulticoreȬProzessorenȱ Speichermodulȱ verfügbarȱ istȱ undȱ somitȱ keinȱ andererȱ Prozessorȱ zurȱ gleichenȱZeitȱaufȱdasȱgleicheȱSpeichermodulȱzugreift.ȱ EinȱNachteilȱvonȱkreuzschienenschalterȬbasiertenȱMultiprozessorenȱist,ȱ dassȱdieȱAnzahlȱderȱKreuzungspunkteȱquadratischȱmitȱderȱAnzahlȱderȱ CPUsȱundȱSpeichermodulenȱwächst.ȱMitȱ100ȱCPUsȱundȱ100ȱSpeicherȬ modulenȱerhältȱmanȱ10ȱ000ȱKreuzungspunkteȱundȱsomitȱauchȱSchalter.ȱȱ KreuzschienenschalterȱsetztȱmanȱschonȱseitȱJahrzehntenȱinȱTelefonnetȬ zenȱein,ȱumȱeineȱGruppeȱankommenderȱLeitungenȱinȱbeliebigerȱWeiseȱ aufȱeineȱGruppeȱabgehenderȱLeitungenȱdurchzuschaltenȱ[Tȱ06].ȱȱȱ DerȱParallelrechnerȱIBMȱRS/6000ȱSPȱ[IRSȱ06]ȱistȱeinȱskalierbarerȱParalȬ lelrechnerȱ (SP:ȱ scalableȱ POWERparallel)ȱ dessenȱ Grundeinheitȱ soȱ geȬ nannteȱFramesȱsind.ȱEinȱFrameȱkannȱbisȱzuȱ16ȱKnotenȱbesitzen.ȱJeȱnachȱ Prozessortypȱ bestehtȱeinȱKnotenȱ ausȱ1ȱ bisȱ4ȱ Prozessoren.ȱ JederȱFrameȱ enthältȱeinenȱsoȱgenanntenȱHighȱPerformanceȱSwitchȱ(HPS),ȱderȱeinemȱ Kreuzschienenschalterȱ entspricht.ȱ Derȱ Rechnerȱ Sunȱ Fireȱ E25Kȱ [Tȱ 06]ȱ benutztȱebenfallsȱeinenȱKreuzschienenverteiler.ȱȱ

IBMȱRS/6000ȱ SPȱ

BeimȱAthlonȱ64ȱX2ȱundȱdemȱOpteronȱ[Aȱ06]ȱhängenȱbeideȱRechnerkerȬ neȱanȱeinemȱCrossbarȱSwitch.ȱÜberȱdiesenȱgreifenȱsieȱaufȱdenȱSpeicherȱ undȱdieȱPeripherieȱzu.ȱBeiȱderȱCacheȬVerwaltungȱhatȱAMDȱdieȱCacheȬ verwaltungȱ desȱ AlphaȬProzessorsȱ vonȱ DECȱ übernommen.ȱ Dieseȱ siehtȱ fünfȱ Bitsȱ zurȱ Markierungȱ vonȱ CacheȬZellenȱ vor:ȱ Modify,ȱ Owner,ȱ ExcȬ lusive,ȱ Sharedȱ undȱ Invalidȱ (MOESIȬProtokoll)ȱ [Hȱ 93].ȱ ȱ Überȱ einenȱ eigenenȱKanal,ȱdenȱ„SnoopȱChannel“,ȱkannȱeinȱKernȱdenȱStatusȱeinerȱ CacheȬZelleȱ desȱ anderenȱ abfragen,ȱ ohneȱ denȱ restlichenȱ Datentransferȱ zuȱbremsen.ȱȱ

Multicoreȱundȱ Crossbarȱ Switchȱȱ

2.2.4 Mehrebenennetzwerke-basierte Multiprozessoren Einȱ n*nȱ Mehrebenennetzwerk,ȱ oderȱ auchȱ OmegaȬNetzwerkȱ [Rȱ 97]ȱ geȬ nannt,ȱ verbindetȱ nȱ Prozessorenȱ mitȱ nȱ Speichermoduln.ȱ Dabeiȱ liegenȱ mehrereȱEbenenȱoderȱBänkeȱvonȱSchalternȱaufȱdemȱWegȱvomȱProzesȬ sorȱzumȱSpeicher.ȱIstȱnȱeineȱPotenzȱvonȱ2,ȱsoȱbenötigtȱmanȱlogȱnȱEbenenȱ undȱ n/2ȱ Schalterȱ proȱ Ebene.ȱ Dieȱ Schalterȱ habenȱ zweiȱ Eingängeȱ undȱ zweiȱ Ausgänge.ȱ Einȱ Prozessor,ȱ derȱ zumȱ Speicherȱ zugreifenȱ möchte,ȱ gibtȱ denȱ Zugriffswertȱ aufȱ dasȱ Speichermodulȱ alsȱ Bitwertȱ an.ȱ Dieseȱ Bitketteȱ enthältȱ fürȱ jedeȱ Ebeneȱ einȱ Kontrollbit.ȱ Derȱ Schalterȱ aufȱ derȱ Ebeneȱ iȱ entscheidetȱ dann,ȱ obȱ derȱ Eingabekanalȱ aufȱ denȱ oberenȱ oderȱ unterenȱAusgabekanalȱgelegtȱwird:ȱ x

IstȱdasȱKontrollbitȱfürȱdenȱSchalterȱeineȱNull,ȱsoȱwirdȱderȱEingangȱ mitȱdemȱoberenȱAusgangȱverbunden.ȱ

53ȱ

2 Rechnerarchitekturen für Parallele und Verteilte Systeme x

Ist das Kontrollbit für den Schalter eine Eins, so wird der Eingang mit dem unteren Ausgang verbunden.

Nachfolgende Abbildung 2-9 zeigt ein Netzwerk, das acht Prozessoren mit acht Speichermodulen verbindet. Weiterhin zeigt die Abbildung, wie Prozessor 3 eine Speicheranfrage an den Speichermodul 3 stellt. Das Speichermodul 3 hat den Bitwert 011, und diese Bitkette enthält die Kontrollbits für die drei Schalter. Abb. 2-9: 8*8 MehrebenenNetzwerk, wobei Prozessor 3 eine Anfrage an den Speichermodul 3 stellt

3 Ebenen Prozessor 0

Speicher 0

000

Prozessor 1

Speicher 1

001

Speicher 2

010

Speicher 3

011

Speicher 4

100

Speicher 5

101

Speicher 6

110

Speicher 7

111

Prozessor 2

1

Prozessor 3 Prozessor 4

1

Prozessor 5 Prozessor 6 Prozessor 7

blockierendes Netzwerk

54

0

Nehmen Sie nun an, dass parallel zum Zugriff von Prozessor 3 auf Speichermodul 3, Prozessor 7 auf Speichermodul 1 zugreifen möchte. Dabei kommt es zu einem Konflikt der beiden Speicheranfragen bei einem Schalter auf Ebene 1 und einer Verbindungsleitung zwischen einem Schalter der Ebene 1 und Ebene 2. Um die parallele Abfrage der beiden Prozessoren abzuarbeiten, muss eine Anfrage blockiert werden. Damit ist ein Mehrebenen-Netzwerk im Vergleich zu einem Kreuzschienenschalter ein blockierendes Netzwerk.

2.2ȱEngȱgekoppelteȱMultiprozessorenȱundȱMulticoreȬProzessorenȱ Engȱ gekoppelteȱ Multiprozessoren,ȱ welcheȱ alsȱ ProzessorȬ Speicherverbindungȱ einȱ MehrebenenȬNetzwerkȱ einsetzen,ȱ warenȱ inȱ denȱ 80erȱ Jahrenȱ dieȱ vonȱ BBNȱ Technologiesȱ (Bolt,ȱ Bernak,ȱ undȱ NewȬ man)ȱ gebautenȱ ButterflyȬMaschinen.ȱ [BBNȱ 89]ȱ [RTȱ 86]ȱ Butterflyȱ desȬ halb,ȱweilȱdieȱeingesetztenȱVerschaltungȱeinemȱSchmetterlingȱmitȱvierȱ Flügelnȱentsprechen.ȱEineȱButterflyȬMaschineȱkonnteȱbisȱzuȱ512ȱCPUsȱ mitȱ lokalemȱ Speicherȱ haben,ȱ undȱ durchȱ dasȱ MehrebenenȬNetzwerkȱ konnteȱ jedeȱ CPUȱ aufȱ denȱ Speicherȱ derȱ anderenȱ CPUsȱ zugreifen.ȱ Dieȱ eingesetztenȱ CPUsȱ warenȱ gewöhnlicheȱ CPUsȱ (Motorolaȱ 68020ȱ undȱ späterȱ Motorolaȱ 88100).ȱ Weitereȱ experimentelleȱ Multiprozessorenȱ mitȱ MehrebenenȬNetzwerkenȱwarenȱderȱRP3ȱvonȱIBMȱ[PBGȱ85]ȱmitȱbisȱzuȱ 512ȱProzessorenȱundȱderȱNYUȬUltracomputerȱ[GGKȱ83]ȱvonȱderȱNewȱ Yorkȱ Universityȱ mitȱ bisȱ zuȱ 4096ȱ Prozessoren.ȱ Dieȱ ButterflyȬMaschine,ȱ derȱ RP3ȱ undȱ derȱ NYUȬUltracomputerȱ gehörenȱ heuteȱ zurȱ Geschichteȱ desȱSupercomputing.ȱȱ

ȱ ȱ ȱ BBNȱButterflyȱ ȱ ȱ ȱ IBMȱRP3ȱȱ ȱ NYUȬUltraȬ computerȱ

2.2.5 Multicore-Prozessoren Durchȱ dieȱ Fortschritteȱ inȱ derȱ VLSIȬTechnologieȱ istȱ esȱ heuteȱ möglich,ȱ zweiȱ oderȱ mehrereȱ leistungsfähigeȱ CPUȬKerneȱ aufȱ einemȱ einzigenȱ Chipȱzuȱvereinen.ȱDieseȱCPUsȱhatȱjedeȱeinenȱeigenenȱCacheȱoderȱnutȬ zenȱ denȱ Cacheȱ undȱ Hauptspeicherȱ gemeinsamȱ undȱ sindȱ somitȱ engȱ gekoppelteȱ Multiprozessorenȱ aufȱ einemȱ Chip.ȱ Demgemäßȱ heißenȱ sieȱ auchȱMultiprocessorȱSystemsȬonȬChipȱ(MPSoc)ȱ[JWȱ05].ȱBeiȱzweiȱKerȬ nenȱ heißenȱ sieȱ DoppelkernȬProzessorȱ (DualȬCore),ȱ beiȱ vierȱ Kernenȱ sprichtȱ manȱ vonȱ einemȱ QuadȬCoreȬProzessorȱ undȱ mitȱ mehrerenȱ KerȬ nenȱheißenȱsieȱMehrkernȬProzessorȱ(ȱMulticoreȬProzessor).ȱȱ Inȱdenȱ90erȱJahrenȱstandȱdieȱTaktȬFrequenzȱvonȱMHzȱbisȱzuȱheuteȱvierȱ GHzȱ imȱ Vordergrundȱ zurȱ Leistungssteigerungȱ vonȱ CPUs.ȱ Dieserȱ Trendȱ wurdeȱ beschränkt,ȱ daȱ durchȱ dieȱ Erhöhungȱ derȱ TaktȬFrequenzȱ erhöhterȱStromverbrauchȱundȱerhöhteȱWärmeabgabeȱmitȱeinhergehenȱ [Boȱ 06],ȱ [Gȱ 01].ȱ Ausȱ diesemȱ Grundȱ wirdȱ heuteȱ versucht,ȱ durchȱ neueȱ Prozessorarchitekturenȱ undȱ derȱ Integrationȱ vonȱ mehrerenȱ CPUȬ Kernenȱ aufȱ einemȱ Chipȱ Leistungssteigerungenȱ zuȱ erhalten.ȱ Vonȱ denȱ bisherȱvorgestelltenȱHardwarearchitekturenȱSuperskalar,ȱSimultaneousȱ Multithreadingȱ undȱ MulticoreȬProzessorenȱ bringenȱ letztereȱ dieȱ besteȱ Leistungssteigerungȱ[HNOȱ97]ȱundȱbestätigenȱdiesenȱTrend.ȱȱ

Gründeȱfürȱ MulticoreȬ Prozessorenȱ

Beiȱ ChipȬMultiprozessorenȱ mitȱ wenigenȱ Kernenȱ herrschenȱ dieȱ beidenȱ Richtungenȱvorȱ[Tȱ06]:ȱ 1.ȱ Durchȱ Duplikationȱ derȱ Befehlspipelineȱ entstehenȱ mehrereȱ BeȬ fehlsausführungseinheiten.ȱ Eineȱ Fetch/DecodeȬInstruktionseinheitȱ

55ȱ

2ȱȱRechnerarchitekturenȱfürȱParalleleȱundȱVerteilteȱSystemeȱ führtȱ denȱ Ausführungseinheitenȱ dieȱ Arbeitȱ zu.ȱ Diesesȱ Vorgehenȱ entsprichtȱdenȱVektorrechnernȱvonȱfrüherȱ[HBȱ84].ȱ 2.ȱ Durchȱ denȱ Einsatzȱ vonȱ mehrerenȱ CPUs,ȱ jedeȱ mitȱ ihrerȱ eigenenȱ Fetch/DecodeȬEinheit,ȱ dieȱ wieȱ einȱ engȱ gekoppelterȱ Multiprozessorȱ arbeitet.ȱȱ ȱ Abb.ȱ2Ȭ10:ȱȱ a)ȱDuplikatiȬ onȱderȱ BefehlspipeȬ lineȱȱ b)ȱEinȱChipȱ mitȱzweiȱ Kernenȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ VonȱdenȱobigenȱinȱAbbildungȱ2Ȭ10ȱdargestelltenȱArchitekturenȱsetzenȱ sichȱinȱderȱletztenȱZeitȱhauptsächlichȱdieȱRichtungȱmehrereȱKerneȱaufȱ einemȱ Chipȱ (Multicore)ȱ unterzubringen,ȱ durch.ȱ Einȱ MulticoreȬ Prozessorȱheißtȱȱ

SymmetrischȬ erȱundȱasymȬ metrischerȱ MulticoreȬ Prozessorȱȱ

56ȱ

x

symmetrischȱoderȱhomogen,ȱwennȱalleȱKerneȱhomogenȱundȱgleichȱ sind.ȱEinȱfürȱdiesenȱProzessorȱübersetztesȱProgrammȱkannȱaufȱjeȬ demȱ beliebigenȱ seinerȱ Kerneȱ laufen.ȱ Dasȱ daraufȱ ablaufendeȱ BeȬ triebssystemȱ istȱ meistensȱ Symmetricȱ Multiprocessingȱ (SMP)Ȭȱ fäȬ hig.ȱȱ

x

asymmetrischȱ oderȱ heterogen,ȱ wennȱ dieȱ Kerneȱ unterschiedlichȱ sindȱ undȱ spezielleȱ Aufgabenȱ haben.ȱ Einȱ Programmȱ kannȱ nurȱ aufȱ einemȱ seinerȱ Übersetzungȱ entsprechendenȱ Kernȱ ausgeführtȱ werȬ den.ȱEinigeȱKerneȱarbeitenȱwieȱklassischeȱProzessoren,ȱandereȱwieȱ asynchroneȱCoprozessoren.ȱAufȱjedemȱProzessorkernȱläuftȱeinȱseȬ paratesȱ Betriebssystemȱ oderȱ eineȱ separateȱ Installationȱ desselbenȱ Betriebssystemsȱ[Sȱ06],ȱundȱdieserȱBetriebȱheißtȱAsymmetricȱMulȬ tiprocessingȱ(AMP).ȱEinsatzgebieteȱsolcherȱMulticoreȬProzessorenȱ

2.2ȱEngȱgekoppelteȱMultiprozessorenȱundȱMulticoreȬProzessorenȱ sindȱ eingebetteteȱ Systeme,ȱ insbesondereȱ audiovisuelleȱ UnterhalȬ tungselektronik,ȱ wieȱ zumȱ Beispielȱ Fernsehgeräte,ȱ DVDȬPlayer,ȱ Camcorder,ȱ Spielkonsolen,ȱ Mobiltelefoneȱ usw.ȱ [Tȱ 06].ȱ Eineȱ typiȬ scheȱ Architekturȱ fürȱ asymmetrischesȱ Multicoreȱ besitztȱ derȱ nachȬ folgendȱvorgestellteȱCellȬProzessorȱmitȱderȱCellȱBroadbandȱEngineȱ Architecture.ȱ SchonȱimȱJahrȱ2001ȱhatȱIBMȱdenȱPower4ȱProzessorȱ[Gȱ01]ȱ[BTRȱ02]ȱaufȱ denȱMarktȱgebrachtȱ(sieheȱAbbildungȱ2Ȭ11).ȱDemȱfolgteȱ2005ȱAMDȱmitȱ demȱ Dualȱ Coreȱ Opteronȱ [Aȱ 06]ȱ [KGAȱ 03]ȱ undȱ 2005/06ȱ Intelȱ mitȱ demȱȱ PentiumȱDȱundȱdemȱȱXeonȱDPȱ[Iȱ06].ȱ ȱ ȱ

Abb.ȱ2Ȭ11:ȱ Power4ȱChipȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ SunȱentwickeltȱdenȱNiagaraȱChipȱaufȱBasisȱdesȱULTRASparcȱmitȱvier,ȱ sechsȱ oderȱ achtȱ SPARCȬKernenȱ [KAOȱ 05],ȱ [Sȱ 07].ȱ Imȱ Gegensatzȱ zumȱ Power4ȱProzessor,ȱderȱeinenȱSharedȱL2ȱCacheȱbesitzt,ȱ(sieheȱAbb.ȱ2Ȭ11)ȱ besitztȱbeimȱNiagaraȱChipȱjederȱKernȱseinenȱeigenenȱL1ȬCacheȱundȱL2Ȭ Cache.ȱȱ

NiagaraȱChip

Toshiba,ȱ Sonyȱ undȱ IBMȱ entwickelnȱ seitȱ demȱ Jahrȱ 2000ȱ gemeinsamȱ eiȬ nenȱ Prozessorȱ namensȱ Cell,ȱ derȱ inȱ derȱ Playstationȱ 3ȱ läuftȱ undȱ inȱ HDTVȬGerätenȱ undȱ Servernȱ eingesetztȱ werdenȱ sollȱ [Cȱ 07]ȱ [KDHȱ 05]. Dieȱ Cellȱ Broadbandȱ Engineȱ Architectureȱ (CBEA)ȱ besitztȱ einenȱ 64ȱ Bitȱ PowerPCȬKernȱ (Powerȱ Processorȱ Elementȱ (PPE))ȱ undȱ achtȱ speziellȱ ausgelegteȱ„Synergistic“ȱKerneȱ(SynergisticȱProcessorȱElementsȱ(SPE))ȱ aufȱ einemȱ Chip,ȱ dieȱ mitȱ einemȱ HochgeschwindigkeitsȬBusȱ (Elementȱ Interconnectȱ Busȱ (EIB))ȱ verbundenȱ sind.ȱ Zusätzlichȱ aufȱ demȱ Chipȱ inȬ tegriertȱistȱeinȱHochgeschwindigkeitsȬSpeicherȬȱundȱeinȱȬI/OȬInterface.ȱȱȱ

Cellȱ

57ȱ

2ȱȱRechnerarchitekturenȱfürȱParalleleȱundȱVerteilteȱSystemeȱ SynergisȬ tischeȱ Architekturȱ

DasȱPowerȱProcessorȱElementȱ(PPE)ȱbesitztȱeineȱ32ȬKbyteȬInstruktionsȬȱ undȱ Datencacheȱ undȱ einenȱ 512ȬKbyteȱ großenȱ einheitlichenȱ Cacheȱ aufȱ derȱzweitenȱEbene.ȱZurȱReduktionȱderȱHauptspeicherzugriffeȱderȱachtȱ Synergisticȱ Processorȱ Elementsȱ (SPE)ȱ besitzenȱ sieȱ keinenȱ Cache,ȱ sonȬ dernȱ einenȱ 256ȬKbyteȱ großenȱ lokalenȱ Speicher.ȱ Zumȱ Datentransferȱ zwischenȱdemȱlokalenȱSpeicherȱundȱdemȱgemeinsamenȱHauptspeicherȱ überȱ denȱ Elementȱ Interconnectȱ Busȱ (EIB)ȱ [KPPȱ 06]ȱ besitztȱ jedeȱ SPEȱ einenȱMemoryȱFlowȱControllerȱ(MFC).ȱ Synergistischeȱ Architekturenȱ [GHFȱ 06]ȱ sindȱ Datenparallelitätȱ ausnutȬ zendeȱ Architekturenȱ undȱ unterstützenȱ einenȱ hohenȱ Threadȱ LevelȬ ParallelismusȱdurchȱeineȱVielzahlȱvonȱProzessorenȱaufȱeinemȱChip.ȱȱȱ

Abb.ȱ2Ȭ12:ȱ Cellȱ Broadbandȱ Engineȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

CellȱLinuxȱ

DasȱBetriebssystemȱfürȱdieȱCellȱBroadbandȱEngineȱArchitectureȱ(Abb.ȱ 2Ȭ12)ȱ ȱ istȱ Cellȱ Linux.ȱ Cellȱ Linuxȱ ist,ȱ wieȱ dieȱ restlicheȱ CellȬSoftware,ȱ Openȱ Source.ȱ Derȱ gegenwärtigeȱ Standȱ vonȱ Cellȱ Linuxȱ fürȱ dieȱ heteroȬ genenȱ Prozessoren,ȱ desȱ Laders,ȱ derȱ Compilerȱ undȱ CompilerprotopyȬ penȱundȱderȱToolsȱundȱdesȱDebuggersȱistȱinȱ[GEMȱ07]ȱbeschrieben.ȱ

80ȱCoreȬ Prototypȱvonȱ Intelȱ

AufȱderȱIntegratedȱSolidȱStateȱCircuitsȱConferenceȱ(ISSCC)ȱzeigteȱIntelȱ denȱ Prototypenȱ einesȱ TerascaleȬProzessorsȱ mitȱ 80ȱ Kernen.ȱ Dieȱ MultiȬ CoreȬCPUȱ sollȱ eineȱ Rechenleistungȱ vonȱ einemȱ Teraflopȱ bietenȱ undȱ

58ȱ

2.2ȱEngȱgekoppelteȱMultiprozessorenȱundȱMulticoreȬProzessorenȱ dabeiȱnurȱ62ȱWattȱbenötigen.ȱIntelȱpräsentierteȱdenȱ80ȱCoreȬPrototypenȱ aufȱ demȱ Intelȱ Developerȱ Forumȱ imȱ Septemberȱ 2006ȱ inȱ Sanȱ Francisco.ȱ DerȱComputerkonzernȱistȱmitȱdemȱPrototypȱeinesȱComputerchipsȱmitȱ 80ȱ Rechenkernenȱ eigenenȱ Angabenȱ zufolgeȱ inȱ eineȱ neueȱ Dimensionȱ vorgestoßen.ȱDerȱProzessorȱseiȱ„kaumȱgrößerȱalsȱeinȱFingernagel“ȱundȱ verbraucheȱmitȱ62ȱWattȱwenigerȱalsȱvieleȱheutigeȱherkömmlicheȱChips.ȱ Dieȱ Rechenleistungȱ liegeȱ imȱ TeraflopȬBereich.ȱ Dieȱ Marktreifeȱ seiȱ ca.ȱ 2010ȱerreicht.ȱȱ DieȱAusnutzungȱderȱIsolationȱderȱmehrerenȱCPUȱaufȱeinemȱChipȱzurȱ FehlerisolationȱundȱFehlertoleranzȱundȱdestruktiveȱAuswirkungenȱvonȱ FehlernȱaufȱdieȱLeistungȱsindȱinȱ[ARJȱ07]ȱanalysiertȱundȱbeschriebenȱ

2.2.5.1 Programmierung von Multicore-Architekturen Dieȱ effizienteȱ Nutzungȱ derȱ mehrerenȱ Kerneȱ istȱ nurȱ möglich,ȱ wennȱ entwederȱ mehrereȱ unabhängigeȱ Prozesseȱ oderȱ paralleleȱ leichtgewichȬ tigeȱ Prozesseȱ (Threads)ȱ zuȱ einemȱ Programmȱ gleichzeitigȱ ausgeführtȱ werden.ȱ Mitȱ anderenȱ Worten:ȱ Dieȱ Multicoreȱ Architekturenȱ künftigerȱ PCȬProzessorenȱ wirdȱ nurȱ dannȱ vernünftigȱ genutzt,ȱ wennȱ auchȱ StanȬ dardȬPCȬAnwendungenȱ mehrfädrigȱ implementiertȱ sind.ȱ Damitȱ entȬ stehtȱ dieȱ Notwendigkeit,ȱ StandardȬPCȬAnwendungenȱ zuȱ parallelisieȬ renȱ undȱ speziellȱ mehrfädrigȱ zuȱ implementieren.ȱ Dieȱ paralleleȬȱ undȱ ThreadȬProgrammierungȱ wirdȱ zumȱ Standardȱ undȱ verlässtȱ dieȱ Nischeȱ desȱHocheistungsrechnen.ȱ[Boȱ06].ȱ Dieȱ mehrfädrigeȱ Arbeitsweiseȱ hatȱ inȱ denȱ Prozessorenȱ zusätzlichȱ zumȱ Parallelismusȱ aufȱ Maschinenbefehlsebenenȱ (Simultaneousȱ MultithreaȬ ding)ȱ denȱ Parallelismusȱ aufȱ Programmebeneȱ eingeführt.ȱ Durchȱ dieȱ parallelȱ arbeitendenȱ Prozessorenȱ derȱ MulticoreȬArchitekturȱ verstärktȱ sichȱ derȱ Parallelismusȱ aufȱ Programmebeneȱ weiter.ȱ Soȱ habenȱ bereitsȱ heutigeȱ Prozessorchipsȱ bisȱ zuȱ achtȱ Prozessorenȱ zuȱ jeȱ vierȱ AusfühȬ rungspfaden,ȱ soȱ dassȱ aufȱ einemȱ Chipȱ bisȱ zuȱ 32ȱ Prozessorenȱ quasiȱ gleichzeitigȱausgeführtȱwerdenȱkönnenȱ(sieheȱAbbildungȱ2Ȭ13ȱ[Boȱ06]).ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

59ȱ

2ȱȱRechnerarchitekturenȱfürȱParalleleȱundȱVerteilteȱSystemeȱ ȱ Abb.ȱ2Ȭ13:ȱ MulticoreȬȱ Architekturȱ mitȱ8x4ȱ AusführungsȬ fädenȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ Durchȱ MulticoreȬArchitekturenȱ verstärktȱ sichȱ ebenfallsȱ dieȱ Kluftȱ zwiȬ schenȱ Arbeitsgeschwindigkeitȱ desȱ Prozessorchipsȱ undȱ derȱ SpeicherȬ chipsȱvorȱallem,ȱweilȱdieȱCoresȱeinesȱChipsȱinȱderȱRegelȱaufȱeinenȱgeȬ meinsamenȱ Hauptspeicherȱ zugreifen.ȱ Derȱ gemeinsameȱ Speicherȱ wirdȱ hierȱ ebenfallsȱ zumȱ Flaschenhals,ȱ weilȱ erȱ Befehleȱ undȱ Datenȱ fürȱ dieȱ Coresȱ liefernȱ mussȱ undȱ zusätzlichȱ zurȱ Kommunikationȱ zwischenȱ denȱ Coresȱ zurȱ Verfügungȱ steht.ȱ Einigeȱ Prozessorenȱ vonȱ Multicore– Architekturenȱ verfügenȱ z.B.überȱ einenȱ separatenȱ Cacheȱ derȱ 1.ȱ Stufeȱ (FirstȱlevelȱCache)ȱsowieȱeinenȱgemeinsamenȱCacheȱderȱ2.ȱStufeȱ(Seȱ condȱlevelȱCache).ȱZumȱTeilȱsindȱdieȱgemeinsamenȱCachesȱauchȱgrupȬ penweiseȱ organisiert.ȱ Einȱ andererȱ Wegȱ ist,ȱ dieȱ einzelnenȱ Prozessorenȱ mitȱ lokalemȱ Speicherȱ zuȱ versehen,ȱ soȱ wieȱ esȱ beiȱ denȱ Synergisticȱ ProȬ cessorȱElementsȱbeiȱdemȱCellȬProcessorȱvorliegt.ȱȱ Aufȱ derȱ Serverseiteȱ wirdȱ künftigȱ dieȱ erhöhteȱ Parallelitätȱ durchȱ dieȱ virtuellenȱparallelenȱProzessorenȱimplementiertȱwerden.ȱWobeiȱnatürȬ lichȱ paralleleȱ Serverȱ durchȱ Threadsȱ abgewickeltȱ werden.ȱ Eineȱ ServerȬ architekturȱ kannȱ dannȱ physischȱ ausȱ mehrerenȱ Multicorearchitekturenȱ bestehen,ȱundȱdieȱMulticoreȱProzessorenȱbildenȱeinenȱengȱgekoppeltenȱ Multiprozessor.ȱBeimȱCellȬProzessorȱbringtȱeinȱzentralerȱProzessor,ȱdasȱ PowerȱProcessorȱElement,ȱdieȱverschiedenenȱThreadsȱüberȱeinȱvirtuelȬ lesȱSchedulingȱLayerȱzumȱAblaufȱaufȱdieȱachtȱvorhandenenȱSynergisticȱ ProcessorȱElements.ȱDieȱvirtuelleȱSchedulingȬSchichtȱverteiltȱdabeiȱdenȱ ThreadȱanȱdasȱersteȱverfügbareȱSynergisticȱProcessorȬElement.ȱȱ ȱ ȱ

60ȱ

2.2 Eng gekoppelte Multiprozessoren und Multicore-Prozessoren

Virtuelle Prozesse

...

VP 1

VP 0

...

Abb. 2-14: Server mit heterogenen MulticoreBausteinen und virtuellen Prozessoren

VP n

Virtualisierung auf Systemebene Lastausgleich/Fehlertoleranz/Platzierung

defekt

Server mit Multicore

... P0

P1

P2

... P7

Multicore Chip 0

P0

P1

P2

P7

Multicore Chip 1

2.2.6 Multiprozessorbetriebssysteme Die zusätzlichen Aufgaben und Probleme eines Multiprozessor- oder Multicorebetriebssystems im Vergleich zu einem Uniprozessorbetriebssystem liegen in der Beherrschung und Ausnutzung der parallel zur Verfügung stehenden Prozessoren oder Kerne. Es lassen sich drei Typen des Betriebs von Multiprozessoren unterscheiden: 1.

Master Slave- oder gebündeltes Multiprocessing [S 06]: Eine einzige Installation eines Betriebssystems betreibt alle Prozessoren gleichermaßen.

Arten von Multiprozessorbetriebssystemen

61

2 Rechnerarchitekturen für Parallele und Verteilte Systeme 2.

Asymmetrisches Multiprocessing: Auf jedem Prozessorkern läuft ein separates Betriebssystem oder eine separate Installation desselben Betriebssystems. Eine Applikation kann nur auf einem bestimmten Prozessor laufen.

3.

Symmetrisches Multiprocessing: Eine einzige Installation eines Betriebssystems betreibt alle Prozessoren gleichermaßen. Applikationen und das Betriebssystem können auf jedem Prozessor laufen.

2.2.6.1 Master Slave Multiprocessing Master verwaltet alle Systemressourcen

Bei der Master-Slave-Organisation existiert ein ausgezeichneter Prozessor, der Master, welcher das Betriebssystem ausführt. Die restlichen Prozessoren sind identisch und bilden eine Ansammlung von Rechenprozessen, welche die Benutzerprozesse ausführen. Ein einziges Betriebssystem, der Master, hat den Überblick über alle Systemressourcen. Benötigt ein Prozess auf einem Slave-Prozessor einen Betriebssystemdienst z.B. zur Ein- Ausgabe, dann generiert er ein Interrupt und wartet darauf, bis der Master den Interrupt behandelt und somit die Dienstleistung zur Verfügung stellt. Dadurch können die Dienste des Betriebssystems dynamisch zugewiesen und von den Applikationen gemeinsam genutzt werden.

Master ist single point of failure und performance bottleneck

Betrachtet man das Master-Slave-Prinzip unter dem Gesichtspunkt der Zuverlässigkeit, dann bewirkt der Ausfall eines Slave-Prozessors nur eine Leistungsreduzierung. Der Ausfall des Masterprozessors bewirkt jedoch einen Totalausfall des Systems und ist somit ein einzelner Ausfallpunkt in dem System (single point of failure). Da alle Slaves den Master ansprechen und der Master alle Ressourcen verwalten muss, kann der Master zum Flaschenhals in dem Multiprozessorsystem werden, und der Leistungszuwachs durch Hinzunahmen von weiteren Slaves ist durch den Master beschränkt (der Master ist ein performance bottleneck).

62

2.2ȱEngȱgekoppelteȱMultiprozessorenȱundȱMulticoreȬProzessorenȱ

2.2.6.2 Asymmetrisches Multiprocessing Einȱ asymmetrischesȱ MultiprozessorȬSystemȱ kannȱ entwederȱ homogenȱ sein,ȱ wennȱ jederȱ Prozessorȱ denselbenȱ Typȱ undȱ dieselbeȱ Versionȱ einesȱ Betriebssystemsȱ betreibt,ȱ oderȱ heterogen,ȱ wennȱ jederȱ Prozessorȱ einȱ anderesȱBetriebssystemȱbetreibt,ȱsoȱdassȱbeispielsweiseȱaufȱeinemȱProȬ zessorȱ dasȱ QNXȱ Neutrinoȱ RTOSȱ läuftȱ undȱ aufȱ demȱ anderenȱ Linuxȱ [Sȱ 06].ȱ Inȱ einemȱ homogenenȱ Umfeldȱ könnenȱ sichȱ Entwicklerȱ mehrereȱ ProzessorenȱamȱbestenȱzuȱNutzeȱmachen,ȱindemȱsieȱeinȱBetriebssystemȱ mitȱeinemȱdezentralenȱProgrammiermodellȱwählen.ȱBeiȱsaubererȱImpȬ lementierungȱ könnenȱ dieȱ Applikationenȱ einesȱ Prozessorsȱ transparentȱ mitȱApplikationenȱundȱSystemdienstenȱwieȱGerätetreibernȱoderȱProtoȬ kollȬStacksȱ aufȱ anderenȱ Prozessorenȱ kommunizieren.ȱ Dieȱ hoheȱ CPUȬ Belastung,ȱ dieȱ fürȱ dieȱ herkömmlicheȱ Kommunikationȱ zwischenȱ ProȬ zessorenȱtypischȱist,ȱbleibtȱhierȱaus.ȱ

Homogenesȱ oderȱ heterogenesȱ asymȬ metrischesȱ MultiȬ processingȱ

Dieȱ Ausführungsumgebungȱ desȱ asymmetrischenȱ Multiprocessingsȱ ähneltȱderȱeinesȱkonventionellenȱUniprozessorȬSystems.ȱFolglichȱbietetȱ asymmetrischesȱ Multiprocessingȱ einenȱ relativȱ direktenȱ Pfadȱ fürȱ dieȱ Portierungȱ vonȱ AltȬCode.ȱ Einȱ direkterȱ Steuermechanismusȱ fürȱ denȱ Gebrauchȱ derȱ CPUȬKerneȱ istȱ ebenfallsȱ vorhanden.ȱ Inȱ derȱ Regelȱ lässtȱ sichȱauchȱmitȱstandardisiertenȱDebugȬToolsȱundȱȬTechnikenȱarbeiten.ȱȱ

AsymȬ metrischesȱ MultiȬ processingȱ arbeitetȱwieȱ UniprozessorȬ betriebsȬ systemȱȱ

MitȱasymmetrischemȱMultiprocessingȱkönnenȱEntwicklerȱentscheiden,ȱ wieȱ gemeinsameȱ HardwareȬRessourcenȱ fürȱ dieȱ Applikationenȱ zwiȬ schenȱ denȱ einzelnenȱ Prozessorenȱ aufgeteiltȱ werden.ȱ Normalerweiseȱ findetȱdieȱBereitstellungȱderȱRessourcenȱwährendȱdesȱBootensȱstatischȱ stattȱundȱumfasstȱSpeicherreservierungȱaufȱphysikalischerȱEbene,ȱPeriȬ pherienutzungȱ undȱ InterruptȬBehandlung.ȱ Wennȱ dasȱ Systemȱ dieȱ ResȬ sourcenȱauchȱdynamischȱzuweisenȱkönnte,ȱwürdeȱdiesȱdieȱKoordinatiȬ onȱzwischenȱdenȱProzessorenȱkomplizierterȱmachen.ȱȱ Inȱ einemȱ asymmetrischenȱ MultiprocessingȬSystemȱ läuftȱ einȱ Prozessȱ immerȱaufȱdemselbenȱProzessor,ȱsogarȱwennȱandereȱnichtȱinȱGebrauchȱ sind.ȱFolglichȱkönnenȱProzessorenȱzuȱstarkȱoderȱzuȱschwachȱausgelasȬ tetȱ sein.ȱ Umȱ diesemȱ Problemȱ zuȱ begegnen,ȱ könnteȱ dasȱ Systemȱ denȱ Applikationenȱ erlauben,ȱ zwischenȱ denȱ Prozessorenȱ nachȱ Bedarfȱ zuȱ wechseln.ȱ Diesȱ könnteȱ allerdingsȱ zuȱ Problemenȱ beiȱ derȱ Übertragungȱ derȱ ProzessȬZustandsinformationenȱ vonȱ einemȱ Prozessorȱ aufȱ denȱ anȬ derenȱ oderȱaberȱ zuȱ Unterbrechungenȱführen,ȱ daȱ eineȱ Applikationȱ aufȱ einemȱProzessorȱgestopptȱundȱaufȱdemȱanderenȱneuȱgestartetȱwerdenȱ mussȱ –ȱ beiȱ unterschiedlichenȱ Betriebssystemenȱ eineȱ schwierige,ȱ wennȱ nichtȱsogarȱunmöglicheȱOption.ȱȱ

Keineȱ Lastverteilungȱ beiȱȱasymȬ metrischemȱ MultiȬ processingȱ ȱ

63ȱ

2ȱȱRechnerarchitekturenȱfürȱParalleleȱundȱVerteilteȱSystemeȱ FürȱdieȱUnterstützungȱvonȱasymmetrischemȱMultiprocessingȱmussȱeinȱ MultiprozessorȱüberȱeineȱAbstraktionsschichtȱverfügen,ȱdieȱbestimmteȱ Ressourcenȱ fürȱ jedenȱ Prozessorȱ gleichȱ erscheinenȱ lässt.ȱ Einȱ Beispielȱ dafürȱ wäreȱ dieȱ Virtualisierungȱ x86Ȭbasierterȱ MulticoreȬProzessorenȱ [Sȱ 06].ȱ Nachteileȱ Asymmetrieȱ

AsymmetrischeȱMultiprozessorȬApplikationen,ȱdieȱaufȱeinenȱProzessorȱ festgelegtȱ sind,ȱ sindȱ nichtȱ inȱ derȱ Lage,ȱ beiȱ Bedarfȱ andereȱ Prozessorenȱ zuȱ nutzen,ȱ selbstȱ wennȱ dieseȱ nichtȱ inȱ Gebrauchȱ sind.ȱ Dasȱ heißt,ȱ derȱ EntwicklerȱsollteȱToolsȱnutzen,ȱdieȱdenȱNutzungsgradȱderȱRessourcenȱ inklusiveȱ CPUȱ analysieren.ȱ Diesȱ geschiehtȱ proȱ Applikationȱ undȱ zeigtȱ denȱ optimalenȱ WegȱzurȱVerteilungȱ derȱ Applikationenȱaufȱdieȱ ProzesȬ sorenȱbeiȱmaximalerȱPerformance.ȱWennȱdasȱBetriebssystemȱauchȱüberȱ „Hooks“ȱverfügt,ȱumȱdenȱgewünschtenȱProzessorȱdynamischȱzuȱwechȬ seln,ȱ bestehtȱ dieȱ Freiheit,ȱ dynamischȱ zwischenȱ denȱ Prozessorenȱ zuȱ wechseln,ȱ ohneȱ Checkpointsȱ oderȱ Applikationsstartȱ undȱ Ȭstoppȱ zuȱ berücksichtigen.ȱ

Vorteileȱ Asymmetrieȱ

ImȱGegensatzȱzuȱdemȱnachfolgendȱbeschriebenenȱSymmetrischenȱMulȬ tiprocessingsȱ ergebenȱ sichȱ beimȱ asymmetrischenȱ Fallȱ natürlichȱ auchȱ Vorteile.ȱ Soȱ wirdȱ ausgeschlossen,ȱ dassȱ dieȱ CacheȬInhalteȱ ständigȱ unȬ gültigȱ werden,ȱ indemȱ Applikationenȱ mitȱ gemeinsamerȱ Datennutzungȱ exklusivȱ aufȱ demselbenȱ Prozessorȱ laufen.ȱ Derȱ mitȱ einerȱ CacheȬ Invalidierungȱ einhergehendeȱ PerformanceȬVerlustȱ inȱ einemȱ SMPȬ Systemȱ bleibtȱ somitȱ aus.ȱ Auchȱ dasȱ Debuggenȱ einerȱ Applikationȱ läuftȱ einfacherȱabȱalsȱbeiȱSMP,ȱdaȱalleȱausführendenȱThreadsȱinȱeinerȱAppliȬ kationȱ aufȱ demselbenȱ Prozessorȱ laufen.ȱ Ausȱ demȱ gleichenȱ Grundȱ lasȬ senȱ sichȱ mitȱ asymmetrischenȱ Multiprocessingȱ auchȱ ältereȱ ApplikatioȬ nenȱfürȱUniprozessorenȱfehlerfreiȱbetreiben.ȱ

2.2.6.3 Symmetrisches Multiprocessing (SMP) BeimȱsymmetrischenȱMultiprocessingȱsindȱalleȱProzessorenȱfunktionalȱ identischȱ undȱ bildenȱ eineȱ Ansammlungȱ vonȱ anonymenȱ Ressourcen.ȱ AlleȱanderenȱHardwareȬRessourcen,ȱwieȱHauptspeicherȱundȱEinȬȱAusȬ gabegeräte,ȱ stehenȱ allenȱ Prozessorenȱ zurȱ Verfügung.ȱ Fallsȱ einȱ oderȱ einigeȱ Prozessorenȱ undȱ nichtȱ alleȱ Zugriffȱ habenȱ aufȱ beispielsweiseȱ spezielleȱEinȬAusgabegeräte,ȱbezeichnetȱmanȱdasȱSystemȱalsȱasymmetȬ risch.ȱ Vorteileȱdesȱ SMPȱfürȱdenȱ Anwenderȱ

64ȱ

BeimȱsymmetrischenȱMultiprocessingȱ(SMP)ȱarbeitenȱalleȱProzessorenȱ mitȱ einemȱ einzigenȱ Betriebssystem.ȱ Daȱ fürȱ dasȱ Betriebssystemȱ alleȱ Systemelementeȱ zuȱ jederȱ Zeitȱ sichtbarȱ sind,ȱ kannȱ esȱ Ressourcenȱ aufȱ denȱverschiedenenȱProzessorenȱbereitstellenȱ–ȱundȱdasȱohneȱVorgabenȱ desȱApplikationsentwicklers.ȱDarüberȱhinausȱkannȱdasȱBetriebssystemȱ

2.2ȱEngȱgekoppelteȱMultiprozessorenȱundȱMulticoreȬProzessorenȱ integrierteȱ Standardfunktionenȱ liefern,ȱ wieȱ zumȱ Beispielȱ pthread_mutex_lock,ȱpthread_mutex_unlock,ȱȱpthread_ spin_lockȱ undȱ pthread_spin_unlock.ȱ Dieseȱ Funktionenȱ lassenȱ mehrereȱ Applikationenȱ aufȱ dieseȱ Ressourcenȱ sicherȱ undȱ einfachȱ zuȬ greifen.ȱDaȱnurȱeinȱBetriebssystemȱexistiert,ȱkannȱdiesesȱbeiȱsymmetriȬ schemȱ Multiprocessingȱ nachȱ Bedarfȱ bestimmtenȱ Applikationenȱ –ȱ undȱ nichtȱ denȱ Prozessorenȱ –ȱ Ressourcenȱ zuordnenȱ undȱ erreichtȱ soȱ eineȱ bessereȱ HardwareȬAuslastung.ȱ Zudemȱ könnenȱ SystemȬTracingȬToolsȱ BetriebsstatistikenȱundȱApplikationsinteraktionenȱfürȱalleȱProzessorenȱ sammeln,ȱsoȱdassȱderȱEntwicklerȱdieȱApplikationenȱbesserȱoptimierenȱ undȱdebuggenȱkann.ȱDieȱSynchronisierungȱderȱApplikationenȱistȱdarȬ überȱ hinausȱ einfacher,ȱ weilȱ Entwicklerȱ Standardfunktionenȱ desȱ BeȬ triebssystemsȱundȱvonȱUniprozessorsystemenȱbewährteȱSynchronisatiȬ onsverfahren,ȱanȱStelleȱkomplexerȱNachrichtenȬbasierterȱMechanismen,ȱ verwendenȱkönnen.ȱ Einȱ Entwicklerȱ mussȱ nochȱ nichtȱ einmalȱ spezielleȱ APIsȱ oderȱ eineȱ speȬ zielleȱ Programmierspracheȱ anwenden.ȱ Einȱ Betriebssystemȱ mitȱ SMPȬ UnterstützungȱverteiltȱdieȱLastȱselbstständigȱaufȱmehrereȱProzessoren.ȱ DerȱPOSIXȬStandard,ȱvorȱallemȱdasȱPthreadȬAPI,ȱwirdȱseitȱvielenȱJahȬ renȱ erfolgreichȱ inȱ HighȬendȬSMPȬUmgebungenȱ eingesetzt.ȱ Code,ȱ derȱ dieȱ POSIXȬSchnittstellenȱ nutzt,ȱ läuftȱ aufȱ Uniprozessorenȱ undȱ MultiȬ prozessorenȱgleichermaßen.ȱBeiȱeinigenȱBetriebssystemenȱkönnenȱdieȬ selbenȱBinärȬCodesȱsogarȱaufȱUniȬȱundȱMultiprozessorenȱlaufen.ȱȱ

2.2.6.3.1 Floating Master Beiȱ derȱ einfachstenȱ Formȱ derȱ symmetrischenȱ Organisation,ȱ Floatingȱ Masterȱ genannt,ȱ istȱ dasȱ kompletteȱ Betriebssystemȱ selbstȱ einȱ einzigerȱ kritischerȱAbschnitt.ȱZuȱverschiedenenȱZeitpunktenȱkannȱdasȱBetriebsȬ systemȱ aufȱ verschiedenenȱ Prozessorenȱ ausgeführtȱ werden.ȱ Dasȱ BeȬ triebssystemȱ„floats“ȱvonȱeinemȱProzessorȱaufȱdenȱNächsten.ȱDadurchȱ sindȱ dieȱ Zugriffeȱ zuȱ gemeinsamenȱ Datenstrukturenȱ desȱ BetriebssysȬ temsȱ serialisiert,ȱ undȱ Konflikteȱ beimȱ Zugriffȱ aufȱ gemeinsameȱ DatenȬ strukturenȱwerdenȱvermieden.ȱȱ

Organisationȱ einesȱSMPȬ fähigenȱ BetriebsȬ systemsȱ

Voraussetzungȱ fürȱ dieseȱ Organisationȱ istȱ natürlich,ȱ dassȱ dieȱ Listeȱ derȱ bereitenȱProzesseȱimȱgemeinsamenȱHauptspeicherȱliegt.ȱBetrachtenȱSieȱ dazuȱ dasȱ Systemȱ inȱ nachfolgenderȱ Abbildungȱ 2Ȭ15,ȱ dasȱ ausȱ dreiȱ ProȬ zessorenȱ undȱ sechsȱ Prozessen,ȱ dieȱ teilweiseȱ rechnend,ȱ bereitȱ undȱ bloȬ ckiertȱ sind,ȱ besteht.ȱ Alleȱ Prozesseȱ liegenȱ imȱ gemeinsamenȱ HauptspeiȬ cherȱ undȱ dreiȱ davonȱ werdenȱ ausgeführt:ȱ Prozessȱ Aȱ aufȱ derȱ CPUȱ 1,ȱ ProzessȱBȱaufȱderȱCPUȱ2ȱundȱProzessȱCȱaufȱderȱCPUȱ3.ȱDieȱProzesseȱDȱ undȱEȱliegenȱimȱHauptspeicherȱundȱwarten,ȱbisȱsieȱanȱderȱReiheȱsind.ȱ Prozessȱ Fȱ liegtȱ ebenfallsȱ imȱ Hauptspeicherȱ undȱ wartet,ȱ bisȱ erȱ debloȬ

Arbeitsweiseȱ einesȱSMPȬ fähigenȱ BetriebsȬ systemsȱ

65ȱ

2ȱȱRechnerarchitekturenȱfürȱParalleleȱundȱVerteilteȱSystemeȱ ckiertȱ wird.ȱ Nehmenȱ Sieȱ nunȱ an,ȱ dassȱ Bȱ sichȱ blockiert,ȱ weilȱ z.B.ȱ seineȱ Zeitscheibeȱ abgelaufenȱ ist.ȱ CPUȱ 2ȱ mussȱ Prozessȱ Bȱ suspendierenȱ undȱ einenȱanderenȱlauffähigenȱProzessȱfinden.ȱDieȱCPUȱ2ȱbeginntȱnunȱmitȱ derȱAusführungȱvonȱBetriebsystemcode,ȱderȱimȱgemeinsamenȱHauptȬ speicherȱ liegt.ȱ Nachdemȱ dieȱRegisterȱ vonȱ Prozessȱ Bȱ gerettetȱ sind,ȱ ruftȱ CPUȱ2ȱdenȱSchedulerȱdesȱBetriebsystemsȱauf,ȱumȱeinenȱanderenȱlaufȬ fähigenȱProzessȱzuȱfinden.ȱDurchȱZugriffȱaufȱdieȱBereitlisteȱkannȱdortȱ derȱ ersteȱ Eintrag,ȱ nämlichȱProzessȱ D,ȱ entferntȱ werdenȱ undȱ CPUȱ2ȱ beȬ ginntȱmitȱderȱAusführungȱvonȱProzessȱD.ȱ Inhaltȱdesȱ Cachesȱbeiȱ einemȱ ProzessȬ wechselȱ

NachȱdemȱUmschaltenȱaufȱdenȱneuenȱProzessȱ DȱwerdenȱvieleȱCacheȬ Fehlerȱauftreten,ȱdaȱderȱCacheȱvonȱCPUȱ2ȱnochȱdenȱCodeȱundȱdieȱDaȬ tenȱ vonȱ Prozessȱ 2ȱ enthält.ȱ Nachȱ einerȱ gewissenȱ Zeitȱ enthältȱ dannȱ derȱ Cacheȱ nurȱ nochȱ Codeȱ undȱ Datenȱ vonȱ Prozessȱ D.ȱ Ausȱ diesemȱ Grundȱ sollteȱ einȱ Prozess,ȱ z.ȱ B.ȱ fallsȱ erȱ eineȱ EinȬȱ Ausgabeȱ tätigt,ȱ nichtȱ sofortȱ vomȱ Prozessorȱ genommenȱ werden,ȱ sondernȱ derȱ Prozessȱ sollteȱ inȱ beȬ stimmtenȱFällenȱaktivȱwartenȱundȱaufȱdemȱProzessorȱverbleiben.ȱEbenȬ fallsȱ istȱ esȱ günstig,ȱ fallsȱ derȱ Prozessȱ vonȱ einemȱ Prozessorȱ genommenȱ wurdeȱundȱderȱProzessorȱinȱderȱZwischenzeitȱuntätigȱwar,ȱdenȱProzessȱ wiederȱ aufȱ denȱ gleichenȱ Prozessorȱ zuȱ laden,ȱ daȱ derȱ Cacheȱ nochȱ denȱ Codeȱ undȱ dieȱ Datenȱ desȱ altenȱ Prozessesȱ undȱ somitȱ auchȱ desȱ neuenȱ gleichenȱProzessesȱenthält.ȱȱȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

ȱ

66ȱ

ȱ

2.2 Eng gekoppelte Multiprozessoren und Multicore-Prozessoren Abb. 2-15: Arbeitsweise des symmetrischen Multiprocessing

Das Prinzip des Floating Master ist ein erster und einfacher Schritt, um ein bestehendes monolithisches Uniprozessorbetriebssystem, z.B. Unix, auf ein eng gekoppeltes Multiprozessorsystem oder einen MulticoreProzessor zu portieren.

2.2.6.4 Lock-Synchronisation Das Prinzip des Floating Master erlaubt jedoch nicht die parallele Ausführung des Betriebssystems auf mehreren Prozessoren. Dies ist ein großer Nachteil, da sich besonders bei Unix-Systemen die Prozesse zu 1/3 ihrer Laufzeit im Betriebssystemmodus befinden. Um Teile des Betriebssystems parallel auf mehreren Prozessoren auszuführen, muss das Betriebssystem in Form von mehreren parallelen und voneinander unabhängigen Prozessen und Tasks vorliegen. Der Zugriff der parallelen Tasks zu gemeinsamen Datenstrukturen muss dann unter wechselseitigem Ausschluss geschehen.

Parallele Ausführung von Betriebssystemcode

67

2 Rechnerarchitekturen für Parallele und Verteilte Systeme Sperren der Daten erlaubt mehr Parallelität

Weiterhin ist das Standardkonstrukt des kritischen Abschnitts, bei dem die Sektion des Codes, welcher die Daten modifiziert und somit eine weitere parallele Ausführung durch andere Prozesse nicht zulässt, bei Multiprozessor-Betriebssystemen nicht angebracht. Ein besseres Vorgehen ist, die Daten selbst zu sperren, anstatt den Code, der die Daten manipuliert. Das Sperren von individuellen Daten erlaubt allen anderen Prozessen fortzufahren, soweit sie nicht die gemeinsamen Daten manipulieren. Dies erlaubt mehr Parallelität und ist damit effizienter. Das Sperren von Daten anstatt von Code bedingt ein objektorientiertes Vorgehen, d.h. dass die Daten zusammen mit ihren Zugriffsfunktionen vorliegen. Die Zugriffsfunktionen realisieren dann den wechselseitigen Ausschluss beim Zugriff auf die Daten.

Interruptsperre bei SMP keine Lösung

Primitive Methoden für den wechselseitigen Ausschluss, wie das Sperren von Interrupts und das temporäre Anheben von Prozessprioritäten sind bei Multiprozessorsystemen nicht anwendbar. Die disableInterrupt- und enable-Interrupt-Instruktion wirkt nur auf den lokalen Prozessor und nicht auf die anderen im System vorhandene Prozessoren.

2.2.6.4.1 Test and Set (TAS) Test and Set

Bei Multiprozessorsystemen lässt sich zur Synchronisation der Test und Set (TAS)-Befehl [M 99] einsetzen. Der TAS-Befehl benutzt zwei Parameter: 1. Can_Not_Enter: Kann der Prozess in den kritischen Abschnitt eintreten? 2. Active: Eine globale Variable, die anzeigt, ob ein anderer Prozess im kritischen Abschnitt ist, und ob möglicherweise der kritische Abschnitt gesperrt (lock) ist. Die Hardware des TAS-Befehls garantiert die Unteilbarkeit der TASOperation Der Ablauf des Hardwarebefehls TAS hat folgende softwaretechnische Beschreibung und sieht folgendermaßen aus :

Programm 2-1: Ablauf des TAS-Befehls

68

procedure TAS (Can_Not_Enter : out BOOLEAN, Active : in out BOOLEAN) is begin Can_Not_Enter := Active; if Active = FALSE then Active := TRUE; end if; end TAS;

2.2 Eng gekoppelte Multiprozessoren und Multicore-Prozessoren Das Essentielle an der TAS-Instruktion ist die unteilbare Operation des Testens (Read) und anschließenden Setzens (Write) der globalen Variablen Active. Bei Multiprozessoren ohne Cache benötigt man für diese zwei Speicherzyklen einen unteilbaren read-modify-write-Zyklus auf dem Systembus. Bei cache-basierten Multiprozessoren, also mit Cache für jede CPU, setzt das MESI-Cachekohärenz-Protokoll die globale Variable Active auf den Zustand Shared. Dadurch fällt dann für das mehrmalige Ausführen des TAS-Befehls kein Busverkehr an.

2.2.6.4.2 Exchange (XCHG) Die Mikroprozessorfamilie IAPX-86 von Intel stellt einen Austauschbefehl Exchange (XCHG) als unteilbare Operation auf einem einzigen Prozessor zur Verfügung [M 99]. Der Hardwarebefehl XCHG hat folgende Wirkung:

eXCHanGe

procedure XCHG (Can_Not_Enter : out BOOLEAN, Active : in out BOOLEAN) is Temp : BOOLEAN; begin Temp := Active; Active := Can_Not_Enter; Can_Not_Enter := Temp; end XCHG;

Programm 2-2: Ablauf des XCHGBefehls

Um die Unteilbarkeit des XCHG-Befehls auf Multiprozessoren ohne Cache sicherzustellen, benötigt man einen systemweiten LOCK-Befehl, welcher den Bus sperrt.

2.2.6.4.3 Spinlocking Mit dem TAS- oder XCHG-Befehl lässt sich ein aktives Warten realisieren. Kann der Prozess den kritischen Abschnitt nicht betreten, muss er also warten, und verbleibt auf dem Prozessor und durchläuft eine Schleife, bis der kritische Abschnitt frei ist. Diese Methode heißt Spinlocking, das aktive Warten in der Schleife selbst ist das Spinning. Die Spin-Lock-Funktionen sind spin_lock() und spin_unlock() und haben mit dem TAS- oder XCHG-Befehl folgende Implementierung:

aktives Warten

procedure spin_lock (Active : out BOOLEAN) is Can_Not_Enter : BOOLEAN; begin Can_Not_Enter := TRUE; while Can_Not_Enter loop -- with TAS-Instruction TAS (Can_Not_Enter, Active);

Programm 2-3: spin_lock, spin_unlock

69

2 Rechnerarchitekturen für Parallele und Verteilte Systeme -- or with XCHG-Instruction -- XCHG(Can_Not_Enter, Active); end loop; end spin_lock; procedure spin_unlock (Active : out BOOLEAN) is begin Active := FALSE; end spin_unlock; Vorteile von Spin-Locks bei Multiprozessoren mit Cache

Das aktive Warten, und damit das Verschwenden von Prozessorzeit bei Spin_Locks, ist besonders bei Multiprozessoren mit Caches angebracht. Viele Ressourcen sind nur für einige Millisekunden gesperrt, und ein Prozesswechsel würde zeitaufwendiger sein und den Cache korrumpieren, als den alten Prozess warten zu lassen und mit dem bestehenden Cacheinhalt weiter arbeiten zu lassen

Read/Write Spin Locks

Zur Erhöhung der Parallelität innerhalb des Betriebssystemkerns bietet Linux zusätzlich Read/Write Spin Locks (read_lock, read_unlock und write_lock, write_unlock) an [BC 03]. Diese sind angebracht für Datenstrukturen, die von vielen Lesern gelesen, aber nur von wenigen Schreibern geschrieben werden.

2.2.6.4.4 Semaphore Das aktive Warten lässt sich vermeiden, falls der Prozess nicht aktiv wartet, sondern in eine Warteschlange verbracht wird. Das Eingliedern und spätere Entnehmen des Prozesses in und aus der Warteschlange erfordert jedoch mehrere Operationen. Die Warteschlange selbst ist eine gemeinsame Datenstruktur, auf die unter wechselseitigem Ausschluss zuzugreifen ist. D.h. der Zugriff auf die Warteschlange muss durch die spin_lock- und spin_unlock-Funktion umschlossen werden. P- und VOperationen

70

Durch dieses Vorgehen erhält man einen Queued Lock oder die bekannten Semaphore mit den P- und V-Operationen von Dijkstra [D 65]. Die Unteilbarkeit der P- und V-Operationen ist dabei nicht durch das Sperren von Interruptroutinen realisiert, sondern durch die spin_lock() und spin_unlock() Funktionen.

2.2ȱEngȱgekoppelteȱMultiprozessorenȱundȱMulticoreȬProzessorenȱ Active : BOOLEAN := FALSE; procedure P (S : in out Sema_Type) is begin spin_lock (Active); S.Counter := S.Counter – 1; if S.Counter < 0 then Enter_Last(S.Sema_Queue,Get_Running_PCB); spin_unlock (Active); -- Block the Process Block; else spin_unlock (Active); end if; end P;

Programmȱ2Ȭ4:ȱ ImplementieȬ rungȱderȱPȬȱ undȱVȬ Operationȱmitȱ spin_lockȱundȱ spin_unlockȱ

procedure V (S ; in out Sema_Type) is begin spin_lock (Active); S.Counter := S.Counter + 1; if S.Counter <= 0 then Process_PCB_Help := Get_First (S.Sema_Queue); -- Unblock the Process Ready; -- Remove Element from Sema_Queue Remove (S.Sema_Queue, Process_PCB_Help); end if; spin_unlock (Active); end V; Dieȱ obigenȱ Prozedurenȱ beschreibenȱ dasȱ exemplarischeȱ Vorgehen,ȱ dasȱ hierȱ didaktischȱ ausgelegtȱist.ȱ Dieȱ konkreteȱ CȬImplementierungȱderȱ P–ȱ undȱVȬOperationenȱinȱLinuxȱkannȱbeiȱBovetȱundȱCesatiȱ[BCȱ03]ȱnachȬ gelesenȱ werden.ȱ Weitereȱ Vorschlägeȱ zurȱ Implementierungȱ vonȱLocks,ȱ nebenȱdemȱhierȱvorgestelltenȱSpinȬȱundȱQueuedȬLockȱsindȱinȱ[GTȱ90]ȱ enthalten.ȱ

2.2.6.4.5 Compare and Swap (CAS) DieȱCompareȱandȱSwapȬCPUȬInstruktionȱ(CASȱoderȱCMPXCHG)ȱverȬ gleichtȱ atomarȱ denȱ Inhaltȱ vonȱ einerȱ Speicherlokationȱ Xȱ mitȱ einemȱ geȬ gebenenȱWertȱOld, undȱwennȱsieȱgleichȱsind,ȱsetztȱsieȱdenȱInhaltȱderȱ SpeicherlokationȱXȱaufȱeinenȱneuenȱWertȱNew.ȱDasȱErgebnisȱderȱOperaȬ tionȱistȱeineȱIndikation,ȱobȱdieȱErsetzungȱOldȱdurchȱNewȱstattgefundenȱ hatȱoderȱnicht.ȱDerȱatomareȱCASȬBefehlȱhatȱsomitȱfolgendeȱWirkung:ȱȱ

CASȬBefehl

71ȱ

2ȱȱRechnerarchitekturenȱfürȱParalleleȱundȱVerteilteȱSystemeȱ Programmȱ2Ȭ5:ȱ Ablaufȱdesȱ CASȬBefehlsȱ

function CAS (X : out REFERENCE, Old: in VARIABLE, New: in VARIABLE) return BOOLEAN is begin if CONT(X) == Old then X:= New; return TRUE; else return FALSE; end if; end CAS; Ersetztȱ manȱ Oldȱ mitȱ Activeȱ undȱ Newȱ mitȱ Inactive,ȱ soȱ kannȱ mitȱ demȱCASȬBefehlȱgetestetȱwerden,ȱobȱeinȱandererȱProzessȱimȱkritischenȱ Abschnittȱ warȱ undȱ somitȱ Activeȱ istȱ oderȱ obȱ erȱ Inactiveȱ warȱ undȱ somitȱnichtȱimȱkritsichenȱAbschnittȱwar.ȱȱ

Programmȱ2Ȭ6:ȱ Ablaufȱdesȱ CASȬBefehlsȱ

function CAS (X : out REFERENCE, Inactive: in VARIABLE, Active: in VARIABLE) return BOOLEAN is begin if CONT(X) == Inactive then X:= Active; return TRUE; else return FALSE; end if; end CAS; DamitȱlassenȱsichȱmitȱdemȱCASȬBefehl,ȱwieȱmitȱdemȱTASȬȱoderȱXCHGȬ Befehl,ȱ Spinlocksȱ undȱ Semaphoreȱ implementieren.ȱ Zusätzlichȱ lassenȱ sichȱ mitȱ demȱ CASȬBefehlȱ sperrȬȱ undȱ wartefreieȱ Algorithmenȱ impleȬ mentieren.ȱ Herilhyȱ [Hȱ 91]ȱ hatȱ nachgewiesen,ȱ dassȱ diesȱ mitȱ einfachenȱ LeseȬ,ȱ Schreiboperationenȱ undȱ somitȱ demȱ XCHGȬȱ undȱ TASȬBefehlȱ nichtȱmöglichȱist.ȱȱ

SperrȬȱundȱ wartefreieȱ Algorithmenȱ ȱ

72ȱ

DieȱsperrȬȱundȱwartefreieȱAlgorithmen,ȱwelcheȱdenȱCASȬBefehlȱbenutȬ zen,ȱlesenȱeineȱgemeinsameȱSpeicherlokationȱundȱspeichernȱsieȱinȱeinerȱ lokalenȱVariablenȱ(TempOld)ȱabȱundȱmerkenȱsichȱsomitȱdenȱaltenȱWert.ȱ BasierendȱaufȱdemȱAltȬWertȱ(TempOld)ȱberechnenȱSieȱdannȱeinenȱneuȬ enȱ Wertȱ (TempNew)ȱ undȱ führenȱ somitȱ eineȱ Operationȱ aus.ȱ Derȱ CASȬ Befehlȱ versuchtȱ dann,ȱ denȱ neuenȱ Wertȱ inȱ dieȱ Speicherzelleȱ zuȱ schreiȬ ben.ȱBevorȱerȱschreibenȱkann,ȱüberprüftȱer,ȱobȱinȱderȱSpeicherlokationȱ nochȱderȱalteȱWertȱsteht.ȱIstȱdiesȱnichtȱderȱFall,ȱsoȱhatȱeinȱandererȱProȬ

2.2 Eng gekoppelte Multiprozessoren und Multicore-Prozessoren zess die Speicherlokation geändert, und der CAS-Befehl ist fehlgeschlagen (er gibt FALSE zurück). Ist der Versuch fehlgeschlagen, beginnt man von vorne: Die Speicherlokation wird erneut gelesen, ein neuer Wert wird berechnet und der CAS-Befehl wird erneut versucht. Mit dem CAS-Befehl, der atomar ist, werden dann die Änderungen hintereinander und seriell zurückgeschrieben. Das bedeutet, die Änderungen finden unter wechselseitigem Ausschluss in irgendeiner Reihenfolge statt. Das folgende Codebeispiel Atomic_Add inkrementiert atomar eine Integer-Variable, dabei benutzt Atomic_Add den CAS-Befehl: procedure Atomic_Add (Var : in REFERENCE, Val : in INTEGER, Return_Code: out INTEGER) is Temp_Old : INTEGER; Temp_New : INTEGER; begin Temp_Old := CONT(Var); Temp_New := Temp_Old + Val; while (NOT (CAS (ADDR(Var), Temp_Old, Temp_New)) loop Temp_Old := CONT(VAR); Temp_New := Temp_Old + Val; end loop; Return_Code := Temp_New; end Atomic_Add;

Programm 2-7: Atomares Addieren mit CAS

Programm 2-7 führt zuerst die Addition aus und testet dann mit dem CAS-Befehl, ob die Addition atomar war und kein anderer Prozess die Addition ebenfalls durchgeführt hat. War sie atomar, schreibt der CAS-Befehl den Wert der Addition in die Variable Var zurück. War sie nicht atomar ausgeführt, wird erneut die Addition ausgeführt und anschließend getestet, ob sie diesmal atomar war.

Double Compare and Swap (DCAS)

Programm 2-7 schreibt den neuen Wert nur in eine einfache Datenstruktur, eine Variable zurück. Dies lässt sich leicht erweitern auf Datenstrukturen wie Listen, Keller, Warteschlangen, Mengen und HashTabellen. Zur leichteren Implementierung von zweifachen Änderungen, wie sie z.B. beim Entfernen eines Elementes in einer doppelt geketteten Liste vorkommen, gibt es eine Erweiterung des CAS-Befehls den Double Compare and Swap (DCAS). DCAS schreibt atomar in zwei neue Speicherlokationen neue Werte.

73

2ȱȱRechnerarchitekturenȱfürȱParalleleȱundȱVerteilteȱSystemeȱ

2.2.6.5 Transactional Memory (TM) Derȱ traditionelleȱ Ansatzȱ zurȱ Synchronisationȱ vonȱ Prozessenȱ oderȱ ThreadsȱistȱdieȱVerwendungȱvonȱLocks.ȱLocksȱbesitzenȱjedochȱdieȱfolȬ gendenȱNachteile:ȱ Nachteileȱvonȱ Locksȱȱ

LockȬFree/ȱ WaitȬFreeȱ

Memoryȱ TransȬ aktionenȱ

74ȱ

x

AktivesȱWarten:ȱIstȱeineȱRessourceȱnichtȱfrei,ȱoderȱistȱeinȱkritischerȱ Abschnittȱ belegt,ȱ soȱ mussȱ derȱ aktuelleȱ Prozessȱ aktivȱ warten.ȱ Einȱ wartenderȱProzessȱverrichtetȱkeineȱArbeit,ȱundȱdiesȱführtȱzurȱeinȬ geschränktenȱParallelität.ȱȱ

x

Wettlaufsituationenȱ(RaceȱConditions):ȱFehlendeȱSynchronisationȱ undȱdasȱfehlendeȱSetzenȱvonȱSperrenȱkönnenȱzuȱWettlaufsituatioȬ nenȱführen.ȱ

x

Verklemmungenȱ (Deadlocks):ȱ Jeȱ nachdemȱ inȱ welcherȱ Reihenfolgeȱ dieȱ Locksȱ angefordertȱ werden,ȱ könnenȱ Verklemmungenȱ (DeadȬ locks)ȱentstehen.ȱȱ

x

Prioritätsumkehrȱ (Priorityȱ Inversion):ȱ Wennȱ einȱ Prozessȱ mitȱ nieȬ dererȱPrioritätȱeineȱSperreȱgesetztȱhatȱundȱeinȱProzessȱhoherȱPrioriȬ tätȱ kommtȱ zumȱ Laufen,ȱ derȱ ebenfallsȱ dieseȱ Sperreȱ anfordert,ȱ soȱ verhindertȱderȱniederprioreȱProzess,ȱderȱdasȱLockȱbesitzt,ȱdasȱWeiȬ terarbeitenȱdesȱhöherpriorenȱProzesses.ȱDasȱheißtȱesȱkommtȱdabeiȱ zuȱeinerȱVerklemmung.ȱȱ

x

Prozessabbruch:ȱ Brichtȱ oderȱ stürztȱ einȱ Prozessȱ ab,ȱ derȱ eineȱ oderȱ mehrereȱSperrenȱgesetztȱhat,ȱsoȱwerdenȱdieȱSperrenȱnichtȱfreigegeȬ ben,ȱundȱaufȱdenȱgemeinsamȱgenutztenȱSpeicherbereichȱkannȱkeinȱ ProzessȱmehrȱzugreifenȱundȱdessenȱZustandȱistȱundefiniert.ȱȱ

Transactionalȱ Memoryȱ (TM)ȱ vermeidetȱ dieȱ obigenȱ Nachteileȱ vonȱ Locks.ȱ TMȱ istȱ einȱ LockȬFree/WaitȬFreeȬKonkurrenzȬKontrollȬ Konstrukt,ȱdasȱaufȱTransaktionenȱbasiert,ȱwieȱsieȱschonȱseitȱJahrzehnȬ tenȱbeiȱDatenbankenȱinȱGebrauchȱsind.ȱDurchȱdasȱWaitȱFreeȱbeiȱTransȬ aktionen,ȱbeiȱderȱjederȱThreadȱFortschritteȱmacht,ȱegalȱwasȱdieȱanderenȱ Threadsȱmachen,ȱwerdenȱbeiȱmehrerenȱThreadsȱerheblicheȱPerformanȬ cegewinneȱimȱGegensatzȱzurȱLockȬSynchronisationȱerreichtȱ[AKSȱ07].ȱȱ Eineȱ Memoryȱ Transaktionȱ istȱ eineȱ Sequenzȱ vonȱ Speicheroperationenȱ aufȱ demȱ gemeinsamenȱ Speicher,ȱ dieȱ entwederȱ komplettȱ ausgeführtȱ undȱfestgeschriebenȱwirdȱ(commit)ȱoderȱabgebrochenȱ(abort)ȱundȱzuȬ rückgesetztȱwirdȱundȱsomitȱkeineȱEffekteȱhatȱ[HMȱ93].ȱTransaktionenȱ sindȱ atomar,ȱ undȱ somitȱ sindȱ alleȱ Operationenȱ ausgeführtȱ oderȱ keineȱ derȱ Operationen,ȱ soȱ alsȱ hätteȱ dieȱ Transaktionȱ nieȱ stattgefunden.ȱ Eineȱ TransaktionȱinȱeinemȱThreadȱläuftȱisoliertȱundȱistȱdieȱeinzigeȱTransakȬ tion,ȱ dieȱ aufȱ demȱ Systemȱ läuft.ȱ Somitȱ sindȱ alleȱ anderenȱ Threads,ȱ dieȱ

2.2ȱEngȱgekoppelteȱMultiprozessorenȱundȱMulticoreȬProzessorenȱ aufȱ denȱ gleichenȱ Speicherȱ zugreifen,ȱ suspendiertȱ undȱ nurȱ derȱ eineȱ Threadȱläuft.ȱTransaktionenȱvermittelnȱdadurchȱdieȱIllusionȱderȱserielȬ lenȱAusführung.ȱSieȱwerdenȱinȱeinemȱeinzelnenȱatomarenȱSchrittȱausȬ geführtȱinȱBezugȱzuȱanderenȱkonkurrentenȱThreads,ȱundȱkeinȱandererȱ ThreadȱführtȱeineȱinȱKonfliktȱdazuȱstehendeȱOperationȱaus.ȱȱ DieseȱausȱDatenbankenȱbekanntenȱTransaktionenȱ(sieheȱzuȱFolgendemȱ auchȱ[HCUȱ77],ȱdieȱdazuȱFallbeispieleȱangeben)ȱkönnenȱinȱȱ 1.ȱSoftwareȱgegossenȱwerdenȱ(SoftwareȱTransactionalȱMemoryȱ(STM)),ȱ STMȱ oderȱ HTM,ȱȱ 2.ȱ direktȱinȱderȱ Hardwareȱimplementiertȱ werdenȱ (Hardwareȱ TransacȬ tionalȱMemoryȱ(HTM)),ȱoderȱ

HyTM,ȱȱ HaSTMȱȱ

3.ȱesȱkannȱeineȱMischungȱ(hybrid)ȱausȱSTMȱundȱHTMȱvorliegenȱ(HybȬ ridȱ Transactionalȱ Memoryȱ (HyTM)ȱ undȱ (Hardwareȱ assistedȱ SoftȬ wareȱTransactionalȱMemoryȱ(HaSTM)).ȱȱ

2.2.6.5.1 Programmsprachliche Realisierung des TM Durchȱ dieȱ konzeptionelleȱ Einfachheitȱ vonȱ Transaktionenȱ könnenȱ sieȱ programmsprachlichȱeinfachȱalsȱeinȱatomarerȱBlockȱvonȱAnweisungenȱ [AKSȱ 07]ȱ inȱ einenȱ Prozessȱ eingebettetȱ werden.ȱ Dieȱ Syntaxȱ istȱ folgenȬ dermaßen:ȱ atomic { S } SȱistȱdabeiȱeineȱAnweisungsfolge,ȱdieȱinȱeinerȱTransaktionȱausgeführtȱ wird.ȱȱ DasȱatomareȱEinfügenȱeinesȱElementesȱinȱeineȱdoppeltȱgeketteteȱListeȱ hatȱdabeiȱfolgendesȱAussehen:ȱȱ // Insert a node into a doubly-linked list atomically atomic { new Node -> prep = node; new Node -> next = node -> next; node -> next -> prep = new Node; node -> next = new Node; }

Programmȱ2-8:ȱ Transactional atomarerȱ Blockȱ

ȱ IstȱdasȱEndeȱdesȱBlockesȱerreicht,ȱsoȱkannȱdieȱTransaktionȱmöglicherȬ weiseȱ festgeschriebenȱ werdenȱ (committed),ȱ andernfallsȱ mussȱ sieȱ abȬ gebrochenȱ(aborted)ȱundȱerneutȱgestartetȱwerden.ȱȱ HarrisȱundȱFraserȱ[HFȱ03]ȱhabenȱeinȱeinfachesȱundȱmächtigesȱSprachȬ konstruktȱ vorgeschlagen,ȱ dasȱ dieȱ Semantikȱ vonȱ bedingtenȱ kritischenȱ Regionenȱ(conditionalȱcriticalȱregions)ȱbesitzt.ȱBedingteȱkritischeȱRegiȬ

Bedingteȱ kritischeȱ Regionenȱ

75ȱ

2 Rechnerarchitekturen für Parallele und Verteilte Systeme onen führten Hoare [Ho 72] und Brinch Hansen [BH 72] ein. Regionen sind Anweisungsfolgen, die unter wechselseitigem Ausschluss laufen. Die Regionen können Bedingungen (boolesche Ausdrücke) besitzen. Betritt ein Prozess die Region, so wird zunächst der wechselseitige Ausschluss hergestellt, anschließend wird die Bedingung ausgewertet. Ergibt die Auswertung der Bedingung TRUE, so darf der Prozess die Region ausführen. Ergibt die Auswertung der Bedingung FALSE, so wird der wechselseitige Ausschluss aufgehoben (so dass andere Prozesse ihre Region betreten und die Bedingung wahr machen können) und der Prozess wartet bis die Bedingung wahr ist. Die syntaktische Form von bedingten kritischen Regionen bei einem atomaren Block ist folgende: atomic (p) { S }

Programm 2-9: Transaktion mit Bedingung

Programm 2-10: Verklemmung bei atomic conditional regions

Programm 2-11: Multi levelTransaktionen

76

Dabei ist p ein optionales Prädikat (Ausdruck vom Typ BOOLEAN) und S ist eine atomare Anweisungsfolge. atomic (queueSize > 0) { remove item from queue and use it } Durch die Möglichkeit, dass nicht alle Bedingungen zu einer Zeit wahr sind, können Verklemmungen entstehen, wie Programm 2-10 zeigt. atomic (queueSize > 0) { atomic (queueSize = 0) { insert elem in queue } } Es liegt in der Verantwortung des Programmierers sicherzustellen, dass zu einer Zeit alle Bedingungen von ineindergeschachtelten bedingten kritischen Regionen wahr werden. Ansonsten sind geschachtelte bedingte kritische Regionen erlaubt, wie nachfolgendes Programm 2-11 zeigt. private void a1 () { atomic (cond1) { . . . } } public void a2 () { atomic (cond2) { a1();} }

2.2 Eng gekoppelte Multiprozessoren und Multicore-Prozessoren Die ineinander geschachtelten bedingten kritischen Regionen [HMJ 05] erscheinen wie eine Transaktion, und für den Programmierer sehen sie aus wie eine einzelne atomare Aktion, vorausgesetzt die beiden Bedingungen cond1 und cond2 sind erfüllt. Lock-basierte Lösungen stellen solche geschachtelte Konstrukte nicht zur Verfügung und führen dort meist auf Verklemmungen.

2.2.6.5.2 Software Transactional Memory (STM) Es gibt eine Vielzahl von softwarebasierten Verfahren von Transactional Memory, teilweise mit Hardwareunterstützung, das sog. Software Transactional Memory (STM) [STM 07] STM benutzt das von Transaktionen bekannte optimistische Konkurrenzprotokoll [KR 81]: Jeder Thread führt seine Modifikationen auf dem gemeinsamen Speicher aus, ohne Rücksicht darauf welche Modifikationen andere Threads an dem gemeinsamen Speicher vorgenommen haben. Jedes Lesen oder Schreiben geht dabei nicht in den gemeinsamen Speicher, sondern wird in einem Log mitprotokolliert. Am Ende der Transaktion wird dann verifiziert, ob andere Threads ebenfalls den gemeinsamen Speicher modifiziert haben. Hat kein anderer Thread den gemeinsamen Speicher modifiziert, so kann die Transaktion verbindlich (commit) und permanent gemacht werden, d.h. der Log wird gültig. Kann die Transaktion nicht verbindlich gemacht werden, so kann die Transaktion zu jeder Zeit abgebrochen werden (abort) und die vorgenommen Änderungen werden zurückgesetzt, d.h. der Log wird verworfen. Die Transaktion wird dann von Beginn an wieder ausgeführt (retry), bis sie erfolgreich ist.

Optimistisches Konkurrenzprotokoll

Mit den primitiven Funktionen abort und retry [HF 03] gelingt dann die Implementierung des optimistischen Konkurrenzprotokolls.

abort retry

Der Vorteil des optimistischen Ansatzes ist erhöhte Konkurrenz: Kein Thread muss auf den Zugriff auf die Ressource warten, und verschiedene Threads, die auf verschiedene Teile einer gemeinsamen Datenstruktur zugreifen, können das konkurrent und gleichzeitig. Der Zugriff auf gemeinsame Datenstrukturen geschieht normalerweise unter dem gleichen Lock und bedingt dabei ein Warten bei gleichzeitigem Zugriff. Außer dem Overhead, dem wiederholten Ausführen (retry), falls die Transaktion fehlgeschlagen ist, fällt kein Warten und anderer Overhead an. In den meisten realistischen Programmen und mit einer großen Anzahl von Prozessoren und Threads kommen Zugriffskonflikte und damit ein Abbruch der Transaktion selten vor.

Vorteil optimistische Konkurrenzkontrolle gegenüber Locks

77

2ȱȱRechnerarchitekturenȱfürȱParalleleȱundȱVerteilteȱSystemeȱ Harrisȱ undȱ Fraserȱ [HFȱ 07]ȱ stellenȱ dreiȱ APIsȱ fürȱ nichtsperrendeȱ undȱ somitȱnichtblockierendeȱSynchronisationsmethodenȱvor:ȱ 1.ȱ ȱ Derȱ Multiwordȱ Compareȱ andȱ Swapȱ (MCAS)ȱ welche,ȱ überȱ denȱ DCASȱ hinaus,ȱ atomarȱ eineȱ oderȱ mehrereȱ Speicherlokationenȱ aufȱ neueȱWerteȱsetzenȱkann.ȱ 2.ȱ Einȱ WordȬbasedȱ Softwareȱ Transactionalȱ Memoryȱ (WSTM),ȱ ȱ derȱ erlaubt,ȱeineȱFolgeȱvonȱLeseȱundȱSchreiboperationenȱinȱeinerȱTransȬ aktionȱzuȱgruppieren.ȱ 3.ȱ Einȱ ObjectȬbasedȱ Softwareȱ Transactionalȱ Memoryȱ (OSTM),ȱ derȱ einenȱtransaktionalenȱZugriffȱaufȱeineȱMengeȱvonȱObjektenȱerlaubt.ȱȱȱ Derȱ Quellcodeȱ derȱ dreiȱ APIsȱ stehtȱ fürȱ Alpha,ȱ Intelȱ IAȬ32,ȱ Intelȱ IAȬ64,ȱ MIPS,ȱ PowerPCȱ undȱ SparcȬProzessorȬFamilieȱ zurȱ Verfügung.ȱ Erȱ istȱ unterȱ[UCȱ07]ȱherunterladbar.ȱ Fürȱ dieȱ Implementierungȱ vonȱ geschachteltenȱ Transaktionen,ȱ TransakȬ tionshandlerȱundȱdemȱZweiȬPhasenȱCommitȬProtokollȱundȱderenȱEinȬ bettungȱ inȱ Programmiersprachenȱ undȱ Laufzeitumgebungenȱ sieheȱ [MCCȱ07].ȱ

2.2.6.5.3 Hardware Transactional Memory (HTM) ImplementieȬ rungȱdesȱTMȱ inȱHardwareȱ

Softwareȱ Transactionalȱ Memoryȱ bringtȱ Performanceeinbußenȱ gegenȬ überȱ inȱ Hardwareȱ implementiertenȱ Hardwareȱ Transactionalȱ Memoryȱ (HTM).ȱDieȱImplementierungȱvonȱHTMȱgeschiehtȱamȱbestenȱmitȱleichtȱ modifiziertenȱ Cachesȱ undȱ denȱ traditionellenȱ CachekoheränzprotokolȬ len.ȱDabeiȱkannȱgrobȱfolgendermaßenȱvorgegangenȱwerden:ȱ x

Buffering:ȱ Dasȱ Puffernȱ oderȱ Loggingȱgeschiehtȱimȱ transaktionalenȱ Cache.ȱ

x

KonfliktȱErkennung:ȱDasȱErkennenȱvonȱZugriffskonfliktenȱbedingtȱ InterventionenȱdesȱCache.ȱ

x

Zurücksetzenȱ oderȱRollback:ȱInvalidiereȱdenȱEintragȱimȱtransaktiȬ onalenȱCache.ȱȱ

x ȱ

Commit:ȱValidiereȱdenȱEintragȱimȱtransaktionalenȱCache.ȱȱ

Dieȱ Hardwareimplementierungȱ desȱ HTMȱ besitztȱ dieȱ folgendenȱ EinȬ schränkungen:ȱ Nachteileȱderȱ Hardwareimp lementierungȱ

78ȱ

x

BeschränkteȱGröße:ȱEsȱwerdenȱkeineȱTransaktionenȱvonȱmehrerenȱ Anweisungenȱ undȱ mehrerenȱ Wörternȱ unterstützt,ȱ insbesondereȱ beiȱaufȱWortgrößenȱbeschränktenȱCaches.ȱEinȱAuswegȱistȱdieȱgroȬ ßeȱ Anzahlȱ vonȱ Transaktionen,ȱ dieȱ ausȱ mehrerenȱ atomarenȱ TransȬ

2.3ȱLoseȱgekoppelteȱMultiprozessorenȱundȱMulticomputerȱ aktionenȱbestehen,ȱȱineinanderȱzuȱschachteln.ȱEineȱdurchȱVirtualiȬ sierungȱ erreichteȱ Unboundedȱ Transactionalȱ Memoryȱ (UTM)ȱ istȱ inȱ [AAKȱ06]ȱbeschrieben.ȱȱ x

NichtȱInterruptfähig:ȱBeiȱderȱAbarbeitungȱderȱTransaktionȱdürfenȱ keineȱInterruptsȱauftreten.ȱȱ

x

KeineȱI/O:ȱDieȱTransaktionȱdarfȱkeineȱI/OȬAnweisungenȱenthalten,ȱ dieȱ könnenȱ nichtȱ rückgängigȱ gemachtȱ werden.ȱ Diesȱ giltȱ auchȱ beiȱ SoftwareȱTransactionalȱMemory.ȱȱȱȱ

2.3 Lose gekoppelte Multiprozessoren und Multicomputer 2.3.1 Architektur von lose gekoppelten Multiprozessoren Beiȱ loseȱ gekoppeltenȱ Multiprozessorenȱ (Abb.ȱ 2Ȭ16)ȱ koppeltȱ manȱ ProȬ zessorenȱ undȱ ihreȱ eigenenȱ lokalenȱ Speicherȱ (ProzessorȬ Speicherpärchen)ȱ überȱ eineȱ Verbindungseinrichtungȱ zusammen.ȱ DaȬ durchȱtrittȱderȱbeiȱengȱgekoppeltemȱSystemȱvorhandeneȱVerbindungsȬ engpassȱzwischenȱProzessorȱundȱSpeicherȱnichtȱmehrȱauf.ȱDaȱderȱvonȱ NeumannȬEngpassȱ hierȱ nichtȱ durchȱ weitereȱ ProzessorȬSpeicherȬ Verkehrȱbelastetetȱwird,ȱskalierenȱdieȱloseȱgekoppeltenȱSystemeȱhöherȱ undȱ dieȱ Anzahlȱ derȱ Prozessoren,ȱ dieȱ zusammengeschaltetȱ werdenȱ können,ȱistȱnachȱobenȱunbeschränkt.ȱ ȱ ȱ ȱ ȱ

Anzahlȱderȱ Prozessorenȱ beiȱloseȱ gekoppeltenȱ Systemenȱ unbeschränktȱ

Abb.ȱ2Ȭ16:ȱ Loseȱ gekoppelterȱ MutiȬ prozessorȱ

ȱ ȱ BeiȱdenȱengȱgekoppeltenȱMultiprozessorenȱgreifenȱalleȱProzessorenȱmitȱ gleicherȱ undȱ einheitlicherȱ Geschwindigkeitȱ aufȱ denȱ gemeinsamenȱ Speicherȱ zu.ȱ Manȱ bezeichnetȱ deshalbȱ dieseȱ Architekturenȱ alsȱ UMAȱ (Uniformȱ Memoryȱ Access)ȬArchitekturen.ȱ Durchȱ dieseȱ Einheitlichkeitȱ istȱdieȱLeistungȱbeiȱUMAȱvorhersagbar.ȱImȱGegensatzȱdazu,ȱgehörtȱbeiȱ loseȱgekoppeltenȱMultiprozessorenȱzuȱjederȱCPUȱeinȱlokalesȱSpeicherȬ modul.ȱ Aufȱ dasȱ lokaleȱ Speichermodulȱ kannȱ dieȱ CPUȱ wesentlichȱ schnellerȱzugreifenȱalsȱaufȱentfernteȱSpeichermodule,ȱalsoȱdenȱlokalenȱ Speicherȱ vonȱ anderenȱ CPUs.ȱ Umȱ nunȱ mehrȱ alsȱ einigeȱ CPUsȱ zusamȬ menschließenȱ zuȱ können,ȱ mussȱ daraufȱ verzichtetȱ werden,ȱ dassȱ alleȱ Speichermoduleȱ dieȱ gleicheȱ Zugriffszeitȱ habenȱ müssen.ȱ [Tȱ 06]ȱ Diesesȱ

Uniformȱ Memoryȱ Accessȱ(UMA)ȱ

79ȱ

2ȱȱRechnerarchitekturenȱfürȱParalleleȱundȱVerteilteȱSystemeȱ ZugeständnisȱführtȱaufȱdasȱKonzeptȱderȱNUMAȬȱ(NonUniformȱMemoȬ ryȱAccessȬ)Architekturen.ȱȱ NonUniformȱ Memoryȱ Accessȱ (NUMA)ȱȱ

NCCȬNUMAȱ

CCȱNUMAȱ

COMAȱ

MitȱeinemȱvorgelagertenȱCacheȱgreiftȱderȱProzessorȱaufȱdenȱlokalȱzuȬ gewiesenenȱ Speicherȱ schnellerȱ zu,ȱ alsȱ aufȱ denȱ allenȱ Prozessorenȱ geȬ meinsamenȱHauptspeicher.ȱManȱbezeichnetȱdeshalbȱdieseȱSpeicherarȬ chitekturȱfürȱMultiprozessoren,ȱbeiȱdenenȱdieȱZugriffszeitenȱvomȱOrtȱ desȱ Speichersȱ abhängen,ȱalsȱ NonȬUniformȱ Memoryȱ Accessȱ oderȱ NonȬ Uniformȱ Memoryȱ Architectureȱ (NUMA).ȱ Dieȱ NUMAȬArchitekturȱ unȬ terscheidetȱzwischenȱeinerȱArchitekturȱmit,ȱȱohneȱCacheȬKohärenzȱundȱ nurȱCaches:ȱ x

Nonȱ Cacheȱ Coherentȱ NUMAȱ (NCCȱ NUMA)ȱ arbeitetȱ ohneȱ CacheȬ Kohärenzȱ(dasȱbedeutet,ȱderȱCacheȱistȱnichtȱvonȱderȱHardwareȱgaȬ rantiertȱundȱdasȱProgrammiermodellȱmussȱdafürȱSorgeȱtragenȱundȱ Instruktionenȱ anbieten,ȱ soȱ dassȱ dieȱ Programmeȱ dieȱ CacheȬ Kohärenzȱherstellenȱkönnen).ȱWährendȱȱ

x

CacheȬCoherentȱNUMAȱ(CCȱNUMA)ȱmitȱeinemȱVerzeichnisȱ(DirecȬ tory)ȱarbeiten.ȱDasȱVerzeichnisȱenthältȱEinträgeȱinȱwelchenȱCachesȱ dieȱ Kopienȱ derȱ Blöckeȱ liegenȱ undȱ obȱ dieȱ Kopieȱ gültigȱ undȱ somitȱ aktuellȱ ist.ȱ CCȬNUMAȬMultiprozessorenȱ heißenȱ auchȱ Directory– basedȱMultiprozessorenȱ[Tȱ06].ȱDasȱVerzeichnisȱistȱeineȱDatenbank,ȱ dieȱAuskunftȱgibt,ȱwoȱundȱinȱwelchemȱZustandȱsichȱdieȱeinzelnenȱ CacheȬZeilenȱ befinden.ȱ Einȱ kommerziellerȱ Vertreterȱ einerȱ CCȱ NUMAȱMaschineȱistȱdieȱMaschineȱvonȱSiliconȱGraphicsȱSGIȱAltixȱ [SGIȱ07].ȱ

x

Cacheȱ Onlyȱ Memoryȱ Architectureȱ (COMA)ȱ benutzenȱ denȱ HauptȬ speicherȱ jederȱ CPUȱ alsȱ Cacheȱ [HLHȱ 92].ȱ Derȱ physischeȱ AdressȬ raumȱistȱdabeiȱinȱCacheȬZeilenȱaufgeteilt.ȱEinȱSpeicher,ȱderȱnurȱdieȱ geradeȱ benötigtenȱ Zeilenȱ anȱ sichȱ zieht,ȱ heißtȱ Attractionȱ Memory.ȱ DaȱnurȱZugriffeȱaufȱlokaleȱSpeicherȱstattfinden,ȱsindȱdieseȱZugriffeȱ attraktiv.ȱȱ

Imȱ Vergleichȱ zuȱ UMAȬArchitekturenȱ undȱ somitȱ zuȱ engȱ gekoppeltenȱ Multiprozessorenȱ weisenȱ NUMAȬMaschinenȱ dieȱ folgendenȱ Merkmaleȱ auf:ȱȱ 1.ȱDurchȱverteiltenȱgemeinsamenȱSpeicherȱ(DistributedȱSharedȱMemoryȱ (DSM))ȱwirdȱeinȱeinzigerȱAdressraumȱhergestellt,ȱderȱfürȱalleȱCPUsȱ sichtbarȱist.ȱ 2.ȱȱDerȱZugriffȱaufȱentferntenȱSpeicherȱerfolgtȱmithilfeȱvonȱLOAD-ȱundȱ STORE–Befehlen.ȱ

80ȱ

2.3 Lose gekoppelte Multiprozessoren und Multicomputer 3. Der Zugriff auf entfernten Speicher ist langsamer als auf lokalen Speicher. Durch diese Merkmale und Eigenschaften laufen alle UMAProgramme unter Verwendung des gleichen Programmiermodells unverändert auf den NUMA-Maschinen. D.h. alle für UMA-Maschinen und somit eng gekoppelten Multiprozessoren entwickelten Programme laufen, durch den verteilten gemeinsamen Speicher, auf den NUMA-Maschinen und somit auf lose gekoppelten Multiprozessoren.

2.3.2 Verteilter gemeinsamer Speicher Bei einer NUMA-Architektur besitzt jeder Prozessor seinen eigenen Speicher. Ein verteilter gemeinsamer Speicher (Distributed Shared Memory (DSM)) [NL 91] ist eine Abstraktion, welche den lokalen Speicher der verschiedenen Prozessoren integriert zu einer einzigen logischen Einheit. Alle Prozesse auf den verschiedenen Prozessoren greifen auf den gemeinsamen Speicher zu. Der verteilte gemeinsame Speicher existiert jedoch nur virtuell. Die Prozesse, die auf den einzelnen Knoten ablaufen, können den verteilten gemeinsamen Speicher genauso wie den traditionellen virtuellen Speicher benutzten (Abb. 2-17).

Abb. 2-17: Verteilter gemeinsamer Speicher

81

2 Rechnerarchitekturen für Parallele und Verteilte Systeme Jeder Knoten in dem System besitzt eine oder auch mehrere CPUs mit Zugriff auf einen gemeinsamen Speicher (eng gekoppelter Multiprozessor mit UMA-Architektur) Die Knoten sind verbunden durch ein Netzwerk. Jeder Knoten hat seinen eigenen virtuellen Speicher und eigene Seitentabellen. Der verteilte gemeinsame Speicher repräsentiert einen virtuellen Speicherraum, auf den alle Knoten Zugriff haben. Führt ein Knoten eine LOAD- oder STORE-Operation auf eine Seite aus, die er nicht hat, so wird ein Trap zum Betriebssystem ausgelöst. Das Betriebssystem sucht die Seite und fordert die Remote-CPU, welche die Seite besitzt, auf, die Seite freizugeben, d.h. die Abbildung aufzuheben und über das Verbindungsnetz zu senden. Trifft die Seite beim Knoten ein, wird die Abbildung hergestellt und der durch Trap abgebrochene Befehl neu gestartet. Praktisch bedient das Betriebssystem die fehlenden Seiten und Seitenfehler nicht mit Seiten von der Platte, sondern aus dem entfernten Speicher des anderen Knotens. Anstatt DSM für Distributed Shared Memory wird auch DSVM benutzt für Distributed Shared Virtual Memory.

2.3.2.1 Implementierungsebenen Die Implementierung von DSM kann auf folgenden verschiedenen Ebenen angesiedelt sein: Implementierungsebenen von DSM

1. Hardware-Ebene: Die Hardwareebene erlaubt die Einbindung von Memory-Mangement Units (MMU) und High-Level-Caches bis hin zu in Hardware implementierten Update- und InvalidateMechanismen für den Cache. Die Algorithmen auf Hardwareebene können gut mit kleineren Zugriffseinheiten, wie einzelnen Speicherzellen umgehen, und bedingen nicht die Betrachtung von Variablen, Objekte, Seiten oder des gesamten DSM als assoziativer Speicher und somit als Datenbasis. 2. Software-Ebene: Auf Softwareebene dient ein Nachrichtenaustausch zwischen den Rechnern zum Zugriff auf entfernte Speicher. a) Betriebssystem: Auf Betriebssystemebene lässt sich der DSM sehr gut mit der virtuellen Speicherverwaltung verknüpfen. Die Einheit des Sharing und Transfers ist somit eine Seite (Page). Ein existierendes Seitenfehlerschema wird vom DSM bei einem Seitenfehler aufgerufen. Das Speicherkohärenzproblem wird dann durch den Seitenfehlerhandler gelöst. b) Laufzeitbibliothek: Bibliotheksroutinen, die den Zugriff zum DSM gestatten, werden mit der Applikation zusammengebunden. Zugriffseinheiten, die vom Laufzeitsystem unterstützt werden, können komplette Objekte oder Tupel sein. Da die Lauf-

82

2.3 Lose gekoppelte Multiprozessoren und Multicomputer zeitbibliothek keine Unterstützung durch spezielle Hardware oder des Betriebssystems erfordert, ist diese Lösung besonders angebracht, wenn verschiedene heterogene Rechner (Heterogenität bezüglich der Hardware und des Betriebssystems, jedoch einheitliches Protokoll) im Netz den DSM zur Verfügung stellen sollen.

2.3.2.2 Speicher Konsistenzmodelle Ein System für DSM, das Replikas von gemeinsamen Daten erlaubt, besitzt Kopien von gemeinsamem Speicher, die mehrfach verfügbar sind und jeweils im lokalen Speicher der Knoten liegen. Das Hauptproblem dabei ist, die Kopien im Hauptspeicher von zwei oder mehreren Knoten kohärent zu halten. Dieses Problem ist gleich gelagert wie bei den Cachekohärenzalgorithmen bei eng gekoppelten Multiprozessoren (siehe Abschnitt 2.2.2).

Kohärenzproblem

Ein weiteres Problem besteht darin, dass bei DSM parallele Zugriffe auf die gemeinsamen Daten der Prozesse auf den verschiedenen Knoten stattfinden können. Diese Zugriffe müssen dann sequenziell geschehen und somit unter wechselseitigem Ausschluss laufen. Zur Synchronisation der parallelen Zugriffe benötigt man dann Synchronisationsprimitiven wie Locks, Semaphore oder Transactional Memory (siehe Abschnitt 2.2.6).

Wechselseitiger Ausschluss

Konsistenzmodelle legen den Grad der Konsistenz fest, die erhalten wird für parallele Applikationen. Gemäß dem absteigenden Grad der Konsistenz sind diese Modelle folgendermaßen geordnet [T 95], [S 97], [PTM 98], [AG 96]:

Konsistenzmodelle

•

Strikte Konsistenz (Strict Consistency): Ein verteilter Speicher ist strikt konsistent, wenn der Wert der durch ein read an einer Speicherstelle erhalten wird, dem Wert entspricht der durch die letzte write-Operation in diese Speicherstelle geschrieben wurde, unabhängig davon auf welchen Knoten die Prozesse die read- und write-Operation ausgeführt haben. Das bedeutet alle writeOperationen sind bei allen anderen Prozessen sofort und zur gleichen Zeit sichtbar.

Strikte Konsistenz

•

Strikte Konsistenz ist nicht erreichbar, da eine Implementierung die Existenz einer globalen absoluten Uhr bedingt. Mit dieser Uhr lässt sich die korrekte und zeitliche Ordnung von read- und write-Operationen bestimmen. Damit können dann Aussagen getroffen werden, welche Operation zuletzt ausgeführt wurde (siehe dazu auch Abschnitt 5.2).

Strikte Konsistenz ist nicht implementier bar

83

2 Rechnerarchitekturen für Parallele und Verteilte Systeme Sequenzielle Konsistenz

•

Sequenzielle Konsistenz (Sequential Consistency): Ein verteilter Speicher ist sequenziell konsistent, wenn alle Prozessoren die gleiche Reihenfolge von Speicheroperationen auf dem gemeinsamen Speicher sehen. Die Konsistenzanforderung des sequentiellen Modells ist schwächer als die des strikten Konsistenzmodells. Es wird nicht garantiert, dass eine read-Operation an einer Speicherzelle den zuletzt durch eine write-Operation in diese Speicherzelle geschriebenen Wert zurückliefert. Eine Konsequenz daraus ist, dass bei einem sequenziellen Speicher ein Programm, das zweimal gestartet wurde, zwei unterschiedliche Ergebnisse haben kann. Um die gleichen Ergebnisse zu erhalten, müssen die Prozesse beim Zugriff auf den gemeinsamen Speicher explizit synchronisiert werden, und die Zugriffe sind damit sequenzialisiert. • Eine weitere von Lamport [L 79] stammende Definition für sequenziellen Konsistenz ist die folgende: Das Ergebnis von irgendeiner Ausführung ist das Gleiche, wie wenn die Operationen von allen Prozessoren in irgendeiner sequenziellen Ordnung ausgeführt werden. Die Operationen von einem einzelnen individuellen Prozessor erscheinen in der Sequenz in der Ordnung, wie sie in dem Programm angegeben wurden. Diese Definition bedeutet: • Laufen Prozesse parallel auf verschiedenen Maschinen (oder pseudoparallel wie beim Timesharing), dann ist jede gültige Reihenfolge akzeptierbar, jedoch müssen alle Prozessoren die gleiche Sequenz von Speicherreferenzen sehen. Reihenfolgen sind gültig, wenn sie in der durch das Programm, das auf jeder Maschine läuft, gegebenen Reihenfolge erscheinen. Ein Speicher, bei dem ein Prozessor eine andere Reihenfolge sieht als ein anderer, ist nicht sequenziell konsistent. Dabei ist zu beachten, dass diese Definition keinen Bezug nimmt auf Zeit und diese Definition nicht auf zeitlichen Relationen basiert. Dadurch wird kein Bezug genommen auf die „zuletzt“ geschriebene Speicherzelle, die Grundlage war bei der strikten Konsistenz. Bei der sequenziellen Konsistenz sieht ein Prozess alle write-Operationen von allen anderen Prozessoren, jedoch nur seine eigenen read-Operationen.

gültige Reihenfolge

Prozessor Konsistenz

•

Bei der Prozessor-Konsistenz (Processor Consistency) braucht die Folge der Speicheroperationen, die zwei Prozessoren sehen, nicht identisch zu sein. Die Ordnung der write-Operationen bleibt allerdings erhalten.

Schwache Konsistenz

•

Schwache-Konsistenz (Weak Consistency) unterscheidet zwischen normalen (lokalen) und synchronisierten Speicherzugriffen. Nur bei synchronisiertem Zugriff muss der Speicher konsistent sein.

84

2.3 Lose gekoppelte Multiprozessoren und Multicomputer Schwache Konsistenzmodelle lassen sich in der Reihenfolge der Abschwächung weiter untergliedern in: •

Freigabe-Konsistenz (Release Consistency) unterteilt die synchronisierten Speicherzugriffe weiter in Anforderungsoperationen (acquire-Operationen) und Freigabeoperationen (releaseOperationen). Die mit einer acquire- und release-Operation umschlossenen Speicherzugriffe bilden einen kritischen Abschnitt und laufen somit unter wechselseitigem Ausschluss. Normale Zugriffe müssen auf die Beendigung von vorhergehenden acquireOperationen warten; release-Operationen müssen warten, bis alle vorhergehenden normalen Zugriffe sichtbar bei allen anderen Prozessoren werden. Synchronisierte Zugriffe sind ProzessorKonsistenz.

•

Träge Freigabe-Konsistenz (Lazy Release Consistency) ist eine Verfeinerung der Freigabe-Konsistenz. Sie verzögert die Verbreitung von Modifikationen, so dass nur die write-Operationen in der Kette der kritischen Abschnitte verbreitet werden muss. Dies geschieht dann bei der acquire-Operation.

•

Eintritts-Konsistenz (Entry Consistency) verlangt die explizite Synchronisation von Speicherzugriffen, auf die gemeinsamen Daten, durch das Programm und somit durch den Programmierer. Jede gemeinsame Variable ist verknüpft mit einer Synchronisationsvariablen (Lock-Variable oder Barrier-Variable). Jeder kritische Abschnitt ist durch Acquire (Var) und Release (Var) gekapselt.

Der Vorteil der abgeschwächteren Konsistenzmodelle ist ihre einfachere Implementierung und damit einhergehend ein Performancegewinn. Weiterhin erlauben sie einem Compiler, je abgeschwächter die Modelle sind, ein Neuordnen und Überlappen der Speicherzugriffe und damit optimierte Befehlsausführungen.

Vorteile abgeschwächterer Konsistenzmodelle

Abhängig von der Applikation braucht nicht synchronisiert zu werden, wenn auf die Daten zu unterschiedlichen Zeiten zugegriffen wird oder wenn sie lokal sind. Darauf kann dann der Programmierer bei den abgeschwächteren Konsistenzmodellen Bezug nehmen und Wartesituationen vermeiden und umgehen, was einen weiterer Performancegewinn ermöglicht. Das sequenzielle Konsistenzmodell enthält meistens die intuitiv erwartete Semantik der Speicherkohärenz und nimmt dem Programmierer die Last der Synchronisation der parallelen Prozesse ab. Beim sequenziellen Konsistenzmodell laufen Programme für eng gekoppelte Mul-

85

2 Rechnerarchitekturen für Parallele und Verteilte Systeme tiprozessoren ohne Modifikation auf Systemen mit sequenzieller Konsistenz. Busgekoppelte Multiprozessoren mit gemeinsamem Speicher und ohne Cache erfüllen nämlich durch ihre seriellen Zugriffe auf den gemeinsamen Speicher das sequenzielle Konsistenzmodell. Nachteile abgeschwächterer Konsistenzmodelle

Der Nachteil der abgeschwächteren Konsistenzmodelle ist, dass die Synchronisation immer mehr von der Systemebene auf die Applikationsebene verschoben und dem Programmierer aufgebürdet wird. Dies geht hin bis zur Eintritts-Konsistenz, bei der der Programmierer voll für die Konsistenz verantwortlich ist. Dazu muss der Programmierer die Applikation und deren Zugriffe auf die Daten genau kennen und bei gemeinsamen Daten die Synchronisation vornehmen.

Race Conditions

Bei fehlender Synchronisation können Wettlaufsituationen (Race Conditions) auftreten. Unbeabsichtigte Wettlaufsituationen sind ein häufiger Grund für schwer auffindbare Programmfehler; bezeichnend für solche Situationen ist nämlich, dass bereits die veränderten Bedingungen zum Programmtest zu einem völligen Verschwinden der Symptome führen können.

Deadlock

Fehlerhafte Synchronisation kann zu Verklemmungen (Deadlocks) des Programms führen. Verklemmungen sind durch mehrere Programmläufe nicht zu erkennen, da es bei einem Programmtest nicht unbedingt zu einer Verklemmung kommen muss. Diese Fehler sind zeitabhängig, d.h. sie treten nur bei einer bestimmten zeitlichen Reihenfolge der Abarbeitung der einzelnen Programmabschnitte auf.

2.3.2.3 Implementierung der Sequenziellen Konsistenz Implementierung durch Serialisierungsserver

Eine einfache Implementierung des sequenziellen Konsistenzmodells ist ein verteilter Speicher mit einem Zugang, der die Zugriffe durch eine FIFO-Warteschlange seriell anordnet. Bei einem in Software implementierten DSM kann die Serialisierung durch einen zentralen Serverknoten realisiert werden, der alle Speicheranfragen befriedigt. Natürlich sind diese zentralisierten Zugänge zum verteilten Speicher Flaschenhälse. Der Server ist weiterhin ein einzelner Ausfallpunkt. Nachfolgende Implementierungen der sequenziellen Konsistenz vermeiden deshalb den zentralen Server und definieren Protokolle zwischen den Knoten und sind somit eine verteilte Lösung. Die Protokolle hängen davon ab, ob das System Replikas und/oder Migration von Blöcken erlaubt.

86

2.3 Lose gekoppelte Multiprozessoren und Multicomputer Man unterscheidet die folgenden Replikations- und Migrationsstrategien [S 97]: 1. Nicht replizierte und nicht migrierende Blöcke (NRNMBs). 2. Nicht replizierte, migrierende Blöcke (NRMBs). 3. Replizierte und migrierende Blöcke (RMBs). 4. Replizierte und nicht migrierende Blöcke (RNMBs)

Replikationsund Migrationsstrategien

Nicht replizierte und nicht migrierende Blöcke (NRNMBs) Diese einfache Strategie (NRNMB-Strategie) besitzt die folgenden Charakteristiken: 1. Es gibt nur eine Kopie von jedem Block im ganzen System. 2. Der Ort eines Blockes ändert sich nie und bleibt fest. 3. Alle Zugriffswünsche für einen Block gehen an den Knoten, welcher den Block besitzt. Gegeben durch diese Charakteristiken kann zur Allokation eines Blockes eine Abbildungsfunktion eingesetzt werden. Diese Funktion bildet einen Block auf einen Knoten ab. Liegt der Block nicht beim Knoten vor, ist also nicht lokal, so tritt eine Fault auf. Der Faulthandler benutzt die Abbildungsfunktion zur Bestimmung des Ortes des Blockes. Er sendet dann eine Zugriffsanforderung an den Blockbesitzenden. Abb. 2-18: NRNMBsStrategie

Sequenzielle Konsistenz ist bei der NRNMBs-Strategie gegeben, da die verschiedenen Zugriffe zu einem gemeinsamen Block in der Reihenfolge der Anforderung an den blockbesitzenden Knoten ausgeführt werden.

NRNMBs garantiert die sequenzielle Konsistenz

Die Methode ist einfach und leicht zu implementieren, sie besitzt jedoch die folgenden Nachteile: 1. Der serielle Datenzugriff ist ein Flaschenhals.

87

2 Rechnerarchitekturen für Parallele und Verteilte Systeme 2. Parallele Zugriffe, welche ein Vorteil von DSM sind, sind nicht möglich, da alle Zugriffe zu verteilten gemeinsamen Speicher seriell ausgeführt werden.

Nicht replizierte und migriernde Blöcke (NRMBs) NRMBs erhält sequenzielle Konsistenz

Bei der NRMBs-Strategie hat jeder Block des gemeinsamen verteilten Speichers eine einzige Kopie in dem gesamten System. Jeder Zugriff zu einem nicht lokalen Block bewirkt eine Migration des Blockes vom gegenwärtigen Knoten zu dem Knoten, der darauf zugreifen will. Im Vergleich zur NRNMBs-Strategie, bei der ein Besitzer des Blocks sich nicht ändert, ändert sich bei der NRMBs-Strategie der Besitzer des Blockes, sobald der Block auf den neuen Knoten verlagert wurde. Bei der Verlagerung eines Blockes wird der Block aus dem lokalen Adressraum des alten Besitzerknotens entfernt. Nur der Prozess, der auf dem Knoten läuft, kann lesend oder schreibend auf die zu diesem Knoten gehörenden Blöcken zugreifen. Aus diesem Grund sichert die NRMBs die sequenzielle Konsistenz.

Abb. 2-19: NRMBsStrategie

Vorteile der NRMBsStrategie

Die Methode hat die folgenden Vorteile: 1. Greift ein Prozess auf Daten zu, die lokal vorliegen, dann fallen keine Kommunikationskosten an. Die fehlende Kommunikation ist bedingt durch die fehlende Migration. 2. Besitzt eine Applikation viele lokale Referenzen, sind die Migrationskosten vernachlässigbar gegenüber den vielen lokalen Zugriffen.

Nachteile der NRMBsStrategie

Die Methode hat jedoch auch die folgenden Nachteile: 1. Migriert ein Block häufig von einem Knoten auf einen anderen, und findet zwischen den Migrationen nur einige Datenzugriffe statt, so tritt Thrashing (Herumschlagen mit unnützer Arbeit) auf. 2. Der Vorteil des Parallelzugriffs liegt nicht, wie bei der NRNMBsMethode, bei der NRMBs-Methode vor.

88

2.3 Lose gekoppelte Multiprozessoren und Multicomputer Bei der NRMBs-Strategie existiert eine einzelne Kopie von jedem Block, und der Ort des Blockes ändert sich durch die Migration dynamisch. Folgende Methoden zur Lokation eines Blockes stehen zur Verfügung: 1. Broadcasting: Jeder Knoten unterhält eine Blocktabelle mit den Blöcken, die er besitzt. Tritt ein Blockfault auf, schickt der Faulthandler einen Broadcast mit der Anforderung für den Block über das Netz. Der Knoten, welcher den angeforderten Block besitzt, antwortet dann und sendet den Block zu dem anfordernden Knoten.

DatenLokation bei der NRMBsStrategie

Ein Nachteil dabei ist, dass alle Knoten und nicht nur der Knoten, welcher den Block besitzt, den Broadcast bearbeiten müssen. 2. Zentralisierter Server: Ein Server verwaltet die Blocktabelle, die Einträge mit Lokalitätsinformation für alle Blöcke des gemeinsamen Adressraumes enthält. Alle Knoten im System kennen den zentralisierten Server. Tritt ein Blockfault auf, so sendet der Faulthandler eine Anfrage für den Block an den zentralen Server. Dieser liest die Lokation für den Block aus der Blocktabelle und sendet eine Anfrage an den gegenwärtigen blockbesitzenden Knoten. Danach ändert er den Eintrag für die Lokation des Blockes auf den neuen Besitzer des Blockes. Nach Erhalt der Anfrage für den Block transferiert der gegenwärtige Besitzer des Blockes den Block zum serveranfragenden Knoten, der nun neuer Besitzer ist. Die Nachteile des zentralen Server-Algorithmus sind: •

Die Lokationsanfragen werden beim Server sequenzialisiert, was die Parallelität einschränkt, und

•

der Ausfall des zentralen Servers bewirkt einen Verlust der Funktionsfähigkeit des DSM.

3. Feste verteilte Server: Die Rolle des zentralen Servers wird dabei verteilt auf mehrere Server. Dazu benötigt man auf mehreren (auf mehr als einem) Knoten einen Blockmanager. Jeder Blockmanager verwaltet eine feste vorbestimmte Untermenge von Blöcken. Die Abbildung von Blöcken auf die Blockmanager und ihre dazugehörige Knoten wird durch eine Abbildungsfunktion realisiert. Tritt ein Blockfault auf, so findet man über die Abbildungsfunktion den Blockmanager, der den Knoten verwaltet. Die Anfrage für den Block geht dann an diesen Blockmanager. Der Blockmanager behandelt dann die Anfrage wie oben beim zentralen Server beschrieben. 4. Dynamisch verteilte Server: Anstatt mehrerer Blockmanager hält man die Lokationsinformation für alle Blöcke in jedem Knoten; d.h.

89

2 Rechnerarchitekturen für Parallele und Verteilte Systeme jeder Knoten besitzt eine Blocktabelle mit Lokationsinformation für alle Blöcke des gemeinsamen Speichers. Die Besitzinformation für den Block ist jedoch nicht zu jeder Zeit korrekt. Sie gibt jedoch einen Hinweis auf eine Sequenz von Knoten, die durchlaufen werden muss, um den wahren Besitzer des Blockes zu finden. Da die Besitzerinformation nur ein Hinweis auf den Besitzer gibt, heißt sie auch mutmaßlicher Besitzer (probable owner). Tritt ein Blockfault auf, extrahiert der Knoten aus der lokalen Blocktabelle den vermutlichen Besitzer des Blockes. Er sendet dann eine Anfrage für den Block an diesem Knoten. Ist dieser Knoten der wahre Besitzer des Blockes, so transferiert er den Block an den anfragenden Knoten und trägt als Besitzerinformation für den Block in seiner Blocktabelle den anfragenden Knoten ein. Andernfalls bestimmt er aus der Blocktabelle den mutmaßlichen Besitzer und sendet die Anfrage weiter an diesen mutmaßlichen Besitzer. Zusätzlich trägt er anschließend in seiner Blocktabelle den anfragenden Knoten als neuen Besitzer des Blockes ein.

Replizierende und migrierende Blöcke (RMBs) Nachteile von nicht replizierenden Strategien

Hauptnachteil bei den nicht replizierenden Strategien ist, das nur ein Prozess auf dem Knoten auf die Daten in dem Block zugreifen kann. Dies schränkt die Parallelität ein. Zur Erhöhung der parallelen Zugriffe auf einen Block kann dieser repliziert werden. Bei mehrfach vorhandenen Blöcken können die read-Operationen parallel auf verschiedenen Knoten, die eine Kopie des Blockes besitzen, ausgeführt werden. Weiterhin reduziert sich der Kommunikationsoverhead, da die Blöcke lokal auf dem Knoten vorliegen und nicht von einem anderen Knoten transferiert werden müssen.

Nachteile von replizierenden Strategien

Nachteilig bei replizierenden Blöcken sind jedoch die writeOperationen, da die verschiedenen Kopien der Blöcke kohärent gehalten werden müssen. Zur Kohärenzerhaltung der Blöcke kommen die in Abschnitt 2.2.2 beschriebenen MESI Cachekohärenz-Protokolle zum Zuge. Diese beiden Protokolle (Write invalidate und Write update) erhalten in der nachfolgend beschriebenen Weise die sequenzielle Konsistenz. 1. Write Invalidate. Tritt ein Write-Fault (entspricht einem Write Miss beim Write Invalidate Cachekohärenz-Protokoll) auf, dann kopiert der Faulthandler irgendeinen gültigen Block eines anderen Knotens auf den Knoten. Anschließend invalidiert er alle anderen Kopien des Blockes, indem er eine Invalidierungsnachricht mit der Blockadresse an alle Knoten sendet, die eine Kopie besitzen. Er besitzt

90

2.3 Lose gekoppelte Multiprozessoren und Multicomputer nun den Block und kann anschließend schreibend auf den Block zugreifen. Er kann so lange schreibend und lesend darauf zugreifen, bis ein anderer Knoten den Block anfordert. Abb. 2-20: Write invalidate bei der RMBsStrategie

Im Vergleich zu dem vorgestellten Cache-Kohärenz-Protokol (Abschnitt 2.4.1.2.1) wurde hier kein Write Once realisiert. Dadurch existiert nach der Invalidierung nur eine modifizierte Kopie des Blockes im System. Diese Kopie liegt bei dem Knoten, der die Schreiboperation durchgeführt hat.

Sequenzialisierung der read- und writeOperationen

Wenn einer der Knoten, der eine Kopie des Blockes vor der Invalidierung hatte, eine read- oder write-Operation durchführen möchte, dann tritt ein Read Miss bzw. Write Miss auf. Der darauf hin angestoßene Faulthandler des Knotens holt dann die gültige

91

2 Rechnerarchitekturen für Parallele und Verteilte Systeme Kopie von dem Knoten, der die write-Operation durchgeführt hat, wieder zurück. Diese Sequenzialisierung der read- und writeOperationen garantiert die sequenzielle Konsistenz. 2. Write update führt die write-Operation zusätzlich bei allen Kopien des Blockes aus. Tritt eine Write-Fault bei einem Knoten auf, dann kopiert der Faulthandler den Block von einem Knoten zum eigenen Knoten. Die write-Operation wird am eigenen Block ausgeführt, und dieser sendet die Adresse der modifizierten Speicherzelle mit dem eigenen Wert zu allen Knoten, die eine Kopie des Blockes besitzen, Die write-Operation ist erst abgeschlossen, wenn alle Kopien des Blockes den neuen Wert ebenfalls geschrieben haben. Der Write Update-Ansatz erfordert daher bei jeder Schreiboperation aufwändigen Netzverkehr. Abb. 2-21: Write Update bei der RMBsStrategie

92

2.3 Lose gekoppelte Multiprozessoren und Multicomputer Die sequenzielle Konsistenz lässt sich durch eine totale Ordnung der write-Operationen auf allen Knoten erreichen. Die totale Ordnung stellt ein zentraler Sequenzer her:

Sequenzer für sequenzielle Konsistenz

Zuerst wird jede Schreiboperation an den Sequenzer geschickt. Der Sequenzer teilt der write-Operation eine Sequenznummer zu und sendet die write-Operation zu allen Knoten, die ein Replikat des Blockes besitzen. Die write-Operationen werden dann an jedem Knoten in Sequenznummerreihenfolge ausgeführt. readOperationen können zwischen zwei aufeinander folgenden writeOperationen ausgeführt werden und spielen zur Erhaltung der sequenziellen Konsistenz keine Rolle. Abb. 2-22: Sequenzer zur Sequenzialisierung der writeOperationen

Beim Write Update-Protokoll geschieht die Datenlokation bei der RMBs-Strategie folgendermaßen: 1. Lokalisiere den Besitzer des Blockes. Ein Besitzer des Blockes ist der Knoten, welcher den Block besitzt, nämlich der Knoten, der zuletzt in den Block geschrieben hat.

Datenlokation bei der RMBsStrategie

2. Es muss vermerkt werden, welche Knoten außerdem noch eine gültige Kopie (Replikat) von dem Block besitzen. Bei jedem Eintrag in der Blocktabelle zu einem Block muss eine Liste der Knoten vorhanden sein, die ebenfalls eine gültige Kopie (Replikat) des Blockes besitzen. Mit dieser Erweiterung können die

93

2 Rechnerarchitekturen für Parallele und Verteilte Systeme bisher bei der NRMBs-Strategie vorgestellten Methoden (Broadcast, zentralisierter Server, feste verteilte Server, dynamisch verteilte Server) übertragen werden zur Datenallokation bei der RMBsStrategie.

Replizierende und nicht migrierende Blöcke (RNMBs) Bei der RNMBs-Strategie kann ein Block repliziert sein auf mehreren Knoten, jedoch ist die Lokation der Replikationen fest. Das Schreiben und Lesen kann entweder auf dem lokalen Block ausgeführt werden oder die Schreib- und Leseanforderung geht an den Knoten, der ein Replikat des Blockes besitzt. Die Replikationen können konsistent gehalten werden, indem beim Schreiben alle Kopien des Blockes aktualisiert werden. Dies entspricht dann dem bei der RMBs-Strategie verwandten Write update-Protokoll. Charakteristiken der RNMBsStrategie

Die RNMBs-Strategie besitzt die folgenden Charakteristiken: 1. Die Lokation eines replizierten Blockes ändert sich nie. 2. Alle Replikationen eines Blockes sind konsistent. 3. Leseanfragen können direkt zu dem Knoten gesendet werden, der eine Replikation des Blockes besitzt. Schreibanfragen zur Sequenzialisierung müssen an einen Sequenzer geschickt werden.

Datenlokation bei der RNMBsStrategie

Zur Datenlokation bei einer read- oder write-Operation kann jeder Knoten eine Blocktabelle besitzen. Der Sequenzer (ist bei irgendeinem Knoten angesiedelt) besitzt zusätzlich noch eine Sequenztabelle. Die Blocktabelle besitzt einen Eintrag für jeden Block des gemeinsamen Speichers. Jeder Eintrag in der Blocktabelle liefert irgendeinen der replizierten Knoten. Die Sequenztabelle hat ebenfalls für jeden Block des gemeinsamen Speichers einen Eintrag. Ein Eintrag der Sequenztabelle hat drei Felder: 1. Ein Feld für die Blockadresse. 2. Eine Liste von Knoten, welche repliziert sind. 3. Ein Sequenzfeld, das bei jeder write-Operation auf den Block um eins inkrementiert wird. Beim Lesen aus dem Block, kann irgendeine Lokation aus den verschiedenen replizierten Lokationen extrahiert werden. Und die Leseanfrage kann an diesen Block gesendet werden. Eine write-Operation geht zum Sequenzer. Der Sequenzer weist der Schreiboperation eine Sequenznummer zu. An alle Knoten in der Replikationsliste sendet er dann die Schreibanforderung mit der Sequenz-

94

2.3 Lose gekoppelte Multiprozessoren und Multicomputer nummer zu. Dies gewährleistet, dass alle Schreiboperationen bei jedem Knoten in der Ordnung der Sequenznummern ausgeführt werden.

2.3.3 Multicomputer Multicomputer lassen sich unterteilen in: •

MPSs (Massively Parallel Systems) – teuere Supercomputer mit vielen CPUs, die über ein properitäres Hochgeschwindigkeitsnetz gekoppelt sind. Ein bekanntes kommerzielles Beispiel ist die IBM SP/S [To 06]. Durch das Hochgeschwindigkeitsnetz, das alle CPUs mit allen anderen CPUs verbindet, sind diese Systeme total vernetzt. Größere Firmen wie IBM oder NEC produzieren solche Supercomputer, und sie sind auch heute noch unter den schnellsten 500 Rechnern der Welt (TOP-500.org) [To 06] verzeichnet. Diese Systeme waren in den 80er und 90er Jahren populär, sie haben aber in den letzten Jahren stark an Bedeutung verloren.

•

Verbindungs-basierte Multicomputer, bei denen die totale Vernetzung eingeschränkt ist, so dass keine direkte Verbindung zu den meisten CPUs besteht. Nur mit den direkt verbundenen CPUs kann direkt kommuniziert werden. Besteht keine direkte Verbindung, so wird die Nachricht zu dem nicht direkt verbundenen Knoten über Zwischenknoten weitergeleitet. Bei fester Anordnung der Prozessoren und deren Verbindungen hat sich hauptsächlich, neben Gitter und Torus, die Hypercube-Topologie durchgesetzt:

•

Ein Hypercube, auch binärer N-Cube genannt, ist durch einen einzigen Parameter, nämlich der Dimension des Hypercubes, charakterisiert. Dieser Parameter bestimmt die Anzahl der Knoten im Hypercube und die Anzahl der Kommunikationskanäle zwischen den einzelnen Knoten. Ein 0-dimensionaler Hypercube besteht aus zwei Knoten, ein 1-dimensionaler Hypercube besteht aus zwei Knoten, und jeder Knoten hat eine Verbindung zum Nachbarn, ein 2-dimensionaler Hypercube besteht aus vier Knoten und zwei Verbindungen zum Nachbarknoten., ein 3-dimensionaler Hypercube besteht aus 8 Knoten, und jeder Knoten hat 3 Verbindungen zum Nachbarn, und so weiter. Demgemäß enthält ein ndimensionaler Hypercube genau 2n Knoten und jeder Knoten hat n Verbindungen zu den Nachbarknoten, und eine Nachricht von einem Knoten kann jeden anderen Knoten über maximal n Sprünge erreichen.

Massively Parallel

95

2 Rechnerarchitekturen für Parallele und Verteilte Systeme Cluster

•

Normale PCs oder Workstations, die meistens mit EthernetNetzen zusammengeschlossen sind und die der Benutzer selbst aus preiswerten Komponenten zusammengebaut hat. Diese Multicomputer heißen Cluster, besitzen aber auch Namen wie NOW (Network of Workstations) oder COW (Cluster of Workstations). Liegt die Betonung darauf, dass das Cluster aus Standardkomponenten und Massenware aufgebaut ist, so bezeichnet man es als Commodity-Cluster oder auch als COTS (Commodity of the shelf).

•

Heterogene Rechner, mit unterschiedlichsten Leistungsstufen und unterschiedlichen Architekturen, die über das Internet miteinander verbunden sind und über Nachrichten miteinander kommunizieren, bezeichnet man als Grid.

NOW COW COTS

Grid

2.3.4 Leistungs-Effizenzmetriken MIPS/Watt

Zur Optimierung von Supercomputing-Applikationen muss ein Supercomputer die meiste Leistung für einen gegebenen Stromverbrauch bieten. Für Mikroprozessoren ist eine möglichst hohe Leistung bei mäßigem Stromverbrauch wünschenswert. Eine gebräuchliche Metrik dafür ist eine Million Instructions per second durch Watt (MIPS/Watt). MIPS/Watt ist das Verhältnis zwischen der Rate, mit der die CPU Instruktionen verarbeitet, zu der aufgewendeten Energie.

EPMI und EPI

Die Metrik MIPS/Watt ist das Inverse von Energie pro eine Million Instruktion (EPMI) (EPMI = 1/(MIPS/Watt) = Watt/MIPS)). Auf eine durchschnittliche Instruktion bezogen ergibt das die Metrik EPI (Energie pro Instruktion) (EPI = Watt/IPS).

energy*delay

MIPS/Watt oder EPI sind ideale Metriken zur Beurteilung der Effizienz des Stromverbrauchs in Umgebungen, in denen die Durchsatzleistung im Vordergrund steht. Bei höheren Taktraten des Prozessors sinkt die Verzögerungszeit (delay), die benötigt wird, um eine Instruktion von ihrem Anfang bis zu ihrem Ende zu bearbeiten. Weiterhin steigt mit der Erhöhung der Taktrate auch der Energieverbrauch. Leider berücksichtigen MIPS/Watt und EPI nicht die sinkende Ausführungszeit einer Instruktion mit dem erhöhten Energieverbrauch und der Spannungssteigerung. Deshalb schlagen Gonzalez, Gordon und Horowitz [GGH 97] als Metrik das Produkt aus Energie und delay (energy*delay) vor. Diese Metrik korrespondiert mit der Aussage, dass der Einsatz von einem Prozent Energie mit einem Prozent Leistungssteigerung einhergeht. Kostet ein Prozent Leistung zwei Prozent Energie, so kann die beim VLSI Design eingesetzte Metrik energie*delay2 benutzt werden.

96

2.4 Load Balancing und High Throughput Cluster Google Da ein Supercomputer Kollektionen von VLSI-Schaltungen sind, wurde die VLSI-Schaltungs-Metriken energy*t und energy*t2 übertragen auf den Supercomputer Blue Gene/L [SWG 06]. Der Blue Gene/L Supercomputer ist am Lawrence Livermore National Laboratories installiert und ist nach der Top500 Liste [To 06] der schnellste Supercomputer der Welt. Die Metriken erlauben dann Evaluationen zu Schaltungsentwurf, Architektur und eingesetzten Software-Techniken. Die Performance (Zeit t) wurde mit Benchmarks (Linpack, NAMD molecular dynamic simulation, UMT2K und WRF Weather Research and Forecasting) für verschiedene Knotenanzahl (Partitionsgrößen) des Blue Gene ermittelt. Einzelne Ergebnisse dieser Performancemessungen sind: •

Energie*t-Kurve ist besser als die Energie-Gerade über verschiedene Knotenanzahlen (von 1 bis 100.000). Oder interpretativ ausgedrückt: Mit weniger Energie wird bei steigender Kontenanzahl die gleiche Performanz erreicht, oder mehr Performanz ist bei gleicher Energie und steigender Knotenanzahl möglich.

•

Erhöhter Thread-level Parallelismus ist effizienter als Spannungserhöhung. Diese Aussage trifft auch auf Multithread-MulticoreChips zu, die bei geringerer Energieaufnahme einen höheren Durchsatz liefern .

•

Beim WRF-Benchmark ist die parallele Effizienz leicht höher als 50 Prozent bei 2000 Prozessoren. Bei 2048 Prozessoren und erhält man einen 1000fachen Speedup mit 2000 Prozessoren. Somit liegt man um 50 Prozent unter dem linearen Speedup.

energy*t energy*t2

2.4 Load Balancing und High Throughput Cluster Google Zur Erbringung einer hohen Serverleistung mit einem High Throughput Cluster (HPC) möge der Webserver von der Suchmaschine Google als Beispiel dienen. Google ist ein Beispiel für eine durchsatzorientierte Arbeitslast und profitiert von Prozessorarchitekturen, die On-ChipParallelismus (Simultanosus Multithreading und On-ChipMultiprocessors) bieten. Google ist aber auch ebenso ein Beispiel für einen Multicomputer und somit für einen Cluster.

97

2 Rechnerarchitekturen für Parallele und Verteilte Systeme

2.4.1 Leistungsmaße und Ausstattung des Google-Clusters GoogleCluster: Leistungsmaße, Größe und Ausstattung

Der Google-Cluster muss folgende Leistung besitzen und folgende Anforderungen erfüllen: •

Jede einzelne Web-Anfrage erfordert das Lesen von Hunderten von Megabytes von Daten und verbraucht 10 Milliarden CPUZyklen [BDH 03].

•

Eine Höchstlast von Tausenden Anfragen pro Sekunde muss bearbeitet werden [BDH 03]

•

Er besteht aus einer Zusammenschaltung von mehr als 15.000 gewöhnlichen Standard-PCs mit fehlertoleranter Software [BDH 03].

•

Das gesamte World Wide Web (mit über 8 Milliarden Seiten und 1 Milliarde Bildern) muss gesichtet, indiziert und gespeichert werden [T 06].

Nach einer Schätzung auf Basis der Unterlagen zum Börsengang von Google im April 2004 sieht die Hardwareausstattung wie folgt aus:

HighendServer versus Standard-PCs

Fehlerentdeckung und -behebung

98

•

719 Gestellrahmen (Racks),

•

63.272 Rechner,

•

126.544 CPUs,

•

253 Terahertz Ersatz-Taktfrequenz,

•

127 Terabyte RAM und

•

5 Petabyte Festplattenspeicher.

Anstatt Highend-Server und somit mächtige Multiprozessorsysteme, mit riesigen Datenbanken und massiven Transaktionsraten und hoher Zuverlässigkeit einzusetzen, hat Google den weltweit größten Cluster mit Standard-PCs aufgebaut. Ein Highend-Server hat zwei bis dreimal die Leistung eines Desktop-PCs, kostet jedoch normalerweise das 5- bis 10-fache eines PCs. Es waren also Kosteneffizienzgründe, die zu dieser Entscheidung führten. Natürlich fallen billige PCs häufiger aus als Highend-Server und fehlertolerante Multiprozessoren. Deshalb wurde die Zuverlässigkeit in Software über den PCs gelöst. Zuverlässigkeit wird durch die Replikation der Services über verschiedene Maschinen erreicht und redundante Auslegung der Hardware, sowie automatischer Fehlerentdeckung und -behebung. Mit dieser fehlertoleranten Software und redundanten Auslegung kommt es überhaupt nicht mehr darauf an, ob die Ausfall-

2.4 Load Balancing und High Throughput Cluster Google rate bei 0,5 Prozent oder bei 2 Prozent im Jahr liegt. Fehler müssen nur entdeckt und behoben werden. Nach der Erfahrung von Google fallen rund 2 Prozent der PCs jedes Jahr aus. Mehr als die Hälfte der Ausfälle geht auf fehlerhafte Festplatten zurück, gefolgt von der Stromversorgung und den RAM-Chips. CPUs fallen überhaupt nicht mehr aus. Für Abstürze ist in erster Linie nicht die Hardware verantwortlich, sondern die Software. Softwarefehler lassen sich durch einfaches Neubooten des Rechners beheben.

2.4.2 Google Server-Aufbau und -Architektur Ruft ein Benutzer die Seite www.google.com auf, so inspiziert das Domain Name System (DNS) die IP-Adresse des Benutzers und bildet sie auf die Adresse des nächst gelegenen Datenzentrums ab (DNSbasierender Lastverteiler). Weltweit betreibt Google mehrere Datenzentren. Dadurch stehen nicht nur die Datensicherungen für den Fall bereit, dass ein Datenzentrum durch eine Naturkatastrophe wie Erdbeben oder Brand zerstört wird, sondern es lassen sich auch die Wege kurz halten. Der Browser sendet dann die Abfrage an das nächst gelegene Datenzentrum.

Weltweit mehrere Datenzentren

Jedes Datenzentrum hat mindestens eine Glasfaserverbindung mit Leitungsgeschwindigkeit OC-48 (2.488 Gbit/s) zum Internet, über die es Anfragen erhält und Antworten sendet [T 06]. Fällt diese Hauptverbindung aus, steht eine Glasfaserverbindung OC-12 (622Mbit/s) von einem anderen Telekommunikationsanbieter zur Verfügung. Die beiden Glasfaserkabel führen auf die, aus Redundanzgründen doppelt ausgelegten, 128-Port-Ethernet-Switches. Jeden Gestellrahmen verlassen vier Gigabit Ethernet-Verbindungen: mit jeweils zwei Verbindungen zu jedem Switch. Jeder Gestellrahmen enthält übereinander gestapelt bis zu 40 Stück 19-Zoll-Einschübe, die eine ungefähre Höhe von 5 cm haben. Mit einem Einschub vorn und einem hinten ergibt dies bis zu 80 PCs pro Gestellrahmen. Im Gestellrahmen befindet sich noch zusätzlich ein Ethernet Switch, der die 80 PCs miteinander verbindet. Mit einem Paar von 128-Port-Switches und vier Verbindungen von jedem Gestellrahmen können bis zu 64 Gestellrahmen unterstützt werden. Somit kann ein Datenzentrum bis zu 5120 PCs umfassen.

Aufbau des Datenzentrums

99

2 Rechnerarchitekturen für Parallele und Verteilte Systeme OC-48 Glasfaserkabel

Abb. 2-23: Typischer Google Cluster

OC-12 Glasfaserkabel

128-Port-GigabitEthernet-Switch

128-Port-GigabitEthernet-Switch

Gigabit-EthernetVerbindungen

Gestellrahmen mit 80 PCs

. . .

. . .

. . .

. . .

. . .

. . .

. . .

. . .

maximal 64 Gestellrahmen und bis zu 5120 PCs

Von jedem Gestellrahmen verlaufen vier Verbindungen (zwei von den vorderen 40 PCs und zwei von den hinteren PCs auf die beiden 128Port-Switches. Dass ein Gestellrahmen betriebsunfähig wird, müssten vier Verbindungen oder zwei Verbindungen und ein Switch ausfallen. Energiedichte eines GoogleCluster

100

Ein PC verbraucht ungefähr 120 W, was rund 10 KW pro Gestellrahmen ergibt. Ein Gestellrahmen beansprucht eine Stellfläche von 3 m2, sodass das Wartungspersonal PCs installieren und entfernen kann und außerdem genügend Platz für die Lüftung bleibt. Diese Parameter ergeben eine Energiedichte von über 3000 W/m2. Die meisten Datenzentren sind für 600 bis 1200W/m2 ausgelegt, so dass spezielle Maßnahmen erforderlich sind, um die Gestellrahmen zu kühlen.

2.4 Load Balancing und High Throughput Cluster Google

Verarbeitung einer Google Anfrage Der Browser des Benutzers sendet eine HTTP-Anfrage zu dem nächst gelegenen Datenzentrum. Die Bearbeitung dieser Anfrage geschieht gänzlich lokal in diesem Google-Cluster. Ein hardware-basierter Lastausgleicher (Load Balancer) in jedem Google-Cluster überwacht die verfügbaren Google Web Servers (GWSs) und führt einen Lastausgleich zwischen ihnen durch.

Load Balancer

Der GWS sendet die Anfrage parallel an den Spell Checker, der eine Rechtschreibprüfung vornimmt, und an den Ad Server. Auf dem Ad Server (Advertisement Server) sind die Internet-Werbebanner der Werbekunden gespeichert. Ein Ad Server sorgt für die Einblendung der Banner auf einer Webseite, für die der Werbekunde Bannereinblendungen gebucht hat. Google macht sein Geschäft zu 99 Prozent mit der Platzierung von Werbung auf den Webseiten und somit mit dem Ad Server.

Spell Checker

Der GWS sendet dann die Anfrage in einer ersten Phase an die Index Servers und in einer zweiten Phase an die Document Servers:

Google Web Server (GWS)

1. Phase:

Parallele Suche der Dokumente in den Index Servers: Diese Server enthalten einen Eintrag für jedes Wort im Web und den dazugehörigen invertierten Index. Ein invertierter Index ist eine Index-Struktur, welche Wörter auf ihre Lokation in einem Dokument oder eine Menge von Dokumenten abspeichert. Ein kleines Beispiel möge erläutern, wie zu einem Wort der invertierte File-Index [W 06, H2 06, ZM 06] erhalten wird. Gegeben seien die drei Texte T0 = “it is what it is“, T1 = “what is it“ und T2 = “it is a banana“ liefert den folgenden invertierten Fileindex: “a“ “banana“ “is“ “it“ “what“

Ad Server

Index Servers

{2} {2} {0, 1, 2} {0, 1, 2] {0, 1}

Eine Suchanfrage für die drei Terme “what“, “is“ und “it“ ergibt die Menge {0, 1, 2} ∩ {0, 1, 2} ∩ {0, 1} = {0, 1}. Eine Suchanfrage für “what is it“ liefert Treffer für die Wörter in Dokument 0 und Dokument 1, obwohl der Term nur fortlaufend in Dokument 1 enthalten ist.

101

2 Rechnerarchitekturen für Parallele und Verteilte Systeme Jeder Eintrag in den Index-Servern listet alle Dokumente (Webseiten, PDF-Dateien, PowerPoint-Presentationen usw.), die das Wort enthalten, und sortiert nach der Rangfolge der Seite. Der Rang der Seite berechnet sich aus einer komplizierten und von Google geheim gehaltenen Formel, wobei aber die Anzahl der Links zu einer Seite und deren eigene Ränge eine große Rolle spielen. Die Suche ist hoch parallelisierbar, indem der Index in viele kleine Teile zerlegt wird, die Google index shards (Scherben) nennt. Jeder Shard hat eine gemäß dem Rang ausgewählte Untermenge von Dokumenten des vollen Index. Jeder Shard entspricht einem Rang der Dokumente. Für jeden Shard steht ein Pool von Maschinen zur Verfügung. In diesem Pool ist eine Maschine als weiterer Lastausgleicher ausgezeichnet. Steht eine Replikation des Shards nicht mehr zur Verfügung, so vermeidet der Lastausgleicher die Benutzung dieser Maschine. Das ClusterManagementsystem versucht, die Maschine wieder einzubinden, und falls dies nicht gelingt, die Maschine zu ersetzen. Das Ergebnis der ersten Phase und der Indexsuche ist eine geordnete Liste von docids (document identifiers). Diese Liste hat der GWS erhalten. 2. Phase Document Servers

Parallele Zusammenstellung der Dokumente gemäß der docid: Der docid referenziert die eigentliche Dokumente und die Dokumentenserver ziehen den Titel, die URLs und die Textausschnitte in der Nähe des Suchbegriffs heraus. Diese Ergebnisse werden dann dem Dokumentenserver zugeleitet. Die Dokumente sind ebenfalls in Shards aufgeteilt, um parallel auf die Dokumente zugreifen zu können. Die Dokumentenserver enthalten viele Kopien des gesamten Webs bei jedem Datenzentrum, was gegenwärtig Hunderte von Tera-Bytes ausmacht.

Am Ende der Anfrage, wenn der GWS die gefundenen Seiten in der Rangordnung der Seite zusammengetragen hat, werden die erkannten Rechtschreibfehler des Spell Checkers und die relevante Werbung des Ad Server hinzugefügt. Zum Schluss formatiert der GWS die Ergebnisse in HTML (Hypertext Markup Language) und schickt sie an den Web-Browser des Anfragenden.

102

2.4 Load Balancing und High Throughput Cluster Google Abb. 2-24: Verarbeitung einer Google Anfrage

Nähere Informationen über das Google File System (GFS) sind in [GGL 03] enthalten, und der Aufbau von Web-Such-Maschinen ist in [BP 06] beschrieben. Speziell die Infrastrukur für das Crawling und die Crawling-Algorithmen sind in [H1 06] erläutert.

103

3 Programmiermodelle für parallele und verteilte Systeme Dasȱ vorherrschendeȱ Programmiermodellȱ fürȱ paralleleȱ undȱ verteilteȱ Systemeȱ istȱ dasȱ ClientȬServerȬModell.ȱ Dasȱ ClientȬServerȬModellȱ istȱ unabhängigȱvonȱderȱzugrundeȱliegendenȱHardwareplattformȱundȱläuftȱ aufȱallenȱArchitekturen:ȱ x

Einprozessorsysteme,ȱ

x

engȱgekoppeltenȱMultiprozessorenȱundȱMulticoreprozessorenȱundȱ

x

loseȱgekoppeltenȱMultiprozessorenȱundȱMulticomputerȱundȱsomitȱ auchȱaufȱCluster.ȱ

Plattformenȱ fürȱdasȱClientȬ ServerȬModellȱ

DasȱClientȬServerȬModellȱistȱinȱAbschnittȱ3.1ȱbeschrieben.ȱDieȱWeiterȬ entwicklungȱ desȱ ClientȬServerȬModellsȱ führtȱ aufȱ dieȱ ServiceȬ orientiertenȱ Architekturenȱ (SOA),ȱ welcheȱ eineȱ verteilteȱ Architekturȱ besitzen.ȱAufȱSOAȱgehtȱAbschnittȱ3.2ȱein.ȱȱȱȱ BeiȱderȱImplementierungȱdesȱClientȬServerȬModells,ȱdesȱSOAȬModells,ȱ denȱparallelenȱServernȱundȱbeiȱdenȱModellenȱfürȱparalleleȱundȱverteilȬ teȱVerarbeitungȱistȱzuȱunterscheiden,ȱȱ x

obȱdieȱProgrammeȱaufȱeinemȱSystemȱmitȱgemeinsamemȱSpeicher,ȱ alsoȱ aufȱ einemȱ Einprozessorsystemȱ oderȱ engȱ gekoppeltenȱ MultiȬ prozessorsystemȱoderȱMulticoreȬProzessoren,ȱȱ

x

oderȱ aufȱ einemȱ Systemȱ mitȱ verteiltemȱ Speicher,ȱ alsoȱ ProzessorȬ Speicherpärchenȱ (loseȱ gekoppeltenȱ Multiprozessor,ȱ MulticompuȬ terȱoderȱCluster)ȱausgeführtȱwerden.ȱȱ

Gemeinsamerȱ Speicherȱoderȱ Verteilterȱ Speicher?ȱ

Beiȱ einemȱ gemeinsamenȱ Speicherȱ könnenȱ dieȱ parallelȱ abgewickeltenȱ ProzesseȱgleichzeitigȱaufȱgemeinsameȱDatenȱzugreifenȱ(sieheȱAbschnittȱ 3.3).ȱ Dasȱ istȱ jedochȱ nichtȱ möglichȱ beiȱ einemȱ Systemȱ mitȱ verteiltemȱ Speicher.ȱȱ Dieȱ Programmiermodelleȱ fürȱ verteiltenȱ Speicherȱ besitzenȱ keineȱ geȬ meinsamenȱDatenȱundȱerfordernȱeineȱverteilteȱProgrammierungȱ(sieheȱ Abschnittȱ3.4).ȱEinȱAusweg,ȱdasȱfehlendeȱGemeinsameȱherzustellen,ȱist,ȱ eineȱzentraleȱInstanzȱoderȱeinenȱzentralenȱServerȱeinzuführen,ȱaufȱdenȱ alleȱ Prozesseȱ zugreifen.ȱ Dieȱ gemeinsamenȱ Datenȱ könnenȱ dannȱ inȱ denȱ

Dasȱ Gemeinsameȱ verwaltetȱeinȱ zentralerȱ Serverȱ

105ȱ

3 Programmiermodelle für parallele und verteilte Systeme zentralen Server gelegt werden, und alle Prozesse und somit Clients haben Zugriff darauf. nebenläufig oder kooperativ

Die verschiedenen nachfolgend vorgestellten Programmiermodelle für gemeinsamen und für verteilten Speicher (Abschnitt 3.3 und Abschnitt 3.4) lassen sich noch horizontal untergliedern in nebenläufig und kooperativ. Bei nebenläufigen Prozessen ist ihr Einsatzgebiet hauptsächlich für parallele Systeme bestimmt. Ist das Programmiermodell kooperativ, so ist das Einsatzgebiet die Client-Server-, Serviceorientierte- oder Verteilte Programmierung. Eine andere Übersicht und Klassifizierung und die Einbettung der objektorientierten Konzepte in konkurrente und verteilte Systeme sind in [BGL 98] beschrieben. Die Klassifizierung der mehr forschungsorientierten Ansätze unterscheidet x

den Bibliotheks-Ansatz und damit aus der Sichtweise des Systementwicklers,

x

den integrativen Ansatz und damit mehr aus der Sichtweise des Anwendungsentwicklers und

x

den reflektierenden Ansatz, der eine Brücke bildet zwischen den beiden anderen Ansätzen.

Unsere hier gewählte Klassifikation unterscheidet nicht die bei objektorientierten Sprachen vorliegenden Bibliotheken und die Sprache integrierten Ansätze. Die nachfolgend vorgestellten Sprachen und Systeme sind mehr praxisorientiert und orientieren sich mehr an den Ansätzen, die in der Industrie und somit in der Praxis im Einsatz sind. Eine weitere schöne Übersicht und Darstellung der verschiedenen Programmiermodelle für konkurrente und verteilte Programme ist die zweite Auflage des Buches von Ben-Ari [BA 06]. Die Java Programmiermodelle Sockets und Remote Method Invocation (RMI) sowie die Beschreibung vieler verteilter Algorithmen in Java und das Ausformulieren in Java von einer großen Anzahl von Algorithmen sind in Garg [G 04] enthalten.

3.1 Client-Server-Modell Ein Client-Server-System, bezeichnet mit dem regulären Ausdruck C+S, [B 04] besteht aus zwei logischen Teilen: Client-ServerSystem C+S

106

x

Einem oder mehreren Clients, welche die Services oder Daten des Servers in Anspruch nehmen und somit anfordern.

3.1 Client-Server-Modell x

Einem Server, der Services oder Daten zur Verfügung stellt.

Zusammen bilden beide ein komplettes System mit unterschiedlichen Bereichen der Zuständigkeit, wobei diese Zuständigkeiten oder Rollen fest zugeordnet sind, entweder ist ein Prozess ein Client oder ein Server. Ein Server kann mehrere Kunden oder Clients bedienen. Die Kunden eines Servers haben keinerlei Kenntnis voneinander und stehen demgemäß auch in keinem Bezug zueinander, außer der Tatsache, dass sie den gleichen Server verwenden. Clients und Server können auf dem gleichen oder auf unterschiedlichen Rechnern ablaufen. Client und Server sind zwei Ausführungspfade oder -einheiten mit einer Konsumenten-Produzentenbeziehung. Clients dienen als Konsumenten und tätigen Anfragen an Server über Services oder Information. Sie benutzen dann die Rückantwort zu ihrem eigenen Zweck und zur Erledigung ihrer Aufgabe. Server spielen die Rolle des Produzenten und erledigen die Daten- oder Serviceanfragen, die von den Clients gestellt wurden. Die Interaktion zwischen den Clients und dem Server verlaufen somit nach einem fest vorgegebenen Protokoll: Der Client sendet eine Anforderung (request) an den Server, dieser erledigt die Anforderung oder Anfrage und schickt eine Rückantwort (reply) zurück an den Client. Ein Client ist ein auslösender Prozess, und ein Server ist ein reagierender Prozess. Clients tätigen eine Anforderung, die eine Reaktion des Servers auslöst. Clients initiieren Aktivitäten zu beliebigen Zeitpunkten, und andererseits warten Server auf Anfragen von Clients und reagieren dann darauf. Der Server stellt somit einen zentralen Punkt dar, an den Anforderungen geschickt werden können, und nach Erledigung der Anfrage sendet der Server das Ergebnis an den Client zurück.

107

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ ȱ Abb.ȱ3Ȭ1:ȱ Clientsȱundȱ ServerȱC+Sȱ

3.1.1 Fehlersemantik WennȱzwischenȱeinemȱClientȱundȱdemȱServerȱeineȱInteraktionȱstattfinȬ det,ȱsoȱmussȱfestgelegtȱwerden,ȱwieȱClientȱundȱServerȱsichȱkoordinieȬ renȱbeimȱAblaufȱderȱInteraktion.ȱDaȱeineȱlokaleȱInteraktionȱ(Interaktionȱ aufȱeinemȱRechner)ȱsichȱnichtȱvonȱeinerȱentferntenȱInteraktionȱ(InterakȬ tionȱ aufȱ unterschiedlichen,ȱ voneinanderȱ entferntenȱ Rechnern)ȱ unterȬ scheidenȱ soll,ȱ mussȱ überprüftȱ werden,ȱ inwieweitȱ sichȱ dieȱ lokalenȱ GeȬ gebenheitenȱaufȱdenȱentferntenȱFallȱübertragenȱlassen.ȱ

Interaktionskoordinationȱȱ

blockierendȱ

108ȱ

WartetȱderȱClientȱnachȱAbsendenȱderȱAnforderungȱanȱdenȱServerȱaufȱ eineȱRückantwort,ȱbevorȱerȱanderenȱAktivitätenȱnachgeht,ȱsoȱliegtȱderȱ blockierendeȱ oderȱ synchroneȱ Fallȱ vor.ȱ Diesesȱ Vorgehenȱ istȱ leichtȱ zuȱ implementieren,ȱjedochȱineffizientȱinȱderȱAusnutzungȱderȱProzessorfäȬ higkeitenȱdesȱClients.ȱWährendȱderȱServerȱdieȱAnfrageȱbearbeitet,ȱruhtȱ

3.1ȱClientȬServerȬModellȱ dieȱ Arbeitȱ desȱ Clients,ȱ undȱ erstȱ wennȱ dieȱ Rückantwortȱ kommt,ȱ setztȱ derȱClientȱseineȱArbeitȱfort.ȱ SendetȱderȱClientȱnurȱseineȱAnforderungȱundȱarbeitetȱsofortȱweiter,ȱsoȱ liegtȱ derȱ nichtȱ blockierendeȱ oderȱ asynchroneȱ Fallȱ vor.ȱ Irgendwannȱ nichtȱ späterȱ nimmtȱ erȱ dannȱ dieȱ Rückantwortȱ entgegen.ȱ Derȱ Vorteilȱ diesesȱ blockierendȱȱ Verfahrensȱ ist,ȱ dassȱ derȱ Clientȱ parallelȱ zurȱ Nachrichtenübertragungȱ weiterarbeitenȱ kannȱ undȱ denȱ ClientȬProzessȱ nichtȱ durchȱ aktivesȱ WarȬ tenȱbelastet,ȱwieȱbeimȱ blockierendenȱ Fall.ȱ Jedochȱ mussȱ beiȱdieserȱ MeȬ thodeȱ derȱ erhöhteȱ Effizienzgewinnȱ mitȱ erhöhterȱ Kontrollkomplexitätȱ beiȱ Erhaltȱ derȱ Rückantwortȱ erkauftȱ werden.ȱ Dieȱ Rückantwortȱ mussȱ dabeiȱ inȱ einerȱ lokalenȱ Warteschlangeȱ abgelegtȱ werden,ȱ welcheȱ derȱ Clientȱdannȱsoȱlangeȱabfragenȱmuss,ȱbisȱdieȱRückantwortȱeingetroffenȱ istȱundȱsomitȱinȱderȱWarteschlangeȱvorliegt.ȱInȱdiesemȱFallȱsprichtȱmanȱ auchȱvonȱverschobenerȱoderȱzurückgestellterȱsynchronerȱ(deferredȱsynȬ chronous)ȱ Kommunikation.ȱ Einȱ alternativesȱ Vorgehenȱ siehtȱ beimȱ ClientȱeineȱRegistrierungȱvonȱRückrufenȱ(callbacks)ȱvor.ȱDieȱRückrufeȱ könnenȱ dannȱ Funktionseingangspunkteȱ oderȱ Ereignisseȱ sein.ȱ Beimȱ EintreffenȱderȱRückantwortȱwerdenȱdannȱdieȱregistriertenȱFunktionenȱ bzw.ȱ Ereignisbehandlungsroutinenȱ aktiviert.ȱ Dieserȱ Ansatzȱ eliminiertȱ dasȱ ständigeȱ Abfragenȱ derȱ lokalenȱ Warteschlange,ȱ generiertȱ jedochȱ möglicherweiseȱ Rückrufeȱ zuȱ ungelegenenȱ Zeitenȱ undȱ benötigtȱ damitȱ zusätzlichenȱ Kontrolloverhead,ȱ umȱ solcheȱ unerwünschtenȱ UnterbreȬ chungenȱauszuschließen.ȱEineȱweitereȱMöglichkeitȱist,ȱdassȱderȱClientȱ nurȱ eineȱ Anforderungȱ abschicktȱ undȱ sichȱ dannȱ nichtȱ mehrȱ umȱ dieȱ Rückantwortȱ kümmert.ȱ Inȱ diesemȱ Fallȱ liegtȱ eineȱ EinȬWegȬ Kommunikationȱ(oneȬway)ȱvor.ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

109ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ Abb.ȱ3Ȭ2:ȱ InteraktionsȬ koordinationsȬ artenȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

ȱ AblaufsemantikȱderȱInteraktionȱ Derȱ Ablaufȱ derȱ Interaktion,ȱ dieȱ zwischenȱ zweiȱ Rechnernȱ stattfindet,ȱ sollȱdieȱgleicheȱSemantikȱbesitzen,ȱwieȱwennȱdieȱInteraktionȱȱlokal,ȱalsoȱ aufȱeinemȱRechnerȱabläuft;ȱd.h.ȱlokaleȱundȱentfernteȱInteraktionȱsollenȱ dieȱ gleicheȱ Syntaxȱ undȱ Semantikȱ besitzen.ȱ Selbstȱ wennȱ dieȱ AnfordeȬ rungenȱ oderȱ Aufrufeȱ derȱ Clientsȱ keinerleiȱ syntaktischenȱ Unterschiedȱ zwischenȱ lokalerȱ undȱ entfernterȱ Interaktionȱ aufweisen,ȱ soȱ mussȱ dochȱ derȱ semantischeȱ Unterschiedȱ mitȱ inȱ eineȱ dieȱ Interaktionȱ benutzendeȱ Anwendungȱeinfließen.ȱȱ UmȱaufȱÜbertragungsfehlerȱundȱAusfälleȱzuȱreagieren,ȱkannȱeineȱAusȬ nahmebehandlungȱ (exceptionȱ handling)ȱ eingeführtȱ sein,ȱ wasȱ dannȱ jedochȱ zuȱ syntaktischenȱ Unterschiedenȱ beiȱ lokalerȱ undȱ entfernterȱ InȬ

110ȱ

3.1ȱClientȬServerȬModellȱ teraktionȱ führt.ȱ Weiterhinȱ führtȱ dasȱ zuȱ semantischenȱ Unterschiedenȱ zwischenȱ lokalerȱ undȱ entfernterȱ Transaktion,ȱ daȱ dieseȱ Fehlerfälleȱ garȱ nichtȱ beiȱ einerȱ lokalenȱ Interaktionȱ auftretenȱ können.ȱ Inȱ vielenȱ ProȬ grammiersprachenȱ wieȱ z.B.ȱ Ada,ȱ C++,ȱ Javaȱ kannȱ eineȱ AusnahmebeȬ handlungsroutineȱ angegebenȱ werden,ȱ dieȱ dannȱ beimȱ Auftretenȱ einesȱ speziellenȱFehlerfallesȱangesprungenȱwird.ȱInȱCȱunterȱUnixȱlassenȱsichȱ fürȱsolcheȱZweckeȱauchȱSignalȬHandlerȱeinsetzen.ȱȱ Daȱ dieȱ Interaktionȱ mitȱ Hilfeȱ zugrundeȱ liegenderȱ NetzwerkkommuniȬ kationȱimplementiertȱist,ȱvergrößertȱdieseȱdieȱAnzahlȱderȱInteraktionsȬ fehler.ȱDieseȱFehlerȱkönnenȱsein:ȱ x

Dieȱ Anforderungȱ gehtȱ verlorenȱ oderȱ erfährtȱ eineȱ Verzögerung,ȱ oderȱ

x

dieȱ Rückantwortȱ gehtȱ verlorenȱ oderȱ erfährtȱ eineȱ Verzögerung,ȱ oderȱ

x

derȱ Serverȱ oderȱ derȱ Clientȱ könnenȱ zwischenzeitlichȱ abgestürztȱ undȱdadurchȱnichtȱerreichbarȱsein.ȱ

Eineȱ unzuverlässigeȱ Interaktionȱ übergibtȱ dieȱ Nachrichtȱ nurȱ demȱ Netz,ȱ undȱ esȱ gibtȱ keineȱ Garantie,ȱ dassȱ dieȱ Nachrichtȱ beimȱ Empfängerȱ anȬ kommt.ȱ Dieȱ Anforderungsnachrichtȱ kommtȱ nichtȱoderȱhöchstensȱeinmalȱ beimȱ Serverȱ an.ȱ Inȱ diesemȱ Fallȱ sprichtȱ manȱ vonȱ mayȱ beȬSemantikȱ derȱ Interaktion.ȱ Eineȱ zuverlässigeȱ Interaktionȱ mussȱ dannȱ selbstȱ vomȱ BeȬ nutzerȱimplementiertȱwerden.ȱȱ

InteraktionsȬ fehlerȱ

mayȱbeȬ Semantikȱȱ

ZurȱErhaltungȱeinerȱzuverlässigenȱInteraktionȱkannȱentwederȱȱ 1.ȱjedeȱNachrichtenübertragungȱdurchȱSendenȱeinerȱRückantwortȱquitȬ tiertȱwerden,ȱoderȱ 2.ȱeinȱRequestȱundȱeinȱReplyȱwerdenȱzusammenȱdurchȱeineȱRückantȬ wortȱquittiert.ȱ Imȱ Fallȱ Einsȱ mussȱ nachȱ demȱ Sendenȱ derȱ Anforderungȱ derȱ Serverȱ anȱ denȱ Clientȱ eineȱ Quittierungȱ zurückschicken.ȱ Eineȱ Rückantwortȱ vomȱ Serverȱ anȱ denȱ Clientȱ wirdȱ dannȱ vomȱ Clientȱ anȱ denȱ Serverȱ quittiert.ȱ Damitȱ brauchtȱ einȱ Requestȱ mitȱ anschließendemȱ Replyȱ vierȱ NachrichȬ tenübertragungen.ȱ ImȱzweitenȱFallȱbetrachtetȱmanȱeineȱClientȬServerȬKommunikationȱalsȱ eineȱ Einheit,ȱ dieȱ quittiertȱ wird.ȱ Derȱ Clientȱ blockiertȱ dabei,ȱ bisȱ dieȱ Rückantwortȱeintrifft,ȱundȱdieseȱRückantwortȱwirdȱquittiert.ȱ ȱ ȱ

111ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ ȱ Abb.ȱ3Ȭ3:ȱ Zuverlässigeȱ NachrichtenȬ übertragungȱȱ a)ȱdurchȱ individuellȱ quittierteȱ Nachrichtenȱ b)ȱdurchȱ Quittierungȱ einesȱRequestȱ undȱReplyȱ ȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ Beiȱ einerȱ zuverlässigenȱ Nachrichtenübertragungȱ mussȱ derȱ SendeproȬ zessȱblockiertȱwerdenȱundȱerȱmussȱwarten,ȱbisȱdieȱRückantwortȱinnerȬ halbȱ einerȱ vorgegebenenȱ Zeitȱ eintrifft.ȱ Trifftȱ dieȱ Rückantwortȱ nichtȱ innerhalbȱ derȱ vorgegebenenȱ Zeitschrankeȱ ein,ȱ soȱ wirdȱ dieȱ Nachrichtȱ erneutȱ gesendetȱ undȱ dieȱ Zeitschrankeȱ neuȱ gesetzt.ȱ Führtȱ dasȱ nachȱ mehrmaligenȱVersuchenȱnichtȱzumȱErfolg,ȱsoȱistȱimȱMomentȱkeinȱSenȬ

112ȱ

3.1ȱClientȬServerȬModellȱ denȱ möglichȱ (dieȱ Leitungȱ istȱ entwederȱ gestörtȱ undȱ dieȱ Paketeȱ gehenȱ verloren,ȱ oderȱ derȱ Empfängerȱ istȱ nichtȱ empfangsbereit).ȱ Erhältȱ einȱ EmpfängerȱdurchȱmehrfachesȱSendenȱdieȱgleicheȱNachrichtȱmehrmals,ȱ soȱkannȱerȱdieȱerneutȱeingehendeȱgleicheȱNachrichtȱbearbeiten,ȱundȱerȱ stelltȱ soȱ sicher,ȱ dassȱ dieȱ eingehendeȱ Anforderungȱ mindestensȱ einmalȱ bearbeitetȱ wirdȱ (atȱ leastȱ once).ȱ Dabeiȱ wirdȱ jedochȱ fürȱ denȱ Erhaltȱ derȱ NachrichtȱbeiȱSystemausfällenȱkeineȱGarantieȱgegeben.ȱȱ

atȱleastȱonceȬ Semantikȱȱ

DieȱatȱleastȱonceȬSemantikȱhatȱdenȱNachteil,ȱdassȱdurchȱdieȱmehrfacheȱ BearbeitungȱderȱAnforderungȱdieȱ Datenȱ inkonsistentȱ werdenȱ können.ȱ BetrachtenȱSieȱ dazuȱ beispielsweiseȱ einenȱ FileȬServer,ȱ derȱ einenȱ gesenȬ detenȱ Datensatzȱ anȱ eineȱ bestehendeȱ Dateiȱ anhängt.ȱ Dieȱ atȱ leastȱ onceȬȱ MethodeȱhängtȱdannȱmöglicherweiseȱdenȱDatensatzȱmehrfachȱanȱeineȱ Dateiȱ hintenȱ an.ȱ Dieseȱ Methodeȱ arbeitetȱ jedochȱ korrekt,ȱ wennȱ einȱ ClientȱeinenȱbestimmtenȱDatensatzȱeinesȱFilesȱvomȱFileȬServerȱzurückȬ habenȱ möchte.ȱ Hierȱ trittȱ nurȱ derȱ Umstandȱ auf,ȱ dassȱderȱ Clientȱ diesenȱ Datensatzȱmöglicherweiseȱmehrfachȱerhält.ȱȱ Besser,ȱ aberȱ mitȱ erhöhtemȱ Implementierungsaufwand,ȱ lässtȱ sichȱ auchȱ bewerkstelligen,ȱ dassȱ dieȱ Nachrichtȱ höchstensȱ einmalȱ (atȱ mostȱ once)ȱ erhaltenȱ wird,ȱ jedochȱ ohneȱ Garantieȱ beiȱ Systemfehlern,ȱ d.h.ȱ mögliȬ cherweiseȱauchȱgarȱnicht.ȱBeiȱdieserȱMethodeȱbenötigtȱderȱEmpfängerȱ eineȱ Anforderungsliste,ȱ welcheȱ dieȱ bisherȱ gesendetenȱ Anforderungenȱ enthält.ȱ Jedesȱ Mal,ȱ wennȱ dannȱ eineȱ neueȱ Anforderungȱ eintrifft,ȱ stelltȱ derȱ Empfängerȱ mitȱ Hilfeȱ derȱ Nachrichtenidentifikationȱ fest,ȱ obȱ schonȱ dieȱ gleicheȱ Anforderungȱ inȱ derȱ Listeȱ steht.ȱ Trifftȱ diesȱ zu,ȱ soȱ gingȱ dieȱ RückantwortȱverlorenȱundȱesȱmussȱerneutȱeineȱRückantwortȱgesendetȱ werden.ȱIstȱdieȱAnforderungȱnochȱnichtȱinȱderȱListeȱvermerkt,ȱsoȱwirdȱ sieȱinȱdieȱListeȱeingetragen.ȱAnschließendȱwirdȱdieȱAnforderungȱbearȬ beitetȱundȱeineȱentsprechendeȱRückantwortȱgesendet.ȱIstȱdieȱRückantȬ wortȱbestätigt,ȱkannȱdieȱAnforderungȱausȱderȱListeȱgestrichenȱwerden.ȱ

atȱmostȱonceȬ Semantikȱ

SollȱauchȱnochȱderȱSystemfehlerȱdesȱPlattenausfallsȱsichȱnichtȱauswirȬ exactlyȱonceȬ ken,ȱsoȱmussȱdieȱAnforderungslisteȱimȱstabilenȱSpeicherȱ(stableȱstoraȬ Semantikȱ ge)ȱgehaltenȱwerden.ȱBeiȱgenauȱeinmalȱmitȱGarantieȱbeiȱSystemfehlernȱ sprichtȱmanȱvonȱderȱexactlyȱonceȬSemantik.ȱȱ ȱ ȱ ȱ ȱ ȱ

113ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ Abb.ȱ3Ȭ4:ȱ Vergleichȱ derȱ

ȱ

a)ȱatȱleastȱ onceȬȱundȱȱ

ȱ

b)ȱatȱmostȱ onceȬȱbzw.ȱ exactlyȱonceȬȱ Semantikȱȱ

ȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

Serverausfälleȱ

114ȱ

FälltȱderȱServerȱaus,ȱnachdemȱdieȱAnforderungȱdenȱServerȱerreichtȱhat,ȱ soȱgibtȱesȱkeineȱMöglichkeit,ȱdiesȱdemȱClientȱmitzuteilen,ȱundȱfürȱdenȱ ClientȱgibtȱesȱkeineȱMöglichkeit,ȱdiesȱherauszufinden.ȱDerȱClientȱkannȱ beimȱAusbleibenȱderȱRückantwortȱerneutȱdieȱAnforderungȱsendenȱundȱ hoffen,ȱ dassȱ derȱ Serverȱ wiederȱ läuft.ȱ Dadurchȱ gleitetȱ manȱ aufȱ dieȱ atȱ

3.1ȱClientȬServerȬModellȱ mostȱ onceȬSemantikebeneȱ abȱ undȱ dieȱ exactlyȱ onceȬSemantikȱ istȱ nichtȱ realisierbar.ȱ Dieȱ Möglichkeitȱ einesȱ Serverausfallesȱ istȱ derȱ Grund,ȱ dassȱ entfernteȱ Interaktionȱ nichtȱ dieȱ Semantikȱ vonȱ lokalerȱ Interaktionȱ erȬ reichtȱundȱsomitȱzwischenȱlokalerȱundȱentfernterȱInteraktionȱzuȱunterȬ scheidenȱist.ȱȱ FälltȱderȱClientȱaus,ȱwährendȱerȱeineȱAnfrageȱangestoßenȱhatȱundȱaufȱ dieȱ Rückantwortȱ wartet,ȱ soȱ istȱ fürȱ denȱ Serverȱ keinȱ Partnerȱ mehrȱ vorȬ handen,ȱ derȱ ihmȱ dasȱ Anfrageergebnisȱ abnimmt.ȱ Berechnungenȱ desȱ Servers,ȱderenȱErgebnisȱerȱnichtȱmehrȱabgenommenȱbekommt,ȱwerdenȱ somitȱzuȱWaisen.ȱ

Clientausfälle

3.1.2 Serverzustände EineȱAnforderung,ȱdieȱeinȱClientȱeinemȱServerȱzuschickt,ȱkannȱmögliȬ cherweiseȱÄnderungenȱderȱvomȱServerȱverwaltetenȱDatenȱoderȱObjekȬ teȱhervorrufen,ȱsoȱdassȱdiesȱAuswirkungenȱaufȱnachfolgendeȱAnfordeȬ rungenȱvonȱClientsȱhat.ȱDerȱServerȱverhältȱsichȱdadurchȱbeiȱdenȱnachȬ folgendenȱ Anforderungenȱ anders.ȱ Dementsprechendȱ lassenȱ sichȱ dieȱ DiensteȱeinesȱServersȱklassifizierenȱinȱȱ x

zustandsinvarianteȱundȱȱ

x

zustandsänderndeȱDienste.ȱ

EinenȱServer,ȱderȱnurȱzustandsinvarianteȱDiensteȱanbietet,ȱbezeichnenȱ wirȱdementsprechendȱalsȱzustandsinvariantȱundȱsonstȱalsȱzustandsänȬ dernd.ȱDenȱZustandȱderȱObjekteȱeinesȱServersȱbezeichnenȱwirȱmitȱZuȬ standȱdesȱServers.ȱȱ Zustandsinvarianteȱ Serverȱ liefernȱ Informationenȱ undȱ Parameter;ȱ dieȱ InformationsmengeȱundȱdieȱParameterȱkönnenȱsichȱzwarȱändern,ȱaberȱ dieseȱ Änderungenȱ sindȱ unabhängigȱ vonȱ denȱ Anforderungenȱ derȱ Clients.ȱ Beispieleȱ vonȱ solchenȱ Servernȱ sindȱ InformationsabrufȬServer,ȱ wieȱWebȬServerȱundȱftpȬServer,ȱAuskunftsȬServerȱwieȱNamensȬServer,ȱ DirectoryȬServerȱ undȱ VermittlungsȬȱ oderȱ BrokerȬServer.ȱ Einȱ weiteresȱ Beispielȱ fürȱ einenȱ zustandsinvariantenȱ Server,ȱ dessenȱ bereitgestellteȱ InformationȱsichȱunabhängigȱvonȱdenȱAnforderungenȱderȱClientsȱstarkȱ ändert,ȱistȱeinȱZeitȬServer.ȱBeiȱzustandsinvariantenȱServernȱführenȱalsoȱ AnforderungenȱvonȱClientsȱnichtȱzuȱneuenȱZuständenȱdesȱServers.ȱ

ZustandsȬ invarianteȱ Serverȱ

BeiȱzustandsänderndenȱServernȱüberführtȱeineȱAnfrageȱdesȱClientsȱdenȱ ZustandsȬ ServerȱmöglicherweiseȱinȱeinenȱneuenȱZustand.ȱAbhängigȱvomȱneuenȱ änderndeȱ ZustandȱdesȱServersȱkönnenȱdannȱgewisseȱAnforderungenȱvonȱClientsȱ Serverȱ nichtȱ mehrȱ befriedigtȱ werdenȱ undȱ führenȱ aufȱ Fehlermeldungen,ȱ dieȱ derȱ Clientȱ vomȱ Serverȱ zurückbekommt.ȱ Einȱ Beispielȱ fürȱ solchȱ einenȱ

115ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ ServerȱistȱeinȱFileȬServer.ȱDieȱAufforderungȱeinesȱClientsȱzumȱLöschenȱ einesȱ Filesȱ führtȱ beiȱ nachfolgendenȱ Leseoperationen,ȱ dieȱ Clientsȱ aufȱ diesemȱFileȱausführenȱwollenȱundȱdieȱnunȱnichtȱmehrȱmöglichȱsind,ȱzuȱ Fehlermeldungen.ȱȱ Beiȱ zustandsinvariantenȱ Servernȱ spieltȱ dieȱ Reihenfolgeȱ derȱ ServiceanȬ forderungenȱderȱClientsȱkeineȱRolle.ȱSieȱkönnenȱinȱirgendeinerȱReihenȬ folgeȱanȱdenȱServerȱgestelltȱwerden.ȱBeiȱzustandsänderndenȱServernȱistȱ dieȱ Reihenfolgeȱ derȱServiceanforderungenȱ vonȱgrößterȱ Bedeutung,ȱ daȱ derȱ Serverȱ möglicherweiseȱ beiȱ Erledigungȱ derȱ Serviceanforderungȱ seinenȱZustandȱändert.ȱȱ

ZustandsspeicherndeȱundȱzustandsloseȱServerȱ Einȱ zustandsändernderȱ Serverȱ kannȱ seinenȱ neuenȱ Zustandȱ speichernȱ oderȱnicht.ȱDementsprechendȱunterscheidetȱmanȱinȱȱ

ZustandsȬ speichernderȱ Serverȱ

x

zustandsspeicherndeȱ(stateful)ȱServerȱoderȱȱ

x

zustandsloseȱ(stateless)ȱServer.ȱ

Beiȱ einemȱ zustandsspeicherndenȱ Serverȱ speichertȱ derȱ Serverȱ nachȱ derȱ Anforderungȱ desȱ Servicesȱ denȱ neuenȱ Zustandȱ inȱ seinenȱ internenȱ ZuȬ standstabellen.ȱDadurchȱkenntȱderȱServerȱdenȱZustandȱundȱderȱServerȱ besitztȱ somitȱ einȱ „Gedächtnis“.ȱ Diesesȱ Gedächtnisȱ desȱ Serversȱ befreitȱ denȱClient,ȱdenȱZustandȱdemȱServerȱmitzuteilen,ȱwasȱdannȱdieȱLängeȱ derȱAnforderungsnachrichtenȱundȱdamitȱdieȱNetzwerkbelastungȱreduȬ ziert.ȱ Derȱ Kommunikationsverlaufȱ oderȱ dieȱ Konversationȱ zwischenȱ demȱClientȱundȱdemȱServerȱbesitztȱdamitȱeineȱKontinuitätȱ(conversatiȬ onalȱ continuityȱ [Aȱ 91]).ȱ Dasȱ Gedächtnisȱ erlaubtȱ demȱ Server,ȱ vorausȬ schauendȱ aufȱ neueȱ zukünftigeȱ Anfragenȱ desȱ Clientsȱ zuȱ schließenȱ (Nachfolgezustände),ȱundȱerȱkannȱVorkehrungenȱtreffenȱundȱentspreȬ chendeȱOperationenȱdurchführen,ȱsoȱdassȱdieseȱzukünftigenȱAnfragenȱ schnellerȱbearbeitetȱwerden.ȱ Dasȱ bisherȱ Gesagteȱ seiȱ amȱ Beispielȱ einesȱ zustandsspeicherndenȱ FileȬ Serversȱerläutert:ȱ Einȱ zustandsspeichernderȱ FileȬServerȱ benutztȱ dasȱ gleicheȱ Vorgehenȱ wieȱeinȱzentralesȱFilesystemȱaufȱeinemȱEinprozessorsystem.ȱDortȱwirdȱ ebenfallsȱ immerȱ derȱ Zustandȱ desȱ Filesȱ gespeichert,ȱ z.B.ȱ welcherȱ ProȬ zessȱhatȱdenȱFileȱgeöffnet,ȱgegenwärtigeȱFilepositionȱundȱwasȱwarȱderȱ letzteȱ geleseneȱ oderȱ geschriebeneȱ Satz.ȱ Dieseȱ Zustandsinformationȱ kannȱ derȱ FileȬServerȱ zusammenȱ mitȱ demȱ Fileȱ abspeichern.ȱ Derȱ FileȬ Serverȱgehtȱdabeiȱfolgendermaßenȱvor:ȱÖffnetȱeinȱClientȱeinenȱFile,ȱsoȱ gibtȱ derȱ Serverȱ demȱ Clientȱ einenȱ Verbindungsidentifierȱ zurück,ȱ derȱ

116ȱ

3.1ȱClientȬServerȬModellȱ eindeutigȱ istȱ fürȱ denȱ geöffnetenȱ Fileȱ undȱ denȱ dazugehörigenȱ Client.ȱ Nachfolgendeȱ Zugriffeȱ desȱ Clientsȱ benutzenȱ denȱ VerbindungsidentiȬ fierȱzumȱZugriffȱaufȱdenȱFile.ȱDiesȱreduziertȱdieȱLängeȱderȱNachrichten,ȱ daȱderȱZustandȱdesȱFilesȱnichtȱvomȱClientȱzumȱServerȱübertragenȱwerȬ denȱmuss.ȱDerȱFilezustandȱundȱmöglicherweiseȱdasȱFileȱselbstȱkannȱimȱ Hauptspeicherȱgehaltenȱwerden;ȱdurchȱdenȱeindeutigenȱVerbindungsȬ identifierȱkannȱdirektȱohneȱPlattenzugriffȱzugegriffenȱwerden.ȱZusätzȬ lichȱ enthältȱ derȱ Zustandȱ Informationȱ darüber,ȱ obȱ derȱ Fileȱ fürȱ sequenȬ tiellen,ȱdirektenȱoderȱindexȬsequentiellenȱZugriffȱgeöffnetȱwurde,ȱundȱ esȱkannȱ dadurchȱeinȱ vorausschauendesȱ Lesenȱ aufȱ denȱ nächstenȱBlockȱ stattfinden.ȱ Imȱ Gegensatzȱ zumȱ obigem,ȱ besitztȱ einȱ zustandsloserȱ Serverȱ keineȱ InȬ formationȱüberȱdenȱZustandȱseinerȱverwaltetenȱObjekte.ȱJedeȱAnfordeȬ rungȱ einesȱ Clientsȱ mussȱ deshalbȱ dieȱ kompletteȱ Zustandsinformation,ȱ beimȱBeispielȱdesȱFileȬServersȱdenȱFile,ȱZugriffsartȱaufȱdenȱFileȱundȱdieȱ Positionȱinnerhalbȱ desȱFiles,ȱ demȱ Serverȱübermitteln,ȱ soȱ dassȱ derȱ SerȬ verȱdieȱgewünschteȱOperationȱausführenȱkann.ȱBeimȱÖffnenȱdesȱFilesȱ brauchtȱ damitȱ derȱ FileȬServerȱ keineȱ Zustandsinformationȱ anzulegenȱ undȱ keinenȱ Verbindungsidentifierȱ fürȱ denȱ Clientȱ zuȱ generieren.ȱ DesȬ halbȱbrauchtȱeinȱzustandsloserȱFileȬServerȱauchȱkeinȱexplizitesȱÖffnenȱ undȱ Schließenȱ aufȱ Filesȱ alsȱ Operationȱ anzubieten.ȱ Derȱ Nachteilȱ einesȱ zustandslosenȱ Serversȱ istȱ somitȱ einȱ Performanzverlust,ȱ daȱ dieȱ ZuȬ standsinformationȱ nichtȱ wieȱ beiȱ einemȱ zustandsspeicherndenȱ Serverȱ imȱHauptspeicherȱgehaltenȱwerdenȱkann.ȱȱ

Zustandsloserȱ Serverȱ

Einȱ zustandsloserȱ Serverȱ bietetȱ jedochȱ Vorteileȱ beimȱ Absturzȱ desȱ SerȬ vers.ȱ Stürztȱ einȱ zustandsspeichernderȱ Serverȱ ab,ȱ soȱ sindȱ damitȱ alleȱ Zustandsbeschreibungenȱ verloren.ȱ Kommtȱ derȱ Serverȱ nachȱ einerȱ geȬ wissenȱ Zeitȱ wiederȱ hoch,ȱ weißȱ derȱ Serverȱ dannȱ nicht,ȱ welcheȱ Clientsȱ welcheȱObjekte,ȱoderȱbeiȱeinemȱFileȬServer,ȱwelcheȱFilesȱbearbeitetȱhat.ȱ NachfolgendeȱAnforderungenȱvonȱClientsȱanȱdenȱServerȱkönnenȱdannȱ vonȱihmȱnichtȱbearbeitetȱwerden.ȱAusȱdiesemȱGrundȱsindȱzustandsloseȱ ServerȱfehlertoleranterȱalsȱZustandsspeichernde.ȱStürztȱeinȱzustandsloȬ serȱ Serverȱ ab,ȱ soȱ bemerktȱ dasȱ einȱ Clientȱ durchȱ dasȱ Ausbleibenȱ einerȱ Rückantwort.ȱ Läuftȱ dannȱ derȱ Serverȱ wieder,ȱ soȱ sendetȱ derȱ Clientȱ erȬ neutȱ eineȱ Anfrageȱ anȱ denȱ Server,ȱ dieȱ erȱ nunȱ abarbeitenȱ kann,ȱ daȱ dieȱ AnfrageȱalleȱZustandsinformationenȱenthält.ȱ

Zustandslosȱ versusȱ zustandsȬ speicherndȱ

Einȱ Serviceȱ (sieheȱ Abschnittȱ 3.2)ȱ sollteȱ möglichstȱ zustandslosȱ sein:ȱ Erȱ sollteȱ alsoȱ keineȱ Informationenȱ vonȱ Clientsȱ zwischenȱ zweiȱ Requests,ȱ bzw.ȱ zwischenȱ zweiȱ Servicesȱ abspeichern.ȱ Damitȱ kannȱ jederȱ ServiceȬ Requestȱsoȱbehandeltȱwerden,ȱalsȱhabeȱerȱkeinenȱVorgänger.ȱDieȱServiȬ cesȱ lassenȱ sichȱ dadurchȱinȱ beliebigerȱReihenfolgeȱaufrufenȱ undȱ bauenȱ

Servicesȱ solltenȱ zustandslosȱ seinȱ

117ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ nichtȱaufȱvorherȱaufgerufenenȱServicesȱauf.ȱEinȱweitererȱVorteilȱdavonȱ ist,ȱ dassȱ zwischenȱ zweiȱ Requestsȱ aufȱ einenȱ anderenȱ Rechner,ȱ derȱ denȱ gleichenȱ Serviceȱ anbietet,ȱ umgeschaltetȱ werdenȱ kann.ȱ Diesȱ bringtȱ fürȱ dieȱAusfallsicherheitȱundȱSkalierbarkeitȱweitereȱfolgendeȱVorteile:ȱFälltȱ einȱRechnerȱaus,ȱsoȱkannȱaufȱeinenȱanderenȱRechner,ȱderȱdenȱgleichenȱ Serviceȱ anbietet,ȱ umgeschaltetȱ werden.ȱ Steigtȱ dieȱ Anzahlȱ derȱ Clients,ȱ dieȱdenȱServiceȱaufrufen,ȱȱanȱundȱsteigtȱsomitȱdieȱLastȱfürȱdenȱRechner,ȱ soȱ kannȱ einfachȱ imȱ laufendenȱ Betriebȱ einȱ weitererȱ Rechnerȱ mitȱ demȱ gleichenȱ Serviceȱ zugeschaltetȱ werden.ȱ Dieserȱ weitereȱ Rechnerȱ überȬ nimmtȱdannȱeinenȱTeilȱderȱLast.ȱȱ

3.1.3 Client-Server versus Verteilt Vorteileȱ ClientȱServerȱ

Einȱ Vorteilȱ desȱ Clientȱ ServerȬModellsȱ istȱ dasȱ intuitiveȱ Aufteilenȱ einerȱ Anwendungȱ inȱ ClientȬTeileȱ undȱ einenȱ ServerȬTeil.ȱ Diesȱ führtȱ zuȱ asymmetrischenȱverteiltenȱAnwendungenȱmitȱnebenläufigenȱAbläufen,ȱ nämlichȱ mehrerenȱ Clientprozessenȱ undȱ einemȱ Serverprozess.ȱ Clientsȱ undȱServerȱbildenȱnatürlicheȱEinheitenȱundȱbeiȱdemȱverteiltenȱEntwurfȱ einesȱverteiltenȱSystemsȱeingeschränkteȱRollen,ȱdieȱeinȱProzessȱannehȬ menȱkann.ȱȱ DieȱInteraktionȱ(requestȱundȱreply)ȱzwischenȱClientȱundȱServerȱistȱgutȱ aufȱ Nachrichtenverkehrȱ (sendȱ undȱ reply)ȱ oderȱ entfernteȱ ProzedurȬȱ oderȱObjektaufrufeȱabbildbar.ȱDieȱInteraktionȱistȱalsoȱaufȱprozeduraleȱ Programmierparadigmenȱ festgelegtȱ undȱ schließtȱ andereȱ ProgramȬ mierparadigmen,ȱ wieȱ funktionalesȱ oderȱ deklarativesȱ Programmieren,ȱ ausȱ[PRPȱ06].ȱ

Nachteileȱ ClientȱServerȱȱ

MitȱdenȱobenȱbeschriebenenȱEinschränkungen,ȱdieȱzuȱVorteilenȱführen,ȱ erkauftȱmanȱsichȱdieȱfolgendenȱNachteile:ȱ 1.ȱ Dieȱ Rechenlastȱ istȱ beiȱ denȱ verteiltenȱ Systemenȱ ungleichmäßigȱ verȬ teilt:ȱWährendȱdieȱClientsȱnurȱAnzeigefunktionenȱerfüllenȱundȱmitȱ vernachlässigbarerȱ Rechenlastȱ vonȱ Appletsȱ nurȱ wenigȱ VerarbeiȬ tungsleistungȱerbringen,ȱliegtȱdieȱvolleȱVerarbeitungsleistungȱbeimȱ Serverȱ(unbalancedȱloadȱdistribution).ȱȱ 2.ȱDaȱderȱServerȱvieleȱClientsȱbedienenȱmuss,ȱliegtȱdieȱvolleȱRechenlastȱ aufȱ demȱ Serverȱ undȱ derȱ Serverȱ wirdȱ zumȱ Leistungsengpassȱ (perȬ formanceȱbottleneck)ȱbeiȱClientȬServerȬSystemen.ȱ 3.ȱ Fälltȱ derȱ Serverȱ aus,ȱ soȱ kannȱ keinȱ Clientȱ mehrȱ arbeiten.ȱ Benutztȱ manȱ zurȱ ClientȬServerȬKommunikationȱ blockierendeȱ KommunikaȬ tion,ȱsoȱwerdenȱbeiȱServerausfallȱdieȱClientsȱinȱderȱBlockierungȱgeȬ haltenȱ undȱ könnenȱ beiȱ einemȱ fehlendenȱ Replyȱ desȱ abgestürztenȱ Serversȱ nichtȱ mehrȱ weiterarbeiten.ȱ Derȱ Serverȱ istȱ dadurchȱ einȱ einȬ

118ȱ

3.1ȱClientȬServerȬModellȱ zelnerȱ Ausfallpunktȱ (singleȱ pointȱ ofȱ failure)ȱ beiȱ ClientȬServerȬ Systemen.ȱ 4.ȱDerȱServerȱbietetȱeinenȱeinzelnenȱAngriffspunktȱ(singleȱpointȱofȱatȬ tack)ȱzurȱLahmlegungȱeinesȱClientȬServerȱSystems.ȱDiesȱermöglichtȱ dieȱ Denialȱ ofȱ Serviceȱ(DOS)ȬAttacken,ȱdieȱgegenȱ denȱ Serverȱ gefahȬ renȱwerden.ȱȱ 5.ȱ Alleȱ Clientsȱ stehenȱ inȱ Interaktionȱ oderȱ kommunizierenȱ überȱ einenȱ Kommunikationskanal,ȱ derȱ zuȱ demȱ einemȱ Serverȱ führt.ȱ Dieserȱ Kommunikationskanalȱ führtȱ zuȱ einemȱ KommunikationsflaschenȬ halsȱ(channelȱbottleneck).ȱ Dieȱ ungleichmäßigeȱ Rechenlastverteilung,ȱ derȱ Leistungsengpassȱ desȱ Servers,ȱ derȱ einzelneȱ Angriffspunktȱ undȱ derȱ KommunikationsflaȬ schenhalsȱ lassenȱ sichȱ nurȱ umgehen,ȱ indemȱ manȱ dieȱ ClientȬServerȬ ArchitekturȱaufgibtȱundȱdieȱFunktionalitätenȱaufȱmehrereȱRechenknoȬ tenȱeinesȱNetzesȱechtȱverteilt.ȱDiesȱführtȱdannȱaufȱeinȱHPCȬClusterȱvonȱ Rechnernȱ oderȱ zuȱ einemȱ Systemȱ vonȱ gleichmäßigȱ ausgelastetenȱ undȱ gleichberechtigtenȱ Rechnernȱ undȱ somitȱ zuȱ PeerȬtoȬPeerȬSystemen.ȱ BesondersȱbeiȱPeerȬtoȬPeerȱSystemen,ȱwieȱz.B.ȱdieȱMusiktauschbörsen,ȱ wirdȱ nochȱ derȱ Nachteil,ȱ derȱ darinȱ besteht,ȱ dassȱ derȱ Serverȱ nichtȱ zenȬ surresistentȱist,ȱausgenutzt.ȱȱ

Umgehungȱ derȱClientȬ ServerȬ Nachteileȱ

Zurȱ Abmilderungȱ undȱ Umgehungȱ derȱ obigenȱ unterȱ Punktȱ zweiȱ undȱ dreiȱ aufgeführtenȱ Nachteileȱ repliziertȱ manȱ denȱ Serverȱ mehrfach.ȱ Dieȱ mehrfachenȱ Replikenȱ erbringenȱ dannȱ eineȱ größereȱ Rechenleistungȱ alsȱ einȱeinzelnerȱServerȱundȱkönnenȱnochȱzusätzlichȱzurȱAusfallsicherheitȱ herangezogenȱwerden.ȱUmȱAusfälleȱzuȱerkennen,ȱmüssenȱdieȱreplizierȬ tenȱ Serverȱ überwachtȱ werdenȱ durchȱ einenȱ weiterenȱ Server,ȱ denȱ wirȱ MonitorȬServerȱ nennen.ȱ Dieserȱ MonitorȬServerȱ istȱ inȱ demȱ ClientȬ ServerȬSystemȱ dannȱ wiederȱ einȱ einzelnerȱ Ausfallpunktȱ undȱ mussȱ demgemäßȱwiederȱrepliziertȱwerden.ȱZurȱÜberwachungȱderȱreplizierȬ tenȱ MonitorȬServerȱ mussȱ wiederȱ einȱ MonitorȬMonitorȬServerȱ dienen.ȱ Dieserȱ Monitor–MonitorȬServerȱ istȱ inȱ demȱ Systemȱ einȱ einzelnerȱ AusȬ fallpunkt,ȱ derȱ sichȱ durchȱ Replizierungȱ eliminierenȱ lässt.ȱ Ausȱ dieserȱ Ketteȱsiehtȱman,ȱdassȱsichȱderȱeinzelneȱAusfallpunktȱdesȱServersȱnichtȱ durchȱ ClientȬServerȬStrukturenȱ lösenȱ lässtȱ undȱ dieȱ ClientȬServerȬ StrukturenȱhierȱinȱeineȱSackgasseȱführen.ȱZurȱErreichungȱderȱAusfallȬ sicherheitȱ sindȱ dieȱ Replizierungenȱ schonȱ inȱ derȱ erstenȱ Stufeȱ abzubreȬ chen,ȱ undȱ anstattȱ einerȱ ClientȬServerȬLösungȱ istȱ eineȱ verteilteȱ Lösungȱ anzustreben,ȱ dieȱ dannȱ zumȱ Erfolgȱ führtȱ undȱ denȱ einzelnenȱ AusfallȬ punktȱausȱdemȱSystemȱeliminiert.ȱȱ

Replizierungȱ desȱServersȱ

ȱ

119ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ Abb.ȱ3Ȭ5:ȱ NichtlösbarȬ keitȱdesȱ einzelnenȱ AusfallȬ punktesȱ durchȱClientȬ ServerȬ Strukturenȱȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

3.2 Service-orientierte Architekturen (SOA) ServiceȬ orientedȱ Architecturesȱ (SOA)ȱ

EineȱkonsequenteȱWeiterführungȱdesȱServerkonzeptesȱundȱseineȱAusȬ richtungȱaufȱVerteilungȱ undȱ damitȱ derȱ Eliminationȱdesȱzentralenȱ SerȬ versȱführtȱaufȱdieȱServiceȬorientiertenȱArchitekturenȱ(SOA).ȱDabeiȱsindȱ nurȱdieȱServicesȱdieȱelementarenȱundȱabstraktenȱEinheitenȱ(GrundeleȬ mente)ȱ einesȱ SOAȬSystems.ȱ Dieȱ Servicesȱ sindȱ nichtȱ aufȱ einemȱ Serverȱ konzentriert,ȱsondernȱaufȱdieȱunterschiedlichenȱRechnerȱimȱNetzȱmögȬ lichstȱgleichmäßigȱverteilt.ȱDieȱSOAȬArchitekturenȱsindȱdadurchȱsymȬ metrischȱ undȱ arbeitenȱ aufȱ Gleichberechtigungsbasisȱ gemäßȱ desȱ EndȬ toȬEndȬȱoderȱPeerȬtoȬPeerȬKonzeptesȱmiteinanderȱzusammen.ȱȱ

Serviceȱ Providerȱ

Serviceȱ Providerȱ sindȱ Organisationen,ȱ dieȱ einenȱ Serviceȱ undȱ dessenȱ Implementierungȱ bereitstellen,ȱ dieȱ ServiceȬBeschreibungȱ publizierenȱ beiȱ einemȱ Serviceȱ Brokerȱ undȱ denȱ technischenȱ undȱ kaufmännischenȱ Supportȱ fürȱ einenȱ Serviceȱ zurȱ Verfügungȱ stellenȱ [Lȱ 07].ȱ Derȱ Serviceȱ Consumerȱ oderȱ Serviceȱ Requestorȱ suchtȱ einenȱ gemäßȱ einerȱ ServicebeȬ schreibungȱ passendenȱ Serviceȱ undȱ nimmtȱ denȱ gefundenenȱ Serviceȱ inȱ Anspruch.ȱ Zumȱ Suchenȱ undȱ Findenȱ einesȱ Serviceȱ benutztȱ erȱ dabeiȱ einenȱ Serviceȱ Brokerȱ (sieheȱ dazuȱ auchȱ Abschnittȱ 3.4.2.1ȱ Lokalisierungȱ desȱKooperationspartnersȱ(Broker)).ȱȱ

ȬȱConsumerȱȱ ȬȱBrokerȱ

120ȱ

3.2 Service-orientierte Architekturen (SOA)

3.2.1 Bestandteile eines Service Ein Service ist eine selbst-beschreibende und offene Softwarekomponente mit folgenden Bestandteilen [L 07] [PG 03] [PTDL 07]: x

Service: Der Service selbst muss einen Namen haben, und falls er unternehmensweit zugänglich sein soll, muss dieser Name eindeutig sein.

x

Service Interfaces: Über die Service-Schnittstelle bekommen die Anwendungskomponenten oder -logik Zugang oder Zugriff zu den Services. Ein und derselbe Service kann dabei verschiedene Schnittstellen aufweisen. Das Service Interface beschreibt die Signatur des Service (seine Eingabe, Ausgabe- und Fehlerparameter und Nachrichtentypen).

x

Service Contract (Service Description): Er beschreibt die Semantik des Service, also die Fähigkeiten des Service (Capability) und sein Verhalten zur Laufzeit (Behaviour). Desweiteren enthält der Service Contract die Quality of Service (QoS)-Beschreibung. Sie enthält funktionale Attribute und nicht-funktionale Qualitäts-Attribute. Qualitäts-Attribute sind beispielsweise Fähigkeitsumfang und die jeweiligen Kosten des Service, Festlegung des NachrichtenProtokolls und Austauschformats, Leistungsmaße des Service, wie z.B. die Antwortzeit, Sicherheitsattribute oder -richtlinien, Festlegung der Verschlüsselungs- und/oder Komprimierungsverfahren, transaktionale Integrität, Zuverlässigkeit, Skalierbarkeit und Verfügbarkeit. Eine algebraische Umsetzung des Verhaltens von Services beschreiben Meridith und Bjorg [MB 03].

x

Service Implementation: Die technische Realisierung und somit Implementierung des Service.

Abbildung 3.6 [L 07] zeigt die Bestandteile eines Service.

121

3 Programmiermodelle für parallele und verteilte Systeme Abb. 3-6: Bestandteile eines Service

Service

Interface A Operation_1(…) Operation_2(…) …

Interface B Operation_1(…) Operation_2(…) …

Service Contract Capability Behavior QoS

Service Implementation Funktion Datenbestand

…

3.2.2 Eigenschaften eines Service Die technischen Merkmale und Eigenschaften eines Service, teilweise im Vergleich zu Objekten und Komponenten [E 07] [M 08], sind Folgende: Philosophie hinter Objekten, Komponenten und Services

x

Objekte, Komponenten und Services besitzen eine unterschiedliche Philosophie und Ausgangsbasis [E 07]:  Objekte: Wiederverwendbarkeit und Wartbarkeit wird erreicht durch Kapselung der Daten und ihrer Funktionen darauf in einer Klasse. Änderungen der internen Details einer Klasse haben keine Auswirkung auf das Gesamtsystem. Die Zusammenarbeit der Objekte über Rechnergrenzen hinweg geschieht nach dem ClientServer-Prinzip und ist mit dem Request-Reply-Protokoll meist synchron. Zur Abbildung der entfernten Methodenaufrufe auf nachrichtenbasierte Abwicklung müssen vor der Laufzeit die entsprechenden Stubs auf der Clientseite und das Skeleton auf der Serverseite aus einer Interfacebeschreibung generiert werden. Für genauere Details siehe dazu auch Abschnitt 3.4.5 Kooperative Modelle mit entfernten Aufrufen.  Komponenten: Die Idee der komponentenbasierten Entwicklung ist, die Anwendung aus vorgefertigten wiederverwendbaren Software-Komponenten zusammenzusetzen. Die Komponenten

122

3.2 Service-orientierte Architekturen (SOA) laufen dazu in einer betriebssystemunabhängigen Laufzeitumgebung, dem Container, ab und müssen vorher im Container installiert werden. Die rechnerübergreifende Kooperation und Kommunikation geschieht durch nachrichtenbasierte Kommunikation oder durch entfernte Methodenaufrufe mit Stubs und Skeleton.  Services: Die logische Trennung von dem, was benötigt wird von dem Mechanismus, der das Benötigte bereitstellt, ist das Herzstück des Service-Modells. Ein Service Consumer ist nur an dem Ergebnis oder Resultat interessiert und nicht daran, wie das Ergebnis oder Resultat zustande kommt. Ein Service ist folgendermaßen definiert: Irgendeine Handlung oder Leistung, die eine Seite einer anderen anbieten kann. Die Handlung oder Leistung ist dabei im Wesentlichen immateriell und beruht nicht auf dem Besitz von irgendetwas. x

Lose Koppelung: Ein Service bietet jedem anderen über das Interface eine Handlung oder Leistung an. Der Service kann dabei mit anderen Services kooperieren (Service Composition). Das beim Client-Server-Konzept verwendete Request-Reply-Protokoll koppelt den Client eng an den Server. Der Client ist an den einen Server gebunden. Services arbeiten autonom, unabhängig und gleichberechtigt miteinander und minimieren die Abhängigkeiten untereinander. Die Koppelung und Kommunikation untereinander trifft nur wenige Annahmen über das Netzwerk oder basiert auf Nachrichtenaustausch, der meist asynchron abläuft.

Koppelung von Services

Der Vorteil der losen Koppelung erleichtert die Integration neuer Services, und Services können ohne großen Aufwand in einem anderen Kontext verwendet und aufgerufen werden. Lose Koppelung fördert die Unabhängigkeit und damit die Wartbarkeit und Austauschbarkeit von Komponenten einer Anwendungslandschaft. x

Interaktionsmechanismen [HHV 06]: Der Grad der Koppelung von Services (von eng nach lose) nimmt nachfolgend bei verschiedenen Interaktionsformen von oben nach unten ab:

Interaktion von Services

 Prossesskommunikation auf einem Rechner: Services rufen sich mit Prozess- bzw. Threadsynchronisations- und -kommunikationsverfahren synchron auf.  Request-Reply synchron: Services rufen sich synchron auf. Siehe für die verschiedenen Verfahren die unter Abschnitt 3.4.5 vorgestellten Verfahren.

123

3 Programmiermodelle für parallele und verteilte Systeme  Nachrichten asynchron: Services rufen sich asynchron durch Zusenden von Nachrichten auf. Realisierung des Nachrichtenaustausches geschieht dabei mit Message-orientierter Middleware (MOM). Siehe dazu auch Abschnitt 3.4.4 kooperative und nachrichtenbasierte Modelle und speziell den Abschnitt 3.4.4.2 Java Message Service (JMS).  Publish/Subscribe (Pub/Sub): Die Kommunikation kann dabei mit dem Pub/Sub-Modell asynchron vonstatten gehen. Aufrufende Services und aufgerufene Services sind über einen Registrierungsmechanismus entkoppelt. Alle registrierten Services erhalten asynchron die Nachricht. Siehe zum Pub/Sub-Modell den Abschnitt 3.4.4.2. Services besitzen keinen Zustand

x

Services sind zustandslos: Services sollten sich aus verschiedenen Ablaufkontexten heraus mehrfach und wiederholt aufrufen lassen. Dies bedingt, dass die Services keinen Zustand halten und sich auch keine Zustandinformation beschaffen auf den dann die unterschiedlichen Aufrufe ausgehen können. Bei einer Zustandsspeicherung könnten die Services von einem Zustand ausgehen und bei jedem Aufruf anders verhalten und ein anderes Ergebnis zurückliefern. Die Serviceaufrufe sind also idempotent, und ein mehrmaliger Aufruf mit denselben Parametern hat denselben Effekt wie der einmalige.

Services lassen sich zur Laufzeit bestimmen und aufrufen

x

Dynamische Komposition {E 07]: Zum flexiblen Ändern oder Wechseln des Service-Providers erlauben die Services ein flexibles Binden und somit eine Auswahl des Service-Providers erst zur Laufzeit. Dies erlaubt auf der Serviceseite eine Änderungen der Fähigkeiten, des Verhaltens und der Quality of Service über die Zeit vorzunehmen. Im Gegensatz dazu ist bei komponentenbasierter Software schon vor der Laufzeit exakt festgelegt, welche Komponenten ein Aufrufer kontaktieren muss.

x

Lastverteilung: Durch Mehrfachinstanzen desselben Services in einem System lässt sich die Last auf diese mehrfach vorhandenen Instanzen verteilen.

3.2.3 Servicekomposition, -management und -überwachung Aus bestehenden Services oder Basisservices lassen sich neue und komplexe Services durch Servicekomposition zusammensetzen. Die Services [M 07] lassen sich

124

3.2 Service-orientierte Architekturen (SOA) x

dynamisch, zur Laufzeit, zu neuen semantischen Services zusammensetzen, oder

x

statisch zusammensetzen, vor dem Ablauf, durch

Servicekomposition

 Orchestrierung. Die Orchestrierung schafft einen neuen Service dadurch, dass vorhandene Services durch einen zentralen Koordinator (orchestrator) gesteuert werden. Der Orchestrator nimmt die Aufrufe von außerhalb entgegen und verteilt die Aufgaben an die einzelnen Services.  Choreographie. Choreographie besitzt keinen zentralen Koordinator. Es wird dabei die Kommunikation zwischen den einzelnen Services festgelegt und beschrieben. Der Gesamtservice resultiert aus einer Reihe von End-to-End-Interaktionen (P2P-Interaktionen) zwischen den (Sub-) Services. Erhaltene Servicekompositionen können als Basisservices für weitere Servicekompositionen dienen oder können als Komplettlösung und -applikation den Service-Consumern angeboten werden. Liegt eine geschichtete Struktur des SOA-Systems vor, dann setzt sich typischerweise eine Servicekomposition aus Services der gleichen oder der direkt darunterliegenden Schicht zusammen.

Rekursive Entwicklung von Servicekompositionen

Ein Service Aggregator führt die Aufgaben der Servicekomposition durch und wird damit zum Service Provider, indem er die Servicebeschreibung der neuen Servicekomposition beim Service Broker veröffentlicht. Der Aggregator

Service Aggregator

x

legt die Aufrufreihenfolge (Koordinationsreihenfolge) (Coordination) der einzelnen Services in der Servicekomposition fest;

x

stellt die Integrität der Servicekomposition (Conformance) her, indem er die Parametertypen der Servicekomposition mit den Parametertypen der einzelnen Services abgleicht und eingrenzt. Er verschmilzt möglicherweise die Daten und führt zur Erhaltung der Integrität der Daten-Transaktionen (Transaction) ein;

x

evaluiert, aggregiert und bündelt die einzelnen Quality of Services und leitet daraus eine für die Komposition gemeinsame Quality of Services (QoS) ab.

Zum Überwachen und Management von kritischen Applikationen und der lose gekoppelten und verteilten SOA-Lösungen benötigt man eine weitere Schicht. Ein Service Operator führt diese Aufgaben aus und wird damit wieder zum Service Provider, indem er die Servicebe-

Service Operator

125

3 Programmiermodelle für parallele und verteilte Systeme schreibung der Arbeiten, die er durchführt, beim Service Broker veröffentlicht. Der Operator x

vermisst, führt Statistiken und macht eine Feinabstimmung über die durchgeführten Aktivitäten der Services (Metrics);

x

überwacht die Zustände (Running, Suspended, Aborted oder Completed) einer jeden Instanz eines Services. Die Serviceinstanzen kann er suspendieren, die Arbeit wieder aufnehmen lassen oder terminieren (State Management);

x

führt bei Ausfällen, Systemfehlverhalten oder geänderten Umgebungen, Reaktionen und Änderungen durch (Change Management);

x

führt eine Kapazitätsplanung und Leistungsmessung durch und veranlasst Leistungsverbesserungen (Load Balancing).

Die Arbeiten des Operators sollte dieser autonom und selbstständig durchführen und sie sollten die Selbst-Eigenschaften besitzen (siehe Abschnitt 1.4.2). Die Selbst-Eigenschaften des Operators sind zukünftiger Forschungsschwerpunkte. Diese umfassen [PTDL 07] SelbstEigenschaften

x

die Selbst-Konfiguration, welche für unterschiedliche Umgebungen und für den speziellen Einsatz das SOA-System automatisch konfiguriert und anpasst;

x

die Selbst-Anpassung, welche dynamisch sich selbst an geänderte Umgebungen und Märkte anpasst;

x

die Selbst-Heilung, die bei Fehler, Selbstzerstörung und Ausfällen den laufenden Betrieb weiter aufrecht erhält;

x

die Selbst-Optimierung, welche die Ressourcen überwacht und automatisch das SOA-System an Endbenutzer- oder Geschäftsbedürfnisse abstimmt und darauf hin optimiert;

x

den Selbst-Schutz, der verhindert, entdeckt, identifiziert und schützt vor Eindringlingen und Angriffen.

Zusammenfassend zeigt die nachfolgende SOA-Pyramide [PTDL 07], [PG 03] die erweiterte Service-orientierte Architektur: Die drei Serviceschichten, ihre Funktionalitäten und Rollen.

126

3.2 Service-orientierte Architekturen (SOA)

Abb. 3-7: SOAPyramide Servicemanagement und -überwachung Metrics State Mngt. Change Mngt. Load Balancing

Service Operator

Managed Services Komposition Coordination Conformance Transaction QoS

Service Aggregator

Composite Services Service: Interface Cabability Behaviour QoS

Basic Services

Service Provider

Service Broker: - veröffentlichen - suchen - finden

Grundlagen (SOC-Middleware mit Service-Broker u. Basis-Services)

Service Consumer

3.2.4 Enterprise Service Bus Web Services sind zurzeit die Erfolg versprechende Service Oriented Computing (SOC)-Technologie. Web-Services benutzten das Internet als Kommunikationsmedium mit dem auf HTTP aufsitzenden Simple Object Access Protocol (SOAP) zur Übertragung von XML-Daten und der Web Services Description Language (WSDL) zur Festlegung der Services. Die Universal Description, Discovery and Integration (UDDI) realisiert den Service Broker. Zur Orchestrierung von Services steht die Business Process Execution Language for Web Services (BPEL4WS) [BPEL 07] zur Verfügung, und die Sprache Web Services Choreography Description Language (WS-CDL) {WSC 05] dient zur

SOC mit Web Services

127

3 Programmiermodelle für parallele und verteilte Systeme Choreographie von Services. Die Web-Service-Technologie ist in Abschnitt 3.4.5.9. beschrieben. Enterprise Service Bus (ESB)

Container

Zum Verbinden von diversen Applikationen und Technologien mit Service-orientierter Architektur benötigt man einen einheitlichen Aufrufmechanismus von Services, der die diversen Anwendungsbausteine plattformunabhängig miteinander verbindet und alle technischen Details der Kommunikation verbirgt. Solch ein auf offenen Standard basierenden Nachrichtenbus ist der Enterprise Service Bus (ESB) [C 04]. Der ESB selbst unterstützt Services, einen Service Broker, Nachrichtenaustausch, ereignisbasierte Interaktionen mit den dazugehörigen Serviceebenen und Management-Werkzeugen. Vereinfachend ist der ESB eine Integrationsbasis von einer Vielzahl von verschiednen Technologien und somit in dieser Technolgie implementierten Applikationen, wie x

Daten-Services, wie der Distributed Query Engine basierend auf XQuery oder der Abfragesprache Structured Query Langugage (SQL),

x

Enterprise-Applikationen mit den dazugehörigen Enterprise Adapters,

x

Web-Services-Applikationen implementiert mit WebSphere oder als .NET-Applikation,

x

Java- oder J2EE-Applikationen, welche den Java Message Service (JMS) zur Kommunikation benutzen,

x

Mainframe-Applikation mit dem MQ Gateway.

Der ESB basiert, wie die Komponententechnologie, auf dem ContainerModell, hier übertragen auf Services. Der Container stellt die Laufzeitumgebung für die Services-Funktionalitäten und nicht funktionalen Eigenschaften dem externen Benutzer zur Verfügung. Mit den oben vorgestellten verschiedenen Technologien lassen sich dann folgende Applikation aufbauen:

128

x

Service-orientierte Kunden-Applikationen mit Orchestrierung als Servicekomposition.

x

Portale, welche die Verknüpfung und den Datenaustausch zwischen heterogenen Anwendungen über ein Portal vornehmen. Ein Portal stellt Funktionen zur Personalisierung, Sicherheit, Navigation und Benutzerverwaltung bereit und dient zur Suche und Präsentation von Informationen.

3.3 Programmiermodelle für gemeinsamen Speicher Abb. 3-8: Enterprise Service Bus

Service orientierte KundenApplikationen

Portale

Zuverlässiger, sicherer, asynchroner Nachrichtenbus Service Interface Service Container

Distributed Query Engine

Service Interface Service Container

Adapter

Service Interface Service Container

Service Interface Service Container

Web Services

J2EE / JMS

WebSphere .NET Applikationen Datenquellen

Enterprise Applikationen

Java Applikationen

Service Interface Service Container

MQ Gateway

Mainframe Applikationen

Multiplattform Support

129

3 Programmiermodelle für parallele und verteilte Systeme

3.3 Programmiermodelle für gemeinsamen Speicher Einprozessor-, eng gekoppelte Systeme und Systeme mit verteiltem gemeinsamem Speicher besitzen gemeinsamen Speicher

Wir setzen bei den nachfolgend beschriebenen Programmiermodellen einen gemeinsamen Speicher voraus, auf den alle auf den Prozessoren ablaufenden Programme zugreifen können. Der gemeinsame Speicher ist bei Einprozessorsystemen und eng über den gemeinsamen Speicher gekoppelte Systeme per se gegeben. Lose gekoppelte Multiprozessoren lassen sich von der Programmierung her als eng gekoppelte Systeme betrachten, wenn sie einen verteilten gemeinsamen Speicher realisiert haben (siehe Abschnitt 2.3.2 Verteilter gemeinsamer Speicher). Durch den verteilten gemeinsamen Speicher besitzen die Programme, die auf den Prozessoren ablaufen, einen gemeinsamen Speicher. Der gemeinsame Speicher kann jedoch verteilt sein auf unterschiedliche Speicher.

race und conditions und Umgehung mit mutual exclusion

Durch den gemeinsamen Speicher kommen bei jeder möglichen Ausführung der Prozesse, die Prozesse zu unterschiedlichen Reihenfolgen des Lesens und Schreibens von Daten, und es kommt zu Wettlaufsituationen (Race Conditions). Zur Vermeidung dieser muss auf gemeinsame Daten unter wechselseitigem Ausschluss (mutual exclusion) zugegriffen werden. Dementsprechend muss ein Programmiermodell für den gemeinsamen Speicher den wechselseitigen Ausschluss unterstützen. Im Gegensatz dazu können die Programme, die auf einem Programmiermodell für verteilten Speicher basieren, auch auf Rechnern mit gemeinsamem Speicher zur Ausführung gebracht werden. Dies geschieht dadurch, dass man die entfernte Kommunikation und entfernten Aufrufe über das Netz auf lokale Kommunikation und Aufrufe abbildet. Dies ist natürlich nur bei den verteilten Programmiermodellen möglich, die keinen verteilten Speicher voraussetzen. Die wichtigsten Ansätze zur Programmierung der Systeme mit gemeinsamem Speicher sind: 1. Parallelisierende Compiler, die selbst die parallel ausführbaren Codesequenzen herausfinden und entsprechend Code für mehrere Prozessoren erzeugen. Siehe dazu Abschnitt 3.3.1. 2.

130

Unix ermöglicht, mit den Systemcalls fork und join, nebenläufige Prozesse (Kinder) zu vergabeln und an dem Ende wieder mit dem Vater zu vereinigen. Siehe dazu Abschnitt 3.3.2.1. Zum wechselseitigen Ausschluss beim Zugriff auf den gemeinsamen Speicher stehen Semaphore zur Verfügung. Zur nachrichtenbasierten Kommunikation zwischen Prozessen dienen Pipes und Warteschlangen (siehe dazu Abschnitt 3.3.2.2 bzw. 3.3.2.3).

3.3 Programmiermodelle für gemeinsamen Speicher 3. Threads („Fäden“) ermöglichen unter der Ebene der parallelen Prozesse eine zweite Parallelitätsebene; d.h. Threads laufen unter einem Prozess oder sind unter einem Prozess „aufgefädelt“. Threads können als Bibliothek unter Unix implementiert sein und folgen dem Posix-Standard (P-Threads) oder sind innerhalb des Betriebssystems implementiert (siehe Abschnitt 3.3.3.2). Threads benutzen beim Zugriff von mehreren Threads zu gemeinsamen Daten das Monitorkonzept. Dieses Konzept wurde von Brinch Hansen [Ha 75] und [H 93] und Hoare [Ho 74] als Synchronisationsmittel für Prozesse zeitgleich entwickelt. Ein Monitor ist ein abstrakter Datentyp bestehend aus den gemeinsamen Daten, auf die mehrere Prozesse mit den Monitorprozeduren zugreifen. Da auf gemeinsame Daten von mehreren Prozessen immer unter wechselseitigem Ausschluss zuzugreifen ist, laufen die Prozeduren eines Monitors unter wechselseitigem Ausschluss und somit kann immer nur ein Prozess im Monitor sein.

Monitorkonzept

Zur Kontrolle der Synchronisation benutzt ein Monitor Bedingungsvariable (condition variable). Auf Bedingungsvariablen sind die Operationen wait und signal definiert. Das wait versetzt einen Prozess in einen Wartezustand und der wartet, bis ein anderer Prozess das signal ausführt. Damit ein anderer Prozess den Monitor betreten kann und das signal ausführen kann, muss natürlich der wartende Prozess beim wait den Monitor freigeben; d.h. er muss beim wait den wechselseitigen Ausschluss aufheben, da nur immer ein Prozess im Monitor sein kann. Führt ein Prozess das signal aus und es wartet kein Prozess, so hat das signal keine Wirkung.

Bedingungsvariable

Buhr und Harji [BH 05] nennen einen Monitor mit Bedingungsvariablen und den Operationen wait und signal darauf einen expliziten-signal Monitor. Sie schlagen einen impliziten-signal Monitor vor, der keine Bedingungsvariable besitzt, sondern nur eine waituntil-Operation mit einem booleschen Ausdruck, basierend auf Monitorvariablen. Ergibt die Auswertung des booleschen Ausdruckes von einem Prozess FALSE, so geht der Prozess in einen Wartezustand. Dabei hebt er den wechselseitigen Ausschluss auf und gibt somit den Monitor für andere Prozesse frei. Ein wartender Prozess wird implizit von einem anderen Prozess aufgeweckt, wenn der andere Prozess den booleschen Ausdruck wahr macht. Der boolesche Ausdruck, also die Bedingung, entspricht der Bedingung bei bedingten kritischen Regionen (siehe Abschnitt 2.2.6.5.1 bei der Erweiterung des atomic).

Impliziter Signal Monitor

131

3 Programmiermodelle für parallele und verteilte Systeme Da es sich bei einem Monitor um ein Objekt mit unter wechselseitigem Ausschluss laufenden Prozeduren handelt, passt dieses Konzept sehr gut zu den objektorientierten Sprachen und lässt sich leicht in diese integrieren oder, wie hier bei den Pthreads, auf diese aufpflanzen. Die Pthreads (siehe nachfolgenden Abschnitt 3.2.3.3) simulieren einen Monitor mit Mutex-Lock-Variable und Bedingungsvariable. 4. OpenMP (Open Multi-Processing) ist ein Industrie Standard API [DM 98] für Multi-Plattform (UNIX und Microsoft Windows) Multiprozessoren mit gemeinsamem Speicher zur Programmierung in C/C++ und Fortran. Im Desktop-Bereich wurde OpenMP 2005 in Microsoft Visual C++ integriert [M 07]. Das OpenMP Architecture Review Board (ARB) [ARB 07] mit den wichtigsten Industrievertretern wie IBM, HP, Sun, Compaq, Silicon Graphics, Intel, usw. spezifiziert den OpenMP-Sprachstandard für Fortran und C/C++. Eine Implementierung von OpenMP nutzt Threadbibliotheken. OpenMP erleichert den Übergang seriell nach parallel

Mit OpenMP gelingt es einem Anfänger, der mit C/C++ vertraut ist, jedoch nicht mit der Parallelisierung, den seriellen Code unter Benutzung von OpenMP-Direktiven in parallelen Code zu transformieren [M 07]. OpenMP erweitert den seriellen Code hin zum parallelen Code mit Compiler- und somit den OpenMP-Direktiven. Das Hinzufügen von Compiler-Direktiven ändert nicht das logische Verhalten des seriellen Codes; er weist nur den Compiler an, welche Codestücke zu parallelisieren sind; der Compiler übernimmt dabei das komplette Threadhandling.

OpenMP nur für eng gekoppelte Multiprozessoren

OpenMP ist in seiner bisherigen Form nur für eng gekoppelte Multiprozessoren einsetzbar. Dies schließt den Einsatz in Clustern aus. Möglichkeiten, den Einsatzbereich von OpenMP auf Cluster auszudehnen, sind: 1. OpenMP auf Task-Graph-Parallelismus (grobkörnige Parallelität) zu erweitern [M 03] oder 2. einen hybriden Ansatz mit der Message Passing InterfaceBibliothek (siehe Abschnitt 3.4.3.1) zu wählen (hybride Programmierung) [Q 04]:  OpenMP innerhalb eines Knotens (Uniprozessor oder eng gekoppelter Multiprozessor mit symmetrischem Multiprozessor) und  MPI (siehe Abschnitt 3.4.3.1) auf dem Verbindungsnetzwerk oder dem lose gekoppelten Multiprozessor.

132

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ Daȱ einȱ heutigesȱ Clusterȱ ausȱ MulticoreȬProzessorenȱ undȱ einemȱ schnellenȱ Verbindungsnetzwerkȱ besteht,ȱ istȱ dieȱ hybrideȱ ProgramȬ mierungȱ mitȱ MPIȱ undȱ OpenMPȱ dieȱ meistȱ eingesetzteȱ undȱ zurzeitȱ gängigsteȱProgrammierung.ȱȱȱ FürȱOpenMPȱgibtȱesȱeinȱJavaȱInterface,ȱgenanntȱOpenMPȱforȱJavaȱ (JOMP)ȱ [BKȱ 00].ȱ Dieȱ JOMPȱ InterfaceȬSpezifikationȱ undȱ dieȱ JOMPȱ APIȱstehtȱaufȱderȱJOMPȱHomepageȱ[EPCCȱ07]ȱzurȱVerfügung.ȱEineȱ kurzeȱEinführungȱinȱJOMPȱistȱinȱ[KYȱ02]ȱenthalten.ȱ Eineȱ Einführungȱ inȱ OpenMpȱ mitȱ C,ȱ C++ȱ undȱ Fortranȱ liegtȱ mitȱ [CDKȱ 01]ȱ vor.ȱ Abschnittȱ 3.3.4ȱ enthältȱ eineȱ kurzeȱ Einweisungȱ inȱ OpenMPȱ fürȱ Cȱ undȱ C++ȱ Programmeȱ undȱ stelltȱ dieȱ wichtigstenȱ OpenMPȬDirektivenȱvor.ȱȱ 5.ȱ Unifiedȱ Parallelȱ Cȱ (UPC)ȱ istȱ eineȱ expliziteȱ paralleleȱ Spracheȱ aufȱ Cȱ basierend,ȱ dieȱ vonȱ einemȱ UPCȬKonsortiumȱ mitȱ derȱ Georgeȱ WaȬ shingtonȱUniversityȱ[UPCȱ07]ȱalsȱKonsortialführerȱseitȱ1999ȱentwiȬ ckeltȱ wurde.ȱ Dieȱ Anzahlȱ derȱ parallelenȱ Threadsȱ istȱ statischȱ undȱ kannȱ entwederȱ beiȱ derȱ Compilierungȱ oderȱ beimȱ Programmstartȱ festgelegtȱ werden.ȱ Jederȱ derȱ Threads,ȱ ȱ genauerȱ gesagtȱ derenȱ AnȬ zahl,ȱ istȱ vorherȱ festgelegtȱ undȱ führtȱ dasȱ gleicheȱ UPCȬProgrammȱ (main)ȱ aus.ȱ UPCȱ realisiertȱ einȱ Singleȱ Programȱ Multipleȱ Dataȱ (SPMD)ȬModellȱ desȱ Parallelismus.ȱ Daȱ UPCȱ eineȱ Erweiterungȱ vonȱ ISOȱ Cȱ ist,ȱ istȱ jedesȱ CȬProgrammȱ auchȱ einȱ UPCȬProgramm,ȱ allerȬ dingsȱ verhältȱ esȱsichȱ anders,ȱ wennȱ esȱmitȱ mehrerenȱ Threadsȱ(>ȱ 1)ȱ läuft.ȱEineȱBeschreibungȱvonȱUPCȱliegtȱmitȱ[ECSȱ05]ȱvor,ȱTutorialsȱ undȱ Manualsȱ stehenȱ aufȱ derȱ Webseiteȱ [UPCȱ 07]ȱ zurȱ Verfügung.ȱ Abschnittȱ3.3.5ȱstelltȱdieȱprägnantestenȱFähigkeitenȱvonȱUPCȱvor.ȱȱ 6.ȱȱFortressȱistȱeinȱOpenȱSourceȱForschungsprojektȱvonȱSunȱ[SSȱ07]ȱzurȱ Entwicklungȱ einerȱ neuenȱ Programmierspracheȱ fürȱ Highȱ PerforȬ manceȱ Computingȱ (HPC).ȱ Fortressȱ istȱ einȱ Nachfolgerȱ derȱ überȱ 50ȱ JahreȱaltenȱSpracheȱFortran,ȱjedochȱistȱFortressȱnichtȱkompatibelȱzuȱ existierendenȱ Versionenȱ vonȱ Fortran.ȱ Guyȱ L.ȱ Stelle,ȱ Jr.,ȱ einerȱ derȱ SprachentwerferȱvonȱFortress,ȱdessenȱvorhergehendeȱArbeitenȱdieȱ Sprachenȱ Schemeȱ undȱ Javaȱ waren,ȱ definiertȱ dasȱ Entwicklungszielȱ vonȱFortressȱfolgendermaßen:ȱȱ ȱ

Fortress:ȱȱ“ToȱDoȱforȱFortranȱWhatȱJava™ȱDidȱforȱC“.ȱȱȱ

ȱ

DieȱüberȱFortranȱhinausgehendenȱZieleȱvonȱFortressȱsind:ȱ

Unifiedȱ ParallelȱCȱ

Fortressȱ

1.ȱ Mathematischeȱ undȱ physikalischeȱ Notation:ȱ Zurȱ besserenȱ LesȬ barkeitȱ derȱ Programmeȱ istȱ dasȱ Anzeigeformatȱ derȱ Programmeȱ Unicodeȱ undȱ zeilenorientierterȱ Unicode.ȱ Editorenȱ wieȱ derȱ Viȱ undȱEmacsȱbenutzenȱeineȱTwikiȬähnlicheȱNotation,ȱdieȱnurȱASȬ

133ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ CIIȬZeichenȱ verwendet.ȱ OperatorȬÜberladungenȱ unterstützenȱ mathematischeȱ Notationen.ȱ Darüberȱ hinausȱ enthaltenȱ numeriȬ scheȱ Typenȱ physikalischeȱ Einheitenȱ undȱ Dimensionen,ȱ wieȱ z.B.ȱ dieȱFunktionȱȱ ȱȱȱȱȱȱȱȱȱȱȱȱkineticEnergy(m:ȱȱബkg,ȱvȱ:ȱബm/s)ȱ:ȱബkgȱm2/s2ȱ=ȱ(mȱv2)/2ȱ 2.ȱ Erweiterungenȱ undȱ dasȱ Wachsenȱ derȱ Sprache:ȱ FortressȬ Programmeȱ sindȱ inȱ Komponentenȱ organisiert.ȱ Komponentenȱ exportierenȱ undȱ importierenȱ APIsȱ undȱ könnenȱ zusammengeȬ bundenȱ werden.ȱ Alleȱ erstelltenȱ Komponentenȱ liegenȱ inȱ einerȱ BibliothekȱmitȱVersionsverwaltungȱvor.ȱDieȱBibliothekȱbildetȱdieȱ Basisȱ fürȱ dieȱ weitereȱ Fortentwicklungȱ undȱ Definitionȱ derȱ SpraȬ che.ȱDieȱSpracheȱselberȱistȱinȱBibliothekenȱbeschrieben,ȱwieȱauchȱ dieȱDefinitionȱvonȱFeldernȱundȱanderenȱBasistypen,ȱsoȱdassȱeineȱ relativȱkleineȱKernspracheȱausreicht.ȱDiesȱwirdȱvorȱallemȱdurchȱ dieȱ generischeȱ Programmierungȱ inȱ Fortressȱ ermöglicht.ȱ Dazuȱ bietetȱ Fortressȱ dieȱ Möglichkeit,ȱ Funktionenȱ generisch,ȱ d.h.ȱ unȬ abhängigȱvonȱDatentypȱoderȱȬstruktur,ȱzuȱdefinieren.ȱMitȱGeneȬ ratorenȱ lassenȱ sichȱ solcheȱ Funktionenȱ aufȱ eineȱ beliebigeȱ DatenȬ strukturȱanwenden.ȱȱ 3.ȱParallelismusȱistȱkeineȱFähigkeitȱvonȱFortress,ȱsondernȱvonȱFortȬ ressȱ vorgegeben:ȱ Fortressȱ besitztȱ einenȱ implizitenȱ Parallelismus.ȱ Einȱ implizitȱ parallelesȱ Konstruktȱ legtȱ eineȱ Gruppeȱ vonȱ einemȱ oderȱ mehrerenȱ implizitenȱ Threadsȱ an.ȱ Implizitȱ paralleleȱ KonȬ strukteȱsindȱbeispielsweiseȱalleȱforȬSchleifenȱundȱdieȱmitȱalso doȬAusdrückenȱ erweitertenȱ doȬAusdrücke,ȱ TupelȬAusdrücke,ȱ dieȱAuswertungȱderȱArgumenteȱeinerȱFunktionȱundȱdieȱSumme.ȱ EsȱexistiertȱeinȱexplizitesȱparallelesȱKonstruktȱzumȱStartenȱeinesȱ Thread,ȱdasȱspawnȬKonstrukt.ȱDerȱwechselseitigeȱAusschlussȱzuȱ gemeinsamenȱDatenȱgeschiehtȱmitȱdemȱatomicȬKonstrukt.ȱȱ 4.ȱMöglichkeitȱdesȱautomatischenȱTestens:ȱZumȱautomatischenȱTesȬ tenȱ kannȱ einȱ FortressȬProgrammȱ mitȱ einemȱ testȬModifierȱ mitȱ Angabeȱ desȱ Testfallsȱ versehenȱ werden.ȱ Zurȱ Überprüfungȱ beȬ stimmterȱ Bedingungenȱ (Boolescheȱ Bedingungen),ȱ dieȱ dasȱ ProȬ grammȱbesitzenȱsoll,ȱdienenȱPropertyȬFunktionen.ȱȱ Einȱ Interpreterȱ fürȱ Fortressȱ undȱ eineȱ Sprachspezifikationȱ stelltȱ dieȱ SunȱForschungsgruppeȱ[SRȱ07]ȱzurȱVerfügung.ȱEineȱüberblickshafteȱ EinführungȱinȱdieȱSpracheȱenthältȱderȱAbschnittȱ3.3.6.ȱ Adaȱ

134ȱ

7.ȱȱAdaȱ83ȱ[Aȱ83]ȱ[Aȱ07]ȱistȱeineȱderȱwenigenȱProgrammiersprachenȱmitȱ inȱ derȱ Spracheȱ integrierterȱ Unterstützungȱ fürȱ Parallelitätȱ undȱ koȬ operativeȱ Verarbeitung.ȱ 1983ȱ wurdeȱ dieȱ Spracheȱ zuȱ einemȱ ANSIȬ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ Standardȱ (ANSI/MILȬSTDȱ 1815),ȱ dieȱ ISOȱ übernahmȱ denȱ Standardȱ 1987ȱalsȱISOȬ8652:1987.ȱAdaȱ83ȱunterstützteȱdynamischeȱTasksȱundȱ entfernteȱ synchroneȱ undȱ blockierendeȱ Aufrufe,ȱ dasȱ soȱ genannteȱ AdaȬRendezvousȱzwischenȱdenȱTasksȱ(sieheȱAbschnittȱ3.3.7.1).ȱDasȱ selektiveȱ AdaȬRendezvousȱ erlaubtȱ einerȱ Serverȱ Taskȱ ausȱ mehrerenȱ Alternativenȱ nurȱ bestimmteȱ ClientȬAnfragenȱ zuȱ akzeptieren.ȱ Dasȱ Pragma SharedȱstellteȱdenȱZugriffȱzuȱgemeinsamenȱVariablenȱnurȱ unterȱ wechselseitigemȱ Ausschluss.ȱ Dieȱ Abbildungȱ desȱ exklusivenȱ Zugriffsȱ aufȱ gemeinsameȱ Ressourcenȱ aufȱ dasȱ AdaȬRendezvousȱ erȬ fordertȱzusätzlicheȱTasksȱundȱerhöhtȱdamitȱdenȱTaskingȬOverheadȱ [CSȱ98].ȱDeshalbȱführteȱAdaȱ95ȱ[Aȱ95],ȱderȱgemeinsameȱISO/ANSIȬ Standardȱ ISOȬ8652,ȱ dasȱ Monitorkonzeptȱ inȱ dieȱ Spracheȱ ein.ȱ Derȱ inȱ AdaȱsimulierteȱMonitorȱsindȱsoȱgenannteȱgeschützteȱObjekteȱ(ProȬ tectedȱ Objects)ȱ (sieheȱ Abschnittȱ 3.3.7.3).ȱ Derȱ Ada95ȬCompilerȱ GNATȱistȱTeilȱdesȱGNUȬCȬCompilersȱgccȱ[GNUȱ07].ȱEineȱguteȱEinȬ führungȱinȱAdaȱ95ȱausȱSichtȱ derȱSoftwaretechnikȱistȱ dasȱ Buchȱ vonȱ Naglȱ[Nȱ03]ȱoderȱdasȱBuchȱvonȱBarnesȱ[Bȱ06].ȱZurzeitȱistȱISO/ANSIȬ StandardȱISOȬ8652:1995/AMDȱ1:2007,ȱinformellȱAdaȱ2005,ȱderȱaktuȬ elleȱStandard.ȱAbschnittȱ3.3.7ȱerläutertȱdieȱParallelitätskonzepteȱvonȱ Adaȱ95.ȱȱ NachfolgendeȱÜbersichtȱ(Abb.ȱ3Ȭ9)ȱzeigtȱdieȱverschiedenenȱundȱwichȬ tigstenȱ Programmiermodelleȱ auf.ȱ Dieȱ hierȱ vorgegebeneȱ UntergliedeȬ rungȱspiegeltȱauchȱdieȱReihenfolgeȱderȱnachfolgendenȱAbschnitteȱwieȬ der,ȱ welcheȱ dieȱ einzelnenȱ ProgrammierȬȱ undȱ Parallelitätsmodelleȱ erȬ läutern.ȱ

135ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ Abb.ȱ3Ȭ9:ȱ ProgrammierȬ modelleȱfürȱ gemeinsamenȱ Speicherȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

3.3.1 Parallelisierende Compiler AusgehendȱvonȱsequentiellenȱProgrammiersprachenȱundȱreinȱsequenȬ tiellenȱ Programmenȱ kannȱ manȱ dieȱ Aufgabenȱ derȱ Parallelisierungȱ eiȬ nemȱCompilerȱübertragen.ȱEinȱparallelisierenderȱCompilerȱermöglichtȱ dieȱ automatischeȱ Umsetzungȱ vonȱ sequentiellemȱ Codeȱ (meistensȱ Cȱ oderȱ Fortranȱ Programme)ȱ inȱ parallelenȱ Codeȱ fürȱ MultithreadingȬ Umgebungen.ȱ Dieȱ Datenflussanalyseȱ desȱ Compilersȱ untersuchtȱ dabeiȱ dieȱ Datenabhängigkeitenȱ inȱ einemȱ sog.ȱ Basisblockȱ (lineareȱ Sequenzȱ

136ȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ vonȱ Anweisungen).ȱ Durchȱ Umordnungȱ derȱ Anweisungenȱ oderȱ EinȬ führungȱ vonȱ weiterenȱ Variablenȱ versuchtȱ derȱ Compilerȱ dieȱ DatenabȬ hängigkeitenȱ zwischenȱ denȱ Anweisungenȱ zuȱ minimieren.ȱ AnweisunȬ gen,ȱ zwischenȱ denenȱ keineȱ Datenabhängigkeitenȱ existieren,ȱ könnenȱ dannȱ nebenläufigȱ abgearbeitetȱ werden.ȱ Besondersȱ Schleifenȱ undȱ derȱ CodeȱdarinȱundȱderenȱDatenabhängigkeitsȬAnalyseȱbietenȱvieleȱParalȬ lelisierungsmöglichkeit.ȱ Gibtȱ esȱ innerhalbȱ einerȱ Schleifeȱ keinerleiȱ DaȬ tenabhängigkeiten,ȱ soȱ istȱ dieȱ Ausführungsreihenfolgeȱ derȱ einzelnenȱ Schleifendurchläufeȱbeliebig,ȱundȱalleȱDurchläufeȱkönnenȱnebenläufigȱ ausgeführtȱwerden.ȱȱ Dieȱ Codegenerierungȱ oderȱ Ȭoptimierungȱ kannȱ ausȱ einerȱ DatenabhänȬ gigkeitsanalyseȱ dieȱ optimaleȱ Reihenfolgeȱ zurȱ parallelenȱ BefehlsabarȬ beitungȱ festlegen.ȱ Weiterhinȱ istȱ ausȱ ihrȱ auchȱ durchȱ Duplizierungȱ vonȱ VariablenȱeineȱoptimaleȱAllokationȱderȱRegisterȱableitbarȱundȱdasȱZiel,ȱ möglichstȱviele,ȱmöglichstȱalleȱVariablenȱinȱdenȱzurȱVerfügungȱstehenȬ denȱRegisterȱzuȱhalten,ȱistȱdadurchȱerreichbar.ȱȱ

DatenabȬ hängigkeitsȬ analyseȱ

Optimaleȱ RegisterȬ allokationȱ

3.3.2 Unix Dasȱ Betriebssystemȱ Unixȱ stelltȱ Systemaufrufeȱ zurȱ Verfügung,ȱ dieȱ ausȱ CȬProgrammenȱ herausȱ aufgerufenȱ werdenȱ können,ȱindemȱ manȱ durchȱ dieȱ Präprozessoranweisungȱ #include dieȱ entsprechendenȱ SystemȬ aufrufeȱ zumȱ Programmȱ hinzufügt.ȱ Dieȱ Systemaufrufeȱ lassenȱ sichȱ unȬ terteilenȱin:ȱȱ x

Aufrufeȱ zurȱ Erzeugungȱ vonȱ dynamischenȱ Prozessenȱ undȱ derenȱ Zusammenführung:ȱforkȱundȱjoin.ȱAufrufeȱzumȱAnlegenȱeinesȱ gemeinsamenȱSpeichersȱundȱAufrufeȱzurȱSynchronisationȱderȱZuȬ griffeȱzumȱgemeinsamenȱSpeicherȱ(Semaphore).ȱȱȱ

x

Aufrufeȱ zurȱ Kommunikationȱ zwischenȱ denȱ parallelenȱ Prozessenȱ mitȱeinerȱRöhreȱ(Pipe)ȱundȱeinerȱWarteschlangeȱ(Queue).ȱ

Eineȱ hervorragendeȱ undȱ leichtȱ verständlicheȱ Beschreibungȱ derȱ Unixȱ SystemaufrufeȱbietetȱHeroldȱ[Hȱ04].ȱ

3.3.2.1 fork, join Fürȱ EinȬȱ undȱ Multiprozessorenȱ istȱ dasȱ Standardprogrammiermodellȱ fürȱ paralleleȱ Prozesseȱ unterȱ Unixȱ derȱ fork/joinȬParallelismus.ȱ Beimȱ Programmstartȱ läuftȱ einȱ Prozess,ȱ derȱ Hauptprozessȱ oderȱ dasȱ main.ȱ WerdenȱnebenläufigeȱProzesseȱbenötigt,ȱsoȱ„vergabelt“ȱ(fork)ȱsichȱderȱ Hauptprozessȱ inȱ einȱ oderȱ mehrereȱ Kindprozesse.ȱ Derȱ Hauptprozessȱ undȱalleȱKindprozesseȱarbeitenȱnebenläufig.ȱKommtȱeinȱKindȱzuȱEndeȱ

fork/joinȬȱ Parallelismusȱ

137ȱ

3 Programmiermodelle für parallele und verteilte Systeme (exit oder quit) oder wird es supendiert, so „vereinigt“ (join) sich der Kontrollfluss der Kinder mit dem des Hauptprozesses. Umschließt man das fork mit einer Schleife, so erzeugt man in der Schleife beliebig viele Kindprozesse, die alle nebenläufig zum Vaterprozess ablaufen. Bei Beendigung der Kindprozesse kann dann der Kontrollfluss von allen Kindprozessen mit von einer Schleife umgebenen join vereinigt werden mit dem Kontrollfluss des Vaters. Mit wait oder waitpid kann der Vater ebenfalls auf die Beendigung eines Kindes warten.

Abb. 3-10: fork/joinParallelismus

Der fork-join-Parallelismus eignet sich gut zur Implementierung des Master Worker-Schemas (siehe Abschnitt 4.2.2.1.1 Master Worker Schema). Dabei ist der Vater der Master, welcher die Kinder (Worker) erzeugt (fork), welche die einzelnen Datenpartionen bearbeiten. Der Vater wartet dann, bis seine Kinder die einzelnen Daten bearbeitet haben und sich beenden (join). Das fork erzeugt eine perfekte Kopie (Kind) des aufrufenden Prozesses (Vater), und das Kind erbt vom Vater die komplette Kopie des Vaters:

138

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ x

GleichesȱProgramm,ȱ

x

gleicheȱDatenȱ(gleicheȱWerteȱinȱVariablen),ȱ

x

gleicherȱProgrammzählerȱ(nachȱderȱKopie),ȱ

x

gleicherȱEigentümerȱ(Owner),ȱ

x

gleichesȱaktuellesȱVerzeichnis,ȱ

x

gleicheȱ Dateienȱ geöffnetȱ (selbstȱ SchreibȬȱ undȱ Lesezeigerȱ istȱ geȬ meinsam).ȱ

Dasȱ forkȱ gibtȱ anȱ denȱ Vaterȱ dieȱ Prozessidentifikationsnummerȱ (PID)ȱ desȱ Kindesȱ zurück,ȱ undȱ dasȱ Kindȱ erhältȱ dieȱ PIDȱ =ȱ 0.ȱ Gibtȱ dasȱ forkȱ eineȱPIDȱ<ȱ0ȱzurück,ȱsoȱliegtȱeinȱFehlerȱvor.ȱDadurch,ȱdassȱeinȱKindȱmitȱ demȱforkȱwiederȱKinderȱerzeugenȱkann,ȱsindȱmitȱdemȱforkȱbeliebigeȱ Prozesshierarchienȱaufbaubar.ȱ Imȱ Vergleichȱ zuȱ anderen,ȱ nachfolgendȱ beschriebenenȱ ProgrammierȬ modellenȱliegenȱbeimȱfork/joinȱdieȱparallelenȱProzesseȱnichtȱbeimȱProȬ grammstartȱ statischȱ vor,ȱ sondernȱ sieȱ werdenȱ dynamischȱ beiȱ Bedarfȱ gestartetȱ (fork)ȱ undȱ lassenȱ sichȱ beimȱ Beendenȱ mitȱ demȱ HauptkonȬ trollflussȱvereinigenȱ(join).ȱ

Dynamischeȱ Prozesseȱ

ȱ ȱ ȱ ȱ

Abb.ȱ3Ȭ11:ȱ fork/joinȱ VaterȬKindȬ Beziehungenȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

139ȱ

3 Programmiermodelle für parallele und verteilte Systeme Gemeinsamer Speicher

Die Speicherbereiche zweier Prozesse sind in Unix und im Gegensatz zu nachfolgend beschriebenen Threads streng getrennt. Wollen zwei Prozesse auf den gleichen gemeinsamen Speicher zugreifen, so muss er mit shmget angelegt werden, der Prozess mit shmat an den Speicher gebunden (attached) werden, so dass er ihn dann mit shmctl manipulieren kann.

Semaphore

Zum wechselseitigen Ausschluss beim gemeinsamen Zugriff auf den gemeinsamen Speicher bietet Unix Semaphore an. Semaphore werden mit semget angelegt. Die verallgemeinerte semop-Operation bietet als Spezialfall die P- und V-Operationen an. semctl stellt Kontrolloperationen wie Initialisieren und Löschen zur Verfügung.

3.3.2.2 Erzeuger-Verbraucher (Pipe) Zur Kommunikation zwischen zwei zyklischen Prozessen, wobei ein Prozess Nachrichten erzeugt und der Andere Nachrichten verbraucht, bietet Unix eine Röhre (Pipeline, Pipe) an. Der Erzeugerprozess schreibt an einem Ende eine Nachricht in die Röhre, die an dem anderen Ende ein Verbraucher dann aus der Röhre liest. Der Nachrichtenpuffer (Röhre) ist ein zyklischer Puffer (Umlaufpuffer) von endlicher Größe implementiert. Abb. 3-12: Kooperation zwischen Erzeuger und Verbraucher mittels Nachrichtenpuffer

Ein Zeiger oder Index für den Erzeuger, genannt Next_Free, zeigt auf das nächste freie Element des Umlaufpuffers. Ein Zeiger oder Index des Verbrauchers (Next_Full) zeigt auf das nächste volle Element des Puffers. Während der Erzeuger Elemente in den Puffer schreibt und der Verbraucher Elemente aus dem Puffer entnimmt, wandern beide Zeiger im Uhrzeigersinn weiter. Ist die Geschwindigkeit von Erzeuger und Verbraucher gleich, d.h. liegt ein Gleichlauf der beiden

140

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ Prozesseȱ vor,ȱ soȱ brauchtȱ nichtȱ synchronisiertȱ zuȱ werden,ȱ daȱ derȱ eineȱ Prozessȱ dieȱ Datenȱ erzeugt,ȱ dieȱ derȱ andereȱ Prozessȱ anschließendȱ verȬ braucht.ȱ Istȱ dieȱ Geschwindigkeitȱ derȱ beidenȱ Prozesseȱ unterschiedlich,ȱ soȱkannȱderȱVerbraucherȱschnellerȱalsȱderȱErzeugerȱsein,ȱoderȱderȱumȬ gekehrteȱFallȱliegtȱvor:ȱ x

Istȱ derȱ Verbraucherȱ schnellerȱ alsȱ derȱ Erzeuger,ȱ soȱ läuftȱ derȱ UmȬ laufpufferȱleer,ȱundȱderȱVerbraucherȱliestȱdasȱalteȱvorherȱgeleseneȱ ElementȱeinȱzweitesȱMal.ȱȱ

x

Istȱ derȱ Erzeugerȱ schnellerȱ alsȱ derȱ Verbraucher,ȱ soȱ läuftȱ derȱ UmȬ laufpufferȱüberȱundȱderȱErzeugerȱüberschreibtȱdieȱalteȱNachricht,ȱ dieȱdadurchȱverlorenȱgeht.ȱȱ

Umȱ keineȱ Nachrichtȱ mehrmalsȱ beimȱ Verbraucherȱ zuȱ empfangenȱ undȱ umȱ keineȱ Nachrichtenȱ zuȱ verlieren,ȱ müssenȱ wirȱ synchronisieren.ȱ Dieȱ Lösungȱ desȱ Synchronisationsproblemsȱ mitȱ Semaphorenȱ istȱ inȱ jedemȱ besserenȱBuchȱüberȱBetriebssystemeȱ[Bȱ90]ȱbeschriebenȱoderȱkannȱderȱ LeserȱleichtȱalsȱSemaphorübungȱselbstȱnachvollziehen.ȱȱ Dieȱ Implementierungȱ einerȱ Pipeȱ mitȱ einemȱ Monitorȱ istȱ inȱ Abschnittȱ 3.3.3.3.4ȱ Erzeugerȱ beschrieben,ȱ undȱ eineȱ Implementierungȱ mitȱ demȱ AdaȬRendezvousȱliegtȱinȱAbschnittȱ3.3.7.2.1ȱErzeugerȬVerbraucherȱmitȱ selektivemȱRendezvousȱ(Pipe)ȱvor.ȱȱ Unixȱ bietetȱ eineȱ Implementierungȱ einerȱ Pipeȱ aufȱ unterschiedlichenȱ Ebenenȱan:ȱȱ

PipesȱinȱUnix

1.ȱ Aufȱ KommandoȬȱ oderȱ Shellebene:ȱ Derȱ senkrechteȱ Strichȱ |ȱ istȱ eineȱ Pipe,ȱ welcheȱ dieȱ Ausgabeȱ desȱ linksȱ stehendenȱ Kommandosȱ (ProȬ zesses)ȱaufȱdieȱEingabeȱdesȱrechtsȱstehendenȱKommandosȱ(ProzesȬ ses)ȱ umleitet.ȱ Programme,ȱ dieȱ ihreȱ Anwendungȱ typischerweiseȱ imȱ DatenstromȱeinerȱPipeȱfinden,ȱnenntȱmanȱFilter.ȱEinȱganzȱtypischerȱ FilterȱistȱdasȱKommandoȱmore.ȱUmȱsichȱlängereȱVerzeichnisseȱseiȬ tenweiseȱ anzusehen,ȱ schaltetȱ manȱ eineȱ Pipeȱ zwischenȱ ls -lȱ undȱ more.ȱȱ 2.ȱȱAufȱSystemebene:ȱDerȱSystemaufrufȱȱ pipe(fd[2]); erzeugtȱeineȱPipeȱundȱgibtȱzweiȱFiledeskriptorenȱfd[0]ȱundȱfd[1]ȱ zurück.ȱ Einȱ Erzeugerȱ (Prozess)ȱ schließtȱ dasȱ Leseendeȱ derȱ Pipeȱ mitȱ close(fd[0])ȱ schreibtȱ mitȱ write (fd[1], Nachricht, 80)ȱ eineȱ Nachrichtȱ inȱ dieȱ Pipe.ȱ Einȱ Verbraucherȱ schließtȱ mitȱ close(fd[1])ȱ dieȱ Schreibseiteȱ derȱ Pipeȱ undȱ liestȱ mitȱ read(fd[0], Nachricht, 80)ȱdieȱNachrichtȱausȱderȱPipe.ȱȱ

141ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ 3.ȱ Aufȱ Dateiebene:ȱ ȱ Eineȱ Namedȱ Pipeȱ oderȱ FIFOȱ (Firstȱ inȱ Firstȱ out)ȱ kannȱmanȱmitȱderȱFunktionȱ int mkfifo (const char *dateiname, mode_t modus); eineȱPipeȱanglegen,ȱdieȱdannȱunterȱdemȱDateinamenȱvonȱeinemȱErȬ zeugerȱ undȱ Verbraucherȱ ansprechbarȱ ist.ȱ Derȱ Parameterȱ modusȱ nimmtȱ dieȱ Berechtigungȱ auf,ȱ wieȱ sieȱ vonȱ chmodȱ bekanntȱ sind.ȱ FIȬ FOsȱ überdauernȱ dieȱ sieȱ verwendendenȱ Prozesse,ȱ weilȱ sieȱ BestandȬ teilȱdesȱDateisystemsȱsind.ȱAllerdingsȱkannȱeineȱFIFOȱkeinenȱInhaltȱ haben,ȱ soȱ langeȱ sieȱ vonȱ keinemȱ Prozessȱ geöffnetȱ ist.ȱ Dasȱ bedeutet,ȱ dassȱ derȱ gepufferteȱ Inhaltȱ verlorenȱ geht,ȱ wennȱ einȱ Erzeugerȱ seinȱ Endeȱ derȱ Pipeȱ schließt,ȱ ohneȱ dassȱ einȱ lesenderȱ Prozessȱ (VerbrauȬ cher)ȱdasȱandereȱEndeȱderȱPipeȱgeöffnetȱhat.ȱ

3.3.2.3 Warteschlange (Queue) Eineȱ Pipeȱ erlaubtȱ nurȱ eineȱ 1:1ȬKommunikation,ȱ indemȱ einȱ Erzeugerȱ einemȱVerbraucherȱeineȱNachrichtȱzusendet.ȱZurȱm:nȬKommunikation,ȱ soȱ dassȱ mȱ >ȱ 0ȱ Prozesseȱ mitȱ nȱ >ȱ 0ȱ Prozessenȱ kommunizierenȱ können,ȱ benötigtȱ manȱ MessageȬQueuesȱ (Nachrichtenwarteschlangen).ȱ Jedeȱ MessageȬQueueȱbesitztȱeineȱKennungȱundȱsomitȱeinenȱMessageȬQueueȱ Identifier.ȱDieȱKennungȱistȱeineȱnichtnegativeȱganzeȱZahl,ȱdieȱbeiȱjederȱ Neueinrichtungȱ(msgget)ȱeinerȱ MessageȬQueueȱ hochgezähltȱ wird.ȱ Istȱ derȱMaximalwertȱerreicht,ȱsoȱbeginntȱdieȱZählungȱwiederȱbeiȱ0.ȱȱ MessageȬȱ Queuesȱ

JedeȱNachrichtȱbestehtȱausȱdreiȱKomponenten:ȱ 1.ȱȱMessageȬTypȱ(z.B.ȱDatentypȱlong),ȱ 2.ȱȱLängeȱderȱNachrichtȱ(Datentypȱsize_t)ȱundȱȱ 3.ȱȱNachrichtȱoderȱMessageȬString.ȱ

mgsgetȱ

Zumȱ Einrichtenȱ oderȱ zumȱ Öffnenȱ einerȱ bereitsȱ existierendenȱ Queueȱ dientȱ dieȱ Funktionȱ msgget.ȱ msggetȱ liefertȱ dieȱ Kennungȱ (MessageȬ Queueȱ Identifier)ȱ zurück.ȱ Dieseȱ Kennungȱ benutzenȱ dannȱ dieȱ nachfolȬ gendȱ beschriebenenȱ Funktionenȱ zurȱ Kennzeichnungȱ derȱ entsprechenȬ denȱQueue.ȱȱ

msgsndȱ

DasȱSendenȱeinerȱNachrichtȱinȱdieȱQueueȱgeschiehtȱmitȱmsgsnd.ȱEineȱ mitȱmgssndȱgeschickteȱNachrichtȱwirdȱimmerȱamȱEndeȱderȱbetreffenȬ denȱMessageȬQueueȱangehängt.ȱ

msgrcvȱ

Mitȱ msgrcvȱ könnenȱ Nachrichtenȱ ausȱ derȱ Queueȱ empfangenȱ werden.ȱ BeiȱerfolgreicherȱAusführungȱgibtȱmsgrcvȱdieȱLängeȱderȱempfangenenȱ Nachrichtȱ zurückȱ undȱ Ȭ1ȱ imȱ Fehlerfalle.ȱ Dasȱ Argumentȱ typȱ legtȱ denȱ TypȱderȱzuȱempfangendenȱNachrichtȱfest:ȱ

142ȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ x

typ == 0ȱ :ȱ Ersteȱ Nachrichtȱ ausȱ derȱ MessageȬQueueȱ (FIFOȬ Warteschlange).ȱ

x

typ > 0ȱ :ȱ Ersteȱ Nachrichtȱ ausȱ derȱ Warteschlange,ȱ dieȱ denȱ Typȱ typȱhat.ȱClient–ServerȬAnwendungen,ȱbeiȱdenenȱnurȱeineȱWarteȬ schlangeȱfürȱdieȱKommunikationȱzwischenȱServerȱundȱdenȱvielenȱ Clientsȱ exisistiert,ȱ benutzenȱ dieȱ ProzessȬidentifikationsnummerȱ (PID)ȱalsȱtypȱzurȱIdentifikationȱdesȱentsprechendenȱClients.ȱȱ

x

typ < 0ȱ:ȱErsteȱNachrichtȱausȱderȱQueue,ȱderenȱTypȱderȱkleinsteȱ Wertȱist,ȱderȱkleinerȱoderȱgleichȱdemȱabsolutenȱBetragȱvonȱtypȱist.ȱȱ

Istȱ keineȱ Nachrichtȱ desȱ gefordertenȱ typȱ inȱ derȱ MessageȬQueue,ȱ soȱ blockiertȱ normalerweiseȱderȱ Empfänger,ȱ bisȱ eineȱNachrichtȱ desȱ geforȬ dertenȱ Typsȱ verfügbarȱ ist.ȱ Sollȱ derȱ Empfängerȱ nichtȱ blockieren,ȱ beimȱ nichtȱ Vorhandenseinȱ derȱ Nachricht,ȱ soȱ kannȱ diesȱ durchȱ Setzenȱ desȱ FlagȬArgumentsȱaufȱIPC_NOWAITȱbewirktȱwerden.ȱȱȱ DasȱAbfragenȱundȱÄndernȱdesȱStatusȱoderȱdasȱLöschenȱeinerȱMessageȬ Queueȱgeschiehtȱmitȱmsgctl.ȱȱ

msgctlȱ

3.3.3 Threads 3.3.3.1 Threads versus Prozesse Einȱ Prozessȱ istȱ definiertȱ durchȱ dieȱBetriebsmittel,ȱ dieȱ erȱ benötigt,ȱ undȱ denȱAdressbereich,ȱinȱdemȱerȱabläuft.ȱEinȱProzessȱwirdȱimȱBetriebssysȬ temȱ beschriebenȱ durchȱ einenȱ Prozesskontrollblockȱ (Processȱ Controlȱ Blockȱ–ȱPCB).ȱDerȱPCBȱbestehtȱausȱdemȱHardwarekontextȱundȱeinemȱ Softwarekontext.ȱ Einȱ Prozesswechselȱ bewirktȱ denȱ komplettenȱ AusȬ tauschȱ desȱ PCB.ȱ Zurȱ Erreichungȱ einesȱ schnellerenȱ Prozesswechselsȱ mussȱdieȱInformation,ȱdieȱbeiȱeinemȱProzesswechselȱauszutauschenȱist,ȱ reduziertȱwerden.ȱDiesȱerreichtȱmanȱdurchȱAufteilungȱeinesȱProzessesȱ inȱmehrereȱ„Miniprozesse“ȱoder,ȱbildlichȱgesprochen,ȱdurchȱAuffädelnȱ mehrererȱ dieserȱ „Miniprozesse“ȱ unterȱ einemȱ Prozess.ȱ Demgemäßȱ beȬ zeichnetȱ manȱ solcheȱ „Miniprozesse“ȱ alsȱ Threadsȱ (Threadȱ –ȱ Faden).ȱ Mehrereȱ oderȱ eineȱ Gruppeȱ vonȱ Threadsȱ habenȱ denȱ gleichenȱ AdressȬ raumȱ undȱ besitzenȱ dieȱ gleichenȱ Betriebsmittelȱ (gleicheȱ Mengeȱ vonȱ offenenȱFiles,ȱKindprozesse,ȱTimer,ȱSignaleȱusw.).ȱNachteiligȱistȱnatürȬ lichȱbeiȱeinemȱAdressraumȱfürȱdieȱThreads,ȱdassȱalleȱThreadsȱdenȱgleiȬ chenȱ Adressraumȱ benutzenȱ undȱ damitȱ dieȱ Schutzmechanismenȱ zwiȬ schenȱverschiedenenȱThreadsȱversagen.ȱDieȱUmgebung,ȱinȱwelcherȱeinȱ Threadȱ abläuft,ȱ istȱ einȱ Prozessȱ (Task).ȱ Einȱ traditionellerȱ Prozessȱ entȬ sprichtȱeinemȱProzessȱmitȱeinemȱThread.ȱȱ

Vergleichȱ Prozessȱȱȱ Threadȱ

143ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ EinȱThreadȱ liegtȱinȱeinemȱ Prozessȱ

Einȱ Prozessȱ bewirktȱ nichts,ȱ wennȱ erȱ keinenȱ Threadȱ enthält,ȱ undȱ einȱ Threadȱ mussȱ genauȱ inȱ einemȱ Prozessȱ liegen.ȱ Einȱ Threadȱ hatȱ wenigsȬ tensȱ seinenȱ eigenenȱ Programmzähler,ȱ seineȱ eigenenȱ Registerȱ undȱ geȬ wöhnlichȱ auchȱ seinenȱ eigenenȱ Keller.ȱ Damitȱ istȱ einȱ Threadȱ dieȱ BasisȬ einheit,ȱ zwischenȱ denenȱ dieȱ CPUȱ einerȱ EinȬȱ oderȱ MultiprozessorȬ Maschineȱ umgeschaltetȱ werdenȱ kann.ȱ Derȱ Prozessȱ istȱ dieȱ AusfühȬ rungsumgebung,ȱ undȱ dieȱ dazugehörigenȱ Aktivitätsträgerȱ sindȱ dieȱ Threads.ȱ Einȱ Prozessȱ besitztȱ einenȱ virtuellenȱ Adressraumȱ undȱ eineȱ Listeȱ mitȱ Zugriffsrechtenȱ aufȱ dieȱ Betriebsmittelȱ nebstȱ notwendigerȱ Verwaltungsinformation.ȱ Einȱ Threadȱ istȱ einȱ elementaresȱ ausführbaresȱ ObjektȱfürȱeinenȱrealenȱProzessorȱundȱläuftȱimȱKontextȱeinesȱProzesses.ȱ

Mehrereȱ Threadsȱinȱ einemȱProzessȱ

VerschiedeneȱThreadsȱinȱeinemȱProzessȱsindȱnichtȱsoȱunabhängigȱwieȱ verschiedeneȱ Prozesse.ȱ Alleȱ Threadsȱ kooperierenȱ miteinanderȱ undȱ teilenȱsichȱdieȱgemeinsamenȱglobalenȱVariablen,ȱaufȱdieȱdannȱsynchroȬ nisiertȱ vonȱ denȱ verschiedenenȱ Threadsȱ zugegriffenȱ wird.ȱ Somitȱ wirdȱ eineȱinȱnachfolgenderȱAbbildungȱdargestellteȱOrganisationȱa)ȱgewählt,ȱ fallsȱzwischenȱdreiȱProzessenȱkeineȱBeziehungenȱbestehen,ȱundȱOrgaȬ nisationȱ b),ȱ fallsȱ dreiȱ Threadsȱ miteinanderȱ kooperieren,ȱ umȱ eineȱ geȬ meinsameȱAufgabeȱzuȱlösen.ȱ ȱ ȱ

Abb.ȱ3Ȭ13:ȱ Prozesseȱundȱ Threadsȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ Durchȱ dieȱ Benutzungȱ derȱ gemeinsamenȱ Betriebsmittelȱ desȱ Prozessesȱ lässtȱ sichȱ dieȱ CPUȱ zwischenȱ Threadsȱ schnellerȱ umschaltenȱ alsȱ zwiȬ schenȱ Prozessen,ȱ daȱ wenigerȱ Informationȱ auszutauschenȱ ist.ȱ Deshalbȱ bezeichnetȱ manȱauchȱ Threadsȱ oftȱalsȱleichtgewichtigeȱ Prozesseȱ(lightȬ

144ȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ weightȱ processes)ȱ undȱ traditionelleȱ Prozesseȱ alsȱ schwergewichtigeȱ Prozesseȱ (heavyweightȱ processes).ȱ Dieȱ Information,ȱ dieȱ einenȱ Threadȱ bzw.ȱ einenȱ Prozessȱ beschreibt,ȱ istȱ inȱ nachfolgenderȱ Abbildungȱ dargeȬ stellt.ȱȱ ȱ ȱ ȱ ȱ

Abb.ȱ3Ȭ14:ȱ Informationȱ fürȱeinenȱ Threadȱundȱ einenȱProzess

ȱ ȱ ȱ ȱ

3.3.3.2 Implementierung von Threads ȱ ZurȱImplementierungȱvonȱThreadsȱgibtȱesȱdreiȱMöglichkeiten:ȱ 1.ȱȱ ThreadsȱaufȱBenutzerebene.ȱ 2.ȱȱ ThreadsȱaufȱBetriebssystemȬȱoderȱKernelebene.ȱ 3.ȱȱ Hybrideȱ Implementierungen,ȱ dieȱ zwischenȱ 1.ȱ undȱ 2.ȱ liegenȱ undȱ bekanntȱsindȱunterȱtwoȬlevelȱScheduler.ȱ Beiȱ derȱ Implementierungȱ imȱ Benutzeradressraumȱ istȱ dasȱ BetriebssysȬ temȱnichtȱinvolviert,ȱundȱeineȱBibliothekȱfürȱThreadsȱübernimmtȱselbstȱ dasȱSchedulingȱundȱUmschaltenȱzwischenȱdenȱThreads.ȱDasȱBetriebsȬ systemȱkenntȱkeineȱThreadsȱundȱesȱbringtȱwieȱgewohntȱProzesseȱzumȱ Ablauf.ȱ Dieserȱ Entwurfȱ istȱ bekanntȱ alsȱ allȬtoȬoneȱ mapping.ȱ Vonȱ allenȱ Threads,ȱ dieȱ zuȱ einemȱ Zeitpunktȱ ablaufbereitȱ sind,ȱ wähltȱ dieȱ ThreadȬ Bibliothekȱ einenȱ aus,ȱ derȱ dannȱ imȱ Kontextȱ desȱ Prozessesȱ läuft,ȱ wennȱ dasȱBetriebssystemȱdiesenȱProzessȱzumȱAblaufȱbringt.ȱȱ

Threadsȱaufȱ BenutzerȬ ebeneȱ

ȱ ȱ ȱ ȱ

145ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ ȱ Abb.ȱ3Ȭ15:ȱ Threadsȱaufȱ BenutzerȬ ebeneȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ DieȱVorteileȱvonȱThreadsȱaufȱBenutzerebeneȱsind:ȱ

Vorteileȱvonȱ Threadsȱaufȱ BenutzerȬ ebeneȱ

146ȱ

x

Daȱ keineȱ Änderungenȱ amȱ Betriebssystemȱ vorgenommenȱ werdenȱ müssen,ȱlässtȱsichȱschnellȱundȱbequemȱeineȱThreadbibliothekȱeinȬ führenȱundȱaufȱdasȱbestehendeȱBetriebssystemȱaufpflanzen.ȱȱ

x

Eineȱ Implementierungȱ imȱ Benutzeradressraumȱ benötigtȱ keineȱ aufwändigenȱ Systemaufrufeȱ zumȱ Anlegenȱ vonȱ Threadsȱ undȱ zumȱ Durchführenȱ vonȱ Umschaltungenȱ zwischenȱ Threads,ȱ dasȱ heißtȱ esȱ findenȱ keineȱ Umschaltungenȱ zwischenȱ Benutzermodusȱ undȱ SysȬ temmodusȱ statt.ȱ Dadurchȱ laufenȱ Anwendungenȱ basierendȱ aufȱ ThreadsȱimȱBenutzeradressraumȱschnellerȱalsȱAnwendungen,ȱwelȬ cheȱaufȱThreadsȱimȱSystemadressraumȱbasieren.ȱȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ x

DaȱalleȱThreadsȱohneȱdasȱBetriebssystemȱlaufen,ȱkönnenȱmehrȱundȱ mehrȱ Threadsȱ angelegtȱ werden,ȱ ohneȱ dasȱ Betriebssystemȱ zuȱ beȬ lasten.ȱ

AllerdingsȱhatȱdieserȱAnsatzȱauchȱzweiȱbeträchtlicheȱNachteile:ȱ x

DaȱdasȱBetriebssystemȱnurȱProzesseȱsieht,ȱkannȱdasȱzuȱeinemȱunȬ fairenȱ Schedulingȱ vonȱ Threadsȱ führen.ȱ Betrachtenȱ wirȱ dazuȱ zweiȱ Prozesse,ȱeinȱProzessȱmitȱeinemȱThreadȱ(Prozessȱa)ȱundȱeinȱandeȬ rerȱ Prozessȱ mitȱ 100ȱ Threadsȱ (Prozessȱ b).ȱ Jederȱ Prozessȱ erhältȱ imȱ AllgemeinenȱfürȱeineȱZeitscheibeȱdenȱProzessor,ȱdamitȱläuftȱdannȱ einȱThreadȱinȱProzessȱaȱ100ȬmalȱschnellerȱalsȱeinȱThreadȱinȱProzessȱ b.ȱ Weiterhinȱ hatȱ dasȱ Anhebenȱ derȱ Prioritätȱ einesȱ Threadsȱ keineȱ Auswirkungen,ȱ daȱ nurȱ denȱ Prozessenȱ gemäßȱ ihrerȱ Prioritätȱ dieȱ CPUȱzugeordnetȱwird.ȱ

x

Daȱ dieȱ Bibliothekȱ vonȱ ThreadȬRoutinenȱ keinenȱ Bezugȱ zumȱ BeȬ triebssystemȱ undȱ derȱ darunterȱ liegendenȱ Rechnerarchitekturȱ hat,ȱ nimmtȱ einȱ ThreadȬProgrammȱ auchȱ mehrfachȱ vorhandeneȱ CPUsȱ nichtȱ zurȱ Kenntnis.ȱ Dasȱ Betriebssystemȱ ordnetȱ verfügbareȱ CPUsȱ nurȱProzessenȱzuȱundȱnichtȱThreads.ȱDamitȱlaufenȱdieȱThreadsȱeiȬ nesȱProzessesȱnieȱechtȱparallel,ȱsondernȱnurȱdieȱProzesse.ȱ

Beiȱ einerȱ Implementierungȱ vonȱ Threadsȱ aufȱ derȱ Betriebssystemebeneȱ kenntȱ dasȱ Betriebssystemȱ Threads,ȱ undȱ jederȱ Benutzerthreadȱ wirdȱ zuȱ einemȱKernelthread.ȱDieȱSchedulingeinheitenȱdesȱBetriebssystemsȱsindȱ dannȱ Threadsȱ undȱ nichtȱ mehrȱ Prozesse.ȱ Daȱ eineȱ EinsȬzuȬeinsȬ ZuordnungȱderȱBenutzerthreadsȱzuȱKernelthreadsȱstattfindet,ȱistȱdieserȱ Ansatzȱ auchȱ alsȱ oneȬtoȬoneȱmappingȱ bekannt.ȱ Einȱ Beispielȱ fürȱ solcheȱ inȱ dasȱ Betriebssystemȱ integrierteȱ Threadsȱ istȱ derȱ MachȬKernel,ȱ derȱ GrundlageȱvielerȱUnixȬbasierterȱBetriebssystemeȱist,ȱwieȱz.B.ȱOSF/1.ȱȱ

Nachteileȱvonȱ Threadsȱaufȱ BenutzerȬ ebeneȱ

Threadsȱaufȱ BetriebsȬ systemebeneȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

147ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ ȱ Abb.ȱ3Ȭ16:ȱ Threadsȱaufȱ BetriebsȬ systemebeneȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

Vorteileȱvonȱ Threadsȱaufȱ BetriebsȬ systemebeneȱ

KernelthreadsȱbesitzenȱnichtȱmehrȱdieȱobenȱerwähntenȱbeidenȱNachteiȬ leȱvonȱBenutzerthreads:ȱȱ x

Daȱ dasȱ Schedulingȱ globalȱ überȱ alleȱ Threadsȱ stattfindet,ȱ können,ȱ fallsȱ mehrereȱ CPUsȱ inȱ demȱ Systemȱ vorhandenȱ sind,ȱ dieȱ Threadsȱ echtȱparallelȱabgearbeitetȱwerden.ȱȱ

Dieȱ obenȱ erwähntenȱ Vorteileȱ vonȱ Benutzerthreadsȱ kehrenȱ sichȱ inȱ NachteileȱbeiȱKernelthreadsȱum:ȱ Nachteileȱvonȱ Threadsȱaufȱ BetriebsȬ systemebeneȱ

148ȱ

x

Zumȱ Anlegenȱ einesȱ neuenȱ Threadsȱ mussȱ vomȱ Benutzermodusȱ inȱ denȱ Systemmodusȱ umgeschaltetȱ werden,ȱ undȱ imȱ Systemmodusȱ werdenȱdannȱdieȱfürȱdieȱThreadsȱangelegtenȱDatenstrukturenȱmaȬ nipuliert.ȱȱ

x

EineȱVielzahlȱvonȱThreadsȱkannȱdasȱBetriebssystemȱstarkȱbelastenȱ undȱdieȱGesamtperformanzȱdesȱSystemsȱreduzieren.ȱȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ Umȱ dieȱ Vorteileȱ desȱ einenȱ Ansatzesȱ nichtȱ zuȱ Nachteilenȱ desȱ anderenȱ Ansatzesȱ werdenȱ zuȱ lassen,ȱ istȱ imȱ SolarisȬBetriebssystemȱ vonȱ Sunȱ einȱ hybriderȱ Ansatzȱ realisiert.ȱ Wieȱ beiȱ einerȱ reinenȱ kernelȬbasiertenȱ ImpȬ lementierungȱ bildetȱ einȱ twoȬlevelȱ Schedulerȱ Benutzerthreadsȱ aufȱ KerȬ nelthreadsȱab.ȱAnstattȱjedemȱBenutzerthreadȱeinenȱKernelthreadȱzuzuȬ ordnen,ȱ bildetȱ manȱ eineȱ Mengeȱ vonȱ Benutzerthreadsȱ aufȱ eineȱ Mengeȱ vonȱKernelthreadsȱab.ȱDieȱAbbildungȱistȱdabeiȱnichtȱstatisch,ȱsondernȱ dynamisch,ȱ undȱ zuȱ unterschiedlichenȱ Zeitenȱ könnenȱ Benutzerthreadsȱ aufȱ unterschiedlicheȱ Kernelthreadsȱ abgebildetȱ werden.ȱ Dieserȱ Ansatzȱ istȱbekanntȱalsȱdasȱsomeȬtoȬoneȱmapping.ȱDieȱThreadȬBibliothekȱundȱderȱ KernȱenthaltenȱdabeiȱDatenstrukturenȱzurȱRepräsentationȱvonȱThreads.ȱ DieȱThreadȬBibliothekȱbildetȱdabeiȱdieȱBenutzerthreadsȱaufȱdieȱverfügȬ barenȱKernelthreadsȱab.ȱJedochȱwerdenȱnichtȱalleȱBenutzerthreadsȱaufȱ Kernelthreadsȱabgebildet:ȱSchläftȱeinȱBenutzerthreadȱhäufigȱoderȱwarȬ tetȱ erȱ oftȱ aufȱ Timerȱ oderȱ einȱ Ereignisȱ oderȱ eineȱ I/OȬBeendigung,ȱ soȱ brauchtȱ ihmȱ keinȱ eigenerȱ Kernelthreadȱ zugeordnetȱ zuȱ werden.ȱ Allenȱ Threads,ȱdieȱCPUȬAktivitätȱzeigen,ȱkannȱeinȱKernelthreadȱzugeordnetȱ werden.ȱ Diesȱ erspartȱ denȱ Overheadȱ desȱ Anlegensȱ einesȱ neuenȱ KerȬ nelthreads.ȱȱ

Hybrid:ȱȱȱȱ twoȬlevelȱ Schedulerȱ

ȱ ȱ ȱ

Abb.ȱ3Ȭ17:ȱ twoȬlevelȱ Scheduler

ȱ ȱ ȱ ȱ ȱ ȱ

ȱ ȱ

149ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ

3.3.3.3 Pthreads Dasȱ Betriebssystemȱ Machȱ [ZKȱ 93]ȱ führteȱ zurȱ Programmierungȱ vonȱ ThreadsȱeineȱCȬThreadsȬBibliothekȱ[CDȱ88]ȱein.ȱFürȱC++ȱstehtȱeineȱBibȬ liothek,ȱ dieȱ Intelȱ Threadingȱ Buildingȱ Blocks,ȱ zurȱ parallelenȱ ProgramȬ mierungȱ mitȱ Threadsȱ zurȱ Verfügungȱ [Rȱ 07].ȱ Danebenȱ habenȱ andereȱ Betriebssystemeȱ(OS/2,ȱWinȱ32,ȱWindowsȱNT),ȱdieȱDistributedȱCompuȬ tingȱ Environmentȱ (DCE),ȱ verschiedeneȱ UnixȬDerivateȱ (OSF/1,ȱ Solaris)ȱ undȱ dieȱ Programmierspracheȱ Javaȱ [KYȱ 02]ȱ [OWȱ 04]ȱ dasȱ ThreadȬ Konzeptȱ aufgegriffenȱ undȱ integriert.ȱ Dieȱ eingeführtenȱ verschiedenenȱ ThreadȬBibliothekenȱ bzw.ȱ inȱ Javaȱ dieȱ Klasseȱ Threadȱ undȱ ThreadGroupȱ [GYJȱ97]ȱ besaßenȱ einȱ unterschiedlichesȱ Interface,ȱ dasȱimȱUnixȬ Bereichȱ durchȱ denȱ POSIXȱ (Portableȱ Operatingȱ Systemȱ Interface),ȱ geȬ nauerȱ POSIXȱ Sectionȱ 1003.1cȬ1995ȬStandard,ȱ festgeschriebenȱ wurde.ȱ POSIXȬthreads,ȱoderȱkurzȱPthreads,ȱsindȱeineȱdefinierteȱMengeȱvonȱCȬ Typenȱ undȱ CȬFunktionsaufrufenȱ mitȱ festgelegterȱ Semantik.ȱ PthreadsȬ ImplementierungenȱwerdenȱinȱderȱFormȱeinesȱHeaderȬFiles,ȱderȱinȱdasȱ Programmȱ eingebundenȱ wird,ȱ undȱ einerȱ Bibliothek,ȱ dieȱ zumȱ ProȬ grammȱhinzugebundenȱwerdenȱmuss,ȱausgeliefert.ȱImȱFolgendenȱstelȬ lenȱwirȱdieȱwichtigstenȱKomponentenȱderȱPthreadsȬBibliothekȱvorȱundȱ gebenȱBeispieleȱfürȱihreȱAnwendung;ȱdabeiȱorientierenȱwirȱunsȱanȱdenȱ Büchernȱ überȱ PthreadȬProgrammierungȱ [Bȱ 97],ȱ [NBFȱ 98],ȱ [HHȱ 97]ȱ [Zȱ 06]ȱausȱdenenȱauchȱeinigeȱBeispielprogrammeȱentnommenȱsind.ȱÜberȱ dasȱ Verständnisȱ desȱ PthreadsȬPaketesȱ findetȱ derȱ Leserȱ einenȱ leichtenȱ ZugangȱzuȱdenȱanderenȱThreadȬPaketenȱundȱzuȱdenȱKlassenȱThreadȱ undȱThreadGroupȱvonȱJavaȱundȱsomitȱzuȱdenȱJavaȬThreads.ȱOechsleȱ [Oȱ01]ȱgehtȱtieferȱaufȱdieȱParallelprogrammierungȱein,ȱundȱerȱgibtȱfürȱ Standardproblemeȱ derȱ Parallelprogrammierungȱ derenȱ ImplementieȬ rungȱmitȱJavaȬThreadsȱan.ȱInȱderȱ2.ȱAuflageȱvonȱdemȱBuchȱvonȱOechsleȱ [Oȱ07]ȱbeschreibtȱderȱAutorȱnochȱzusätzlichȱdieȱklassischenȱSynchroniȬ sationsmechanismenȱ (Semaphore,ȱ Messageȱ Queues,ȱ Pipes)ȱ undȱ dieȱ ConcurrentȬKlassenbibliothekȱ ausȱ Javaȱ 5ȱ (Tiger).ȱ Nebenȱ anderenȱ istȱ auchȱinȱ[KYȱ02]ȱ{OWȱ04]ȱdieȱJavaȬThreadȬProgrammierungȱbeschrieben.ȱȱ

3.3.3.3.1 Thread Verwaltungsroutinen DieȱOperationȱzumȱErzeugenȱundȱStartenȱeinesȱThreadȱist:ȱ pthread_ȱ createȱ

150ȱ

int pthread_create(pthread_t *thread_handle, // handle auf Thread-Datenstruktur pthread_attr_t attr, // Thread-Attribut pthread_func_t thread_func, // aufzurufende Funktion für den // Thread

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ pthread_addr_t arg); // Argumente für die aufzurufende // Funktion DieȱRoutineȱwirdȱvonȱeinemȱKoordinatorȬ,ȱVaterȬȱoderȱErzeugerthreadȱ aufgerufenȱundȱführtȱdazu,ȱdassȱeinȱneuerȱThreadȱmitȱderȱAusführungȱ derȱangegebenenȱFunktionȱthread_funcȱbeginnt.ȱMitȱdemȱParameterȱ argȱ wirdȱ derȱ Funktionȱ einȱ einzigesȱ Argumentȱ übergeben.ȱ argȱ wirdȱ normalerweiseȱ alsȱ Zeigerȱ aufȱ Anwendungsparameterȱ übergeben.ȱ Derȱ ersteȱ Parameterȱ istȱ einȱ Zeigerȱ aufȱ eineȱ bereitsȱ vorabȱ zuȱ allokierendeȱ ThreadȬDatenstrukturȱ pthread_t.ȱ Eineȱ zusätzlicheȱ AttriȬ butbeschreibungȱ attrȱ ermöglichtȱ es,ȱ genauereȱ Eigenschaftenȱ einesȱ Threadsȱ festzulegen,ȱ wieȱ z.B.ȱ Konfigurationȱ desȱ Kellers,ȱ Festlegungȱ derȱ Schedulingȱ Strategieȱ undȱ derȱ Prioritätȱ desȱ Threads.ȱ Dieseȱ EigenȬ schaftenȱ werdenȱ festgelegtȱ mitȱ pthread_attr...ȬFunktionen.ȱ Inȱ vielenȱ Fällenȱ kannȱ derȱ Wertȱ NULLȱ fürȱ diesesȱ Argumentȱ verwendetȱ werden,ȱ umȱ anzuzeigen,ȱ dassȱ defaultȬCharakteristikenȱ fürȱ diesenȱ Threadȱ vorliegen.ȱ pthread_createȱ gibtȱ beiȱ erfolgreicherȱ AusfühȬ rungȱeinenȱNullwertȱzurück;ȱeinȱnichtȱNullwertȱzeigtȱundȱidentifiziertȱ einenȱFehler.ȱȱ Derȱ gestarteteȱ Threadȱ läuftȱ dannȱ nebenläufigȱ zuȱ seinemȱ Erzeugerȱ abȱ undȱ meldetȱ amȱ Endeȱ seinerȱ Bearbeitungȱ einȱ Ergebnisȱ zurückȱ mitȱ derȱ Operation:ȱ int pthread_exit(pthread_addr_t result);

pthread_exit

Aufȱ diesesȱ Ergebnisȱ kannȱ vomȱ ThreadȬErzeugerȱ anȱ beliebigerȱ Stelleȱ gewartetȱwerdenȱmitȱderȱOperation:ȱ int pthread_join(pthread_t thread, // Identifikation des Thread pthread_addr_t *result); // Ergebnis der Bearbeitung

pthread_join

DerȱAufruferȱspezifiziertȱdenȱbetreffendenȱThreadȱüberȱdessenȱDatenȬ strukturȱ threadȱ undȱ erhältȱ eineȱ Referenzȱ aufȱ dasȱ Ergebnisȱ überȱ denȱ Ausgabeparameterȱ result.ȱ Anschließendȱ kannȱ derȱ Threadȱ explizitȱ gelöschtȱwerdenȱdurch:ȱ int pthread_detach(pthread_t thread); // Identifikation des Thread

pthread_ȱ detachȱ

Dieȱ Operationȱ pthread_detachȱ zerstörtȱ denȱ internenȱ ThreadȬ kontrollblockȱundȱgibtȱdenȱthreadlokalenȱKellerȱfrei.ȱDanachȱistȱnatürȬ lichȱkeinȱpthread_joinȱfürȱdiesenȱThreadȱmehrȱmöglich.ȱȱ

151ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ Nebenȱ pthread_exitȱ kannȱ einȱ Threadȱ auchȱ explizitȱ durchȱ einenȱ anderenȱ beendetȱ werdenȱ oderȱ erȱ kannȱ sichȱ auchȱ selbstȱ imȱ Rahmenȱ einesȱFehlerfallesȱabbrechen.ȱDazuȱdientȱdieȱOperation:ȱ pthread_ȱ cancelȱ

int pthread_cancel(pthread_t thread); // Identifikation des Thread Einȱ Threadȱ kannȱ allerdingsȱ auchȱ verhindern,ȱ dassȱ eineȱ pthread_cancelȬOperationȱ sofortȱ wirksamȱ wird.ȱ Diesȱ istȱ fürȱ kritiȬ scheȱAbschnitteȱwichtig,ȱderenȱAbbruchȱzuȱinkonsistentenȱWertenȱvonȱ Semaphorenȱführenȱwürde.ȱDieȱAusschlussoperationȱist:ȱ

pthread_ȱ setcancelȱ

int pthread_setcancel(int state); // Cancel-Status Eineȱ Statusangabeȱ vonȱ state=CANCEL_OFFȱ verzögertȱ etwaigeȱ pthread_cancelȬOperationenȱ fürȱ denȱ aufrufendenȱ Threadȱ undȱ state=CANCEL_ONȱerlaubtȱdieseȱwieder.ȱ Inȱ folgendemȱ Beispielȱ erzeugtȱ einȱ VaterȬThreadȱ fürȱ jedesȱ Paarȱ einesȱ Feldesȱ einenȱ Threadȱ zurȱ Additionȱ derȱ beidenȱ Elemente.ȱ Derȱ erzeugteȱ Threadȱ gibtȱ dannȱ dieȱ Additionȱ derȱ beidenȱ Elementeȱ alsȱ Ergebnisȱ zuȬ rück.ȱ

Programmȱ3Ȭ1:ȱ Additionȱvonȱ Integerpaarenȱ durchȱjeweilsȱ einenȱThreadȱ

#include #define length 10 int field [length] [2]; // Feld von Paaren, die addiert werden int sums [length]; // Summenfeld void add_op_thread(pthread_addr_t arg) // Operation zum Addieren { int* input = (int*) arg; // Eingabeparameter des Thread int output; output = input[0] + input[1]; // Addition pthread_exit((pthread_addr_t) output); // Rückgabe Ergebnis und Terminieren } main (void)// main thread, Erzeugerthread {

152ȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ pthread_t thread[length]; // zu erzeugende Bearbeitungsthreads int i, result; // Laufvariable, Einzelergebnis for (i=0; i < length; i++) // Erzeugung der Bearbeitungsthreads pthread_create (&thread[i], // thread Datenstruktur NULL, // thread-Attribut add_op_thread, // aufzurufende Funktion (pthread_addr_t)field[i]); // Zeiger auf Parameter for (i=0; i < length; i++) { // Warten auf Ergebnis der einzelnen Threads pthread_join(thread[i], // Identifikation des Thread &result); // Ergebnis der Bearbeitung // Einfügen des Ergebnisses sums[i] =result; // Löschen der Threads pthread_detach(thread[i]); } }

3.3.3.3.2 Wechselseitiger Ausschluss ZumȱwechselseitigenȱAusschluss,ȱbeimȱZugriffȱaufȱgemeinsameȱDatenȱ vonȱ mehrerenȱ Threadsȱ aus,ȱ oderȱ zurȱ Realisierungȱ vonȱ kritischenȱ AbȬ schnitten,ȱ stehenȱ binäreȱ Semaphoreȱ zurȱ Verfügung.ȱ Dieȱ Semaphoreȱ nehmenȱdieȱZuständeȱgesperrtȱundȱfreiȱan.ȱEinȱThreadȱwirdȱbeiȱeinemȱ gesperrtenȱSemaphorȱsoȱlangeȱblockiert,ȱbisȱderȱSemaphorȱfreigegebenȱ wird.ȱWartenȱmehrereȱThreadsȱanȱeinemȱSemaphor,ȱsoȱwirdȱeinerȱfreiȬ gegebenȱundȱdieȱübrigenȱbleibenȱblockiert.ȱȱ EinȱSemaphorȱoderȱauchȱMutexȱ(mutualȱexclusion)ȱwirdȱdurchȱfolgenȬ deȱOperationȱerzeugtȱundȱinitialisiert:ȱ int pthread_mutex_init(pthread_mutex_t *mutex, // Mutex pthread_mutexattr_t attr); // Mutex-Attribut

pthread_ȱ mutex_initȱ

153ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ DerȱParameterȱmutexȱistȱeineȱvorabȱallokierteȱDatenstrukturȱdesȱMuȬ texȬTyps.ȱ Dasȱ MutexȬAttributȱ beschreibtȱ dieȱ Artȱ desȱ Semaphorsȱ geȬ nauer;ȱ umȱ einȱ DefaultȬAttributȱ zuȱ verwenden,ȱ reichtȱ einȱ NULLȬ Attribut.ȱȱ DasȱSperrenȱeinesȱSemaphorsȱgeschiehtȱmit:ȱ pthread_ȱ

int pthread_mutex_lock(pthread_mutex_t *mutex);

mutex_lockȱ

DerȱThread,ȱderȱdiesenȱAufrufȱausführt,ȱblockiertȱbisȱzurȱFreigabeȱdesȱ SemaphorsȱdurchȱeinenȱanderenȱThread.ȱZurȱVermeidungȱderȱBlockieȬ rungȱ undȱ desȱ Wartensȱ kannȱ auchȱ getestetȱ werden,ȱ obȱ einȱ Semaphorȱ freiȱist.ȱIstȱerȱfrei,ȱsoȱwirdȱerȱgesperrt,ȱfallsȱerȱaberȱgesperrtȱwar,ȱsoȱwarȬ tetȱ derȱ testendeȱ Threadȱ nichtȱ undȱ erȱ kannȱ daraufȱ reagieren,ȱindemȱ erȱ aufȱdenȱZugriffȱzuȱdenȱgemeinsamenȱDatenȱverzichtet.ȱDieȱTestoperaȬ tionenȱlautet:ȱ

pthread_ȱ

int pthread_mutex_trylock(pthread_mutex_t *mutex);

mutex_trylockȱ

Durchȱ denȱ Rückgabewertȱ lässtȱ sichȱ dannȱ feststellen,ȱ obȱ gesperrtȱ warȱ oderȱnichtȱ(1ȱ=ȱSperrenȱerfolgreich,ȱZugriffȱzuȱgemeinsamenȱDatenȱistȱ möglich,ȱ0ȱ=ȱSperrenȱnichtȱmöglich,ȱSemaphorȱwarȱgesperrt,ȱZugriffȱzuȱ gemeinsamenȱDatenȱistȱnichtȱmöglich).ȱ DieȱFreigabeȱeinesȱgesperrtenȱSemaphorsȱgeschiehtȱdurch:ȱ

pthread_ȱ

int pthread_mutex_unlock(pthread_mutex_t *mutex);

mutex_unlockȱ

ZumȱLöschenȱeinesȱSemaphorsȱdient:ȱ

pthread_ȱ

int pthread_mutex_destroy(pthread_mutex_t *mutex);

mutex_destroyȱ

Zurȱ Illustrationȱ derȱ MutexȬOperationenȱ greifenȱ wirȱ Programmȱ 3Ȭ1ȱ wiederȱ auf,ȱ indemȱ wirȱ dieȱ Gesamtsummeȱ totalȱ überȱ alleȱ Paareȱ vonȱ Integerȱ inȱ jedemȱ Threadȱ aufsummieren.ȱ Damitȱ wirdȱ totalȱ zuȱ einemȱ gemeinsamenȱDatumȱvonȱallenȱThreadsȱundȱmussȱunterȱwechselseitiȬ genȱAusschlussȱgestelltȱwerdenȱȱȱ

Programmȱ3Ȭ2:ȱ Wechselseitigerȱ Ausschlussȱbeimȱ Zugriffȱzuȱ gemeinsamemȱ Datumȱtotalȱ

#include #define length 10 int field [length] [2]; // Feld von Paaren, die addiert werden int total = 0; // Gesamtaddition pthread_mutex_t mutex; // Semaphor

ȱ

void add_op_thread(pthread_addr_t arg) // Operation zum Addieren { int* input = (int*) arg;

154ȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ // Eingabeparameter des Thread int output; pthread_mutex_lock (&mutex); // Sperren des Semaphors total += input[0] + input[1]; // Addition und Zugriff zu total unter // wechselseitigem Ausschluss pthread_mutex_unlock(&mutex); // Freigabe des Semaphors } main (void) // main Thread, Erzeugerthread { pthread_t thread[length]; // zu erzeugende Bearbeitungsthreads int i, dummy; // Laufvariable, // dummy als Ergebnisrückgabe pthread_mutex_init(&mutex, // mutex-Datenstruktur NULL); // mutex default-Attribut for (i=0; i < length; i++) // Erzeugung der Bearbeitungsthreads pthread_create(&thread[i], // thread Datenstruktur NULL, // thread-Attribut add_op_thread, // aufzurufende Funktion (pthread-addr_t) field[i]); // Zeiger auf Parameter for (i=0; i < length; i++) { // Warten auf Ergebnis der einzelnen Threads pthread_join(thread[i], //Identifikation des Thread &dummy); // Ergebnis der Bearbeitung // Löschen der Threads

155ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ pthread_detach(thread[i]); } pthread_mutex_destroy(&mutex); // Löschen des Semaphors }

3.3.3.3.3 Bedingungsvariable Allgemeineȱ Synchronisationsbedingungenȱ könnenȱ mitȱ Hilfeȱ vonȱ BeȬ dingungsvariablenȱ (conditionȱ variables)ȱ formuliertȱ werden.ȱ Eineȱ BeȬ dingungsvariableȱistȱassoziiertȱmitȱeinerȱSperrvariablenȱundȱgibtȱeinenȱ booleschenȱ Zustandȱ dieserȱ Variablenȱ an.ȱ Derȱ Unterschiedȱ zwischenȱ Sperrvariablenȱ undȱ Bedingungsvariablenȱ bestehtȱ darin,ȱ dassȱ SperrvaȬ riableȱzumȱkurzzeitigenȱSperrenȱdienen,ȱwieȱesȱbeiȱkritischenȱAbschnitȬ tenȱbenötigtȱwird,ȱwährendȱBedingungsvariableȱzumȱlängerenȱWartenȱ dienen,ȱbisȱeineȱBedingungȱwahrȱwird.ȱȱ Wieȱ beiȱ Semaphorenȱ stehenȱ beiȱ Bedingungsvariablenȱ Funktionenȱ beȬ reitȱzumȱErzeugenȱundȱLöschen:ȱ pthread_ȱ cond_initȱ

pthread_ȱ cond_destroyȱ

int pthread_cond_init (pthread_cond_t *condvar, // Bedingungsvariable pthread_cond_attr_t attr); // Bedingungsvariable-Attribut ȱ int pthread_cond_destroy (pthread_cond_t *condvar); // Bedingungsvariable Bedingungsvariablenȱ sindȱ assoziiertȱ mitȱ einemȱ Semaphor,ȱ deshalbȱ mussȱ immerȱ mitȱ einerȱ Bedingungsvariablenȱ auchȱ einȱ Semaphorȱ erȬ zeugtȱ werden.ȱ Einȱ Threadȱ kannȱ aufȱ eineȱ Bedingungsvariableȱ wartenȱ mitȱderȱOperation:ȱ

pthread_ȱ cond_waitȱ

int pthread_cond_wait (pthread_cond_t *cond, // Bedingungsvariable pthread_mutex_t *mutex); // mit Bedingungsvariable // assoziierter Semaphor pthread_cond_waitȱgibtȱdieȱmitȱderȱBedingungȱassoziierteȱSperrvaȬ riableȱ mutexȱ freiȱ undȱ blockiertȱ denȱ Thread,ȱ bisȱ dieȱ Bedingungȱ wahrȱ wirdȱ (signalisiertȱ durchȱ pthread_cond_signalȱ oderȱ pthread_cond_broadcast).ȱ Anschließendȱ wirdȱ dieȱ Sperrvariableȱ wiederȱ gesperrtȱ undȱ derȱ Threadȱ fährtȱmitȱ seinerȱ Ausführungȱfort.ȱ Daȱ esȱkeineȱGarantieȱgibt,ȱdassȱdieȱBedingungȱwahrȱist,ȱwennȱderȱThreadȱ mitȱ seinerȱ Ausführungȱ fortfährt,ȱ sollteȱ derȱ aufgeweckteȱ Threadȱ dieȱ

156ȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ Bedingungȱ selbstȱ auswertenȱ undȱ erstȱ fortfahren,ȱ wennȱ sieȱ wahrȱ ist.ȱ Diesȱkannȱfolgendermaßenȱrealisiertȱwerden:ȱ pthread_mutex_lock (&mutex); // ... while (/* condition is not true */) pthread_cond_wait(&condvar, &mutex); // ... pthread_mutex_unlock(&mutex); Unterȱ Angabeȱ einesȱ Timeoutsȱ istȱ esȱ auchȱ möglich,ȱ nurȱ fürȱ eineȱ beȬ grenzteȱ Zeitȱ aufȱ eineȱ Bedingungsvariableȱ zuȱ warten;ȱ dazuȱ dientȱ dieȱ Operation:ȱ int pthread_cond_timedwait(pthread_cond_t *cond, // Bedingungsvariable pthread_mutex_t *mutex, // assoziierter Mutex struct timespec *abstime); // absolute Zeit

pthread_ȱ cond_timed_ȱ waitȱ

DieȱOperationȱgibtȱdenȱWertȱ–1ȱzurück,ȱwennȱderȱangegebeneȱabsoluteȱ Zeitpunktȱ erreichtȱ ist,ȱ ohneȱ dassȱ dieȱ Bedingungȱ eingetroffenȱ ist.ȱ Dieȱ AbsolutzeitȱentsprichtȱdemȱfolgendenȱZeitformat:ȱ struct timespec {unsigned long sec; // Sekunden-Komponente long nsec; // Nanosekunden-Komponente }; Zurȱ Umwandlungȱ derȱ absolutenȱ Zeitȱ inȱ eineȱ relativeȱ Zeitȱ stehtȱ dieȱ folgendeȱOperationȱzurȱVerfügung:ȱ int pthread_get_expiration_np ( struct timespec *delta, // relative Zeit struct timespec *abstime);// absolute Zeit

pthread_get_ expiration_npȱ

WennȱeineȱBedingungȱundȱdamitȱdieȱdazugehörigeȱBedingungsvariabȬ leȱwahrȱwird,ȱsoȱkannȱdiesȱdurchȱdieȱnachfolgendeȱOperationȱsignaliȬ siertȱwerden:ȱ int pthread_cond_signal(pthread_cond_t *cond); // Bedingungsvariable

pthread_ȱ cond_signalȱ

Fallsȱ irgendwelcheȱ anderenȱ Threadsȱ wartenȱ (anȱ derȱ pthread_cond_waitȬȱoderȱpthread_cond_timedwaitȬOperation),ȱ dannȱ wirdȱ wenigstensȱ einerȱ dieserȱ Threadsȱ aufgewecktȱ undȱ erȱ kannȱ

157ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ fortfahren.ȱ Wartenȱ keineȱ Threads,ȱ dannȱ hatȱ dieȱ Operationȱ keineȱ WirȬ kung.ȱ SollenȱalleȱwartendenȱThreadsȱweiterȱfortfahrenȱundȱnichtȱnurȱeiner,ȱsoȱ kannȱdiesȱdurchȱdieȱnachfolgendeȱOperationȱbewerkstelligtȱwerden:ȱ pthread_cond _broadcastȱ

int pthread_cond_broadcast(pthread_cond_t *cond); // Bedingungsvariable

3.3.3.3.4 Erzeuger-Verbraucher (Pipe) mit Threads Zurȱ Illustrationȱ vonȱ Bedingungsvariablenȱ dientȱ dasȱ ErzeugerȬ VerbraucherȬProblemȱ(sieheȱ[Bȱ90])ȱoderȱdieȱunterȱUnixȱimplementierteȱ Pipeȱ (sieheȱ Abschnittȱ 3.1.2.2ȱ pipe,ȱ queue).ȱ Erzeugerȱ undȱ Verbraucherȱ repräsentierenȱ Threads,ȱ dieȱ aufȱ einenȱ gemeinsamenȱ Umlaufpufferȱ zugreifen.ȱWirȱbenutzenȱeineȱSperrvariableȱlockȱzumȱwechselseitigenȱ AusschlussȱbeimȱZugriffȱaufȱdenȱPuffer.ȱFallsȱdannȱeinȱThreadȱexklusiȬ venȱ Zugriffȱ aufȱ denȱ Pufferȱ hat,ȱ benutzenȱ wirȱ dieȱ Bedingungsvariableȱ non_full,ȱ umȱ denȱ Erzeugerȱ wartenȱ zuȱ lassen,ȱ bisȱ derȱ Pufferȱ nichtȱ vollȱ ist,ȱ undȱ dieȱ Bedingungsvariableȱ non_empty,ȱ umȱ denȱ VerbrauȬ cherȱwartenȱzuȱlassen,ȱbisȱderȱPufferȱnichtȱleerȱist.ȱȱ Programmȱ 3Ȭ3:ȱ ErzeugerȬ Verbrauch erȬ Problemȱ

/* Producer consumer with bounded buffer The producer reads characters from stdin and puts them into the buffer. The consumer gets characters form the buffer and writes them to stdout. The two threads execute concurrently except when synchronised by the buffer. */ #include <stdio.h> #include typedef struct buffer { pthread_mutex_t lock; pthread_cond_t non_empty, non_full; char *chars; // chars [0 .. size-1] int size; int next_free, next_full; // producer and consumer indices int count; // number of unconsumed indices } *buffer_t buffer_t buffer_alloc (int size) {

158ȱ

3.3 Programmiermodelle für gemeinsamen Speicher buffer_t b; extern char *malloc(); b = (buffer_t)malloc(sizeof(struct buffer)); pthread_mutex_init (&(b->lock), NULL); pthread_cond_init(&(b->non_empty), NULL); pthread_cond_init(&(b->non_full),NULL); b->chars = malloc ((unsigned) size); b->size = size; b->next_free = b->next_full = b->count = 0; return b; } void buffer_free (buffer_t b) { pthread_mutex_destroy(&(b->lock)); pthread_cond_destroy(&(b->non_empty)); pthread_cond_destroy(&(b->non_full)); free(b->chars); free(b); } void producer (buffer_t b) { char ch; do { ch = getchar(); pthread_mutex_lock (&(b->lock)); while (b->count == b->size) pthread_cond_wait (&(b->non_full), &(b->lock)); // assert b->count >= 0 && b->count < b->size b->chars[b->next_free] = ch; b->next_free = (b->next_free + 1) % b->size; b->count += 1; pthread_cond_signal(&(b->non_empty)); pthread_mutex_unlock(&(b->lock)); } while (ch != EOF); } void consumer(buffer_t b) { char ch; do {

159

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ pthread_mutex_lock(&(b->lock)); while (b->count == 0) pthread_cond_wait(&(b->non_empty),&(b->lock)); // assert b->count > 0 && b->count < b->size ch = b->chars[b->next_full]; b->next_full = (b->next_full + 1) % b->size; b->count -= 1; pthread_cond_signal(&(b->non_full)); pthread_mutex_unlock(&(b->lock)); if (ch != EOF) printf(“%c“, ch); } while (ch != EOF); } #define BUFFER_SIZE 10 main() { buffer_t b; b = buffer_alloc (BUFFER_SIZE); pthread_t thread1, thread2; int dummy; pthread_create(&thread1, NULL, producer, (pthread_addr_t) b); pthread_create(&thread2, NULL, consumer, (pthread_addr_t) b); pthread_join(thread1, &dummy); pthread_join(thread2, &dummy); pthread_detach(&thread1); pthread_detach(&thread2); buffer_free(b); }

3.3.4 OpenMP OpenMPȱsetztȱdenȱfork/joinȬParallelismusȱ[Mȱ07]ȱvonȱUnixȱein,ȱsoȱwieȱ erȱ inȱ Abschnittȱ 3.3.2.1ȱ beschriebenȱ ist.ȱ Dasȱ Ausführungsmodellȱ siehtȱ dabeiȱfolgendermaßenȱaus:ȱ

160ȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ 1.ȱ Beiȱ Programmstartȱ läuftȱ nurȱ derȱ Masterthread,ȱ mitȱ derȱ ThreadȬ Identifikationȱ 0,ȱ undȱ erȱ führtȱ dieȱ sequentiellenȱ Anteileȱ desȱ AlgoȬ rithmusȱaus.ȱȱ

Ausführungs modellȱvonȱ OpenMPȱ

2.ȱ Anȱ einemȱ Punktȱ desȱ Ablaufsȱ benötigtȱ derȱ Algorithmusȱ paralleleȱ Abläufe:ȱ Derȱ Masterthreadȱ generiertȱ zusätzlicheȱ weitereȱ Threadsȱ (fork).ȱ Optimalȱ istȱ natürlich,ȱ wennȱ dieȱ Anzahlȱ derȱ erzeugtenȱ ThreadsȱderȱAnzahlȱderȱvorliegendenȱCPUsȱentspricht.ȱ 3.ȱDerȱMasterthreadȱundȱdieȱgeneriertenȱThreadsȱarbeitenȱdenȱparalleȬ lenȱ Teilȱ ab.ȱ Anȱ dessenȱ Ende,ȱ aufȱ dasȱ derȱ Masterthreadȱ wartet,ȱ beȬ endenȱsichȱdieȱerzeugtenȱThreadsȱoderȱsieȱwerdenȱsuspendiert.ȱȱ 4.ȱBeiȱBeendigungȱderȱThreadsȱkehrtȱdieȱKontrolleȱzurückȱzumȱMasterȬ threadȱ (join).ȱ Esȱ wirdȱ nunȱ zuȱ Punktȱ 1ȱ zurückgekehrtȱ undȱ derȱ Kreislaufȱkannȱvonȱneuemȱbeginnen.ȱȱ Beiȱ einemȱ OpenMPȬProgrammȱ wechselnȱ sichȱ paralleleȱ Regionenȱ mitȱ seriellenȱAbschnittenȱab.ȱȱ AusȱProgrammiersichtȱstehenȱzurȱVerfügung:ȱȱ 1.ȱDirektivenȱanȱdenȱCompiler,ȱwelcheȱfürȱCȱundȱC++ȱdieȱFormȱȱhabenȱȱ #pragma omp direktive-name [clause[clause]…]ȱȱȱ ȱȱȱȱEineȱDirektiveȱistȱeineȱPräprozessorȬDirektive,ȱdeshalbȱdasȱ#.ȱȱ 2.ȱBibliotheksfunktionenȱbzw.ȱKlassen,ȱdieȱinȱCȱmitȱȱ #include einzubindenȱ sind.ȱ Dieȱ Bibliotheksfunktionenȱ dienenȱ z.B.ȱ zurȱ BeȬ stimmungȱderȱThreadanzahlȱwährendȱderȱLaufzeit,ȱzurȱErmittelung,ȱ obȱdasȱProgrammȱsichȱaktuellȱimȱparallelenȱoderȱsequentiellenȱZuȬ standȱbefindet,ȱu.s.w.ȱȱ 3.ȱEnvironmentȬVariablenȱbzw.ȱProperties,ȱdieȱinȱCȱmitȱset zuȱsetzenȱ sind.ȱ Umgebungsvariableȱ liefernȱ Information,ȱ wieȱ z.B.ȱ dieȱ ThreadȬ Identifikation.ȱDurchȱgezieltesȱVerändernȱbestimmterȱUmgebungsȬ variableȱlässtȱsichȱdieȱAusführungȱvonȱOpenMPȱverändern,ȱsoȱkannȱ dieȱAnzahlȱvonȱThreadsȱz.ȱB.ȱdieȱSchleifenoptimierungȱzurȱLaufzeitȱ beeinflusstȱwerden.ȱȱȱ Eineȱ interessanteȱ Eigenschaftȱ vonȱ OpenMPȱ ist,ȱ dassȱ dieȱ Programmeȱ auchȱkorrektȱlaufen,ȱwennȱderȱCompilerȱdieȱOpenMPȬDirektivenȱnichtȱ kenntȱ undȱ alsȱ Kommmentarȱ bewertetȱ (alsoȱ ignoriert).ȱ Einȱ OpenMPȬ Programm,ȱ beiȱ demȱ dieȱ Direktivenȱ ignoriertȱ werden,ȱ liefertȱ dasselbeȱ Ergebnis,ȱnurȱläuftȱesȱnatürlichȱlangsamer.ȱ

161ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ

3.3.4.1 Parallel Pragma DieȱDirektiveȱȱ #pragma omp parallel { block } definiertȱ eineȱ paralleleȱ Regionȱ (mehrereȱ Threads)ȱ überȱ einemȱ AnweiȬ sungsblock.ȱDieȱThreadsȱwerdenȱbeimȱPassierenȱderȱParallelȬDirektiveȱ erzeugtȱ undȱ blockierenȱ amȱ Endeȱ derȱ Region.ȱ Solangeȱ nichtsȱ anderesȱ angegebenȱist,ȱwerdenȱdieȱDatenȱvonȱdenȱThreadsȱgeteilt.ȱȱ DieȱAnzahlȱderȱThreadsȱentsprichtȱȱ 1.ȱȱaufȱvielenȱSystemenȱderȱAnzahlȱderȱzurȱVerfügungȱstehendenȱProȬ zessoren,ȱoderȱ 2.ȱ kannȱ überȱ eineȱ Umgebungsvariableȱ festgelegtȱ werden,ȱ z.B.ȱ fürȱ vierȱ Threadsȱmitȱset OMP_NUM_THREADS=4,ȱȱoderȱȱ 3.ȱ istȱ überȱ dieȱ Bibliotheksfunktionȱ omp_set_num_threads()ȱ einȬ stellbar.ȱ NormalerweiseȱistȱdieȱAnzahlȱderȱThreadsȱkonstantȱfürȱalleȱRegionen,ȱ sieȱ kannȱ jedochȱ imȱ dynamischenȱ Modusȱ verändern.ȱ Dazuȱ stehenȱ dieȱ Bibliotheksfunktionenȱ omp_set_dynamic()ȱ undȱ dieȱ UmgebungsvaȬ riableȱOMP_DYNMICȱzurȱVerfügung.ȱ Programmȱ3Ȭ4:ȱ Pragmaȱ parallelȱ

#include main() { int nthreads, tid; #pragma omp parallel private (nthreads, tid) { /* Hole und drucke die Nummer des Threads */ tid = omp_get_thread_num(); printf(“Hello World from thread = %d\n”, tid); /* Block wird nur von Thread mit Id = 0 (Master) ausgeführt */ if (tid == 0) { nthreads = omp_get_num_threads(); printf(“Number of Threads = %d\n, nthreads); } } /* Implizite Barriere, alle Threads bis auf den Master Thread beenden sich */ }

162ȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ

3.3.4.2 Gültigkeitsbereiche von Daten BeiȱderȱProgrammierungȱmitȱgemeinsamemȱSpeicherȱsindȱzumeistȱdieȱ Datenȱ inȱ allenȱ Threadsȱ sichtbar.ȱ Beiȱ derȱ Programmierungȱ bestehtȱ jeȬ dochȱdieȱNotwendigkeitȱfürȱDaten,ȱdieȱjederȱThreadȱbesitzt,ȱundȱdemȱ AustauschȱvonȱDatenȱzwischenȱdemȱsequentiellenȱundȱdemȱparallelenȱ Teil.ȱDafürȱdienenȱdieȱsogenanntenȱdataȱclauses.ȱ

Datenȱ Klauselnȱ

AnȱDatenklauselnȱbietetȱOpenMPȱan:ȱ x

SharedȬDatenȱ sindȱ gleichzeitigȱ fürȱ alleȱ Threadsȱ zugreifbarȱ undȱ änderbar.ȱSieȱliegenȱfürȱalleȱThreadsȱanȱderȱgleichenȱundȱgemeinȬ samenȱ Speicherstelle.ȱ Ohneȱ Angabeȱ einerȱ Klauselȱ sindȱ dieȱ Datenȱ perȱdefaultȱgemeinsameȱDaten.ȱDieȱeinzigeȱAusnahmeȱdavonȱbilȬ detȱdieȱSchleifenvariablen.ȱȱ

x

Beiȱ privateȬDatenȱ besitztȱ jederȱ Threadȱ eineȱ Kopieȱ derȱ Daten.ȱ privateȱ Datenȱ besitzenȱ keinenȱ Initialwert,ȱ undȱ dieȱ Werteȱ werȬ denȱnichtȱaußerhalbȱdesȱparallelenȱAbschnittsȱbewahrt.ȱȱ

x

FirstprivateȬDatenȱ sindȱ privateȬDaten,ȱ mitȱ demȱ UnterȬ schied,ȱ dassȱ sieȱ mitȱ demȱ letztenȱ Wertȱ vorȱ (first)ȱ demȱ parallelenȱ Abschnittȱinitialisiertȱwerden.ȱȱ

x

LastprivateȬDatenȱsindȱprivateȬDaten,ȱmitȱdemȱUnterschied,ȱ dassȱ derȱ Thread,ȱ welcherȱ dieȱ letzteȱ Iterationȱ ausführt,ȱ anschlieȬ ßendȱ denȱ Wertȱ ausȱ demȱ parallelenȱ Abschnittȱ herauskopiert.ȱ firstprivateȱ undȱ lastprivateȱ könnenȱ beideȱ inȱ derȱ Klauselȱ vorkommen.ȱȱȱ

x

Threadprivate-Datenȱ sindȱ globaleȱ Datenȱ imȱ parallelenȱ ProȬ grammabschnitt,ȱjedochȱprivat.ȱDerȱglobaleȱWertȱwirdȱüberȱdenȱ parallelenȱAbschnittȱhinwegȱbewahrt.ȱȱ

x

copyinȱistȱanalogȱzuȱfirstprivate fürȱprivateȬDaten,ȱallerȬ dingsȱfürȱglobaleȱDaten,ȱwelcheȱnichtȱinitialisiertȱwerden.ȱcopyinȱ überträgtȱ explizitȱ denȱ globalenȱ Wertȱ anȱ dieȱ privatenȱ Daten.ȱ Einȱ copyoutȱexistiertȱnicht,ȱdaȱderȱglobaleȱWertȱerhaltenȱbleibt.ȱȱȱ

x

ReductionȬDatenȱsindȱprivateȬȱDaten,ȱdieȱjedochȱamȱEndeȱaufȱ einenȱglobalenȱWertȱzusammengefasstȱ(reduziert)ȱwerden.ȱSoȱlässtȱ sichȱzumȱBeispielȱdieȱSummeȱallerȱElementeȱeinesȱFeldesȱparallelȱ bestimmen.ȱȱ

ȱ

163ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ

3.3.4.3 Lastverteilung unter Threads 3.3.4.3.1 for Pragma Dieȱ forȬDirektiveȱ teiltȱ Schleifeniterationenȱ unterȱ Threadsȱ auf.ȱ Imȱ Rumpfȱ derȱ Schleifeȱ darfȱ esȱ natürlichȱ zwischenȱ denȱ Iterationenȱ keineȱ Datenabhängigkeitenȱ geben.ȱ Amȱ Endeȱ derȱ parallelenȱ Regionȱ stehtȱ wiederȱeineȱimpliziteȱBarriere.ȱDasȱȱ #pragma omp for nowait hebtȱdieseȱBarriereȱauf.ȱDiesȱkannȱsinnvollȱsein,ȱfallsȱzweiȱhintereinanȬ derliegendeȱKonstrukteȱvorliegenȱundȱdieȱBarriereȱerstȱnachȱdemȱzweiȬ tenȱ Konstruktȱ gesetztȱ werdenȱ soll.ȱ Jederȱ Threadȱ bearbeitetȱ dabeiȱ eineȱ MengeȱvonȱSchleifendurchläufenȱab.ȱDasȱnachfolgendeȱforȬKonstruktȱ teiltȱbeiȱdreiȱThreadsȱdieȱSchleifendurchläufeȱ1ȱbisȱ4ȱaufȱThreadȱ1,ȱdieȱ Schleifendurchläufeȱ5ȱbisȱ8ȱaufȱThreadȱ2ȱundȱdieȱSchleifendurchläufeȱ9ȱ bisȱ12ȱaufȱThreadȱ3ȱauf.ȱ #pragma omp parallel #pragma omp for for(i = 1, i < 13, i++) c[i] = a[i] + b[i]; DasȱCodeȬFragmentȱ #pragma omp parallel { #pragma omp for for(i = 0, i < MAX, i++) { res[i] = huge(); } } istȱdurchȱKombinationȱderȱDirektivenȱäquivalentȱzuȱ #pragma omp parallel for for(i = 0, i < MAX, i++) { res[i] = huge(); } omp forȬKonstrukteȱ könnenȱ durchȱ Verwendungȱ derȱ scheduleȬ Klauselȱ dieȱ Zuteilungȱ zuȱ denȱ einzelnenȱ Threadsȱ folgendermaßenȱ beȬ einflussen:ȱ x

164ȱ

schedule(static [,chunk]) teiltȱ jedemȱ Threadȱ statischȱ chunkȱIterationenȱzu.ȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ x

schedule(dynamic [,chunk])ȱ jederȱ Threadȱ holtȱ sichȱ chunkȱ IterationenȱausȱeinerȱWarteschlange.ȱȱ

x

schedule(guided [,chunk])ȱ wirktȱ wieȱ dynamic,ȱ nurȱ dassȱ dieȱchunkȬGrößeȱwährendȱderȱAusführungȱbisȱchunkȱwächst.ȱȱ

x

schedule(runtime)ȱ dabeiȱ kommtȱ derȱ ScheduleȬParameterȱ ausȱ derȱOMP_SCHEDULEȬUmgebungsvariable.ȱ

3.3.4.3.2 section Pragma Beimȱ sectionȱ Pragmaȱ könnenȱ unabhängigeȱ Codeabschnitteȱ parallelȱ ausgeführtȱ undȱ somitȱ verschiedenenȱ Threadsȱ zugewiesenȱ werden.ȱ NachfolgendesȱCodefragmentȱzeigtȱdreiȱunabhängigeȱCodeabschnitteȱ,ȱ dieȱparallelȱdurchȱdreiȱThreadsȱbearbeitetȱwerden.ȱȱ #pragma omp parallel sections { #pragma omp section independent1(); #pragma omp section independent2(); #pragma omp section independent3(); }

3.3.4.3.3 single Pragma EineȱparalleleȱRegionȱkannȱCodeȱenthalten,ȱderȱnurȱvonȱeinemȱThreadȱ ausgeführtȱwerdenȱsollȱ(z.B.ȱeineȱE/AȬOperation).ȱDazuȱdientȱdieȱsingle-Direktive,ȱdieȱeinenȱCodebereichȱklammert.ȱDerȱersteȱThread,ȱderȱ dieseȱStelleȱerreicht,ȱführtȱdannȱdenȱsingleȬBereichȱaus.ȱAmȱEndeȱdesȱ BereichsȱwartenȱdannȱdieȱThreadsȱ(impliziteȱBarriere).ȱ #pragma omp parallel { DoManyThings(); #pragma omp single { printf(“Hello from single”\n”); } /* Die anderen Threads warten hier */ DoRestofThings(); }

165ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ

3.3.4.3.4 master Pragma Kannȱ einȱ Codeblockȱ nurȱ vomȱ MasterȬThreadȱ ausgeführtȱ werdenȱ undȱ nichtȱvonȱjedemȱThread,ȱwieȱbeiȱsingle,ȱsoȱmussȱdieserȱCodebereichȱ durchȱdieȱmaster-Direktiveȱgeklammertȱwerden.ȱ #pragma omp parallel { DoManyThings(); #pragma omp master { /* Springe weiter falls nicht Master printf(“Hello from master”\n”); } /* Keine implizite Barriere */ DoRestofThings(); }

3.3.4.4 Synchronisation Mitȱ derȱ single-ȱ undȱ master-Direktiveȱ konnteȱ festgelegtȱ werden,ȱ dassȱimmerȱnurȱeinȱThreadȱbzw.ȱderȱMasterȱdenȱCodeȱausführt.ȱDamitȱ greiftȱimmerȱnurȱeinȱThreadȱaufȱdieȱDatenȱzuȱundȱdieȱanderenȱhabenȱ keinenȱ Zugriff.ȱ Wollenȱ nunȱ alleȱ Threadsȱ aufȱ dieȱ gemeinsameȱ Datenȱ zugreifen,ȱ soȱ mussȱ zurȱ Vermeidungȱ vonȱ Wettlaufsituationenȱ derȱ ZuȬ griffȱunterȱwechselseitigenȱAusschlussȱgestelltȱwerden.ȱȱ

3.3.4.4.1 Kritische Abschnitte Einȱ mitȱ demȱ criticalȱ Pragmaȱ umschlossenerȱ Programmabschnittȱ widȱ vonȱ allenȱ Threadsȱ durchlaufen,ȱ allerdingsȱ niemalsȱ gleichzeitig.ȱ Somitȱ istȱ derȱ wechselseitigeȱ Ausschlussȱ gewährleistet,ȱ undȱ zuȱ einemȱ ZeitpunktȱkannȱnurȱeinȱThreadȱinȱdemȱkritischenȱAbschnittȱsein.ȱȱ float res; #pragma omp parallel { float B; int i; #pragma omp for for (i= 0; i
166ȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ Transaktionenȱzuȱverwenden.ȱDerȱCompilerȱistȱjedochȱanȱdiesenȱHinȬ weisȱnichtȱgebundenȱundȱȱkannȱihnȱignorieren.ȱȱ Dieȱ Klauselȱ orderedȱ führtȱ dieȱ Iterationenȱ einerȱ Schleifeȱ inȱ derȱ seȬ quenziellenȱ Ordnungȱ aus.ȱ Dieȱ einzelnenȱ Schleifendurchläufeȱ werdenȱ alsoȱdabeiȱserialisiert.ȱȱ

3.3.4.4.2 Sperrfunktionen Dieȱ Laufzeitbibliothekȱ omp.hȱ enthältȱ einfacheȱ Funktionenȱ fürȱ Locksȱ undȱbietetȱsomitȱweitereȱMöglichkeitenȱzurȱSynchronisation.ȱȱȱ DieȱFunktionȱȱ x

omp_init_lockȱinitialisiertȱdenȱLockȱmitȱeinerȱLockvariablen.ȱ

x

omp_set_lockȱ versetztȱ denȱ ausführendenȱ Threadȱ inȱ einenȱ WarȬ tezustand,ȱbisȱderȱspezifizierteȱLockȱfreiȱist.ȱIstȱderȱLockȱfrei,ȱsoȱbeȬ legtȱderȱThreadȱdenȱLock.ȱ

x

omp_test_lockȱversuchtȱeinenȱLockȱzuȱbelegen.ȱIstȱderȱLockȱfrei,ȱ soȱbelegtȱerȱdenȱLockȱundȱgibtȱeinenȱWertȱungleichȱNullȱzurück.ȱIstȱ derȱ Lockȱ belegt,ȱ soȱ wirdȱ derȱ Wertȱ Nullȱ zurückȱ gegeben.ȱ Derȱ ThreadȱgehtȱdabeiȱinȱkeinenȱWartezustand.ȱȱ

x

omp_unset_lockȱgibtȱdenȱLockȱfrei.ȱ

x

omp_destroy_lockȱzerstörtȱschließlichȱdenȱLock.ȱȱȱ

3.3.4.4.3 Barrieresynchronisation DieȱOpenMPȬKonstrukteȱ Ȭȱparallelȱ Ȭȱforȱundȱ Ȭȱsingleȱȱ beinhaltenȱ implizteȱ Barrieren.ȱ Unnötigeȱ Barrierenȱ versetzenȱ dieȱ Threadsȱ inȱ einenȱ Wartezustand,ȱ undȱ beimȱ Wartenȱ erledigenȱsieȱ keineȱ Arbeit.ȱ Unnötigeȱ Barrierenȱ kannȱ manȱ mitȱ derȱ nowaitȬKlauselȱ unterȬ drückenȱ (sieheȱ Abschnittȱ 3.3.4.3.1ȱ forȱ Pragma).ȱ Diesȱ geschiehtȱ jedochȱ aufȱeigeneȱGefahr.ȱȱ Nebenȱ implizitenȱ Barrierenȱ könnenȱ Barrierenȱ explizitȱ gesetztȱ werdenȱ mitȱderȱbarrier-Direktive.ȱAnȱderȱbarrierȬDirektivenȱwartetȱjederȱ Thread,ȱbisȱalleȱanderenȱThreadsȱdieȱBarriereȱerreichtȱhaben.ȱȱ ȱ

167ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ #pragma omp parallel shared (A,B,C) { DoSomeWork(A,B); Printf(“Processed A into B\n”); #pragma omp barrier /* Warte bis alle Threads eintreffen */ DoSomeWork(B,C); Printf(“Processed B into C\n”); }

3.3.5 Unified Parallel C (UPC) 3.3.5.1 Identifier THREADS und MYTHREAD Zurȱ Bestimmungȱ derȱ Anzahlȱ derȱ laufendenȱ Threadsȱ dientȱ derȱ IdentiȬ fierȱ THREADS.ȱ Jederȱ Threadȱ bekommtȱ dabeiȱ einenȱ eindeutigenȱ IdentiȬ fierȱMYTHREADȱvonȱ0ȱbisȱTHREADSȱȱȱ1.ȱZumȱEinsatzȱkommenȱMYTHREADSȱ undȱ THREADSȱ zurȱ Unterteilungȱ derȱ Arbeitȱ zwischenȱ Threadsȱ undȱ zurȱ Bestimmungȱ welcherȱ Threadȱ dieȱ einzelnenȱ Teileȱ derȱ Arbeitȱ ausführenȱsoll.ȱȱ Nachfolgendesȱ Programmȱ 3Ȭȱ teiltȱ dasȱ UPCȬProgrammȱ helloworldȱ mitȱ derȱCompileroptionȱ–THREADS 4ȱaufȱvierȱThreadsȱauf:ȱ upcc – o hello –THREADS 4 helloworld.upc DurchȱdieȱstatischeȱFestlegungȱaufȱvierȱThreadsȱzurȱCompilierzeitȱläuftȱ helloworld.upcȱ(main)ȱparallelȱinȱvierȱThreadsȱab.ȱȱ Programmȱȱ 3Ȭ5ȱ:ȱ helloworld.ȱ upcȱ

#include #include <stdio> main() { printf(“Thread %d of %d: hello UPC world\n”, MYTHREAD,THREADS); } Mitȱ #include ȱ stehenȱ nebenȱ Anderemȱ dieȱ Identifierȱ THREADSȱundȱMYTHREAD zurȱVerfügung.ȱEineȱmöglicheȱAusgabeȱdesȱ Programmsȱ3ȬȱundȱdamitȱderȱparallelenȱAusführungȱvonȱprintfȱdurchȱ vierȱThreadsȱistȱFolgende:ȱ Thread Thread Thread Thread

168ȱ

1 3 2 0

of of of of

4: 4: 4: 4:

hello hello hello hello

UPC UPC UPC UPC

world world world world

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ Dieȱ einzelnenȱ Ausgabezeilenȱ könnenȱ inȱ beliebigerȱ Reihenfolgeȱ erȬ scheinen.ȱ

3.3.5.2 Private und Shared Data EsȱgibtȱinȱUPCȱzweiȱTypenȱvonȱDatenȱ(Variablen,ȱFelderȱundȱStruktuȬ ren):ȱȱ x

Fürȱ einenȱ Threadȱ privateȱ (private)ȱ Daten,ȱ aufȱ dieȱ nurȱ derȱ Threadȱzugreifenȱdarfȱundȱ

x

gemeinsameȱ (shared)ȱ Daten,ȱ dieȱ mehrȱ alsȱ einȱ Threadȱ lesenȱ undȱ schreibenȱdürfenȱundȱzurȱKommunikationȱunterȱThreadsȱdienen.ȱȱ

BeiȱdefaultȱsindȱVariablenȱprivate,ȱsomitȱerzeugtȱdieȱDeklarationȱ int fahrenheit, celsius; eineȱInstanzȱfürȱjedeȱVariableȱundȱjedenȱThread.ȱAufȱjedeȱInstanzȱdarfȱ nurȱ derȱ dazugehörigeȱ Threadȱ zugreifen,ȱ undȱ dieȱ verschiedenenȱ InȬ stanzenȱkönnenȱunterschiedlicheȱWerteȱbesitzen.ȱ ImȱGegensatzȱdazuȱlegtȱdieȱDeklarationȱ static shared int step=10; eineȱgemeinsameȱVariableȱvomȱTypȱintȱundȱWertȱ10ȱan.ȱEsȱgibtȱnurȱ eineȱInstanzȱvonȱstep, undȱdieseȱInstanzȱistȱfürȱalleȱThreadsȱsichtbar.ȱȱ

3.3.5.3 Shared Arrays WirȱnehmenȱimȱFolgendenȱan,ȱdassȱTHREADSȱdenȱWertȱ4ȱbesitzt,ȱalsoȱ vierȱThreadsȱsindȱparallelȱaktiv.ȱDieȱDeklarationȱ shared int y[THREADS]; gewährtȱ allenȱ vierȱ Threadsȱ Zugriffȱ zuȱ demȱ gemeinsamenȱ Feldȱ y mitȱ Feldgrößeȱ vier.ȱ Jedochȱ besitztȱ dasȱ gemeinsameȱ Feldȱ yȱ eineȱ logischeȱ Partition,ȱ indemȱ jedesȱ Feldelementȱ eineȱ Affinitätȱ zuȱ genauȱ einemȱ Threadȱ besitzt.ȱ y[0]ȱ gehörtȱ zuȱ Threadȱ 0,ȱ y[1]ȱ gehörtȱ zuȱ Threadȱ 1,ȱ y[2]ȱgehörtȱzuȱThreadȱ2ȱundȱy[3]ȱgehörtȱzuȱThreadȱ3.ȱAufȱdieȱeinemȱ Threadȱ gehörendenȱ Feldelementeȱ hatȱ einȱ Threadȱ schnellerenȱ Zugriffȱ (daȱ eineȱ Plattformȱ ihnȱ inȱ demȱ Speicherȱ ablegt,ȱ derȱ zuȱ diesemȱ Threadȱ (Prozess)ȱ gehört),ȱ alsȱ aufȱ Feldelemente,ȱ dieȱ nichtȱ zuȱ diesemȱ Threadȱ gehören.ȱ Perȱ defaultȱ werdenȱ Feldelementeȱ RoundȬRobinȱ aufȱ dieȱ Threadsȱverteilt.ȱȱ Gemeinsameȱ Felderȱ lassenȱ sichȱ blockweiseȱ aufȱ dieȱ Threadsȱ verteilen.ȱ Nehmenȱ wirȱ wiederȱ an,ȱ dassȱ THREADSȱ vierȱ ist,ȱ soȱ werdenȱ durchȱ dieȱ

169ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ nachfolgendeȱ Deklarationȱ beiȱ Blockgrößeȱ (blocksize)ȱ vierȱ immerȱ vierȱ FeldelementeȱaufȱdieȱvierȱThreadsȱverteilt:ȱ shared [4] int y[4*THREADS]; Elementȱ iȱ vonȱ einemȱ geblocktenȱ Feldȱ gehörtȱ zuȱ demȱ Threadȱ mitȱ folȬ genderȱNummerȱ¬i/blocksize¼ȱmodȱTHREADS.ȱ

3.3.5.4 Zeiger ZeigerȱinȱCȱistȱeinesȱderȱhervorstechendenȱMerkmaleȱvonȱC.ȱUPCȱüberȬ trägtȱ diesesȱ PointerȬKonzeptȱ aufȱ privateȱ undȱ sharedȱ Daten.ȱ Derȱ häuȬ figsteȱGebrauchȱundȱEinsatzȱvonȱZeigernȱsind:ȱ int *p1; PointerȱaufȱprivateȱDatenȱoderȱlokaleȱgemeinsameȱDaten.ȱ shared int *p2; UnabhängigerȱZugriffȱvonȱThreadsȱaufȱgemeinsameȱ(shared)ȱDaten.ȱ shared int *shared p3; GemeinsamerȱZugriffȱvonȱallenȱThreadsȱaufȱgemeinsameȱDatenȱ(shared).ȱȱ ZeigerȱaufȱsharedȬDatenȱbesitzenȱdreiȱFelder:ȱ 1.ȱDieȱNummerȱdesȱThreads,ȱ 2.ȱdieȱlokaleȱAdresseȱdesȱBlockesȱundȱ 3.ȱdieȱPositionȱinnerhalbȱdesȱBlockes.ȱ Zeigerarithmetikȱ unterstütztȱ geblockteȱ undȱ ungeblockteȱ FeldverteiȬ lungen.ȱDieȱUmwandlungȱvonȱsharedȱzuȱprivateȬDatenȱistȱerlaubt,ȱ jedochȱnichtȱumgekehrt.ȱBeiȱderȱUmwandlungȱeinesȱZeigersȱvonȱsharedȱinȱeinenȱprivateȬZeigerȱgehtȱdieȱNummerȱdesȱThreadsȱverloren.ȱ Dieseȱ Umwandlungȱ istȱ auchȱ nurȱ erlaubt,ȱ fallsȱ dieȱ Daten,ȱ aufȱ dieȱ derȱ Zeigerȱzeigt,ȱdemȱlokalenȱThreadȱgehören.ȱȱ

3.3.5.5 Lastverteilung unter Threads, upc_forall Unabhängigeȱ Iterationenȱ einerȱ Zählschleifeȱ könnenȱ überȱ mehrereȱ Threadsȱ verteiltȱ werdenȱ mitȱ einerȱ upc_forallȬSchleife.ȱ Beiȱ derȱ upc_forall-Schleifeȱ mussȱ dieȱ Zugehörigkeitȱ derȱ Feldelementeȱ zuȱ denȱ Threadsȱ mitȱ angegebenȱ werden.ȱ Dazuȱ gehenȱ wirȱ imȱ Folgendenȱ vonȱ vierȱ Threadsȱ ausȱ undȱ derȱ sharedȬDeklarationenȱ derȱ dreiȱ Felderȱ a[100], b[100]ȱundȱc[100]ȱundȱderȱprivateȬDeklarationȱi:ȱ

170ȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ shared int a[100], b[100], c[100]; int i; ZurȱAngabeȱderȱZugehörigkeitȱderȱFeldelementeȱzuȱdenȱThreadsȱgibtȱ esȱdreiȱMöglichkeiten:ȱ 1.ȱExpliziteȱAngabeȱderȱZugehörigkeitȱmitȱeinemȱsharedȬPointer:ȱ

upc_forallȱ

upc_forall (i=0; i<100; i++; &a[i]) a[i]=b[i]*c[i]; 2.ȱ Impliziteȱ Angabeȱ derȱ Zugehörigkeitȱ mitȱ einemȱ IntegerȬAusdruckȱ undȱVerteilungȱaufȱdieȱThreadsȱmitȱRoundȬRobin:ȱ upc_forall (i=0; i<100; i++; i) a[i]=b[i]*c[i]; 3.ȱImpliziteȱAngabeȱderȱZugehörigkeitȱundȱVerteilungȱinȱEinheiten:ȱ upc_forall (i=0; i<100; i++; (i*THREADS)/100) a[i]=b[i]*c[i]; BeiȱvierȱThreadsȱergibtȱdasȱfolgendeȱVerteilung:ȱSchleifendurchlaufȱ 0..24ȱ aufȱ Threadȱ 0,ȱ Schleifendurchlaufȱ 25..49ȱ aufȱ Threadȱ 1,ȱ SchleiȬ fendurchlaufȱ 50..74ȱ aufȱ Threadȱ 2ȱ undȱ Schleifendurchlaufȱ 75Ȭ99ȱ aufȱ Threadȱ3.ȱȱ

3.3.5.6 Sperrfunktionen Aufȱ gemeinsameȱ (shared)ȱ Datenȱ dürfenȱ mehrereȱ Threadsȱ nurȱ unterȱ wechselseitigemȱAuschlussȱzugreifen.ȱDazuȱbietetȱUPCȱLocksȱan.ȱEineȱ LockȬVariableȱ hatȱ denȱ Typȱ upc_lock_t.ȱ Daȱ dieȱ Realisierungȱ desȱ Locksȱ implementationsabhängigȱ ist,ȱ könnenȱ Locksȱ nurȱ durchȱ Zeigerȱ manipuliertȱwerden.ȱȱ DieȱkollektiveȱFunktionȱȱ upc_lock_t *upc_all_lock_alloc(void)ȱ wirdȱ vonȱ allenȱ Threadsȱ ausgeführt,ȱ undȱ alleȱ Threadsȱ erhaltenȱ denȱ Pointer.ȱȱupc_all_lock_alloc belegtȱdynamischȱeinenȱLock.ȱ DieȱFunktionȱȱ upc_lock_t *upc_global_lock_alloc(void)ȱ führtȱ einȱ Threadȱ aus,ȱ derȱ auchȱ denȱ upc_global_lock_allocȱȱbelegtȱeinȱLock.ȱȱ

Pointerȱ

erhält.ȱȱ

171ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ DieȱUmklammerungȱeinesȱkritischenȱAbschnitts,ȱundȱsomitȱderȱwechȬ selseitigeȱAusschlussȱgeschiehtȱmitȱdenȱbeidenȱFunktionenȱ void upc_lock(upc_lock_t *l) und void upc_unlock(upc_lock_t *l). DieȱFunktionȱ int upc_lock_attempt (upc_lock_t *l); versuchtȱeinenȱLockȱzuȱbelegen.ȱIstȱderȱLockȱnichtȱdurchȱeinenȱanderenȱ Threadȱbelegt,ȱsoȱbelegtȱdieȱFunktionȱdenȱLockȱundȱsieȱgibtȱdenȱWertȱ1ȱ zurück.ȱAndernfallsȱgibtȱsieȱdenȱWertȱ0ȱzurück.ȱȱ DieȱFreigabeȱeinesȱLocksȱgeschiehtȱmitȱ void upc_lock_free(upc_lock_free(upc_lock_t *ptr);

3.3.5.7 Barrieresynchronisation 3.3.5.7.1 Barrieren upc_barrierȱ

UPCȱbietetȱSynchronisationȱdurchȱBarrierenȱan;ȱd.h.ȱalleȱThreadsȱmüsȬ senȱ dieȱ Barriereȱ erreichen,ȱ bevorȱ einerȱ vonȱ ihnenȱ weiterȱ fortȱ fahrenȱ kann.ȱDieȱdazuȱentsprechendeȱFunktionȱheißt:ȱ upc_barrier expression; DerȱAusdruckȱexpressionȱistȱoptionalȱundȱdientȱzurȱMarkierungȱderȱ Barriereȱ fürȱ Zweckeȱ desȱ Debugging.ȱ Diesȱ trifftȱ auchȱ aufȱ dieȱ nachfolȬ gendenȱSplitȱPhaseȬBarrierenȱzu.ȱ

3.3.5.7.2 Split Phase Barrieren Barrieresynchronisationȱistȱunerwünscht,ȱdaȱdieȱThreadsȱanȱderȱBarrieȬ reȱ wartenȱ undȱ inȱ ihremȱ Codeȱ nichtȱ voranschreitenȱ können.ȱ Zurȱ VerȬ meidungȱdieserȱLeerlaufzeitenȱführtȱUPCȱnichtȬblockierendeȱBarrierenȱ oderȱSplitȱPhaseȬBarrierenȱein.ȱȱ Beendetȱ einȱ Threadȱ seineȱ Berechnung,ȱ soȱ informiertȱ erȱ darüberȱ dieȱ anderenȱThreadsȱmitȱȱ upc_notify,ȱ upc_waitȱ

upc_notify expression; Erȱ kannȱ dann,ȱ anstattȱ zuȱ warten,ȱ lokaleȱ Berechnungenȱ durchführen.ȱ ErstȱwennȱerȱdieseȱBerechnungenȱdurchgeführtȱhat,ȱgehtȱerȱmitȱ upc_wait expression;

172ȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ möglicherweiseȱinȱdenȱWartezustand.ȱHabenȱalleȱanderenȱThreadsȱdasȱ upc_notifyȱausgeführt,ȱsoȱbefreitȱdasȱdenȱThreadȱausȱdemȱWartezuȬ standȱundȱerȱkannȱinȱdieȱnächsteȱPhaseȱderȱBerechnungenȱeintreten.ȱȱ upc_notifyȱundȱupc_waitȱsindȱkollektiveȱOperationenȱundȱwerdenȱ vonȱ allenȱ Threadsȱ ausgeführt.ȱ Nachdemȱ alleȱ Threadsȱ dieȱ paralleleȱ Phaseȱ abgeschlossenȱ haben,ȱ informierenȱ sieȱ darüberȱ dieȱ anderenȱ Threadsȱmitȱeinemȱupc_notify.ȱSieȱtretenȱdannȱinȱeineȱSynchronisaȬ tionsphaseȱeinȱundȱmitȱupc_waitȱwartenȱsie,ȱbisȱdieȱanderenȱThreadsȱ ebenfallsȱ ihreȱ paralleleȱ Phaseȱ abgeschlossenȱ habenȱ (Splitȱ PhaseȬ Barrieren).ȱȱȱ

3.3.6 Fortress Fortressȱ gehtȱ genauȱ denȱ umgekehrtenȱ Wegȱ wieȱ UPC,ȱ indemȱ sieȱ dieȱ Speicherbelegungȱ nichtȱ manipulierbarȱ undȱ zugreifbarȱ fürȱ denȱ ProȬ grammiererȱ macht,ȱ sondernȱ dieseȱ Aufgabeȱ vorȱ demȱ Programmiererȱ verbirgtȱ undȱ dementsprechendȱ demȱ Laufzeitsystemȱ undȱ somitȱ derȱ FortressȬBibliothekȱüberlässt.ȱDiesȱähneltȱsehrȱstarkȱdemȱVorgehenȱvonȱ Java,ȱ dasȱ auchȱ eineȱ automatischeȱ Speicherverwaltungȱ zurȱ Laufzeitȱ anbietet.ȱDesweiterenȱstelltȱFortressȱimpliziteȱThreadsȱzurȱVerfügung,ȱ undȱ somitȱ brauchtȱ sichȱ einȱ Programmiererȱ nichtȱ umȱ dieȱ ParallelisieȬ rungȱ zuȱ kümmern.ȱ Diesȱ schließtȱ natürlichȱ fehlerhafteȱ Parallelisierungȱ undȱ Synchronistionsfehlerȱ aus.ȱ Aufȱ derȱ anderenȱ Seiteȱ sindȱ dadurchȱ parallelȱ vorgebeneȱ Algorithmenȱ schwerȱ zuȱ implementieren,ȱ daȱ derȱ ProgrammiererȱnurȱdurchȱeineȱspawnȬAnweisungȱThreadsȱselbstȱstarȬ tenȱkann.ȱDieȱSynchronisationȱistȱebenfallsȱschwachȱausgeprägt,ȱundȱesȱ stehtȱmitȱderȱatomicȬAnweisungȱnurȱderȱwechselseitigeȱAusschlussȱzurȱ Verfügung.ȱȱȱ

LaufzeitȬ systemȱ (Bibliothek)ȱ verwaltetȱ Speicherȱundȱ Parallelitätȱ

3.3.6.1 Datentypen AnȱnumerischenȱDatentypenȱstelltȱFortressȱzurȱVerfügung:ȱ x

GanzzahlenȱmitȱVorzeichenȱvonȱbeliebigerȱGrößeȱ

x

Integers ള: 

x

NatürlicheȱZahlenȱvonȱbeliebigerȱGröße

x

Naturals ത: 

x

RationaleȱZahlen

x

Rational ഩ: 

x

ReelleȱundȱkomplexeȱZahlen

x

Real ബ, Complex ഑(Schließen ള തund ഩ ein)ȱ

173ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ x

GanzzahlenȱbestimmterȱGröße

x

FixedȬsizeȱintegers: ളളളളളളള... undȱത തത...

x

Gleitkommazahlen

x

FloatingȬpoint:ȱബബബബബ...ȱundȱ഑഑഑ ...ȱ

Wieȱ beiȱ derȱ Cȱ Standardȱ TemplateȬBibliothekȱ sindȱ inȱ derȱ FortressȬ Bibiliothekȱ folgendeȱ Typenȱ definiertȱ (durchȱ OperatorȬÜberladungȱ Ȭȱ opr):ȱȱ x

String,ȱ

x

Boolean,ȱ

x

Listen,ȱ

x

Vektorenȱ(Felder),ȱ

x

MengenȱundȱMultimengen,ȱ

x

Abbildungenȱ(Maps),ȱ

x

MatrizenȱundȱmehrdimensionaleȱFelder,ȱ

x

Integers,ȱfloats,ȱrationals,ȱmitȱphysikalischenȱEinheiten.ȱ

3.3.6.2 Ausdrücke und Anweisungen Fortressȱ besitztȱnurȱ Ausdrückeȱ

AllesȱinȱFortressȱistȱeinȱAusdruck.ȱ()ȱistȱdabeiȱderȱvoidȬWertȱfürȱeinenȱ Ausdruck.ȱDieȱAnweisungenȱwhile,ȱfor,ȱZuweisungȱ(v := e)ȱundȱBindungȱ (v = e)ȱ sindȱ Ausdrückeȱ vomȱ Typȱ void,undȱ einigeȱ Anweisungenȱ (if, do, atomic, try case, typecase, dispatch, spawn)ȱ besitzenȱ keinenȱ VoidȬWert,ȱ sonȬ dernȱeinenȱfestenȱWert.ȱ DerȱZustandȱeinesȱausführendenȱFortressȬProgrammsȱbestehtȱausȱeinerȱ Mengeȱ vonȱ Threadsȱ undȱ einemȱ Speicher.ȱ Dieȱ Ausführtungȱ desȱ ProȬ grammesȱ bestehtȱ ausȱ derȱ Auswertungȱ vonȱ Ausdrückenȱ inȱ jedemȱ vonȱ seinenȱ Threads.ȱ Dieȱ normaleȱ Beendigungȱ derȱ Auswertungȱ einesȱ AusȬ druckesȱliefertȱalsȱErgebnisȱeinenȱWert.ȱȱ

AggregatȬ ausdrückeȱ

Aggregatausdrückeȱ sindȱ Mengen,ȱ Felder,ȱ Maps,ȱ Listenkonstanteȱ undȱ Bedeutungsumfangȱ (Comprehension).ȱ Eineȱ Beschreibungȱ desȱ BedeuȬ tungsumfangsȱ legtȱ dieȱ Elementeȱ einerȱ Kollektionȱ mitȱ einerȱ Regel,ȱ dieȱ fürȱalleȱElementeȱgilt,ȱfest.ȱȱ EinȱAusdruckȱvȱ൸HistȱdabeiȱeineȱGenerierungȱeinesȱObjektes.ȱ ȱ

174ȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ Menge:ȱȱȱȱȱȱȱ { 2, 3, 5, 7 } MitȱComprehensionȱȱ ^[_[൸SULPHV` Felder: [ “cat” ඎ “dog”, “mouse” ඎ “cat” ] ȱ MitȱComprehensionȱ [ x2ඎx3 | x ൸ fibs, x < 1000 ] Liste:ȱ ೆ0, 1, 1, 2, 3, 5, 8, 13ೇȱ MitȱComprehension ೆx(x+1)/2 | x ൸ 1#100 ೇ ȱ FeldȱmitȱAggregatkonstanten:ȱ Identity = [ 1 0 01] ȱȱȱȱȱȱȱȱȱȱMitȱComprehensionȱ a = [(x, y, 1) ඎ0.0 | x ൸1 : xSIZE 

\൸1 : ySIZE

(1, y, z) ඎ0.0 | y ൸1 : ySIZE 

]൸2 : zSIZE

(x, 1, z) ඎ0.0 | x ൸2 : xSIZE 

z ൸2 : zSIZE

(x, y, z) ඎx + y ˜ z | x ൸2 : xSIZE 

y ൸2 : ySIZE z ൸2 : zSIZE@

175ȱ

3 Programmiermodelle für parallele und verteilte Systeme Felder können statisch (mit festen angegebenen Feldgrenzen) oder dynamisch (ohne Angabe der Feldgrenzen) sein. Feldgrenzen besitzen dabei den nat Typparameter.

3.3.6.3 Juxtaposition Operator Die Nebeneinanderschreibung (juxtaposition) von Operanden ist ein Infixoperator mit folgender Semantik: 1. Ist der linke Operand eine Funktion, so führt Juxtaposition eine Funktionsapplikation aus. 2. Ist der linke Operand eine Zahl, so führt Juxtaposition zu einer Multiplikation. 3. Ist der linke Operand ein String, so führt Juxtaposition zu einer Konkatenation von Strings. Unter Anwendung von 1. und 2. möge sich der Leser die Abarbeitung des Beispiels überlegen: y = 3 x sin x cos 2 x log log x

3.3.6.4 Objekte, Traits, Top-level-Funktionen und Komponenten 3.3.6.4.1 Objekte Objekt

Ein Objekt besteht aus Feldern und Methoden. Die Felder eines Objekts sind in seiner Definition spezifiziert. Eine Definition eines Objekts kann auch Methodendefinitionen enthalten. Objekte können parametrisiert werden. Jede Methode eines Objektes oder Traits besitzt einen impliziten self-Parameter, der den Empfänger des Methodenaufrufes bezeichnet. Der self-Parameter kann explizit gemacht werden durch self.Methodenname. Jedes Objekt erweitert (extends) eine Menge von Traits, seine Supertraits. Ein Objekt erbt die konkreten Methoden von seinen Supertraits und muss eine Definition enthalten von jeder deklarierten Methode, die nicht von seinen Supertraits definiert sind.

Programm 3-6 : Parametrisiertes Objekt

object Cart(re: ബ, im: ബ) extends ഑



opr +(self, other: Cart): Cart = Cart(self.re + other.re, self.im + other.im) opr -(self): Cart = Cart(-self.re, -self.im) opr -(self, other: Cart): Cart = Cart(self.re - other.re, self.im – other.im)

176

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ opr ˜(self, other: Cart): Cart = Cart(self.re ˜ other.re – self.im ˜ other.im, self.re ˜ other.im + self.im ˜ other.re) opr |self| : ബ= ¥((self.re)2 + (self.im)2) ... end

3.3.6.4.2 Traits Traitsȱ (Charakterzüge)ȱ sindȱ wieȱ Interfacesȱ benannteȱ ProgrammkonȬ strukte,ȱdieȱeineȱMengeȱvonȱMethodenȱdeklarieren.ȱDieȱMethodeȱeinesȱ Traitȱkannȱabstraktȱoderȱkonkretȱsein:ȱAbstrakteȱMethodenȱdeklarierenȱ nurȱdieȱMethode,ȱwährendȱkonkreteȱMethodenȱauchȱdieȱMethodeȱdeȬ finieren.ȱ EinȱTraitȱkannȱandereȱ Traitsȱ erweiternȱ(extends):ȱ Erȱ erbtȱ(inherits)ȱdieȱMethodenȱvonȱdenȱanderenȱTraits,ȱdieȱerȱerweitert.ȱMehrfachȬ vererbungȱvonȱMethodenȱistȱmöglich.ȱEinȱTraitȱstelltȱdieȱererbtenȱMeȬ thodenȱ sowieȱ dieȱ neuȱ deklariertenȱ Methodenȱ zurȱ Verfügung.ȱ Traitsȱ enthaltenȱ keineȱ Felddeklarationen.ȱ Aufȱ dieȱ Felderȱ kannȱ trotzdemȱ mitȱ getter-ȱundȱsetterȬFunktionsdeklarationenȱzugegriffenȱwerden.ȱDieȱTraitsȱ selberȱ undȱ derenȱ Methodenȱ könnenȱ parametrisiertȱ werden.ȱ Einȱ Traitȱ gibtȱdieȱObjekte,ȱdieȱesȱenthältȱ(comprises),ȱan.ȱBeispielsweiseȱistȱderȱTypȱ BooleanȱinȱFortressȱalsȱTraitȱ(Trait Fortress.Core.Boolean)ȱdefiniert:ȱȱ

Traitsȱ

trait Boolean

Programmȱ3Ȭ7:ȱ TraitȱBooleanȱ

extends BooleanAlgebra Boolean,š,›, ¬,›,false,true comprises { true, false } opr š (self, other: Boolean): Boolean opr ›(self, other: Boolean): Boolean opr ¬(self): Boolean opr ›(self, other: Boolean): Boolean end object true extends Boolean opr š(self, other: Boolean) = other opr ›(self, other: Boolean) = self opr ¬(self) = false opr ›(self, other: Boolean) = ¬other end

177ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ object false extends Boolean opr š(self, other: Boolean) = self opr › (self, other: Boolean) = other opr ¬(self) = true opr ›(self, other: Boolean) = other end TopȬLevelȱȬ Funktionenȱ

Nebenȱ Objectsȱ undȱ Traitsȱ könnenȱ TopȬLevelȬFunktionenȱ definiertȱ werden.ȱ TopȬlevelȱ Funktionenȱ liefernȱ Werte,ȱ dieȱ anȱ Funktionenȱ überȬ gebenȱoderȱzurückgegebenȱwerdenȱundȱderenȱWerteȱFelderȱundȱVariȬ ablenȱzugewiesenȱwerdenȱkönnen.ȱ

3.3.6.4.3 Komponenten und APIs Komponentenȱ

Komponentenȱ sindȱ dieȱ fundamentalenȱ Strukturenȱ vonȱ FortressȬ Programmen.ȱ Sieȱimportierenȱ (imports)ȱundȱ exportierenȱ (exports)ȱ AppliȬ cationȱProgrammingȱInterfacesȱ(APIs),ȱdasȱInterfaceȱvonȱKomponenten.ȱȱ

Datenbankȱ fortressȱȱ

Komponentenȱ werdenȱ nichtȱ direktȱ manipuliertȱ undȱ sindȱ nichtȱ abänȬ derbar,ȱ sondernȱ inȱ einerȱ persistentenȱ Datenbankȱ (KomponentenverȬ waltungssystem,ȱBibliothek),ȱgenanntȱfortress,ȱgespeichert.ȱFortressȱistȱ einȱ Agent,ȱ welcherȱ dieȱ Operationenȱ Compiliierung,ȱ Binden,ȱ Upgadeȱ undȱ Ausführungȱ vonȱ Komponentenȱ vornimmt.ȱ Dieȱ Datenbankȱ führtȱ ebenfallsȱ eineȱ Listeȱ derȱ installiertenȱ APIs.ȱ Dieȱ Anspracheȱ derȱ DatenȬ bankȱgeschiehtȱüberȱdieȱKommandosȱeinerȱinteraktivenȱShell.ȱDieȱShellȱ bietetȱ nochȱ weitereȱ Funktionalitätenȱ wieȱ Installierenȱ von,ȱ DeinstallieȬ renȱvon,ȱEntfernenȱvon,ȱundȱUpgradeȱvonȱKomponenten.ȱȱ Beiȱ derȱ Kompilationȱ einerȱ Komponenteȱ wirdȱ dieseȱ inȱ derȱ Datenbankȱ abgelegt,ȱdabeiȱmüssenȱdieȱreferenziertenȱAPIsȱinȱderȱDatenbankȱvorȬ handenȱ sein.ȱ Jedeȱ Komponenteȱ importiertȱ implizitȱ dasȱ FortresskernȬ API;ȱ jedeȱ Datenbankȱ hatȱ wenigstensȱ eineȱ Komponente,ȱ welcheȱ dieȱ ganzenȱAPIsȱimplementiert.ȱȱȱ

APIȬ Generatorenȱ

178ȱ

Eineȱ Komponenteȱ Komponenteȱ exportiertȱ dieȱ APIȱ Komponente.ȱ KompoȬ nentenȱ undȱ APIsȱ existierenȱ inȱ einemȱ sparatenȱ Namensraum,ȱ deshalbȱ istȱ esȱ erlaubt,ȱ dassȱ beideȱ denȱ gleichenȱ Namenȱ besitzen.ȱ Istȱ alsoȱ KomȬ ponenteȱ nochȱ nichtȱ definiertȱ soȱ wirdȱ durchȱ Compilierungȱ (fortress api Komponente.fss)ȱderȱKomponentenȱausȱderenȱDefinitionȱautomatischȱdieȱ APIȱ generiertȱ undȱ einȱ neuerȱ SourceȬFileȱ erstellt.ȱ Dieserȱ automatischȱ generierteȱQuellcodeȱkannȱweiterȱeditiertȱwerdenȱundȱinȱeinemȱseparaȬ tenȱ Schrittȱ compiliertȱ undȱ inȱ dieȱ fortressȬBibliothekȱ eingebrachtȱ werȬ den.ȱȱȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ

3.3.6.5 Parallelität 3.3.6.5.1 Schleifen und sonstige Konstrukte EineȱforȬSchleifeȱbeginntȱmitȱdemȱreserviertenȱWortȱforȱgefolgtȱvonȱeinerȱ GeneratorlisteȱundȱdemȱreserviertenȱWortȱdo. Schleifenȱ(forȱundȱdo)ȱsindȱ byȱdefaultȱparallel,ȱoderȱmitȱseqȱwähltȱmanȱeinenȱsequentiellenȱGeneraȬ tor,ȱderȱsequentiellenȱCodeȱgeneriert.ȱAnsonstenȱlegtȱdieȱGeneratorlisteȱ denȱParallelismusȱinȱderȱSchleifeȱfest:ȱFürȱjedeȱIterationȱinȱderȱSchleifeȱ startetȱeinȱseparaterȱThread,ȱderȱdenȱSchleifenkörperȱausführt.ȱ EinigeȱBeispieleȱfürȱGeneratorenȱinȱforȬSchleifenȱsind:ȱ x

1:nȱ–ȱGenerator:ȱ for i൸1:m, j൸1:n do a[i,j] := b[i] c[j] end

x

seq(1:m)ȱistȱeinȱsequentiellerȱGenerator:ȱ for i൸seq(1:m) do for j൸seq(1:n) do print a[i,j] end end

x

a.indicesȱistȱeinȱGeneratorȱfürȱdieȱIndizesȱvonȱdemȱFeldȱa:ȱȱ for (i,j)൸a.indices do a[i,j] := b[i] c[j] end

x

a.indices.rowMajorȱistȱeinȱsequentiellerȱGeneratorȱvonȱIndizes:ȱ for (i,j)൸a.indices.rowMajor do print a[i,j] end

WeitereȱprimitiveȱKonstrukte,ȱdieȱimpliziteȱThreadsȱundȱdamitȱParalleȬ lisierung,ȱverursachenȱsind:ȱȱ ȱ

179ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ x

IterationȱeinerȱforȬSchleife:ȱ for x ൸ 1#1000 do a[x] := x end

x

TuplesȱinȱBindungenȱundȱParameterȱinȱFunktionsaufrufen:ȱ (a1, a2, a3) = (e1, e2, e3) f(e1, e2)

x

ReduktionsȬAusdrückeȱwieȱ¦ȱundȱ–ȱmitȱeinerȱoptionalenȱGeȬ neratorliste.ȱȱ

3.3.6.5.2 Datenverteilung Datenverteilungenȱ vonȱ großenȱ Datenstrukturenȱ zurȱ Laufzeitȱ sindȱ inȱ derȱ Standardbibliothekȱ vonȱ Fortressȱ definiert.ȱ Sollȱ ausȱ PerformanceȬ gründenȱdieȱvorgegebeneȱVerteilungȱfürȱeineȱbestimmteȱPlattformȱundȱ fürȱ Programmeȱ geändertȱ werden,ȱ soȱ kannȱ dieȱ Standardverteilungȱ überschriebenȱwerden.ȱDiesȱistȱbesondersȱangebracht,ȱwennȱdieȱAppliȬ kationȱ nichtȱ aufȱ einemȱ engȱ gekoppeltenȱ Multiprozessorȱ ablaufenȱ soll,ȱ sondernȱüberȱmehrereȱRechnerȱimȱNetzȱverteiltȱist.ȱDannȱmüssenȱnämȬ lichȱderȱThreadȱundȱdieȱdazugehörigenȱDatenȱaufȱdemȱgleichenȱRechȬ nerȱliegen.ȱȱ Regionȱ

Jederȱ Thread,ȱ jedesȱ Objektȱ oȱ undȱ jedesȱ Elementȱ einesȱ Feldesȱ aȱ liegtȱ einerȱassoziiertenȱRegion,ȱdieȱmitȱo.regionȱbzw.ȱa.region(i)ȱabgefragtȱwerȬ denȱ kann.ȱ Mitȱ demȱ atȬAusdruckȱ kannȱ einȱ Threadȱ anȱ eineȱ bestimmteȱ Regionȱgebundenȱwerden.ȱ

3.3.6.5.3 Explizite Threads Dasȱ Anlegenȱ einesȱ Thread,ȱ derȱ parallelȱ zuȱ anderenȱ Threadsȱ seinenȱ Ausdruckȱauswertet,ȱgeschiehtȱmit:ȱ t1 = spawn do e1 end t2 = spawn do e2 end EinȱThreadȱbesitztȱdieȱfolgendenȱMethoden:ȱ x

180ȱ

DieȱvalȬMethodeȱ(a1 = t1.value())ȱliefertȱdenȱWertȱdesȱAusdruckesȱbeiȱ BeendigungȱdesȱThreads.ȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ x

DieȱwaitȬMethodeȱ(t1.wait(t2))ȱwartetȱaufȱdieȱBeendigungȱeinesȱandeȬ renȱThreadsȱundȱgibtȱkeinenȱWertȱzurück.ȱ

x

Dieȱ readyȬMethodeȱ gibtȱ trueȱ zurück,ȱ fallsȱ sichȱ derȱ Threadȱ beendetȱ hat,ȱandernfallsȱfalse.ȱ

x

DieȱstopȬMethodeȱ(t1.stop())ȱversuchtȱeinenȱThreadȱzuȱterminieren.ȱȱ

3.3.6.5.4 Atomic-Block Variablenȱ inȱ einemȱ Schleifenkörper,ȱ dieȱ keineȱ Zuweisungȱ erhalten,ȱ sindȱlokal.ȱVariableȱinȱeinemȱSchleifenkörper,ȱdieȱnichtȱgelesenȱwerden,ȱ heißenȱ ReduktionsȬVariable.ȱ Beiȱ Variablen,ȱ dieȱ imȱ Schleifenkörperȱ geändertȱ werden,ȱ jedochȱ keineȱ ReduktionsȬVariableȱ sind,ȱ mussȱ derȱ Zugriffȱ daraufȱ unterȱ wechselseitigemȱ Ausschlussȱ geschehen.ȱ Inȱ FortȬ ressȱ istȱ derȱ wechselseitigeȱ Ausschlussȱ mitȱ atomarenȱ Transaktionenȱ realisiertȱ(sieheȱAbschnittȱ2.2.6.5)ȱoderȱdurchȱatomareȱBlöcke.ȱȱȱ EinȱatomicȬAusdruckȱ(atomic e1)ȱbeginntȱmitȱdemȱWortȱatomicȱgefolgtȱvonȱ einemȱ Ausdruckskörper.ȱDerȱ Wertȱ undȱ Typȱ desȱ atomic-Ausdruckesȱ istȱ derȱWertȱundȱTypȱdesȱAusdruckskörpers.ȱ

atomicȱundȱ tryatomicȱ

Einȱ tryatomicȬAusdruckȱ (tryatomic e1)ȱ beginntȱ mitȱ demȱ Wortȱ tryatomicȱ geȬ folgtȱ vonȱ einemȱ Ausdruckskörper.ȱ tryatomicȱ versuchtȱ denȱ AusdrucksȬ körperȱauszuführen.ȱFallsȱesȱihmȱgelingt,ȱgibtȱerȱdenȱWertȱundȱTypȱdesȱ Ausdruckskörpersȱ zurück.ȱ Andernfallsȱ wurdeȱ erȱ abgebrochenȱ durchȱ eineȱbenutzerdefinierteȱabortȬFunktion,ȱundȱdieȱAusnahmeȱAtomicAbortedȱ wirdȱausgelöst.ȱWurdeȱerȱdurchȱeinenȱZugriffskonfliktȱabgebrochen,ȱsoȱ löstȱdiesȱdieȱAusnahmeȱAtomicConflictȱaus.ȱȱ NachfolgendesȱProgrammȱ3Ȭ8ȱzeigtȱdenȱEinsatzȱdesȱatomicȬKonstruktesȱ inȱ einerȱ Schleife,ȱ dieȱ gleichzeitigȱ lesendȱ undȱ schreibendȱ aufȱ einȱ FeldȬ elementȱhist[a[i,j]]ȱzugreift.ȱ histogram nat lo, nat sz  (a: A[#,#]): Int[lo#sz] = do hist : Int[lo#sz] := 0

Programmȱ3Ȭ8:ȱ AtomicȱBlockȱ

for i,j ൸ a.indices do atomic do hist[a[i,j]] += 1 end end hist end

181ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ

3.3.7 Ada Derȱ AdaȬTermȱ fürȱ einenȱ Prozessȱ istȱ Task.ȱ Eineȱ TaskȬDeklarationȱ beȬ sitztȱ eineȱ Spezifikationȱ (task)ȱ undȱ einenȱ Körperȱ (taskȱ body).ȱ Dieȱ TaskȬSpezifikationȱlegtȱdieȱKommunikationȱ(EingangsaufrufeȱȬȱentry)ȱ mitȱanderenȱTasksȱfest.ȱDerȱTaskkörperȱistȱeineȱausführbareȱFolgeȱvonȱ AnweisungenȱundȱenthältȱAnnahmeanweisungenȱ(accept)ȱfürȱdieȱinȱ derȱ Spezifikationȱ angegebenenȱ Eingangsaufrufe.ȱ Dieȱ Deklarationȱ vonȱ Tasksȱ kannȱ inȱ Blöcken,ȱ Paketspezifikationen,ȱ Paketkörper,ȱ UnterproȬ grammkörperȱundȱinȱTaskkörperȱerfolgen.ȱTasksȱwerdenȱnichtȱausgeȬ führt,ȱsondernȱaktiviert.ȱDieȱAktivierungȱgeschiehtȱentwederȱ x

implizit,ȱ nachȱ derȱ Elaborationȱ derȱ Taskdeklaration,ȱ undȱ dieȱ Taskȱ beginntȱmitȱderȱAusführungȱdesȱTaskkörpersȱ(task body),ȱoderȱ

x

explizitȱdurchȱnew.ȱDerȱDeklarationsteilȱenthältȱdazuȱdieȱDeklaraȬ tionȱeinesȱTasktypȱ(task type),ȱderȱdannȱdynamischȱundȱmögliȬ cherweiseȱ auchȱ mehrfachȱ durchȱ newȱ dieȱ Tasksȱ vonȱ diesemȱ Typȱ startet.ȱȱȱ

DerȱMaster,ȱderȱdieȱTaskȱgestartetȱhat,ȱundȱdieȱTaskȱselbstȱlaufenȱnachȱ derenȱ Aktivierungȱ parallel.ȱ Derȱ Masterȱ wartet,ȱ bisȱ sichȱ alleȱ vonȱ ihmȱ gestartetenȱTasksȱbeendetȱhaben.ȱDieȱTaskȱselberȱterminiert,ȱwennȱ x

dieȱletzteȱAnweisungȱausgeführtȱwurde,ȱundȱ

x

alleȱvonȱihrȱgestartetenȱTasksȱterminiertȱsind,ȱoderȱ

x

dieȱTerminierungȱerzwungenȱwurde.ȱ

3.3.7.1 Ada-Rendezvous entryȱcall,ȱ acceptȱ

Synchronisationȱ undȱ Kommunikationȱ vonȱ Tasksȱ erfolgenȱ mitȱ EinȬ gangsaufrufenȱ (entry call)ȱ undȱ Annahmeanweisungenȱ (accept).ȱ DieȱTasksspezifiktionȱenthältȱdieȱSpezifikationȱdesȱEingangsaufrufes:ȱ task Print_Page is entry Send(P: in Page); end Print_Page; Eingangsaufrufeȱ(entry calls)ȱvonȱanderenȱTasksȱentsprechenȱProȬ zeduraufrufen:ȱ Print_Page.Send(Current_Page); OderȱmitȱAngabeȱdesȱformalenȱParameters:ȱȱ Print_Page.Send(P => Current_Page); DerȱKörperȱderȱ(mitȱdemȱentry)ȱgerufenenȱTaskȱmussȱeineȱAnnahmeȬ anweisungȱ(accept)ȱausführen:ȱ

182ȱ

3.3ȱProgrammiermodelleȱfürȱgemeinsamenȱSpeicherȱ accept Send(P: in Page) do -- Anweisungen end Send; Annahmeanweisungenȱ (accept)ȱ stehenȱ inȱ Taskkörperȱ (task body),ȱ dieȱTaskspezifikationȱenthältȱdieȱDeklarationȱdesȱentry.ȱȱ Dieȱ Kommunikationȱ zwischenȱ Tasksȱ geschiehtȱ mitȱ Hilfeȱ vonȱ EinȬ gangsaufrufenȱ (entry calls)ȱ undȱ Annahmeanweisungenȱ (accepts).ȱEineȱSendetaskȱführtȱdabeiȱeinenȱEingangsaufrufȱausȱundȱeineȱ Empfangstaskȱ dieȱ Annahmeanweisung.ȱ Derȱ Eingangsaufrufȱ inȱ einerȱ TaskȱhatȱzunächstȱdieȱWirkung,ȱdassȱdieȱAusführungȱderȱTaskȱruht.ȱEsȱ wirdȱsoȱlangeȱgewartet,ȱbisȱdieȱaufgerufeneȱTaskȱeineȱAnnahmeanweiȬ sungȱ fürȱ denȱ gerufenenȱ Eingangȱ erreicht.ȱ Gelangtȱ umgekehrtȱ dieȱ beȬ dienendeȱTaskȱanȱeineȱAnnahmeanweisungȱfürȱeinenȱEingang,ȱzuȱwelȬ chemȱ nochȱ keinȱ Eingangsaufrufȱ vorliegt,ȱ soȱ unterbrichtȱ dieȱ Taskȱ dieȱ Ausführungȱ bisȱ einȱ entsprechenderȱ Eingangsaufrufȱ vorliegt.ȱ Hatȱ dieȱ Sendetaskȱ denȱ Eingangsaufrufȱ undȱ dieȱ Empfangstaskȱ dieȱ AnnahmeȬ anweisungȱerreicht,ȱsoȱerfolgtȱwieȱbeiȱeinemȱProzeduraufrufȱdieȱErsetȬ zungȱ derȱ formalenȱ durchȱ dieȱ aktuellenȱ Parameter,ȱ undȱ dieȱ gerufeneȱ TaskȱführtȱdenȱRumpfȱderȱAnnahemeanweisungȱaus.ȱDieȱrufendeȱTaskȱ bleibtȱdabeiȱweiterhinȱblockiert.ȱȱȱ

AdaȬȱ Rendezvousȱ

Nachȱ derȱ Ausführungȱ desȱ Rumpfesȱ derȱ Annahmeanweisungȱ setzenȱ dieȱ beidenȱ Tasksȱ ihreȱ Verarbeitungȱ mitȱ derȱ aufȱ denȱ Eingangsaufrufȱ bzw.ȱ derȱ Annahmeanweisungȱ folgendenȱ Anweisungȱ parallelȱ undȱ asynchronȱfort.ȱȱ DieseȱInteraktionȱistȱdasȱRendezvousȱinȱAda.ȱ RufenȱmehrereȱTasksȱdenȱgleichenȱEingangȱeinerȱTaskȱauf,ȱsoȱwerdenȱ sieȱ inȱ eineȱ Warteschlangeȱ fürȱ diesenȱ Eingangȱ eingereiht.ȱ Beimȱ ErreiȬ chenȱeinerȱAnnahmeanweisungȱwirdȱjeweilsȱdieȱersteȱTaskȱderȱWarteȬ schlangeȱ bedient.ȱ Dieȱ Einreihungȱ inȱ dieȱ Warteschlangeȱ erfolgtȱ nachȱ demȱPrinzipȱFirstȱIn,ȱFirstȱOut.ȱȱ Zurȱ Illustrationȱ desȱ Rendezvousȱ wählenȱ wirȱ dieȱ Realisierungȱ desȱ wechselseitigenȱ Auschlussesȱ undȱ damitȱ dieȱ Simulationȱ einesȱ binärenȱ Semaphorsȱ mitȱ denȱ PȬȱ undȱ VȬOperationen.ȱ Dazuȱ definierenȱ wirȱ eineȱ Servertaskȱ mitȱ denȱ Eingängenȱ Pȱ undȱ V.ȱ Währendȱ dieȱ rufendenȱ Tasksȱ dieȱEingängeȱPȱundȱVȱkennen,ȱkenntȱdieȱServertaskȱnichtȱdieȱTasks,ȱdieȱ dieseȱEingängeȱaufrufenȱundȱihreȱDienstleistungȱinȱAnspruchȱnehmen.ȱ DasȱAdaȬRendezvousȱistȱdeshalbȱeinseitigȱanonym.ȱȱ

Einseitigȱ anonymesȱ AdaȬ Rendezvousȱ

183ȱ

3 Programmiermodelle für parallele und verteilte Systeme Nachfolgendes Ada-Programm zeigt eine Servertask Sema mit den Eingängen P und V und zwei Tasks P1 und P2, die diese Eingänge aufrufen und damit einen wechselseitigen Ausschluss realisieren. Programm 3-9: Semaphor Server und Clients P1 und P2

-- … -- gerufene Task stellt die Dienstleistungen P und V -- zur Verfügung: -- Taskspezifikation task Sema is entry P; entry V; end Sema; task P1; task P2; -- Taskkörper task body Sema begin loop accept P; accept V; end loop; end Sema; -- Rufende Tasks P1 und P2 rufen die Eingänge P und -- V auf. task body P1 is begin loop Sema.P; -- Kritischer Abschnitt Sema.V; end loop; end P1; task body P2 is begin loop Sema.P; -- Kritischer Abschnitt Sema.V; end loop; end P2;

184

3.3 Programmiermodelle für gemeinsamen Speicher Ruft die Task P1 den Eingang P auf, so muss sie warten bis die Sematask die Annahmeanweisung ausführt und damit das Rendezvous initiiert. Zu beachten ist, dass die Annahmeanweisung in Programm 3keinen Rumpf enthält. P1 kann nach Beendigung des Rendezvous in den kritsichen Abschnitt gelangen. Ruft die Task P2 den Eingang P auf, so muss sie warten, da die Sematask auf ein Rendezvous mit einem VAufruf wartet. Dies wird erst erreicht, wenn die Task P1 den kritischen Abschnitt verlässt und das Rendezvous mit dem V-Aufruf durchführt.

3.3.7.2 Selektive Ada-Rendezvous Zur Verfeinerung der Beziehungen zwischen Clienttasks und Servertasks kann eine Servertask auf mehrere Anforderungen (Eingangsaufrufe) von Clients warten und eine entsprechende angeforderte Dienstleistung auswählen und sie vollbringen. Für solch ein Angebot von alternativen Dienstleitungen einer Servertask dient eine Selectanweisung (select). Fordern andere Tasks gleichzeitig von einer Servertask mehrere Dienstleistungen an, so wickelt die Servertask sie nacheinander ab. Die Reihenfolge dabei ist indeterministisch, aber fair.

SelectAnweisung

Stellt eine Servertask ihre Dienstleistungen nur unter gewissen Bedingungen zur Verfügung, so können die verschiedenen Alternativen in der Selectanweisung mit einer Bedingung (oder einem Wächter – Guard) versehen werden. Eine Selectanweisung mit Wächtern hat folgendes Aussehen:

Guard

select when Condition_1 => accept Entry_1 do -- Körper der Annahmeanweisung_1 end Entry_1; -- andere Anweisungen or when Condition_2 => accept Entry_2 do -- Körper der Annahmeanweisung_2 end Entry_2; -- andere Anweisungen or . . . else – optional -- Anweisungen für den else-Teil end select;

185

3 Programmiermodelle für parallele und verteilte Systeme Eine Selectanweisung mit Wächtern besitzt die folgende Semantik: Semantik von select

Zunächst werden alle den Alternativen vorausgehende Wächter (Bedingungen) ausgewertet. Eine Alternative heißt •

offen, falls ihr entweder keine Bedingung vorausgeht (alternative without a guard) oder wenn die Bedingung true ist, andernfalls heißt die Alternative

•

gesperrt, und die Bedingung ist false.

Sind alle Alternativen gesperrt, so werden die Anweisungen des elseZweiges ausgeführt, falls dieser vorhanden ist. Fehlt der else-Zweig, so löst dies eine Ausnahme (exception PROGRAM_ERROR) aus. Andernfalls wird aus allen offenen Alternativen diejenige ausgewählt, für welche ein Eingangsaufruf vorliegt. Liegt kein Eingangsaufruf vor, so werden die Anweisungen des else-Zweiges ausgeführt. Fehlt der elseZweig, so wartet die Task auf einen passenden Eingangsaufruf. Für mögliche weitere Formen der Selectanweisung mit mehreren alternativen Annahmeanweisungen und auf das Gegenstück auf der Clientseite, der Selectanweisung für Eingangsaufrufe, sei auf die Literatur verwiesen [N 03] und [B 06].

3.3.7.2.1 Erzeuger-Verbraucher (Pipe) mit selektivem Rendezvous Zur Illustration des selektiven Ada-Rendezvous dient das ErzeugerVerbraucher-Problem oder die Implementierung einer Pipe. Die Verwaltung der Pipe, realisiert als Umlaufpuffer, übernimmt eine Servertask Buffer. Die Task Buffer bietet einer Task Producer die Dienstleistung send an und einer Task Consumer die Dienstleistung receive. Die Tasks Producer und Consumer sind somit Clienten der Servertask Buffer. Programm 310: ErzeugerVerbraucherProblem mit selektivem AdaRendezvous

-- … subtype Message_Type is INTEGER; -- Server task Buffer is entry Send (Message : in Message_Type); entry Receive (Message : out Message_Type); end; task Producer; task Consumer;

186

3.3 Programmiermodelle für gemeinsamen Speicher -- Taskkörper task body Buffer is Max_Messages : constant := 12; Subtype Buffer_Range is INTEGER range 0 .. (Max_Messages -1); -- Umlaufpuffer Cyclic_Buffer : array (Buffer_Range) of Message_Type; Next_Free : Buffer_Range := 0; Next_Full : Buffer_Range := 0; Count : Buffer_Range := 0; begin loop select when Count < Max_Messages => accept Send (Message : in Message_Type) do Cyclic_Buffer (Next_Free) := Message; Next_Free := (Next_Free + 1) MOD Max_Messages; Count := Count + 1; end Send; or when Count > 0 => accept Receive (Message : out Message_Type) do Message := Cyclic_Buffer (Next_Full); Next_Full := (Next_Full + 1)MOD Max_Messages; Count := Count - 1; end Receive; end select; end loop; end Buffer; -- Clients task body Producer is Message : Message_Type; begin loop -- Produziere Nachricht Buffer.Send(Message); end loop; end Producer;

187

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ task body Consumer is Message : Message_Type; begin loop Buffer.Receive_Message; -- Verarbeite Nachricht end loop; end Consumer; IstȱinȱobigemȱProgrammȱinȱderȱSelektanweisungȱeineȱBedingungȱfalse,ȱdannȱistȱinȱjedemȱFallȱdieȱandereȱBedingungȱtrue;ȱd.h.ȱwennȱderȱ Pufferȱleerȱist,ȱdannȱtrifftȱdieȱersteȱAlternativeȱzu,ȱundȱwennȱderȱPufferȱ vollȱist,ȱsoȱtrifftȱdieȱzweiteȱAlternativeȱzu.ȱȱ

3.3.7.3 Geschützte Objekte

Geschützteȱ Objekteȱ=ȱ Monitorȱ

188ȱ

Adaȱ83ȱkenntȱalsȱeinzigesȱSynchronisationsmittelȱdasȱRendezvouskonȬ zeptȱ undȱ botȱ somitȱ nurȱ einȱ nachrichtenorientiertesȱ SynchronisationsȬ mittel.ȱ Nachrichtenbasierteȱ Synchronisationȱ bedingtȱ immerȱ dasȱ AnleȬ genȱ einerȱ Task,ȱ welcheȱ dieȱ Kommunikationȱ anbietet,ȱ undȱ verursachtȱ somitȱTaskingoverhead.ȱWeiterhinȱistȱeinȱasynchronerȱDatenaustauschȱ mitȱ demȱ Rendezvouskonzeptȱ ineffizientȱ undȱ umständlichȱ zuȱ proȬ grammieren.ȱFürȱreinȱdatenorientierteȱSynchronisation,ȱwieȱdemȱMoniȬ torkonzept,ȱ führteȱ dannȱ Adaȱ 95ȱ geschützteȱ Objekteȱ (protectedȱ type)ȱ ein.ȱGeschützeȱObjekteȱsindȱalsoȱeineȱSimulationȱdesȱMonitorkonzeptsȱ undȱ bestehen,ȱ wieȱ inȱ Adaȱ üblich,ȱ ausȱ einerȱ Spezifikationȱ undȱ einemȱ Körper.ȱ Geschützteȱ Objekteȱ sindȱ abstrakteȱ Datentypenȱ mitȱ gemeinsaȬ menȱ undȱgekapseltenȱ Datenȱ (geschützteȱ Daten)ȱ undȱZugriffsoperatioȬ nenȱ aufȱ dieseȱ gemeinsamenȱ Daten.ȱ Dieȱ Zugriffsoperationenȱ könnenȱ sein:ȱ x

Funktionen,ȱdieȱnurȱlesendȱaufȱdieȱgemeinsamenȱDatenȱzugreifen.ȱ Standardmäßigȱ dürfenȱ Funktionenȱ nurȱ inȬParameterȱ haben;ȱ d.h.ȱ dieȱ Parameterȱ dürfenȱ nichtȱ gesetztȱ werdenȱ undȱ somitȱ linksȱ vonȱ Zuweisungenȱ stehen.ȱ Dadurchȱ dassȱ vonȱ Funktionenȱ nurȱ lesendȱ aufȱ dieȱ Datenȱ zugegriffenȱ wird,ȱ laufenȱ Funktionenȱ nichtȱ unterȱ wechselseitigemȱAusschluss.ȱ

x

Prozeduren,ȱ dieȱ lesendȱ undȱ schreibendȱ aufȱ dieȱ gekapselteȱ Datenȱ zugreifen.ȱ Durchȱ dieȱ schreibendenȱ Zugriffeȱ müssenȱ Prozedurenȱ implizitȱ unterȱ wechselseitigemȱ Ausschlussȱ laufen.ȱ Prozeduren,ȱ wieȱ nachfolgendeȱ Eingängeȱ greifenȱalsoȱ exklusivȱaufȱ dieȱ gemeinȬ samenȱDatenȱzu.ȱȱ

x

Eingänge,ȱ könnenȱ lesendȱ undȱ schreibendȱ aufȱ dieȱ gemeinsamenȱ Datenȱ zugreifenȱ undȱ laufenȱ somitȱ unterȱ implizitemȱ wechselseitiȬ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ gemȱ Ausschluss.ȱ Asynchroneȱ Eingangsaufrufeȱ initiierenȱ dieȱ AusȬ führungȱdesȱKörpersȱderȱEingänge.ȱ x

Mitȱ Eingängenȱ lassenȱ sichȱ Interruptroutinenȱ assoziierenȱ (pragmaȱ Attach_Handler)ȱ [CSȱ 98].ȱ Einȱ asynchronerȱ Eingangsaufrufȱ startetȱ dannȱdieȱInterruptroutine.ȱȱ

x

VerknüpftȱsindȱEingängeȱmitȱBedingungenȱ(whenȱCondition)ȱwieȱ beiȱ bedingtenȱ kritischenȱ Abschnitten.ȱ Ergibtȱ dieȱ Auswertungȱ derȱ Bedingungȱ true,ȱ soȱ istȱ derȱ Eingangȱ offenȱ undȱ einȱ vorliegenderȱ Eingangsaufrufȱwirdȱakzeptiert.

Mitȱ einemȱ geschütztenȱ Objektȱ lassenȱ sichȱ leichtȱ zählendeȱ oderȱ allgeȬ meineȱSemaphoreȱ[BAȱ06]ȱimplementieren.ȱDerȱZählerȱCountȱistȱdabeiȱ einȱ gekapselterȱ Typ,ȱ undȱ derȱ Eingangȱ Pȱ undȱ dieȱ Prozedurȱ Vȱ dekreȬ mentierenȱ bzw.ȱ inkrementierenȱ ihn.ȱ Dabeiȱ laufenȱ derȱ Eingangȱ Pȱ undȱ dieȱProzedurȱVȱunterȱwechselseitigemȱAusschluss.ȱȱȱȱ protected type Counting_Sema (Initial Natural) is entry P; procedure V; private Count: Natural := Initial; end Counting_Sema;

Programmȱ3Ȭ 11:ȱZählenderȱ Semaphorȱmitȱ geschütztemȱ Objektȱ

protected body Counting_Sema is entry P when Count > 0 begin Count := Count - 1; end P; procedure V is begin Count := Count – 1; end V; end Counting_Sema;

3.4 Programmiermodelle für verteilten Speicher Beiȱ denȱ Modellenȱ fürȱ verteiltenȱ Speicherȱ unterscheidenȱ wirȱ wieder,ȱ wieȱbeiȱdenȱModellenȱfürȱgemeinsamenȱSpeicher,ȱinȱȱ x

nebenläufigeȱundȱȱ

x

kooperativeȱModelle.ȱ

189ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ

3.4.1 Überblick nebenläufige Modelle Dieȱ nebenläufigenȱ Programmiermodelleȱ fürȱ verteiltenȱ Speicherȱ unterȬ scheidenȱsichȱin:ȱ x

NachrichtenbasierteȱModelle,ȱd.ȱh.ȱsieȱbesitzenȱeineȱSendeȬȱ(send)ȱ undȱ Empfangsanweisungȱ (receive)ȱ zurȱ Übermittlungȱ vonȱ WerȬ tenȱanȱandereȱparalleleȱProzesse.ȱȱ

x

Aufȱ Datenparallelitätȱ basierendeȱ Modelle.ȱ Datenparallelitätȱ beȬ zeichnetȱdiejenigeȱParallelität,ȱdieȱerhaltenȱwird,ȱwennȱdieȱgleicheȱ Operationȱ aufȱ einigeȱ oderȱ alleȱ Elementeȱ einesȱ DatenȬEnsemblesȱ (meistensȱFelder)ȱangewandtȱwird.ȱȱ

3.4.1.1 Nachrichtenbasierte Modelle Dieȱdreiȱ wichtigstenȱVertreterȱ derȱ nachrichtenbasiertenȱ nebenläufigenȱ Modelleȱsind:ȱ Messageȱ Passingȱ Interfaceȱ (MPI)ȱ

1.ȱ Dasȱ Messageȱ Passingȱ Interfaceȱ (MPI)ȱ istȱ eineȱ NachrichtenausȬ tauschbibliothek,ȱdieȱaufȱhomogenenȱParallelrechnernȱeineȱeffizienȬ teȱundȱschnelleȱKommunikationȱermöglicht.ȱMPIȱistȱdasȱheuteȱwohlȱ amȱmeistenȱeingesetzteȱModellȱfürȱparalleleȱundȱnebenläufigeȱProȬ grammierung.ȱ MPIȱ besitztȱ eineȱ BroadcastȬAnweisung,ȱ indemȱ einȱ ProzessȱanȱalleȱanderenȱProzesseȱeinenȱWertȱsendenȱkann.ȱWeiterȬ hinȱeineȱBarriersynchronisation,ȱbeiȱderȱdieȱProzesseȱwarten,ȱbisȱalȬ leȱ Prozesseȱ eineȱ Barriereȱ erreichtȱ habenȱ undȱ dannȱ wiederȱ parallelȱ weiterarbeiten.ȱ Abȱ MPIȬ2ȱ stehenȱ auchȱ dynamischeȱ Prozesseȱ zurȱ Verfügung.ȱ Dieȱ kompletteȱ Bibliothekȱ istȱ inȱ nachfolgendemȱ AbȬ schnittȱ3.4.3.1ȱbeschrieben.ȱ

Transputer,ȱ Occamȱ

2. Occamȱistȱderȱ“Assembler“ȱfürȱTransputer.ȱTransputerȱistȱeinȱvonȱ derȱ Firmaȱ Inmosȱ (britischeȱ Semiconductorȱ Companyȱ undȱ späterȱ Tochterȱ vonȱ SGSȬThomson)ȱ inȱ denȱ 80erȱ Jahrenȱ entwickelterȱ RISCȬ Mikroprozessorȱ (16ȱ Bitȱ –ȱ T212,ȱ 32ȱ BitȬȱ T414,ȱ 32ȱ Bitȱ undȱ FloatingȬ pointȱ Prozessorȱ –ȱ T800ȱ undȱ derȱ 1993ȱ letztmaligȱ aufȱ denȱ Marktȱ geȬ kommeneȱ200ȱMIPSȱstarkeȱTȱ9000ȱmitȱSuperskalarverarbeitung)ȱ[Tȱ 07].ȱNebenȱdemȱMikroprozessorȱbesitztȱeinȱTransputerchipȱvierȱbiȬ direktionaleȱVerbindungskanäle.ȱJeȱnachdemȱwieȱvieleȱderȱVerbinȬ dungskanäleȱ manȱ beiȱ einemȱ Transputerȱ benutzt,ȱ könnenȱ beiȱ zweiȱ KanälenȱeineȱPipe,ȱbeiȱdreiȱeinȱBaumȱundȱbeiȱvierȱeineȱMatrixȱoderȱ Torusȱ oderȱ einȱ Hypercubeȱ derȱ Dimensionȱ 4ȱ aufgebautȱ werden.ȱ Durchȱ dieȱ beliebigeȱ Zusammenschaltungȱ derȱ vierȱ bidirektionalenȱ Kanäleȱ lassenȱ sichȱ mitȱ Transputernȱ problemangepassteȱ paralleleȱ Rechnerstrukturenȱ aufbauen.ȱ Dieȱ PLACEDȱ PARȬAnweisungȱ vonȱ Occamȱ bildetȱ dannȱ dieȱ logischenȱ parallelenȱ Prozesseȱ undȱ VerbinȬ dungskanäleȱaufȱrealeȱTransputerȱundȱderenȱrealeȱVerbindungenȱab.ȱȱ

190ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ ȱ

DerȱTransputerȱhatȱnurȱaufȱdemȱMarktȱderȱmassivȱparallelenȱComȬ puterȱ Fußȱ fassenȱ können.ȱ Fürȱ denȱ DesktopȬMarketȱ warȱ erȱ durchȱ dasȱfehlendeȱBetriebssystemȱ(keinȱUnix,ȱkeinȱMSȬDOS)ȱnichtȱallgeȬ meinȱgenugȱundȱfürȱdenȱMicrocontrollerȬȱundȱEmbeddedȬMarktȱzuȱ mächtigȱ undȱ zuȱ teuer.ȱ Somitȱ zähltȱ heuteȱ derȱ Transputerȱ zurȱ GeȬ schichteȱderȱMikroprozessorentwicklung.ȱ Occamȱ bautȱ aufȱ denȱ Communicatingȱ Sequentialȱ Processesȱ (CSP)ȱ FormalismusȱvonȱHoareȱ[Hȱ78]ȱaufȱundȱistȱsomitȱeineȱImplementieȬ rungȱ derȱ CSP.ȱ Fürȱ Occamȱ existierenȱ nebenȱ Transputerplattformenȱ auchȱ nochȱ andereȱ Plattformenȱ (z.B.ȱ Intel)ȱ undȱ JavaȬ Implementierungenȱ [WJȱ 07].ȱ Abschnittȱ 3.4.3.2ȱ enthältȱ eineȱ kurzeȱ SprachbeschreibungȱvonȱOccam.ȱȱ

Communicati ngȱSequentialȱ Processesȱ (CSP)ȱ

3.ȱ Dieȱ Plattformȱ PVMȱ (Parallelȱ Virtualȱ Machine)ȱ [GBDȱ 94],ȱ dieȱ esȱ ermöglicht,ȱ mehrereȱ Rechnerȱ mitȱ einemȱ UnixȬȱ oderȱ WindowsȬ Betriebssystemȱ zuȱ einerȱ parallelenȱ Recheneinheitȱ mitȱ verteiltemȱ Speicher,ȱeinerȱvirtuellenȱMaschine,ȱzusammenzufassen.ȱ

PVMȱ(Parallelȱ Virtualȱ Machine)ȱ

Dieȱ Universityȱ ofȱ Tennessee,ȱ Oakȱ Ridgeȱ Nationalȱ Laborartoryȱ (ORNL)ȱundȱEmoryȱUniversity,ȱentwickltenȱPVM.ȱDieȱersteȱVersionȱ vomȱ Oakȱ Ridgeȱ Nationalȱ Laboratoryȱ herausgegeben,ȱ datiertȱ aufȱ 1989.ȱEineȱweitereȱvonȱderȱUniversityȱofȱTennesseeȱumgeschriebeneȱ Versionȱ wurdeȱ 1991ȱ freigegeben.ȱ Eineȱ Versionȱ 3,ȱ welcheȱ FehltoleȬ ranzȱundȱguteȱPortabilitätȱbietet,ȱkamȱ1993ȱherausȱundȱkannȱunterȱ [PVMȱ07]ȱheruntergeladenȱwerden.ȱȱ ȱ

InȱderȱGrundversionȱenthältȱPVMȱnurȱBibliothkenȱfürȱCȱundȱFortȬ ran.ȱMittlerweileȱstehenȱauchȱBibliothekenȱfürȱandereȱSprachen,ȱwieȱ z.B.ȱJavaȱ(JPVM)ȱ[Vȱ07],ȱPerlȱundȱeinȱAufsatzȱfürȱC++ȱderȱPVMȱumȱ objektorientierteȱEigenschaftenȱerweitertȱmitȱNamenȱCPPVMȱ[Gȱ01],ȱ zurȱVerfügung.ȱVerschiedeneȱLinuxȬDistributionenȱenthaltenȱebenȬ fallsȱPVM.ȱȱȱ

ȱ

WeiterentwicklungenȱvonȱPVMȱundȱVerschmelzungȱvonȱPVMȱmitȱ MPI,ȱeinȱKollaborationsprojektȱvonȱORNL,ȱUniversityȱofȱTennesseeȱ undȱ Emoryȱ University,ȱ sindȱ dieȱ Heterogenousȱ Adaptableȱ ReconfiȬ gurableȱNEtworkedȱSystemsȱ(HARNESS)ȱ[OTEȱ07].ȱȱ

ȱ

Dasȱ Hauptzielȱ vonȱ PVMȱ istȱ nichtȱ dieȱ Erreichungȱ einerȱ möglichstȱ hohenȱ Rechenleistungȱ umȱ jedenȱ Preis,ȱ wieȱ beiȱ MPI,ȱ sondernȱ dieȱ Möglichkeit,ȱ verschiedensteȱ Hardwareȱ undȱ Architekturenȱ undȱ unȬ terschiedlichenȱBetriebssystemenȱzuȱeinemȱheterogenenȱClusterȱzuȬ sammenzuschließen.ȱMPIȱimȱGegensatzȱdazuȱgehtȱvonȱhomogenenȱ Rechnernȱ aus,ȱ undȱ derȱ Fokusȱ liegtȱ aufȱ derȱ Erzielungȱ einerȱ mögȬ lichstȱhohenȱRechenleistung.ȱȱ

ȱ

Abschnittȱ3.4.3.3ȱenthältȱeineȱkurzeȱEinführungȱinȱPVM.ȱ

HARNESS

191ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ

3.4.1.2 Datenparallelität ausnutzende Modelle ZweiȱBeispieleȱfürȱDatenparallelitätȱausnutzendeȱSprachenȱsind:ȱ 1.ȱ ȱ Highȱ Performanceȱ Fortranȱ (HPF)ȱ [KLSȱ 94]ȱ istȱ eineȱ aufȱ Fortranȱ 90ȱ basierendeȱSpracheȱzurȱbesserenȱAusnutzungȱderȱDatenparallelitätȱ inȱFortranȬProgrammen.ȱFortranȱermöglichtȱeinfachereȱDatenparalȬ lelisierungȱ alsȱ C,ȱ daȱkeineȱ Zeigerȱ vorhandenȱ sindȱundȱ somitȱ keineȱ dynamischenȱDatenstrukturenȱunterstütztȱwerden.ȱ CompilerȬ direktivenȱ

DerȱHPFȬCompilerȱgaukeltȱeinemȱHPFȬProgrammierer,ȱauchȱinȱverȬ teilterȱUmgebung,ȱeinenȱglobalenȱAdressraumȱ(IndexraumȱfürȱFelȬ der)ȱvor,ȱwieȱbeiȱeinemȱseriellenȱFortranȬProgramm.ȱDieȱVerteilungȱ derȱDatenȱaufȱdieȱverteiltenȱSpeicherȱderȱeinzelnenȱProzessorenȱeiȬ nesȱ Parallelrechnersȱ wirdȱ mitȱ Hilfeȱ vonȱ Direktivenȱ gesteuert.ȱ Derȱ HPFȬCompilerȱ erzeugtȱ automatischȱ dieȱ erforderlichenȱ Aufrufeȱ derȱ Kommunikationsroutinenȱ fürȱ denȱ Zugriffȱ aufȱ dieȱ verteiltenȱ Daten.ȱ DieȱEffizienzȱdesȱHPFȬProgrammsȱhängtȱdannȱhauptsächlichȱdavonȱ ab,ȱwieȱgeschicktȱderȱProgrammiererȱdieȱDatenȱmitȱHilfeȱderȱDirekȬ tivenȱaufȱdieȱProzessorenȱverteilenȱkann,ȱsoȱdassȱbeimȱZugriffȱmögȬ lichstȱ wenigȱ (impliziter)ȱ KommunikationsȬOverheadȱ erforderlichȱ ist;ȱdasȱistȱdasȱProblemȱderȱLokalitätȱderȱZugriffe.ȱȱ DieȱzentralenȱIdeenȱvonȱHPFȱundȱderȱangebotenenȱDirektivenȱsind:ȱ

TemplateȬ Direktiveȱ

MitȱderȱTEMPLATEȬDirektiveȱlassenȱsichȱIndexräumeȱ(IndexȱTempȬ late)ȱdefinieren,ȱz.B.:ȱ ȱ

ALIGNȬ Direktiveȱ

!HPF$ȱTEMPLATEȱt(1:100,ȱ1:100)ȱȱ Dieȱ ALIGNȬDirektiveȱ beschreibtȱ dieȱ Ausrichtungȱ vonȱ Feldernȱ zuȱ IndexräumenȱoderȱzuȱanderenȱFeldern,ȱwieȱz.B.:ȱ

ȱ

!HPF$ȱALIGNȱA(I,J)ȱWITHȱt(J,I)ȱ !HPF$ȱALIGNȱB(I,J)ȱWITHȱt(2*I,ȱ2*J)ȱȱȱ ȱ

DISTRIBUTE ȬDirektiveȱȱ

DieȱLayoutȬDirektiveȱDISTRIBUTEȱbeschreibt,ȱwieȱeinzelneȱIndexȬ Dimensionenȱ aufȱ pȱ Prozessorenȱ verteiltȱ werden,ȱ d.h.ȱ dieȱ PartitioȬ nierungȱderȱFelder.ȱȱȱȱȱȱȱȱȱ ȱȱȱȱȱREALȱA(100,100),ȱB(50,50),ȱCȱ(100,100,2)ȱ ȱȱȱȱȱ!HPF$ȱDISTRIBUTEȱt(BLOCK,*),ȱCȱ(CYCLIC,BLOCK,*)ȱ Dabeiȱgibtȱ BLOCKȱan:ȱDatenelementȱiȱwirdȱaufȱProzessorȱi DIV pȱȱabgebildet.ȱ

192ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ CYCLIC: Datenelementȱ iȱ wirdȱ aufȱ Prozessor i MOD p abgebilȬ det. *ȱ:ȱElementeȱdieserȱDimensionȱwerdenȱnichtȱverteilt.ȱȱ MitȱREDISTRIBUTEȱundȱREALIGNȱistȱzurȱLaufzeitȱeineȱReorganisaȬ tionȱderȱDatenȱmöglich.ȱȱ Dieȱ PROCESSORSȬDirektiveȱ erklärtȱ eineȱ oderȱ mehrereȱ geradlinigeȱ Prozessoranordnungen.ȱ Dieȱ IntrinsicȬFunktionȱ NUMBER_OF_PROCESSORSȱ liefertȱ dieȱ Anzahlȱ derȱ aktuellenȱ physikaliȬ schenȱ Prozessorenȱ zurück.ȱ Durchȱ dieȱ PROCESSORSȬDirektiveȱ unȬ terstütztȱ HPFȱ mehrdimensionaleȱ virtuelleȱ Prozessortopologien.ȱ EiȬ neȱ MatrixȬMultiplikationȱ aufȱ einemȱ 2*2ȬGridȱ zeigtȱ nachfolgendesȱ Programm:ȱ ȱȱ REAL*4,ȱDIMENSIONȱ(1000,1000)ȱ::ȱA,B,Cȱ ȱȱ !HPF$ȱPROCESSORSȱGRID(2,2)ȱ ȱȱ !HPF$ȱDISTRIBUTEȱC(BLOCK,BLOCK)ȱontoȱGRIDȱ

PROCESSORSȬ Direktiveȱ

Programmȱ3Ȭ12:ȱ Virtuelleȱ ProzessortopolȬ ogieȱ

ȱȱ !HPF$ȱALIGNȱA(I,J)ȱWITHȱC(I,*)ȱ !HPF$ȱALIGNȱB(I,J)ȱWITHȱC(*,J)ȱ ȱȱ INTEGERȱ:ȱI,J,Kȱ DOȱIȱ=ȱ1,ȱ1000ȱ ȱȱȱȱ ȱȱDOȱJȱ=ȱ1,ȱ1000ȱ ȱȱȱȱȱȱȱȱȱDOȱKȱ=ȱ1,ȱ1000ȱ ȱȱȱȱȱȱȱȱȱȱȱC(I,J)ȱ=ȱC(I,J)ȱ+ȱA(I,K)ȱ*ȱB(K,J)ȱ ȱȱȱȱȱȱȱȱȱȱENDȱDOȱ ȱȱȱȱȱȱȱȱENDȱDOȱ ȱȱȱȱȱȱENDȱDOȱ Zumȱ Anzeigen,ȱ dassȱ derȱ Compilerȱ fürȱ dieȱ iterativenȱ SchleifenȬ durchläufeȱ parallelenȱ Codeȱ erzeugenȱ kann,ȱ d.h.ȱ derȱ Schleifencodeȱ wirdȱ unabhängigȱ voneinanderȱ durchlaufenȱ undȱ kannȱ konfliktfreiȱ parallelȱ ausgeführtȱ werden,ȱ dienenȱ dieȱ INDEPENDENT–Direktiveȱ undȱfürȱZählschleifenȱdieȱFORALLȬAnweisung,ȱwieȱz.B.:ȱ FORALLȱ(I=1:100)ȱA(I,2)ȱ=ȱC(I,5,1)ȱ DanebenȱexistierenȱnochȱparalleleȱZuweisungen,ȱwieȱz.ȱB.:ȱ M(1:N,7)ȱ=ȱ0.5.ȱ 2.ȱ ȱ Highȱ Performanceȱ Javaȱ (HPJava)ȱ istȱ eineȱ Umgebungȱ fürȱ wissenȬ schaftlichesȱundȱparallelesȱProgrammierungȱunterȱJava.ȱHPJavaȱunȬ

HPJavaȱ

193ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ terstütztȱparallelesȱProgrammierenȱaufȱverteiltenȱundȱgemeinsamenȱ Speichernȱ –ȱ besondersȱ fürȱ Datenparallelitätȱ undȱ verteiltenȱ Feldernȱ ähnlichȱ wieȱ beiȱ Highȱ Performanceȱ Fortran.ȱ HPJavaȱ erweitertȱ Javaȱ mitȱ multiȬdimensionalenȱ Feldernȱ (multiarray)ȱ mitȱ Eigenschaftenȱ ähnlichȱdenȱFeldernȱinȱFortran.ȱDasȱHPJavaȱDevelopmentȱKitȱstehtȱ imȱWebȱunterȱ[PTLHPȱ07]ȱzumȱHerunterladenȱbereit.ȱȱ DasȱJavaȱGrandeȱForumȱ(JGF)ȱ[JGFȱ07]ȱversucht,ȱeineȱzumȱEinsatzȱ inȱ Highȱ Performanceȱ Anwendungenȱ besserȱ geeigneteȱ JavaȬ Umgebungȱ zuȱ definieren;ȱ z.ȱ B.ȱ durchȱ neueȱ Schlüsselwörterȱ strictfpȱ undȱ fastfpȱ fürȱ eineȱ CPUȱ undȱ Floatingȱ PointȬEinsatzȱ mitȱneuenȱKlassenȱfürȱmehrdimensionaleȱFelderȱoderȱdurchȱFestleȬ genȱeinerȱSchnittstelleȱfürȱdasȱMessageȱPassingȱInterface.ȱȱ

3.4.2 Überblick kooperative Modelle 3.4.2.1 Lokalisierung des Kooperationspartners (Broker) Willȱ einȱ Prozessȱ kooperativȱ mitȱ einemȱ anderenȱ Prozessȱ zusammenarȬ beitenȱundȱsomitȱeinenȱDienstȱdesȱanderenȱProzessesȱaufrufen,ȱsoȱmussȱ erȱ dieȱ Adresseȱ (denȱ Rechner)ȱ desȱ Kooperationspartnersȱ kennen.ȱ Dieȱ Lokalisierungȱ desȱ Kooperationspartnersȱ kannȱ aufȱ folgendeȱ Artȱ undȱ Weiseȱgeschehen:ȱȱ 1.ȱȱDurchȱdirekteȱAngabeȱderȱAdresseȱdesȱPartnersȱ(statischesȱBinden).ȱ 2.ȱȱDurchȱUmsetzenȱeinesȱlogischenȱNamensȱdesȱKooperationspartnersȱ inȱeineȱphysikalischeȱAdresseȱüberȱeinenȱBroadcastȱoderȱüberȱeinenȱ Brokerȱ(dynamischesȱBinden).ȱȱ Nachteilȱ statischesȱ Bindenȱ

ImȱFallȱ1ȱerfolgtȱdasȱBindenȱeinesȱPartnersȱmitȱeinemȱentsprechendenȱ AufrufȱstatischȱbeiȱderȱÜbersetzungȱdesȱaufrufendenȱProgramms.ȱFallsȱ derȱ Partnerȱ aufȱ einerȱ anderenȱ Maschineȱ laufenȱ sollȱ oderȱ fallsȱ sichȱ dieȱ Schnittstelleȱ desȱ Partnersȱ ändert,ȱ müssenȱ beiȱ diesemȱ Verfahrenȱ diejeȬ nigenȱProgramme,ȱwelcheȱAufrufeȱanȱdenȱPartnerȱvornehmen,ȱgefunȬ denȱundȱneuȱübersetztȱwerden.ȱDieȱAnwendungȱistȱdadurchȱvonȱeinerȱ konkretenȱ Systemkonfigurationȱ undȱ speziellȱ vonȱ denȱ NetzwerkadresȬ senȱabhängig.ȱ

Vorteilȱ dynamischesȱ Bindenȱ

ImȱFallȱ2ȱkannȱdasȱBindenȱdynamischȱbeiȱBeginnȱdesȱProgrammablaufsȱ oderȱgarȱerstȱbeiȱderȱAusführungȱdesȱAufrufesȱerfolgen.ȱDieȱIndirektiȬ onȱ überȱ einenȱ Brokerȱ ermöglichtȱ eineȱ Änderungȱ derȱ Adressenȱ desȱ Partners,ȱ ohneȱ dassȱ derȱ andereȱ Partnerȱ davonȱ beeinträchtigtȱ ist.ȱ DaȬ durchȱkönnenȱdynamischeȱSystemrekonfigurationenȱundȱmobileȱPartȬ nerȱunterstütztȱwerden.ȱ

194ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ Zumȱ dynamischenȱ Bindenȱ mussȱ einȱ Mechanismusȱ zumȱ Exportierenȱ derȱangebotenenȱAufrufschnittstellenȱ(Dienstes)ȱexistieren.ȱDasȱbedeuȬ tet,ȱ derȱ Serverȱ sendetȱ seinenȱ Namen,ȱ seineȱ Versionsnummer,ȱ eineȱ Identifikation,ȱ möglicherweiseȱ weitereȱ Informationenȱ undȱ seineȱ AdȬ resseȱzuȱeinemȱBroker.ȱȱ

Brokerȱ

DieȱAdresseȱistȱdabeiȱsystemabhängigȱundȱkannȱeineȱEthernetȬAdresse,ȱ eineȱ IPȬAdresse,ȱ eineȱ X.500ȬAdresseȱ oderȱ eineȱ Prozessidentifikationȱ sein.ȱZusätzlichȱkannȱnochȱweitereȱumfangreicheȱInformation,ȱz.B.ȱdieȱ Authentifikationȱ betreffend,ȱ mitgeschicktȱ werden.ȱ Derȱ Brokerȱ trägtȱ dannȱdenȱNamenȱdesȱDienstesȱundȱseineȱAdresseȱinȱeineȱNamenstabelȬ leȱein.ȱDieserȱVorgangȱheißtȱRegistrierungȱdesȱDienstes.ȱSollȱeinȱDienstȱ nichtȱmehrȱlängerȱzurȱVerfügungȱstehen,ȱsoȱkannȱderȱNamenstabellenȬ eintragȱdurchȱDeregistrierungȱgelöschtȱwerden.ȱDazuȱmussȱderȱBrokerȱ eineȱbekannteȱundȱfesteȱAdresseȱhaben;ȱdieseȱAdresseȱfürȱdenȱBrokerȱ istȱbeispielsweiseȱbeiȱRPCsȱimmerȱdieȱAdresseȱ111.ȱEineȱandereȱMögȬ lichkeit,ȱ dieȱ imȱ Internetȱ genutztȱ wird,ȱ ist,ȱ denȱ logischenȱ Namenȱ desȱ Brokersȱ überȱ dasȱ Domainȱ Nameȱ Systemȱ (DNS)ȱ aufzulösen.ȱ Mitȱ derȱ erhaltenenȱ IPȬAdresseȱ vonȱ demȱ Brokerȱ kannȱ dannȱ derȱ Brokerȱ angeȬ sprochenȱwerdenȱundȱdieȱAdresseȱdesȱDienstesȱermitteltȱwerden.ȱȱ

Registrierungȱ undȱ DeregistrieȬ rungȱ

NachȱderȱRegistierungȱdesȱAufrufesȱstehtȱderȱAufrufȱmitȱseinerȱAdresȬ seȱimȱNetzȱzurȱVerfügung.ȱEinȱClientȱkannȱdannȱdenȱDienstȱinȱfolgenȬ denȱSchrittenȱinȱAnspruchȱnehmen:ȱ 1.ȱEinȱClientȱfragtȱnachȱderȱAdresseȱdesȱDienstesȱbeimȱBrokerȱnach.ȱ 2.ȱ Derȱ Brokerȱ gibtȱ demȱ anfragendenȱ Clientȱ dieȱ Adresseȱ desȱ Servers,ȱ derȱdenȱDienstȱanbietet.ȱȱ 3.ȱMitȱderȱAdresseȱdesȱServersȱkannȱderȱClientȱdenȱDienstȱdesȱServersȱ aufrufen.ȱ 4.ȱ Derȱ Serverȱ führtȱ denȱ Dienstȱ aus,ȱ undȱ derȱ Serverȱ gibtȱ dasȱ Ergebnisȱ desȱAufrufesȱanȱdenȱClientȱzurück.ȱ DieȱkooperativenȱNachrichtenȬȱundȱAufrufmodelleȱfolgenȱalleȱdemȱinȱ Abbildungȱ3Ȭ18ȱdargestelltenȱDreieckȱClientȬBrokerȬServerȱ ȱ ȱ ȱ ȱ ȱ ȱ

195ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ ȱ Abb.ȱ3Ȭ18:ȱ Dreieckȱ ClientȬBrokerȬ Serverȱ

ȱ ȱ ȱ

Broker Registriere den Dienst

ȱ ȱ Gib mir die Adresse

ȱ des Dienstes ȱ ȱ ȱ

Hier ist die Adresse Rufe den Dienst auf

Client

Server Dienst

ȱ ȱ

Gib Ergebnis zurück

ȱ ȱ

3.4.2.2 Datenrepräsentation auf unterschiedlichen Maschinen UnterschiedȬ licheȱDatenreȬ präsentationȱ

BeiȱderȱNachrichtenübertragungȱsindȱwirȱdavonȱausgegangen,ȱdassȱdieȱ beidenȱ Kooperationspartnerȱ eineȱ identischeȱ Datendarstellungȱ benutȬ zen.ȱEinȱgroßesȱverteiltesȱSystemȱenthältȱjedochȱverschiedeneȱMaschiȬ nen.ȱ Jedeȱ dieserȱ Maschinenȱ benutztȱ eineȱ andereȱ Repräsentationȱ fürȱ Zahlen,ȱ Charactersȱ undȱ andereȱ Daten.ȱ Beispielsweiseȱ benutzenȱ IBMȬ Großrechnerȱ EBCDICȬCodeȱ zurȱ Darstellungȱ vonȱ Characters,ȱ währendȱ Personalȱ Computerȱ undȱ Minicomputerȱ ASCIIȬCodeȱ verwenden.ȱ ÄhnȬ licheȱ Problemeȱ tretenȱ mitȱ derȱ Darstellungȱ vonȱ Ganzzahlenȱ undȱ GleitȬ kommazahlenȱ auf.ȱ Mancheȱ Maschinenȱ benutzenȱ fürȱ Ganzzahlenȱ dasȱ Einerkomplementȱ undȱ mancheȱ dasȱ Zweierkomplement.ȱ Beiȱ GleitȬ kommazahlenȱ variierenȱ dieȱ Größeȱ derȱ Mantisseȱ undȱ desȱ Exponentenȱ vonȱ Maschineȱ zuȱ Maschine,ȱ fallsȱ nichtȱ einȱ genormtesȱ Formatȱ (ANȬ SI/IEEEȱ754ȬGleitkommaȬzahlenȬFormat)ȱverwendetȱwurde.ȱȱ

littleȱendianȱ bigȱendianȱ

EinȱweiteresȱProblemȱistȱdurchȱdieȱAblageȱderȱBytesȱimȱSpeicherȱgegeȬ ben.ȱEntwederȱliegtȱdasȱniederwertigsteȱByteȱaufȱderȱniedrigstenȱSpeiȬ cheradresseȱoderȱumgekehrt,ȱdasȱhöchstwertigeȱByteȱliegtȱaufȱniedrigsȬ terȱ Speicheradresse.ȱ Dieȱ beidenȱ ByteȬOrdnungenȱ heißenȱ littleȱ endianȱ bzw.ȱbigȱendian.ȱIntelȬ,ȱNationalȱSemiconductorȱProzessorenȱundȱVAȬ

196ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ XenȱbenutzenȱdasȱlittleȱendianȬFormat,ȱwährendȱMotorolaȬProzessoren,ȱ dieȱIBMȱ370ȱundȱSparcȬRechnerȱdasȱbigȱendianȬFormatȱbenutzen.ȱȱ Nachrichtenȱ werdenȱ Byteȱ fürȱ Byteȱ überȱ dasȱ Netzwerkȱ geschickt.ȱ DaȬ durchȱistȱdasȱersteȱabgeschickteȱByteȱauchȱdasȱersteȱByte,ȱdasȱankommt.ȱ Sendetȱ eineȱ Maschineȱ mitȱ littleȱ endianȬFormatȱ anȱ eineȱ Maschineȱ mitȱ bigȱendianȬFormat,ȱsoȱwirdȱdasȱniederwertigsteȱByteȱzumȱhöchstwertiȬ genȱByte.ȱBeispielsweiseȱwirdȱeineȱIntegerzahlȱ1ȱzuȱ224,ȱdaȱBitȱ0ȱimȱlittleȱ endianȬFormatȱzuȱBitȱ24ȱwirdȱimȱbigȱendianȬFormat.ȱȱ Mitȱ Informationȱ überȱ dieȱ Typenȱ derȱ einzelnenȱ Parameter,ȱ kannȱ vonȱ einerȱ Datendarstellungȱ inȱ eineȱ andereȱ Datendarstellungȱ (bigȱ endianȱ –ȱ littleȱ endian,ȱ EBCDICȱ –ȱ ASCII,ȱ Einerkomplementȱ –ȱ ZweierkompleȬ ment)ȱ gewandeltȱ werden.ȱ Dabeiȱ mussȱ dieȱ zuȱ übertragendeȱ Nachrichtȱ eineȱ Indikationȱ enthalten,ȱ welchesȱ Datenformatȱ vorliegt.ȱ Derȱ ClientȬ Stubȱ hängtȱ dabeiȱ vorȱ dieȱ Nachrichtȱ dieȱ Indikationȱ desȱ verwendetenȱ Formats.ȱ Kommtȱ dieȱ Nachrichtȱ beimȱServerȬStubȱan,ȱüberprüftȱ erȱ dasȱ verwendeteȱ Datenformatȱ desȱ Clients.ȱ Stimmtȱ dasȱ Datenformatȱ desȱ Clientsȱ mitȱ seinemȱ eigenenȱ überein,ȱ brauchtȱ nichtȱ gewandeltȱ zuȱ werȬ den.ȱȱ Liegtȱ keineȱ Übereinstimmungȱ vor,ȱ wandeltȱ erȱ dieȱ Nachrichtȱ vomȱ n*(nȬ1)ȱ fremdenȱ Datenformatȱ inȱ seinȱ eigenesȱ Datenformatȱ um.ȱ Hängenȱ imȱ KonvertieȬ NetzȱnȱverschiedeneȱMaschinenȱmitȱverschiedenenȱDatendarstellungen,ȱ rungenȱ sindȱ dafürȱ nȱ *ȱ (nȬ1)ȱ Konvertierungsroutinenȱ notwendig.ȱ Dieȱ Anzahlȱ derȱKonvertierungsroutinenȱfürȱeinenȱDatentypȱsteigtȱdadurchȱquadraȬ tischȱmitȱderȱAnzahlȱnȱderȱMaschinen.ȱȱ DieseȱAnzahlȱlässtȱsichȱaufȱ2*nȱreduzierenȱ(derȱAnstiegȱistȱnurȱlinear),ȱ fallsȱ einȱ maschinenunabhängigesȱ Netzwerkdatenformatȱ (TransferforȬ mat)ȱ verwendetȱ wird.ȱ Derȱ ClientȬStubȱ wandeltȱ dabeiȱ dieȱ eigeneȱ DaȬ tendarstellungȱ inȱ dieȱ Netzwerkdatendarstellung.ȱ Dieȱ Nachrichtȱ wirdȱ dannȱ inȱ derȱ Netzwerkdatendarstellungȱ übertragen,ȱ undȱ derȱ ServerȬ Stubȱ wandeltȱ dieȱ Netzwerkdatendarstellungȱ wiederȱ inȱ seineȱ eigeneȱ Datendarstellungȱ um.ȱ Einȱ Nachteilȱ diesesȱ Verfahrensȱ ist,ȱ dassȱ zweiȱ unnötigeȱ Konvertierungenȱ durchgeführtȱ werden,ȱ fallsȱ beideȱ MaschiȬ nenȱgleichȱsindȱundȱsomitȱdieȱgleicheȱDatendarstellungȱbenutzen.ȱAuȬ ßerdemȱistȱdieȱdirekteȱKonvertierungȱeffizienter,ȱdaȱnurȱeinȱKonvertieȬ rungsvorgangȱproȱAufrufȱoderȱRückmeldungȱerforderlichȱist,ȱwährendȱ beiȱ einemȱ maschinenunabhängigenȱ Transferformatȱ zweiȱ KonvertieȬ rungenȱnötigȱsind.ȱ

2*nȱ KonvertieȬ rungenȱ

Demȱ Xeroxȱ Courierȱ RPCȬProtokollȱ unterliegtȱ einȱ DatenrepräsentatiȬ onsstandard,ȱ denȱ sowohlȱ dieȱ Clientsȱ alsȱ auchȱ derȱ Serverȱ verwendenȱ müssen.ȱ Esȱ istȱ dieȱ bigȱ endianȬReihenfolge.ȱ Dieȱ maximaleȱ Größeȱ irȬ

16ȬBitȬXeroxȬ NSȬZeichenȬ satzȱ

197ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ gendeinesȱFeldesȱbeträgtȱ16ȱBit.ȱZeichenȱwerdenȱinȱdemȱ16ȬBitȬXeroxȬ NSȬZeichensatzȱ verschlüsselt.ȱ Dieserȱ benutztȱ 8ȬBitȬASCIIȱ fürȱ normaleȱ Zeiȱ chen,ȱwobeiȱaufȱandereȱspezielleȱZeichensätzeȱwieȱbeispielsweiseȱGrieȬ chischȱ ausgewichenȱ werdenȱ kann.ȱ Derȱ griechischeȱ Zeichensatzȱ istȱ sinnvoll,ȱ wennȱ z.B.ȱ einȱ mathematischerȱ Textȱ anȱ bestimmteȱ Druckerȱ gesendetȱwird.ȱȱ eXternalȱ Dataȱ Representati onȱ(XDR)ȱ Networkȱ Dataȱ Representati onȱ(NDR)ȱ

Implizitesȱ versusȱ explizitesȱ Typingȱ

Derȱ vonȱ Sunȱ RPCȱ verwendeteȱ Datenrepräsentationsstandardȱ heißtȱ eXternalȱ Dataȱ Representationȱ (XDR).ȱ Erȱ besitztȱ eineȱ bigȱ endianȬ Reihenfolge,ȱundȱdieȱmaximaleȱGrößeȱirgendeinesȱFeldesȱbeträgtȱ32ȱBit.ȱȱ Anstelleȱ einesȱ einzigenȱ NetzȬStandardsȱ unterstütztȱ NDRȱ (Networkȱ Dataȱ Representation)ȱ mehrereȱ Formate.ȱ Diesȱ ermöglichtȱ demȱ Sender,ȱ seinȱeigenesȱinternesȱFormatȱzuȱbenutzen,ȱfallsȱesȱeinesȱderȱunterstütȬ zendenȱ Formateȱ ist.ȱ Derȱ Empfängerȱ muss,ȱ fallsȱ sichȱ seinȱ Formatȱ vonȱ demȱdesȱSendersȱunterscheidet,ȱdiesesȱinȱseinȱeigenesȱFormatȱumwanȬ deln.ȱDiesȱwirdȱalsȱdieȱ„derȱEmpfängerȱwirdȇsȱschonȱrichten“ȬMethodeȱ bezeichnet.ȱDieseȱTechnikȱbesitztȱdadurchȱdenȱVorteil,ȱdassȱwennȱzweiȱ SystemeȱmitȱgleicherȱDatenrepräsentationȱmiteinanderȱkommunizieren,ȱ sieȱüberhauptȱkeineȱDatenȱumzuwandelnȱbrauchen.ȱȱ XDRȱundȱNDRȱbenutzenȱdasȱsoȱgenannteȱimpliziteȱTyping.ȱDasȱbedeuȬ tet,ȱ dassȱ nurȱ derȱ Wertȱ einerȱ Variablenȱ überȱ dasȱ Netzȱ geschicktȱ wirdȱ undȱnichtȱderȱVariablentyp.ȱImȱGegensatzȱdazuȱverwendetȱdasȱvonȱderȱ ISOȱ (Internationalȱ Standardsȱ Organization)ȱ definierteȱ Transferformatȱ (Transfersyntax)ȱdasȱexpliziteȱTyping.ȱDieȱdazugehörigeȱBeschreibungȱ vonȱDatenstrukturenȱistȱinȱderȱBeschreibungsspracheȱASN.1ȱ(Abstractȱ SyntaxȱNotationȱ1)ȱgegeben.ȱASN.1ȱüberträgtȱdenȱTypȱjedesȱDatenfelȬ desȱ(verschlüsseltȱinȱeinemȱByte)ȱzusammenȱmitȱdessenȱWertȱinȱeinerȱ Nachricht.ȱWennȱbeispielsweiseȱeineȱ32ȬBitȬIntegerȱübertragenȱwerdenȱ soll,ȱsoȱwürdeȱbeiȱimplizitenȱTypingȱnurȱderȱ32ȬBitȬWertȱüberȱdasȱNetzȱ übertragen.ȱ Beiȱ explizitemȱ Typingȱ inȱ ASN.1ȱ würdeȱ dagegenȱ einȱ Byteȱ übermittelt,ȱwelchesȱangibt,ȱdassȱderȱnächsteȱWertȱeinȱIntegerȱist.ȱDemȱ folgtȱeinȱweiteresȱByte,ȱdasȱdieȱLängeȱdesȱIntegerȬFeldesȱinȱByteȱangibt,ȱ sowieȱ ein,ȱ zwei,ȱ dreiȱ oderȱ vierȱ Bytes,ȱ dieȱ denȱ tatsächlichenȱ Wertȱ desȱ Integersȱenthalten.ȱ DieȱkooperativenȱModelleȱuntergliedernȱsichȱinȱȱ x

198ȱ

nachrichtenȬbasierteȱ Modelle,ȱ wobeiȱ einȱ Prozessȱ einemȱ anderenȱ Prozessȱ eineȱ Nachrichtȱ zusendenȱ (send)ȱ kann,ȱ dieȱ dieserȱ dannȱ empfängtȱ(receive).ȱDerȱAufrufȱeinesȱDienstesȱwirdȱdabeiȱinȱeineȱ Nachrichtȱverpackt.ȱȱȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ x

Entfernteȱ Aufrufe,ȱ wobeiȱ derȱ Dienstȱ direktȱ aufgerufenȱ wird.ȱ Derȱ Dienstȱkannȱseinȱȱ



eineȱProzedur,ȱȱ



eineȱMethodeȱeinesȱObjektes,ȱ



eineȱ durchȱ seinȱ Interfaceȱ spezifierteȱ Methodeȱ undȱ damitȱ eineȱ MethodeȱeinerȱKomponentenȱoderȱȱ



einȱService.ȱȱȱ

3.4.2.3 Nachrichtenbasierte Modelle DieȱaufȱeinemȱClusterȱoderȱGridȱablaufendenȱProgrammeȱsindȱparalleȬ leȱ Programme,ȱ dieȱ durchȱ einenȱ Nachrichtenaustauschȱ miteinanderȱ kommunizierenȱkönnen.ȱJedesȱparalleleȱProgrammȱbenötigtȱalsoȱFunkȬ tionenȱzumȱSendenȱundȱEmpfangenȱvonȱDatenȱoderȱNachrichten.ȱFürȱ denȱNachrichtenaustauschȱstehenȱzurȱVerfügung:ȱ 1.ȱ TCP/IPȬSocketsȱ mitȱ denȱ SendȬȱ undȱ ReceiveȬFunktionen.ȱ Dieȱ ProȬ grammierung,ȱ welcheȱ dieȱ aufȱ TCPI/IPȱ basierendeȱ Socketȱ APIȱ beȬ nutzenȱ undȱ zurȱ Absicherungȱ desȱ Nachrichtenverkehrsȱ dasȱ Secureȱ Socketȱ Layerȱ (SSL)ȱ einsetzen,ȱ bezeichnetȱ manȱ alsȱ NetzwerkproȬ grammierungȱ [Zȱ 06].ȱ Fürȱ synchroneȱ Nachrichtenübertragungȱ sindȱ Socketsȱ dasȱ meistȱ verbreiteteȱ undȱ amȱ bestenȱ dokumentierteȱ NachȬ richtenübertragungssystem.ȱJedesȱBetriebssystemȱbietetȱSocketsȱan,ȱ undȱsieȱsindȱdadurchȱderȱdeȱfactoȬStandardȱfürȱNetzwerkapplikatiȬ onenȱ aufȱ TCP/IPȬNetzen.ȱ Socketsȱ wurdenȱ 1981ȱ imȱ Rahmenȱ einesȱ DARPAȱ (Defenseȱ Advancedȱ Researchȱ Projectsȱ Agency)ȬAuftragesȱ anȱderȱUniversityȱofȱCaliforniaȱatȱBerkeleyȱentwickeltȱundȱsindȱdaȬ durchȱ imȱ 4.3BSDȱ (Berkeleyȱ Softwareȱ Distribution)ȱ UnixȬSystemȱ enthalten.ȱ1986ȱführteȱAT&TȱdasȱTransportȱLayerȱInterfaceȱ(TLI)ȱein,ȱ dasȱdieȱgleichenȱFunktionalitätenȱwieȱSocketsȱanbietet,ȱjedochȱinȱeiȬ nerȱ mehrȱ netzwerkunabhängigenȱ Art.ȱ Unixȱ SVR4ȱ enthältȱ beides,ȱ Socketsȱ undȱ TLI,ȱ aberȱ wieȱ schonȱ erwähntȱ sindȱ Socketsȱ weiterȱ verȬ breitet.ȱ BSDȬSocketsȱ undȱ TLIȱ sowieȱ ihreȱ Programmierungȱ sindȱ beiȱ Stevensȱ[Sȱ92]ȱundȱPadovanoȱ[Pȱ93]ȱbeschrieben.ȱEineȱBeschreibungȱ derȱ beiȱ denȱ WindowsȬBetriebssystemenȱ zurȱ Verfügungȱ gestelltenȱ Sockets,ȱdieȱsoȱgenanntenȱWinSock,ȱistȱinȱ[Boȱ96]ȱenthalten.ȱTCP/IPȬ SocketsȱsindȱinȱallenȱBetriebssystemeȱeingebettet,ȱundȱOpenSolaris,ȱ einȱ OpenȬSourceȬProjektȱ vonȱ Sunȱ Microsystems,ȱ dürfteȱ zurȱ Zeitȱ wohlȱdieȱeffizientesteȱImplementierungȱdesȱTCP/IPȬStacksȱundȱdaȬ mitȱ derȱ SocketȬAPIȱ anbieten.ȱ Dieȱ Programmierungȱ undȱ denȱ UmȬ gangȱ mitȱ derȱ SocketȬAPIȱ inȱ denȱ Programmiersprachenȱ C,ȱ Java,ȱ Python,ȱPerl,ȱRubyȱundȱTclȱbeschreibtȱJonesȱ[Jȱ04].ȱWeiterhinȱbesitztȱ

199ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ dieȱ Programmierspracheȱ Javaȱ diverseȱ Klassenȱ zurȱ SocketprogramȬ mierungȱ [Jȱ 99].ȱ Nachfolgenderȱ Abschnittȱ 3.4.4.1ȱ führtȱ inȱ dieȱ SoȬ cketprogrammierungȱein.ȱȱ Vorteileȱ MessageȬ Serverȱ

Komponentenȱ einerȱJMSȬ Applikationȱ

2.ȱ ȱ Javaȱ Messageȱ Serviceȱ (JMS):ȱ Nachteiligȱ beiȱ TCP/IPȬSocketsȱ istȱ derȱ synchroneȱ Nachrichtenaustausch.ȱ Einȱ Clientȱ versendetȱ eineȱ NachȬ richt,ȱ daraufhinȱ wirdȱ erȱ blockiert,ȱ undȱ erȱ mussȱ wartenȱ bisȱ eineȱ Rückantwortȱzurückkommt.ȱBeiȱasynchronerȱKommunikationȱkannȱ einȱClientȱeineȱNachrichtȱanȱeinenȱMessageȱServiceȱ(MessageȬServer)ȱ sendenȱundȱsofortȱinȱseinemȱProgrammlaufȱfortfahren,ȱohneȱaufȱdieȱ RückmeldungȱdesȱKommunikationspartnersȱwartenȱzuȱmüssen.ȱEinȱ weitererȱ Vorteilȱ derȱ asynchronenȱ Nachrichtenübertragungȱ liegtȱ darin,ȱdassȱSenderȱundȱEmpfängerȱdurchȱdenȱdazwischenliegendenȱ MessageȬServerȱ nurȱ loseȱ gekoppeltȱ sind.ȱ Sieȱ brauchenȱ daherȱ nichtȱ dieȱ gleicheȱ Technologieȱ zuȱ verwenden.ȱ Unterschiedlicheȱ Clientsȱ sendenȱihreȱNachricht,ȱdieȱmitȱeinemȱBestimmungsortȱversehenȱist,ȱ anȱ denȱ MessageȬServer.ȱ Derȱ Empfängerȱ bekommtȱ dieȱ Nachrichtȱ vonȱdemȱMessageȬServerȱundȱverarbeitetȱsie.ȱȱ ȱ

Derȱ Javaȱ Messageȱ Serviceȱ (JMS)ȱ stelltȱ einenȱ zentralenȱ MessageȬ Serverȱ zurȱ Verfügung,ȱ dessenȱ Implementierungȱ inȱ derȱ JMSȬ SpezifikationȱJMSȱProviderȱheißt.ȱEineȱJMSȬApplikationȱbestehtȱausȱ vielenȱJMSȬClientsȱundȱgewöhnlichȱeinemȱJMSȱProvider.ȱ

ȱ

DieȱKomponentenȱeinerȱJMSȬApplikationȱheißen:ȱȱ x

Producer,ȱ fürȱ denȱ Clientteilȱ einerȱ Applikation,ȱ welcherȱ dieȱ NachrichtȱerzeugtȱundȱanȱdasȱZielȱ(Destination)ȱverschickt.ȱ

x

Destination,ȱ fürȱ einȱ Objekt,ȱ überȱ welchesȱ derȱ Clientȱ denȱ BeȬ stimmungsortȱ einerȱ Nachrichtȱ beimȱ Sendenȱ bzw.ȱ Empfangenȱ spezifiziert.ȱȱ

x

Consumer,ȱfürȱdenȱTeilȱderȱApplikation,ȱderȱdieȱNachrichtȱvonȱ ihremȱZielȱempfängtȱundȱverarbeitet.ȱ

JMSȱ stelltȱ zweiȱ Nachrichtenmodelleȱ zurȱ Verfügung,ȱ dieȱ inȱ derȱ JMSȬSpezifikationȱMessagingȱDomainsȱgenanntȱwerden:ȱȱ PointȬtoȬpointȱ (PTP)ȱ

200ȱ

1.ȱȱPointȬtoȬPointȬModellȱ(PTP,ȱ1:1ȬKommunikation):ȱDerȱErzeugerȱ erzeugtȱ eineȱ Nachrichtȱ undȱ verschicktȱ dieseȱ überȱ einenȱ virtuelȬ lenȱKanal,ȱderȱQueueȱgenanntȱwird.ȱEineȱWarteschlangeȱ(Queue)ȱ kannȱvieleȱEmpfängerȱhaben,ȱaberȱnurȱeinȱEmpfängerȱkannȱdieȱ Nachrichtȱ konsumieren.ȱ PTPȱ bietetȱ einenȱ QueueBrowser,ȱ derȱ einemȱClientȱerlaubt,ȱdenȱInhaltȱderȱQueueȱzuȱinspizieren,ȱbevorȱ erȱdieȱNachrichtȱkonsumiert.ȱ

3.4 Programmiermodelle für verteilten Speicher 2. Publish/Subscribe-Modell (Pub/Sub, 1:m-Kommunikation): Ein Erzeuger produziert die Nachricht und verschickt diese über einen virtuellen Kanal, der Topic genannt wird (publish). Ein oder mehrere Empfänger können sich zu einem Topic verbinden (subscribe) und die Nachricht erhalten. Jeder zu dem Topic registrierten Empfänger erhält dann eine Kopie der Nachricht.

Publish/ Subscribe (Pub/Sub)

Abb. 3-19: PTP versus Pub/Sub

Das Application Programming Interface für den Message Server ist in Abschnitt 3.4.4.2 beschrieben.

3.4.2.4 Entfernte Aufruf-Modelle Die bisher vorgestellten Modelle basierten darauf, dass das verteilte System bereits in Clients, Server oder verteilte Prozessen untergliedert ist und somit schon die verteilte Struktur vorliegt. Diesem Programmiermodell liegt das Senden und Empfangen von Nachrichten zwischen den Prozessen als Basis der Verteilung zugrunde. Es entspricht dadurch weniger der Vorstellung, die vorhandene, nicht verteilte An-

201

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ wendungȱ aufȱ mehrereȱ Rechnerȱ zuȱ verteilen.ȱ Eineȱ nochȱ nichtȱ verteilteȱ monolithischeȱAnwendungȱlässtȱsichȱalsȱeineȱAnsammlungȱvonȱProzeȬ durenȱbetrachten.ȱDieseȱAnsammlungȱvonȱProzedurenȱteiltȱmanȱdannȱ inȱ Prozeduraufruferȱ undȱ damitȱ Clientsȱ undȱ dieȱ Prozedurȱ selbst,ȱ dieȱ dadurchȱzuȱeinemȱServerȱwird.ȱManȱprägtȱalsoȱnachträglichȱderȱmonoȬ lithischenȱ Strukturȱ eineȱ ClientȬServerȬStrukturȱ aufȱ undȱ verteiltȱ dieȱ ProzedurenȱaufȱmehrereȱRechner.ȱDurchȱdiesesȱVorgehenȱerscheintȱdieȱ verteilteȱ Abarbeitungȱ derȱ Prozedurenȱ wieȱ eineȱ zentralisierteȱ AbwickȬ lungȱ derȱ Prozeduren.ȱ Dasȱ verteilteȱ Systemȱ stelltȱ sichȱ demȱ Benutzerȱ dadurchȱ wieȱ einȱ zentralesȱ monolithischesȱ Systemȱ dar.ȱ Voraussetzungȱ fürȱdiesesȱVorgehenȱist,ȱdassȱeinȱProgrammȱ(Prozedur)ȱeineȱProzedurȱ aufȱ einerȱ anderenȱ Maschineȱ aufrufenȱ kann;ȱ d.h.ȱ esȱ müssenȱ entfernteȱ Prozeduraufrufeȱ(RemoteȱCalls,ȱRCs)ȱvorliegen.ȱ Dieȱ entferntenȱ Aufrufmodelleȱ (sieheȱ nachfolgendenȱ Abschnittȱ 3.4.5)ȱ gehenȱvonȱȱ x

entferntenȱ Prozeduraufrufenȱ (Remoteȱ Procedureȱ Callsȱ (RPCs))ȱ (Abschnittȱ3.4.5.5),ȱhinȱzuȱȱ

x

entferntenȱObjektȬȱundȱsomitȱMethodenaufrufenȱmitȱderȱCommonȱ Objectȱ Requestȱ Brokerȱ Architectureȱ (CORBA)ȱ (Abschnittȱ 3.4.5.6)ȱ undȱ denȱ aufȱ Javaȱ basierendenȱ Remoteȱ Methodȱ Invocationȱ (RMI)ȱ (Abschnittȱ3.4.5.7),ȱweiterȱzuȱȱ

x

entferntenȱ Komponentenaufrufen,ȱ demȱ Distributedȱ Componentȱ Objectȱ Modelȱ (DCOM)ȱ undȱ demȱ .NETȱ Remotingȱ (Abschnittȱ 3.4.5.8)ȱbisȱhinȱzuȱȱ

x

entferntenȱ Serviceaufrufenȱ mitȱ denȱ Webȱ Servicesȱ (Abschnittȱ 3.4.5.9)ȱ undȱ demȱ vereinfachtenȱ Serviceaufrufȱ demȱ XMLȬRPCȱ AbȬ schnittȱ(3.4.5.10).ȱȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ

202ȱ

3.4 Programmiermodelle für verteilten Speicher

Abb. 3-20: Programmiermodelle für verteilten Speicher

203

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ

3.4.3 Nebenläufige und nachrichtenbasierte Modelle 3.4.3.1 Message Passing Interface (MPI) MPIȬ1,ȱMPIȬ2ȱ

DasȱMessageȱPassingȱInterfaceȱ(MPI)ȱistȱeineȱvonȱIEEEȱstandardisierteȱ KommunikationsbibliothekȱfürȱdieȱProgrammiersprechenȱC,ȱC++,ȱFortȬ ranȱ 77ȱ undȱ Fortranȱ 90.ȱ Dasȱ MPIȬForumȱ [MPIȱ 94],ȱ eineȱ internationaleȱ Entwicklergemeinschaftȱ ausȱ Vertreternȱ derȱ Industrie,ȱ Universitätenȱ undȱ Forschungseinrichtungen,ȱ entwickeltȱ MPIȱ seitȱ 1992.ȱ Imȱ Jahrȱ 1995ȱ erschienȱ MPIȬ1,ȱ dieȱ ersteȱ Versionȱ desȱ Standards,ȱ 1997ȱ erschienȱ mitȱ MPIȬ2ȱ dieȱ zweiteȱ Version.ȱ Dasȱ Konsortiumȱ Openȱ MPIȱ [OMȱ 07]ȱ stelltȱ eineȱOpenȱSourceȱMPIȬ2ȬImplementationȱzurȱVerfügung.ȱȱ BeiȱMPIȬ2ȱ[GHLȱ00],ȱ{BMȱ06]ȱkamȱzusätzlichȱȱȱ x

dieȱdynamischeȱProzesserzeugungȱundȱProzessverwaltungȱundȱ

x

dieȱȱparalleleȱEinȬȱundȱAusgabeȱhinzu.ȱȱ

Dynamischeȱ Prozesseȱ

Beiȱ MPIȬ1ȱ mussȱ dieȱ Anzahlȱ vonȱ Prozessenȱ einerȱ MPIȬAnwendungȱ konstantȱsein.ȱBeimȱStartȱderȱAnwendungȱwirdȱsieȱfestgelegtȱundȱkannȱ imȱ Nachhineinȱ nichtȱ mehrȱ verändertȱ werden.ȱ Unterȱ MPIȬ2ȱ könnenȱ ProzesseȱbeiȱBedarfȱundȱsomitȱdynamischȱerzeugtȱwerden.ȱDesȱWeiteȬ renȱ können,ȱ getrenntȱ gestartet,ȱ unabhängigeȱ MPIȬProgrammeȱ miteinȬ anderȱ kommunizieren.ȱ Diesȱ ermöglicht,ȱ Clientȱ ServerȬAnwendungenȱ mitȱgehendenȱundȱkommendenȱClientsȱmitȱMPIȬ2ȱzuȱrealisieren.ȱȱȱ

SchreibȬȱundȱ LeseȬ funktionenȱ

DerȱMPIȬStandardȱstelltȱeineȱVielzahlȱvonȱSchreibȬȱundȱLesefunktionenȱ zurȱVerfügung.ȱDieseȱFunktionenȱorientierenȱsichȱanȱdenȱnachfolgendȱ vorgestelltenȱunterschiedlichenȱSendeȬȱundȱEmpfangsfunktionen.ȱMPIȬ 2ȱ stelltȱ eineȱ Dateisystemschnittstelleȱ mitȱ parallelerȱ Semantikȱ zurȱ VerȬ fügung.ȱDieȱSchnittstelleȱistȱarchitekturunabhägigȱundȱabstrahiertȱvonȱ denȱ Unterschiedenȱ beiȱ verschiedenenȱ parallelenȱ Dateisystemen,ȱ wieȱ NFS,ȱPVFSȱ oderȱ GPFS.ȱAufȱ diesenȱ verschiedenenȱ parallelenȱ DateisysȬ temenȱbasiertȱnatürlichȱdieȱImplementationȱdesȱMPIȬ2ȬDateisystems.ȱȱ AnleitungenȱfürȱMPIȱmitȱBeispielenȱinȱCȱundȱFortranȱsindȱinȱ[GLSȱ99],ȱ [GLSȱ 07]ȱ undȱ [GLTȱ 99]ȱ enthalten.ȱ Parallelprogrammierungȱ inȱ Cȱ mitȱ MPIȱ undȱ OpenMPȱ beschreibtȱ [Qȱ 03].ȱ Dasȱ kompletteȱ Referenzmanualȱ zuȱMPIȱliegtȱinȱ[GOHȱ98]ȱundȱ[SOHȱ00]ȱvor,ȱundȱeineȱBeschreibungȱderȱ CȬSchnittstelleȱ desȱ MPIȬStandardsȱ istȱ imȱ Anhangȱ vonȱ [BMȱ 06]ȱ beȬ schrieben.ȱ Dieȱ offizielleȱ Versionȱ derȱ MPIȱ Dokumentationȱ stelltȱ dasȱ MPIȬForumȱ inȱ PostscriptȬȱ undȱ HTMLȬVersionenȱ [MPIȱ 07]ȱ zurȱ VerfüȬ gung.ȱ Derȱ folgendeȱAbschnittȱ gibtȱ nurȱeinenȱÜberblickȱ überȱ dieȱMPIȬ FunktionenȱundȱenthältȱnichtȱalleȱFunktionenȱderȱMPIȬBibliothek.ȱUmȱ

204ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ einenȱvollständigenȱÜberblickȱzuȱerhalten,ȱsollteȱmanȱaufȱdieȱReferenzȬ ManualsȱzuȱMPIȱzurückgreifen.ȱȱ EsȱexistierenȱMPIȬImplementationȱfürȱvieleȱHardwareȬPlattformenȱvonȱ kommerziellenȱ Anbieternȱ undȱ freiȱ erhältlicheȱ diverseȱ ImplementieȬ rungenȱdesȱMPIȬStandards:ȱ x

MPICH,ȱMPICH2ȱ[MPCȱ07]ȱistȱeineȱamȱArgonneȱNationalȱLaboraȬ toryȱ entwickelteȱ freieȱ MPIȬImplementierung.ȱ ȱ MPICH2ȱ istȱ eineȱ kompletteȱNeuentwicklungȱdesȱArgonneȱNationalȱLaboratory.ȱDieȱ neusteȱ Versionȱ MPICHȬ2ȱ unterstütztȱ nebenȱ TCP/IPȬNetzenȱ auchȱ Infiniband.ȱȱ

x

MPICHȬGMȱ istȱ eineȱ aufȱ MPICHȱ basierendeȱ MPIȬImplementationȱ vonȱMyricomȱfürȱMyrinet.ȱȱȱ

x

MPICHȱ G2ȱ [MPGȱ 07]ȱ istȱ einȱ Abkömmlingȱ vonȱ MPICH,ȱ dieȱ aufȱ einemȱClusterverbundȱundȱsomitȱeinemȱGridȱläuft.ȱDieȱBibiliothekȱ setztȱ aufȱ demȱ Globusȱ Toolkitȱauf,ȱdasȱ dieȱUnterschiedeȱzwischenȱ denȱverschiedenenȱClusternȱüberbrückt.ȱȱ

x

IntelȱMPIȱLibraryȱ{MPIIȱ07]:ȱEsȱhandeltȱsichȱumȱeineȱaufȱMPICH2ȱ basierendeȱ kommerzielleȱ MPIȬImplementierungȱ vonȱ Intel.ȱ Dieȱ BibliothekȱunterstütztȱInfiniband.ȱȱȱ

x

Scaliȱ MPIȱ Connectȱ [MPISȱ 07]ȱ istȱ eineȱ kommerziellȱ vonȱ Scaliȱ verȬ triebeneȱ MPIȬImplementaion,ȱ dieȱ TCP/IPȬ,ȱ EthernetȬ,ȱ SCIȬ,ȱ MyriȬ netȬȱundȱInfinibandȬNetzeȱunterstützt.ȱȱ

x

MPI/Proȱ [MPIV1ȱ 07]ȱ istȱ eineȱ kommerzielleȱ MPIȬImplementation,ȱ dieȱ unterȱ Linux,ȱ MACȱ OSȱ Xȱ undȱ Windowsȱ läuft.ȱ ChaMPIon/Proȱ [MPIV2ȱ 07]ȱ istȱ eineȱ weitereȱ kommerzielleȱ MPIȬImplementation,ȱ welcheȱdieȱKommunikationȱunterȱTCP/IP,ȱSharedȱMemory,ȱMyriȬ net,ȱ Infinibandȱ undȱ Quadricsȱ unterstützt.ȱ Dieȱ MPIȬ Implementationȱistȱmultithreaded,ȱwodurchȱKommunikationȱundȱ BerechnungȱeinesȱMPIȬProgrammesȱgleichzeitigȱabgewickeltȱwerȬ denȱkönnen.ȱȱȱ

x

LAM/MPIȱ[LMȱ07].ȱLAMȱstehtȱfürȱLocalȱAreaȱMulticomputerȱundȱ istȱBestandteilȱderȱmeistenȱLinuxȬDistributionenȱundȱsomitȱfreiȱerȬ hältlich.ȱLAM/MPIȱimplementiertȱdenȱStandardȱMPIȬ1ȱvollständigȱ undȱ denȱ Standardȱ MPIȬ2ȱ fastȱ vollständig.ȱ Esȱ unterstütztȱ TCP/IPȬ,ȱ InfinibandȬȱundȱMyrinetȬNetze.ȱȱ Zumȱ Startenȱ vonȱ MPIȬProgrammenȱ undȱ zumȱ Teilȱ auchȱ fürȱ dieȱ Kommunikationȱ verwendetȱ LAM/MPIȱ einenȱ Dämon.ȱ Dieserȱ DäȬ monȱ mussȱaufȱallenȱ Knotenȱ gestartetȱ werdenȱ undȱmussȱ vorȱStartȱ desȱMPIȬProgrammesȱlaufen.ȱȱ

ImplementatiȬ onenȱvonȱMPIȱ

205ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ LAM/MPIȱ unterstütztȱ heterogeneȱ Clusterȱ undȱ istȱ gridfähig.ȱ Beiȱ GridsȱwirdȱaufȱdasȱGlobusȱToolkitȱzurückgegriffen.ȱȱ LAM/MPIȱstelltȱzurȱCompilationȱundȱAusführungȱeineȱkomfortabȬ leȱ Laufzeitumgebungȱ zurȱ Verfügung,ȱ dieȱ überblickshaftȱ folgendeȱ Komponentenȱumfasst:ȱ lambootȱ–ȱLAMȬUniversumȱstarten.ȱ lamshrinkȱ–ȱLAMȬUniversumȱschrumpfen.ȱȱ lamgrowȱ–ȱLAMȬUniversumȱvergrößern.ȱ lamhaltȱ–ȱLAMȬUniversumȱstoppen.ȱȱ lamwipeȱ–ȱLAMȬUniversumȱstoppenȱ(langsam).ȱ laminfo –ȱInformationȱüberȱLAMȬKonfigurationȱausgeben.ȱȱ lamnode ȱ–ȱInformationȱüberȱLAMȬKnotenȱausgeben.ȱȱ lamcleanȱ–ȱLAMȬSystemȱaufräumenȱUniversumȱschrumpfen.ȱȱ lamexecȱ–ȱNichtȬMPIȬProgrammȱaufȱLAMȬKnotenȱstarten.ȱ mpiccȱ–ȱCȬWrapperȬCompiler.ȱȱ mpic++ȱ–ȱC++ȬWrapperȬCompiler.ȱȱ mpif77ȱ–ȱFORTRANȬWrapperȬCompiler.ȱȱ mpirun –ȱMPIȬProgrammȱaufȱLAMȬKnotenȱstarten.ȱȱ mpiexecȱ–ȱMPIȬProgrammȱaufȱLAMȬKnotenȱstarten.ȱȱȱ mpitaskȱ–ȱMPIȬProgrammȱüberwachen.ȱ MPJȱ

Messageȱ Passingȱ inȱ Javaȱ (MPJ)ȱ [CGJȱ 00]ȱ istȱ einȱ objektorientiertesȱ Interfaceȱ fürȱ dieȱ Standardbibliothekȱ MPI.ȱ Dasȱ Interfaceȱ mpiJavaȱ istȱ keineȱ Erweiterungȱ vonȱ Java,ȱ sondernȱ portierbarȱ aufȱ kompatibleȱ JavaȬ Entwicklungsumgebungenȱ undȱ MPIȬUmgebungen.ȱ mpiJavaȱ kannȱ unȬ terȱ[PTLȱ07]ȱheruntergeladenȱwerden.ȱȱȱ

3.4.3.1.1 Initialisieren und Beenden von Prozessen mpi.hȱ Dieȱ Schnittstelleȱzurȱ MPIȬBibliothekȱ istȱ inȱ mpi.hȱ enthalten.ȱ Inȱ mpi.hȱ sindȱ alleȱ MPIȬFunktionenȱ deklariertȱ undȱ dieȱ MPIȬspezifischenȱ KonȬ stantenȱ definiert.ȱ Alleȱ Bezeichnerȱ inȱ mpi.hȱ beginnenȱ mitȱ MPI_.ȱ Beiȱ Konstantenȱ bestehtȱ derȱ Restȱ ausȱ Großbuchstabenȱ (z.B.ȱ MPI_DOUBLE),ȱ beiȱ Funktionenȱ folgenȱ einȱ oderȱ mehrereȱ durchȱ Tiefstricheȱ getrennteȱ Worte,ȱwobeiȱnurȱderȱersteȱBuchstabeȱdesȱerstenȱWortesȱgroßȱgeschrieȬ benȱwirdȱ(z.B.ȱMPI_Init).ȱ

206ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ Nebenȱ denȱ benutzerdefiniertenȱ Datentypenȱ stelltȱ MPIȱ einigeȱ vordefiȬ nierteȱ Datentypenȱ bereit,ȱ dieȱ Maschinenunabhängigkeitȱ garantieren.ȱ Dieseȱsind:ȱ ȱ

Vordefinierteȱ Datentypenȱ

ȱ MPI_BYTEȱ

ȱ

MPI_CHARȱ

ȱ

MPI_DOUBLEȱ

ȱ

MPI_FLOATȱ

ȱ

MPI_INTȱ

ȱ

MPI_LONGȱ

ȱ

MPI_LONG_DOUBLEȱ

ȱ

MPI_PACKEDȱ

ȱ

MPI_REALȱ

ȱ

MPI_SHORTȱ

ȱ

MPI_UNSIGNEDȱ

ȱ

MPI_UNSIGNED_CHARȱ

ȱ

MPI_UNSIGNED_LONGȱ

ȱ

MPI_UNSIGNED_SHORTȱ

MPI_InitȱundȱMPI_Finalizeȱ Umȱ dasȱ MPIȬSystemȱ zuȱ initialisieren,ȱ istȱ einȱ Aufrufȱ derȱ Funktionȱ MPI_Initȱ notwendig.ȱ MPI_Initȱ mussȱ vorȱ allenȱ anderenȱ MPIȬ Funktionenȱ aufgerufenȱ werdenȱ undȱ darfȱ nichtȱ mehrfachȱ aufgerufenȱ werden.ȱȱ int MPI_Init (int *argc , char ***argv);

MPI_Initȱ

Dieȱ Bedeutungȱ derȱ beidenȱ optionalenȱ Argumenteȱ argcȱ undȱ argvȱ istȱ identischȱmitȱdenȱKommandozeilenȬArgumentenȱderȱCȬmainȬFunktion.ȱ argcȱistȱeinȱPointerȱaufȱdieȱAnzahlȱderȱübergebenenȱArgumenteȱ(PoinȬ terȱaufȱdasȱersteȱArgumentȱderȱmainȬFunktion)ȱundȱargvȱistȱeinȱPoinȬ terȱ aufȱ denȱ Argumentvektorȱ (Pointerȱ aufȱ dasȱ zweiteȱ Argumentȱ derȱ mainȬFunktion).ȱ Auchȱ MPIȬProgramme,ȱ dieȱ keineȱ Kommandozeilenargumenteȱ abfraȬ gen,ȱmüssenȱdieȱParameterȱargcȱundȱargvȱangeben,ȱdennȱdieseȱwerȬ denȱanȱdieȱInitialisierungsfunktionȱMPI_Init weitergereicht.ȱEinȱTest,ȱ

207ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ obȱdieȱMPI_Initȱbereitsȱaufgerufenȱwurde,ȱgeschiehtȱmitȱderȱFunktiȬ onȱȱ MPI_ȱ Initializedȱ

int MPI_Initialized (int *flag); flagȱhatȱdenȱWertȱTRUE,ȱwennȱMPI_Initȱbereitsȱaufgerufenȱwurde,ȱ ansonstenȱFALSE.ȱ ZumȱBeendenȱeinerȱMPIȬUmgebungȱdientȱdieȱFunktionȱȱ

MPI_Finalizeȱ

int MPI_Finalize(); AlleȱMPIȬProzesseȱmüssenȱdieseȱRoutineȱvorȱihrerȱBeendigungȱaufruȬ fen.ȱȱ

3.4.3.1.2 Kommunikator und Rang EinȱKommunikatorȱistȱeineȱGruppeȱvonȱProzessen,ȱdieȱsichȱzueinanderȱ Nachrichtenȱ sendenȱ undȱ somitȱ zusammenȱ arbeiten.ȱ Nachȱ derȱ InitialiȬ sierungȱdurchȱMPI_InitȱexistiertȱbereitsȱderȱvordefinierteȱKommuniȬ katorȱ oderȱ dieȱ Gruppeȱ MPI_COMM_WORLD,ȱ dieȱ denȱ Typȱ MPI_Commȱ besitzt.ȱ Erȱ enthältȱ dieȱ Gruppeȱ allerȱ gestartetenȱ Prozesseȱ (Prozessstartȱ mitȱ mpirun oder mpiexec.ȱ Einȱ Kommunikatorȱ definiertȱ einenȱ Raum,ȱdenȱeineȱNachrichtȱnichtȱverlassenȱkann.ȱ

MPI_Comm_sizeȱundȱMPI_Comm_rankȱ ZurȱAbfrageȱderȱgestartetenȱProzesseȱinnerhalbȱeinesȱKommunikatorsȱ dientȱdieȱFunktionȱȱ MPI_Comm_ȱ sizeȱ

int MPI_Comm_size (MPI_Comm Comm, int *size); Derȱ ersteȱ Parameterȱ istȱ derȱ Kommunikatorȱ undȱ MPI_Comm_sizeȱ lieȬ fertȱ imȱ zweitenȱ Parameterȱ dieȱ Anzahlȱ pȱ derȱ Prozesse.ȱ Dieȱ pȱ Prozesseȱ einesȱKommunikatorsȱsindȱvonȱ0ȱbisȱpȬ1ȱdurchnummeriert.ȱDieȱNumȬ merȱeinesȱProzessesȱistȱseinȱRang.ȱȱ DerȱRangȱeinesȱProzessesȱinnerhalbȱdesȱKommunikatorsȱbestimmtȱdieȱ Funktionȱ

MPI_Comm_ȱ rankȱ

int MPI_Comm_rank (MPI-Comm comm, int *myrank) mitȱihremȱzweitenȱArgument.ȱȱ Dieȱ Differenzierungȱ derȱ Prozesseȱ nachȱ ihremȱ Rangȱ erlaubtȱ mehrereȱ paralleleȱProzesse,ȱwelcheȱdasȱgleicheȱAussehenȱhaben,ȱausȱdemȱgleiȬ chenȱProgrammcodeȱzuȱgenerieren.ȱÜberȱdenȱRangȱderȱProzesseȱkannȱ dannȱ derȱ Kontrollflussȱ inȱ verschiedenenȱ Prozessenȱ unterschiedlichȱ gesteuertȱwerden.ȱȱ

208ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ DieȱFunktionȱ int MPI_Get_processor_name (char *Name, int *len)

ȱ MPI_Get_pro cessor_nameȱ

liefertȱ denȱ Namenȱ derȱ Maschineȱ zurück,ȱ aufȱ derȱ derȱ aufrufendeȱ ProȬ zessȱ läuft.ȱ DieserȱNameȱ stimmtȱ mitȱ demȱ Namenȱ überein,ȱ welcherȱ dieȱ CȬFunktionȱgethostbynameȱliefertȱ(sieheȱAbschnittȱ3.4.4.1).ȱ

3.4.3.1.3 Blockierendes Senden und Empfangen Derȱ grundlegendeȱ Kommunikationsmechanismusȱ beiȱ MPIȱ istȱ dieȱ PunktȬzuȬPunktȬKommunikationȱ (1:1ȬKommunikation).ȱ Beiȱ dieserȱ Kommunikationȱ sendetȱ einȱ Prozessȱ eineȱ Nachrichtȱ anȱ einenȱ empfanȬ gendenȱ Prozess.ȱ Derȱ sendendeȱ Prozessȱ wartetȱ dabei,ȱ bisȱ derȱ empfanȬ gendeȱProzessȱanȱderȱEmpfangsanweisungȱsteht,ȱundȱderȱempfangenȬ deȱ Prozessȱ wartetȱ bisȱ derȱ sendendeȱ Prozessȱ anȱ derȱ Sendeanweisungȱ steht.ȱ Dieseȱ Interaktionȱ (blockierendesȱ Sendenȱ undȱ Empfangen)ȱ heißtȱ Rendezvousȱ(sieheȱAbschnittȱ3.3.7.1).ȱȱ DieȱFunktionȱzumȱblockierendenȱSendenȱvonȱDatenȱist:ȱ int MPI_Send (void *buf, int count, MPI_Datatype type, int dest, int tag, MPI_Comm comm);

MPI_Sendȱ

Derȱ ersteȱ Parameterȱ bufȱ enthältȱ dieȱ Adresseȱ derȱ zuȱ versendendenȱ Daten,ȱundȱimȱParameterȱcountȱstehtȱdieȱAnzahlȱderȱzuȱversendendenȱ Daten.ȱDerȱParameterȱtypeȱbeschreibtȱdenȱTyp,ȱderȱzuȱversendendenȱ Datenelemente.ȱ Derȱ Empfängerȱ derȱ Datenȱ istȱ durchȱ destȱ undȱ commȱ festgelegt.ȱ Derȱ Parameterȱ destȱ gibtȱ denȱ Rangȱ desȱ Prozessesȱ inȱ derȱ Gruppeȱ (Kommunikator)ȱ commȱ anȱ (Standardgruppeȱ istȱ MPI_COMM_WORLD).ȱDerȱParameterȱtagȱistȱeinȱEtikett,ȱdasȱderȱSenderȱ demȱEmpfängerȱübermittelt,ȱumȱdieȱArtȱderȱNachrichtȱanzuzeigen.ȱDieȱ Prozesseȱ tauschenȱ gewöhnlichȱ vieleȱ Nachrichtenȱ aus,ȱ beiȱ denenȱ dieȱ Datenȱ vomȱ gleichenȱ Typ,ȱ aberȱ vonȱ unterschiedlicherȱ Bedeutungȱ sind.ȱ EinȱEtikettȱ(tag)ȱbietetȱdieȱMöglichkeit,ȱdassȱderȱEmpfängerȱdieȱNachȬ richtȱselektierenȱkann.ȱ DieȱzuȱMPI_SendȱkorrespondierendeȱFunktionȱzumȱEmpfangenȱist:ȱ int MPI_Recv (void *buf, int maxbuf, MPI_Datatype type, int source,int tag, MPI_Comm comm, MPI_Status &status); Dieȱ erstenȱ sechsȱ Parameterȱ korrespondierenȱ zuȱ denȱ Parameternȱ vonȱ MPI_Send.ȱDerȱEmpfangsbufferȱbufȱmussȱeinȱvomȱEmpfängerȱbereitȬ

MPI_Recvȱ

209ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ gestellterȱ Speicherȱ sein,ȱ derȱ mindestensȱ maxbufȱ Datenelementeȱ desȱ Typsȱ typeȱ aufnehmenȱ kann.ȱ sourceȱ gibtȱ denȱ Rangȱ desȱ Sendersȱ an,ȱ umȱ sicherzugehen,ȱ dassȱ derȱ Empfängerȱ auchȱ dieȱ richtigeȱ Nachrichtȱ erhält.ȱȱ Esȱ gibtȱ eineȱ vordefinierteȱ Konstanteȱ MPI_ANY_SOURCE,ȱ fallsȱ einȱ ProȬ zessȱvonȱirgendeinemȱSenderȱeineȱNachrichtȱempfangenȱwill.ȱDieȱVaȬ riableȱstatusȱ vomȱTypȱMPI_STATUSȱistȱeineȱStrukturȱmitȱdenȱKomȬ ponentenȱȱ MPI_STATUSȱ

typedef struct {int MPI_SOURCE; int MPI_TAG; int MPI_ERROR; … } MPI_Status; Wurdeȱ dieȱ Nachrichtȱ mitȱ MPI_ANY_SOURCEȱ empfangen,ȱ soȱ kannȱ derȱ Empfängerȱ mitȱ status.MPI_SOURCEȱ sowohlȱ denȱ Rangȱ desȱ AbsenȬ ders,ȱ alsȱ auchȱ dasȱ Etikettȱ mitȱ status.MPI_TAGȱ derȱ Nachrichtȱ abfraȬ gen.ȱȱ ȱ DieȱPunkteȱinȱMPI_StatusȱstehenȱfürȱweitereȱKomponenten,ȱaufȱdieȱ mitȱderȱFunktionȱ

MPI_Get_ȱ countȱ

int MPI_Get_count(MPI_Status *status, MPI_Datatype type, int *count); zugegriffenȱ wird.ȱ MPI_Get_countȱ liefertȱ inȱ countȱ dieȱ Anzahlȱ derȱ tatsächlichȱ übertragenenȱ Elemente.ȱ Eineȱ typischeȱ Anwendungȱ vonȱ MPI_GET_CountȱistȱdasȱSondierenȱeinerȱeingehendenȱNachrichtȱmitȱȱ

MPI_Probeȱ

int MPI_Probe(int src, int tag, MPI_Comm comm, MPI_Status *stat); MPI_Probeȱ kehrtȱ zumȱ Aufruferȱ zurück,ȱ sobaldȱ eineȱ Nachrichtȱ vomȱ Absenderȱ srcȱ mitȱ Etikettȱ tagȱ zumȱ Empfangȱ vorliegt.ȱ Dieȱ Nachrichtȱ selbstȱ wirdȱ dabeiȱ nichtȱ empfangen,ȱ jedochȱ wirdȱ dieȱ Statusvariableȱ gesetzt.ȱ Derȱ Empfängerȱ kannȱ mitȱ MPI_Get-Countȱ (&status, …)ȱ dieȱ Größeȱ derȱ Nachrichtȱ ermitteln,ȱ kannȱ genügendȱ Speicherplatzȱ reȬ servierenȱundȱdieȱNachrichtȱschließlichȱmitȱMPI_Recvȱempfangen.ȱȱ ȱ ȱ ȱ

210ȱ

3.4 Programmiermodelle für verteilten Speicher Der MPI-Standard bietet vier Modi für das blockierende Senden an: MPI-Send

•

Standardmodus: MPI_Send

•

Gepufferter Modus: MPI_Bsend

•

Synchroner Modus: MPI_Ssend

MPI_Ssend

•

Empfangsbereiter Modus: MPI_Rsend

MPIRsend

MPI-Bsend

Beim blockierenden Senden und Empfangen muss dem Senden von einem Prozess eine Empfangsanweisung eines anderen Prozesses gegenüberstehen, sonst entstehen Verklemmungen (Deadlocks). Ein Deadlock zeigt das folgende Programm: Prozess 0:

Prozess 1:

… MPI_Send (dest=1); MPI_Recv (src=1); …

… MPI_Send (dest=0); MPI_Recv (src=0); …

Deadlock !

Das Weiterleiten einer Nachricht durch gleichzeitiges Senden und Empfangen geschieht mit: int MPI_Sendrecv (void *sendbuf, int sendcount, MPI_Datatype sendtype, int dest, int sendtag, void *recvbuf, int recvcount, MPI_Datatype recvtype, int src, int srctag, MPI_Comm comm, MPI_Status *status);

MPI_ Sendrecv

MPI_Sendrecv enthält die kombinierten Parameter von MPI_Send und MPI_Recv. und ist wie MPI_Send eine blockierende Operation. MPI_Sendrecv führt diese beiden Befehle in zwei unabhängigen Verarbeitungssträngen, also quasiparallel aus. Adressat dest und Absender src dürfen identisch sein. Die beiden Speicherbereiche sendbuf und recvbuf dürfen nicht identisch sein und dürfen sich auch nicht

211

3 Programmiermodelle für parallele und verteilte Systeme überlappen, da MPISendrecv umkopiert. Das Umkopieren der Daten vom Empfangs- in den Sendepuffer unterbleibt bei der Funktion MPI_ Sendrecv_ replace

int MPI_Sendrecv_replace (void *buf, int count, MPI_Datatype type, int dest, int sendtag, int src, int recvtag, MPI_Comm comm, MPI_Status *status); Anzahl und Typ der Daten für beide Richtungen müssen allerdings bei MPI_Sendrecv_replace identisch sein.

3.4.3.1.4 Nichtblockierendes Senden und Empfangen Für das sofortige (I – Immediate) oder nicht blockierende Senden dient die Funktion MPI_Isend. Diese Funktion stößt den sofortigen Transfer an. MPI_Isend

int MPI_Isend (void *buf, int count, MPI_Datatype type, int dest, int tag, MPI_Comm comm, MPI_Request *request); Die Argumente von MPI_Isend entsprechen denen von MPI_Send, nur das letzte Objekt request ist neu hinzugekommen. Request dient zum Abfragen des Endes der Sendeoperation. Das Abfragen geschieht mit den Routinen MPI_Test oder beim Warten auf Abschluss der Kommunikation mit MPI_Wait. Das Gegenstück zur Routine MPI_Isend ist die nicht blockierende Empfangsoperation MPI-Irecv:

MPI_Irecv

int MPI_Irecv (void *buf, int maxbuf, MPI_Datatype type, int source, int tag, MPI_Comm comm, MPI_Request *request); Die Parameter von MPI_Irecv entsprechen denen von MPI_Recv, nur das Argument status wurde durch das Argument *request vom Typ MPI_Request ersetzt. Mit MPI_Wait kann auf Abschluss

212

3.4 Programmiermodelle für verteilten Speicher der Empfangsoperation gewartet werden, und mit MPI_Test kann der Empfang getestet werden. Die Routine MPI_Test überprüft, ob eine nicht blockierende Sendeoperation beendet ist. Ist die Sendeoperation beendet, enthält die Variable flag den Wert TRUE, andernfalls den Wert FALSE.

MPI_Test

int MPI_Test (MPI_request * request, int *flag, MPI_Status *status); Die Routine MPI_Wait blockiert den aufrufenden Prozess so lange, bis die Kommunikation vollständig abgeschlossen ist: int MPI_Wait (MPI_Request *request, MPI_Status *status);

MPI_Wait

Ein Prozess, der mehrere Transferwünsche gleichzeitig aktiviert hat, sollte bei der Komplettierung dieses Transfer flexibel sein. Der MPIStandard bietet dafür drei Varianten (Any-Variante, All-Variante und Some-Variante) von MPI_Wait und MPI_Test an.

Any-Variante Ist mindestens einer der Transfers abgeschlossen, so lässt sich die Blockierung lösen mit MPI_Waitany oder mit MPI_Testany testen. int MPI_Waitany (int count, MPI_Request *array_of_requests, int *index, MPI_Status *status);

MPI_Waitany

int MPI_Testany (int count, MPI_Request *array_of_requests, int *index, int *flag, MPI_Status *status);

MPI_Testany

All-Variante Will man nicht auf irgendeine der ausgeführten Transfers warten, sondern auf alle, so benutzt man MPI_Waitall bzw. die nicht blockierende Test-Variante MPI_Testall. int MPI_Waitall (int count, MPI_Request *array_of_requests, MPI_Status *array_of_statuses);

MPI_Waitall

int MPI_Testall (int count, MPI_Request *array_of_requests, int *flag, MPI_Status *array_of_statuses);

MPI_Testany

213

3 Programmiermodelle für parallele und verteilte Systeme

Some-Variante Ist mindestens einer der angegebenen Transfers beendet, so kann das Blockieren beendet werden mit MPI_Waitsome und wieder mit MPI_Testsome getestet werden. MPI_ Waitsome

MPI_ Testsome

int MPI_Waitsome (int incount, MPI_Request *array_of_requests, int *outcount, int *array_of_indices, MPI_Status *array_of_statuses); int MPI_Testsome (int incount, MPI_Request *array_of_requests, int *outcount, int *array_of_indices, MPI_Status *array_of_statuses);

3.4.3.1.5 Persistente Kommunikation Jeder Aufruf von MPI_Isend erzeugt ein Ticket vom Typ MPI_Request, das nach Abwicklung der Transaktion durch MPI_Wait gelöscht wird. Ein Prozess, der in einer Schleife viele gleiche oder ähnliche Nachrichten (gleiche Anzahl, gleicher Typ) zum selben Partner schickt, löst und annulliert bei jedem Durchlauf ein Ticket mit identischen Parametern. Viel besser und effizienter ist es, wenn ein Prozess ein Ticket löst, das für beliebig viele Nachrichten gilt. Die Ausstellung eines solchen Tickets geschieht mittels MPI_Send_init: MPI_Send_ init

int MPI_Send_init (void *buf, int count, MPI_Datatype type, int dest, int tag, MPI_Comm comm, MPI_Request *request); Die Parameter von MPI_Send_init sind dieselben wie bei MPI_Isend. MPI_Send_init verhält sich aber ganz anders:

214

•

MPI_Send_init liefert ein Ticket MPI_Request, welches für beliebig viele Nachrichten gültig ist.

•

MPI_Send_init stößt keinen Nachrichtentransfer an. Insbesondere braucht der Sendepuffer buf beim Aufruf von MPI_Send_init noch keine Daten zu enthalten. Nach Aufruf

3.4 Programmiermodelle für verteilten Speicher von MPI_Send_init ist der Nachrichtentransfer mit Ticket request noch inaktiv. Die Aktivierung bzw. der Anstoß des Nachrichtentransfers geschieht mit dem Aufruf der Funktion MPI_Start. int MPI_Start (MPI_Request *request);

MPI_Start

Auf die Abwicklung eines aktivierten Nachrichtenverkehrs kann mit den üblichen Funktionen MPI_Wait oder MPI_Test gewartet werden. Das Ticket wird dabei nicht annulliert, sondern nur inaktiviert. Ein MPI_Start aktiviert dann wieder das Ticket. Das Paar MPIStart/Wait kann beliebig oft ausgeführt werden, der Aufwand zur Ticketverwaltung fällt dabei nur einmal an. Wie die Aktivierung des Sendetickets mit MPI_Start_init kann das Empfangsticket beim Empfang der Nachricht mit MPI_Recv_init aktiviert werden. int MPI_Recv_init (void *buf, int count, MPI_Datatype type, int src, int tag, MPI_Comm comm, MPI_Request *request);

MPI_Recv_ init

Eine ganze Liste von Tickets reqs[0],,,reqs[nreq -1] kann man mit int MPI_Startall (int nreq, MPI_request *reqs);

MPI_Startall

aktivieren. Das Feld reqs kann auch eine Mischung aus Sende- und Empfangstickets enthalten. Persistente und nicht persistente Transfers sind kompatibel zueinander. Ein mit einem persistentem Ticket verschickte Nachricht kann mit einem einzigen Ticket empfangen werden und umgekehrt. Dauertickets gibt es für alle vier Sendemodi: Neben MPI_Send_init gibt es auch MPI_Bsend_init, MPI_Send_init und MPI_Rsend_init. Zur Annullierung eines Dauertickets muss explizit die Funktion int MPI_Request_free (MPI_Request *request);

MPI_ Request_free

215

3 Programmiermodelle für parallele und verteilte Systeme aufgerufen werden. MPI_Request_free setzt request auf den Wert MPI_REQUEST_NULL.

3.4.3.1.6 Broadcast Außer der Punkt-zu-Punkt-Kommunikation (1:1-Kommunikation), bei der ein Prozess eine Nachricht direkt an einen anderen Prozess sendet, ist auch eine 1:n-Kommunikation oder ein Broadcast möglich. Bei einem Broadcast sendet ein Prozess eine Nachricht an mehrere Empfänger. Dies lässt sich auch über eine Abfolge von Punkt-zu-PunktNachrichten realisieren, aber einfacher und eleganter geht das mit der Rundsende-Funktion MPI_Bcast: MPI_Bcast

int MPI_Bcast (void *buf, int count, MPI_Datatype type, int root, MPI_Comm comm);

Kollektive Kommunikationsfunktion

MPI_Bcast verschickt die in buf abgelegten Daten an alle Prozesse der Gruppe comm. Sie ist somit gleichzeitig Sende- und Empfangsfunktion und muss von allen Prozessen der Gruppe aufgerufen werden. MPI_Bcast ist somit eine kollektive Kommunikationsfunktion. Kollektive Kommunikationsfunktionen müssen grundsätzlich von allen Prozessen des verwendeten Kommunikators ausgeführt werden. Nachrichten, die mit MPI_Bcast verschickt werden, können nicht mit MPI_Recv oder MPI_Irecv empfangen werden. Der Parameter .root enthält den Rang des Senders, d.h. des Prozesses, der den Broadcast auslöst und somit die Daten verteilt. Alle anderen Prozesse der Gruppe com sind somit Empfänger des Broadcast. MPI_Bcast synchronisiert die Prozesse nicht. Wenn BPI_Bcast in einem Prozess die Kontrolle an den Aufrufer zurückgibt, so hat der Absender root inzwischen MPI_Bcast aufgerufen. Über den Zustand der anderen Prozesse relativ zu MPI_Bcast kann man dagegen keine verlässlichen Annahmen machen. Der MPI-Standard schreibt in diesem Fall keine Synchronisation vor.

Barrierensynchronisation

Um Prozesse innerhalb der Gruppe comm explizit zu synchronisieren muss die Funktion MPI_Barrier benutzt werden:

MPI_Barrier

int MPI_Barrier (MPI_Comm comm); Auch MPI_Barrier ist eine kollektive Funktion und muss von allen Prozessen in der Gruppe comm aufgerufen werden. MPI_Barrier kehrt erst dann zum Aufrufer zurück, wenn die Funktion von allen

216

3.4 Programmiermodelle für verteilten Speicher Prozessen in comm aufgerufen wurde; d.h. wenn alle Prozesse die Barriere überwunden haben. .

3.4.3.1.7 Weitere kollektive Kommunikationsfunktionen Das Rundsenden an alle Prozesse mit MPI_Bcast ist nur eine von insgesamt vierzehn kollektiven Operationen des MPI-Standards. Weitere kollektive Funktionen erlauben •

das Verteilen der Daten auf verschiedene Prozesse (MPI_Bcast, MPI_Scatter und MPI_Scatterv),

•

Einsammeln von Daten von verschiedenen (MPI_Gather, MPI_Gatherv und MPI_Allgather),

•

Versenden von allen Daten an alle Prozesse (MPI_Alltoall),

•

Einsammeln von Daten von verschiedenen Prozessen und Zusammenfassen (Reduktion) der Daten (MPI-Reduce, MPI_Allreduce und MPI_Scan) und

•

Versenden von allen Daten an alle Prozesse und deren Zusammenfassung (MPI_Reduce_Scatter).

Prozessen

Alle beteiligten Prozesse der Gruppe comm rufen dabei die entsprechende Funktion (kollektive Kommunikationsfunktionen) auf.

3.4.3.1.8 Kommunikator und Gruppenmanagement Kommunikatoren Die kollektiven Kommunikationsfunktionen wirken immer auf alle vorhandenen Prozesse. Zur Einschränkung der kollektiven Operationen auf Untermengen von Prozessen müssen die Kommunikatoren eingeschränkt werden, und es müssen neben dem StandardKommunikator MPI_COMM_WORLD neue Kommunikatoren definierbar sein. Die neuen Kommunikatoren besítzen dann wieder den Typ MPI_Comm. Mit dem Typ MPI_Comm lassen sich dann neue Kommunikatoren definieren und einander zuweisen. Ein neuer Kommunikator lässt sich mit MPI_Comm_dup duplizieren und somit erzeugen: int MPI_Comm_dup(MPI_Comm comm, MPI_Comm *newcomm) MPI_Comm_dup erzeugt eine Kopie newcomm des Kommunikators comm mit identischer Prozessgruppe. Alle Prozesse in comm müssen MPI_Comm_dup aufrufen, da er eine kollektive Operation ist.

MPI_Comm_ dup

217

3 Programmiermodelle für parallele und verteilte Systeme Somit lässt sich für den Standardkommunikator MPI_COMM_WORLD ein neuer Kommunikator myworld erzeugen, der die gleichen Prozesse besitzt wie MPI_COMM_WORLD. MPI_Comm myworld; … MPI_Comm_dup(MPI_COMM_WORLD, &myworld); Zur Unterteilung des Kommunikators comm in mehrere Kommunikatoren mit disjunkten Prozessgruppen geschieht mit der Funktion MPI_Comm_split. MPI_Comm_ split

int MPI_Comm_split(MPI_COMM comm, int color, int key, MPI_Com *newcomm) MPI_Comm_split ist eine kollektive Operation und muss von allen Prozessen in comm aufgerufen werden. Alle Prozesse mit dem gleichen Wert von color landen im selben neuen Kommunikator newcomm. Der Rang der Prozesse in newcomm ist durch den Wert von key geregelt. Treten gleiche key-Werte auf, so entspricht die Rangordnung der im alten Kommunikator comm. Wenn ein Kommunikator nicht mehr benötigt wird, so rufen alle Prozesse die kollektive Funktion

MPI_Comm_ free

int MPI_Comm_free (MPI_Comm *comm) auf.

Prozessgruppen Prozessgruppen sind in einen Kommunikator eingebettet und besitzen den Datentyp MPI_Group. Mit der Funktion MPI_Comm_ group

int MPI_Comm_group (MPI_Comm comm, MPI_Group *grp) verschaftt man sich Zugriff und somit einen Handle grp auf die Prozessgruppe von comm. Mit einem bereits vorhandenen Komunikator comm, der alle Prozesse von grp enthält, kann man einen neuen Kommunikator newcomm schaffen mit der Prozessgruppe grp. Dies geschieht mit der Funktion

MPI_Comm_ create

int MPI_Comm_create (MPI_Comm comm, MPI_Group grp, MPI_Comm *newcomm) MPI_Comm_create ist eine kollektive Funktion, die von allen Prozessen des Kommunikators comm aufgerufen werden muss, auch solchen, die nicht in grp enthalten sind.

218

3.4 Programmiermodelle für verteilten Speicher Die Erzeugung neuer Gruppen aus bereits vorhandenen Gruppen geschieht mit den Funktionen MPI_Group_incl oder MPI_Group_excl. int MPI_Group_incl (MPI_Group grp, int n, int *rank, MPI_Group *newgrp) int MPI_Group_excl (MPI_Group grp, int n, int *rank, MPI_Group *newgrp)

MPI_Group_ incl MPI_Group_ excl

MPI_Group_incl erzeugt aus der Vorlage grp die neue Gruppe newgrp. Sie enthält n Prozesse, wobei der Rang i der neuen Gruppe dem Rang rank[i] der Vorlage entspricht. MPI_Group_excl überträgt die bei MPI_Group_incl nicht ausgewählten Prozesse in die neue Gruppe newgrp. MPI_Group_excl arbeitet komplementär zu MPI_Group_incl. Mit einem Beispiel dazu, sei grp = (a,b,c,d,e,f,g) und n = 3 und rank = [6,0,2]. Damit liefert MPI_Group_incl die Gruppe (f,a,c) und MPI_Group_excl die Gruppe (b,d,e,g). Die Angabe des ranges aus n Tripel und somit einer Folge von Rängen spezifiziert mehrere Gruppen, die in die neue Gruppe übernommen werden. Die ersten beiden Werte eines Tripels geben den ersten und letzten Rang an, der dritte Wert den Abstand aufeinanderfolgender Ränge. Mit MPI_Group_range_incl lassen sich dann mit n Tripel eine neue Gruppe festlegen und mit MPI_Group_range_excl die dazu komplementäre Gruppe. int MPI_Group_range_incl (MPI_Group grp, int n, int ranges [] [3], MPI_Group *newgrp) int MPI_Group_range_excl (MPI_Group grp, int n, int ranges [] [3], MPI_Group *newgrp)

MPI_Group_ range_incl MPI_Group_ range_excl

Mit einem Beispiel dazu, sei grp = (a,b,c,d,e,f,g,h,i,j) und n = 3 und

219

3 Programmiermodelle für parallele und verteilte Systeme ranges

= [[6,7,1] [1,6,2] [0,9,4].

Damit liefert das erste Tripel die Gruppe (g,h), das Zweite (b,d,f) und das Dritte schließlich (a,e,i). Insgesamt liefert MPI_Group_range_incl (g,h.b,d,f,a,e,i).

die

Gruppe

Aus zwei Gruppen grp1 und grp2 lassen sich mit den üblichen Mengenoperationen neue Gruppen bilden: MPI_Group_ union MPI_Group_ intersection

MPI_Group_ difference

int MPI_Group_union (MPI_Group grp1, MPI_Group grp2, MPI_Group *newgrp) int MPI_Group_intersection (MPI_Group grp1, MPI_Group grp2, MPI_Group *newgrp) int MPI_Group_difference (MPI_Group grp1, MPI_Group grp2, MPI_Group *newgrp) Bei der Festlegung der Ordnung der Ränge ist dabei das erste Argument grp1 bestimmend und wird unter Wahrung der Ordnung der Elemente aus grp1 übernommen. Zur Freigabe der Ressourcen, die eine Gruppe belegt, sollte man diese, falls sie nicht mehr benötigt wird, freigeben.

MPI_Group_ free

int MPI_Group_free (MPI_Group *grp)

MPI_Group_ size

int MPI_Group_size (MPI_Group grp,int *size)

MPI_Group_ rank

int MPI_Group_rank (MPI_Group grp,int *rank)

MPI_Group_ compare

int MPI_Group_compare (MPI_Group grp1, MPI_Group grp2, int *result)

Zur Erhaltung des Überblicks über die vorhandenen Gruppen gibt es, wie bei den Kommunikatoren, Funktionen zur Feststellung der Anzahl und des Ranges der Prozesse.

Zwei Gruppen lassen sich vergleichen mit der Funktion

Sie liefert in result den Wert •

220

MPI_IDENT, falls grp1 und grp2 dieselben Prozesse in derselben Ordnung enthalten.

3.4 Programmiermodelle für verteilten Speicher •

MPI_SIMILAR, falls grp1 und grp2 dieselben Prozesse, aber in unterschiedlicher Ordnung enthalten.

•

MPI_UNEQUAL in allen anderen Fällen.

3.4.3.2 Occam Der Begriff Occam geht auf den englischen Philosphen William von Occam (ca. 1290 – 1369) zurück. Er prägte den Satz „Entia non sunt multiplicanda praeter necessistatem“ – „Die Sachen sind nicht zu multiplizieren (komplizieren) bevor es notwendig ist“. Demgemäß ist Occam [I 88] [TO 07] •

eine einfache blockstrukturierte Sprache mit Typen und Typüberprüfungen,

•

sie enthält Funktionen und Prozeduren, jedoch keine rekursive Prozeduren,

•

besitzt statische parallele Prozesse mit bockierender, synchroner und ungepufferten Kommunikation und

•

lässt sich gut auf Transputerarchitekturen bzw. –netze abbilden.

Zur Verdeutlichung der Blockstruktur müssen alle Ausdrücke eines Blockes in Occam eingerückt werden. Eine Reihe von Anweisungen (Block) müssen dadurch auf der gleichen Einrückungsebene stehen. Diese Kenntlichmachung der Blockstruktur durch Einrückungen findet man auch in anderen Programmiersprachen vor, und heißt off-side rule. Zur Einsparung des Strichpunktes endet jeder Ausdruck am Ende der Zeile.

Off-side rule

3.4.3.2.1 SEQ- versus PAR-Konstrukt Das Konstrukt SEQ schreibt die sequenzielle Ausführung der aufgelisteten Ausdrücke vor. Das SEQ-Konstrukt endet, wenn der letzte Prozess terminiert. SEQ x := x + 1 y := x * x

Programm 3-13: Sequenzielle Ausführung

Bei PAR kann die Liste der Ausdrücke parallel ausgeführt werden. Das nachfolgende Programm 3-13 enthält als Ausdrücke die Prozeduraufrufe P1(), P2(), P3(). Die Komponentenprozesse P1, P2, P3 werden zusammen und parallel ausgeführt. Das PAR-Konstrukt endet, wenn alle parallelen Prozesse beendet sind.

221

3 Programmiermodelle für parallele und verteilte Systeme Programm 3-14: Parallele Ausführung

PAR P1() P2() P3() Das PAR-Konstrukt realisiert einen fork/join-Parallelismus. Zu Beginn „vergabelt“ obiges Programm 3-13 in die drei Prozesse P1, P2, und P3. Am Ende des PAR-Konstrukts wird gewartet bis alle Prozesse beendet sind (implizite Barriere) und der Kontrollfluss vereinigt sich.

Kommunikation mit ! und ?

Programm 3-15: Kommunikation über Kanäle

Programm 3-16: Parallele Kommunikation

Die Kommunikation zwischen Prozessen geschieht über benannte Kanäle. Ein Prozess gibt mit dem Ausrufezeichen (!) Daten aus, während ein anderer Prozess mit dem Fragezeichen (?) die Daten einliest. Die Ein- und Ausgabe ist dabei synchron und blockierend. Die Eingabe im nachfolgenden Programm liest einen Wert über den Kanal c1 ein, addiert eins und gibt das Ergebnis über Kanal c2 aus. SEQ c1 ? x x := x + 1 c2 ! x Das PAR-Konstrukt erlaubt die parallele Kommunikation auf Kanal c1 und c2. PAR c1 ? x c2 ! y Die Kommunikation ist blockierend und synchron und ungepuffert, wie beim Ada-Rendezvous. Der Unterschied zum Ada-Rendezvous ist jedoch, dass die Kommuniktion über eine send/receive, bzw. ! / ? von Nachrichten über Kanäle geschieht, während bei Ada entfernte Aufrufe vorliegen (siehe Abschnitt 3.3.7.1).

3.4.3.2.2 ALT-Konstrukt Wächter (Guard)

222

Das ALT-Konstrukt specifiziert eine Liste von bewachten EingabeKommandos (Guards). Die Wächter sind eine Kombination von booleschen Ausdrücken und einem Eingabekommando. (Beide sind dabei optional.) Jeder Wächter, für den die Auswertung des booleschen Ausdruckes true ergibt und eine entsprechende Eingabe über den Kanal vorliegt, ist offen. Irgendeine der offenen Alternativen wird ausgewählt und ausgeführt.

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ ALT count1 < 100 & c1 ? data SEQ count1 := count1 + 1 merged ! data count2 < 100 & c2 ? data SEQ count2 := count2 + 1 merged ! data status ? request SEQ out ! count1 out ! count2

Programmȱ3Ȭ 17ȱ:ȱȱALTȱmitȱ Wächterȱȱ

Programmȱ 3Ȭ15ȱ liestȱ zunächst,ȱ daȱ dieȱ beidenȱ Wächterȱ offenȱ sind,ȱ dieȱ Datenȱ vomȱ Kanalȱ c1ȱ undȱ c2ȱ ein,ȱ jeȱ nachdemȱ anȱ welchemȱ Kanalȱ dieȱ Datenȱvorliegen.ȱDieȱDatenȱwerdenȱdannȱüberȱdenȱKanalȱmergedȱausȬ gegeben.ȱ Erreichtȱ count1ȱ oderȱ count2ȱ dieȱ Grenzeȱ Hundert,ȱ soȱ werȬ denȱ dieȱ beidenȱ Wächterȱ false,ȱ wasȱ dieȱ entsprechendeȱ Kanäleȱ (c1ȱ oderȱc2)ȱsperrt.ȱEineȱAnfrageȱamȱKanalȱstatusȱbewirktȱdieȱAusgabeȱ vonȱcount1ȱundȱcount2ȱüberȱdenȱKanalȱout.ȱȱ Dasȱ ALTȬKonstruktȱ vonȱ Occamȱ entsprichtȱ demȱ selektivenȱ AdaȬ Rendezvousȱ(sieheȱAbschnittȱ3.3.7.2).ȱDerȱUnterschiedȱliegtȱnurȱdarin,ȱ dassȱbeiȱAdaȱvorliegendeȱentfernteȱEingangsaufrufeȱvorliegenȱmüssenȱ undȱbeiȱOccamȱmüssenȱEingabenȱ(Nachrichten)ȱüberȱeinenȱKanalȱvorȬ liegen.ȱȱ

Adaȱbietetȱ entfernteȱ Aufrufeȱ Occamȱbietetȱ NachrichtenȬ verkehrȱ

ȱ

3.4.3.2.3 IF- WHILE- Konstrukt, SEQ- und PAR-Zählschleifen EineȱbedingteȱAnweisungȱhatȱdieȱForm:ȱ IF Cond1 P1 Cond2 P2 Cond3 P3 . . .

IFȬAnweisung

P1ȱwirdȱausgeführt,ȱwennȱCond1ȱtrueȱist,ȱP2ȱwirdȱausgeführt,ȱwennȱ Cond2ȱtrueȱistȱundȱsoȱweiter.ȱNurȱeinerȱderȱProzesseȱwirdȱdabeiȱausȬ geführt,ȱundȱanschließendȱterminiertȱdasȱIFȬKonstrukt.ȱ

223ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ EineȱwhileȬSchleifeȱ WHILEȬ Schleifeȱ

WHILE Cond P führtȱdenȱProzessȱPȱsoȱlangeȱaus,ȱbisȱderȱWertȱvonȱCondȱFalseȱist.ȱȱȱ

Zählschleifeȱ

EineȱZählschleifeȱwiederholtȱeinenȱProzessȱPȱfürȱeineȱfesteȱAnzahlȱn.ȱ SEQ i = 1 FOR n P

Programmȱ3Ȭ 18:ȱ Zählschleifeȱ

DerȱProzessȱPȱwirdȱnȱmalȱausgeführt.ȱ SEQ i = 3 FOR 4 User[i] ! Message Dieȱ Botschaftȱ Messageȱ wirdȱ sequenziellȱ überȱ Kanalȱ User[3],ȱ User[4],ȱUser[5] undȱUser[6]ȱausgegeben.ȱ

Paralleleȱ Zählschleifenȱ

ZurȱKonstruktionȱeinesȱFeldesȱvonȱparallelenȱProzessenȱkannȱderȱRepȬ likatorȱauchȱbeimȱPARȬKonstruktȱbenutztȱwerden.ȱ

Programmȱ3Ȭ 19:ȱParalleleȱ Zählschleifeȱ

PAR i = 0 FOR n Pi DieȱparalleleȱZählschleifeȱführtȱeinȱFeldȱvonȱnȱgleichenȱProzessenȱpaȬ rallelȱaus.ȱDerȱIndexȱi hatȱdenȱWertȱ0,1,...,ȱnȬ1ȱinȱP0,ȱP1,ȱ…, Pn-1. PAR i = 3 FOR 4 User [i] ! Message DieȱparalleleȱZählschleifeȱgibtȱdieȱBotschaftȱMessageȱparallelȱüberȱdieȱ einzelnenȱKanäleȱUser [3]ȱbisȱUser [6]ȱaus.

3.4.3.2.4 Prozeduren EineȱProzedurdefinitionȱdefiniertȱeinenȱNamenȱfürȱeinenȱProzess.ȱDieȱ formalenȱParameterȱfolgenȱinȱKlammernȱdemȱProzedurnamen:ȱ PROC Name (Formalpar1, Formalpar2, . . . ) P : AnȱParameterübergabeartenȱstehenȱWertȬȱ(VAL)ȱundȱReferenzübergaȬ beȱzurȱVerfügung.ȱȱ ȱ

224ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ PROC Writes (CHAN of BYTE Stream, VAL [] Byte String) SEQ I = 0 FOR SIZE String Stream ! String[i] :

Programmȱ3Ȭ20:ȱ Prozedurȱ

EineȱProzedurȱkannȱdurchȱAngabeȱdesȱProzedurnamensȱundȱderȱaktuȬ ellenȱParameterȱaufgerufenȱwerden:ȱ SEQ . . . Writes(Screen, “Hello world“ -- Ruft die in Programm 3- spezifizierte Prozedur auf . . .

Programmȱ3Ȭ21:ȱ ProzeduraufȬ rufȱ

3.4.3.2.5 Konfiguration EinȱOccamȬProgrammȱlässtȱsichȱentwederȱaufȱeinemȱProzessorȱ(TransȬ puter)ȱ oderȱ fürȱ vieleȱ Prozessorenȱ (Transputernetz)ȱ konfigurieren.ȱ Dasȱ logischeȱ Verhaltenȱ desȱ Programmesȱ ändertȱ sichȱ dabeiȱ nicht,ȱ jedochȱ verbessertȱsichȱdasȱLaufzeitverhaltenȱmitȱderȱAnzahlȱderȱverwendetenȱ Prozessoren.ȱȱ Zurȱ Ausführungȱ aufȱ einemȱ Multiprozessorsystemȱ stehtȱ das PLACED PAR-KonstruktȱzurȱVerfügung: PLACED PAR PROCESSOR 1 P1 PROCESSOR 2 P2 PROCESSOR 3 P3 . . . Dieȱ einzelnenȱ Prozesse P1, P2, P3, … werdenȱ aufȱ denȱ entspreȬ chendenȱProzessorenȱausgeführt.ȱȱ Entsprechendȱ zurȱ parallelenȱ Schleifeȱ gibtȱ esȱ einȱ paralleles PLACED PAR: PLACED PAR i = 0 FOR n PROCESSOR i Pi

225ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ Zurȱ Festlegung,ȱ welcherȱ logischeȱ Kanalȱ einemȱ physikalischenȱ Kanalȱ entspricht,ȱdientȱPLACE: PLACE Name AT expr:

3.4.3.3 Parallel Virtual Machine (PVM) DieȱParallelȱVirtualȱMachineȱ(PVM)ȱbestehtȱausȱdreiȱTeilen:ȱ 1.ȱDerȱPVMȬDämonȱ(pvmd3),ȱumȱmehrereȱRechnerȱzuȱeinemȱvirtuellenȱ Parallelrechnerȱ zusammenzuschließen.ȱ Derȱ Dämonȱ aufȱ jedemȱ Rechnerȱ istȱ dasȱ Steuerungsmodulȱ fürȱ dieȱ Tasksȱ undȱ bildetȱ dieȱ Kommunikationȱ derȱ zwischenȱ denȱ PVMȬProgrammenȱ (Tasks)ȱ aufȱ TCP/IPȱ oderȱ UDPȱ (sieheȱ nachfolgendenȱ Abschnittȱ 3.4.4.1ȱ TCP/IPȬ Sockets)ȱab.ȱȱ 2.ȱ Dieȱ Bibliothekȱ libpvm3.aȱ zumȱ Zweckeȱ desȱ NachrichtenaustauȬ schesȱ undȱ derȱ Verwaltungȱ vonȱ Prozessen.ȱ Wirȱ gehenȱ nachfolgendȱ nurȱ aufȱ dieȱ PVMȬRoutinenȱ fürȱ dieȱ Spracheȱ Cȱ undȱ dieȱ CȬNotationȱ ein.ȱȱ 3.ȱDieȱPVMȬKonsoleȱȱmitȱKommandosȱzuȱInstallation,ȱStarten,ȱBeenden,ȱ Erweiterungȱ undȱ Einschränkung,ȱ Überwachungȱ undȱ Anzeigeȱ vonȱ Informationenȱ derȱ Parallelȱ Virtualȱ Machine.ȱ XPVMȱ stelltȱ einȱ graȬ phischesȱInterfaceȱfürȱdieȱPVMȬKonsoleȱzurȱVerfügung.ȱXPVMȱentȬ hältȱ mehrereȱ animierteȱ Darstellungenȱ zurȱ Beobachtungȱ undȱ zumȱ DebuggenȱderȱAusführungȱvonȱPVMȬProgrammen.ȱȱ

3.4.3.3.1 Dämon-Prozesse Daemonȱ pvmdȱ

Aufȱ jedemȱ anȱ derȱ parallelenȱ virtuellenȱ Maschineȱ beteiligtenȱ Rechnerȱ läuftȱimȱHintergrundȱeinȱDämonȬProzessȱpvmd3.ȱDerȱDämonȱläuftȱalsȱ normalerȱBenutzerȬProzess,ȱderȱmitȱdenȱPVMȬProgrammenȱmittelsȱderȱ PVMȬBibliotheksroutinenȱkommuniziert.ȱDieȱDämoneȱkommunizierenȱ ihrerseitsȱ untereinanderȱ undȱ vermittelnȱ dieȱ Datenübertragungenȱ zwiȬ schenȱdenȱTasks.ȱȱ DasȱKommandoȱȱ pvmd mytoplogy&

MasterȬȱundȱ SlaveȬ Dämoneȱ

226ȱ

startetȱ denȱ DämonȬProzess,ȱ derȱ auchȱ alsȱ MasterȬDämonȱ bezeichnetȱ wird.ȱDieȱanderenȱheißenȱSlaveȬDämone.ȱDasȱArgumentȱfürȱpvmd,ȱderȱ sogannteȱ Hostfileȱ mytopology,ȱ definiertȱ dieȱ anȱ dieserȱ parallelenȱ virtuellenȱ Maschineȱ beteiligtenȱ Rechner.ȱ ȱ Derȱ MasterȬDämonȱ startetȱ alleȱ benötigtenȱ Dämoneȱ (Slaves)ȱ aufȱ allenȱ verlangtenȱ Rechnern.ȱ ObȬ wohlȱalleȱDämoneȱgleichberechtigtȱsind,ȱistȱnurȱderȱMasterȱinȱderȱLageȱ zurȱparallelenȱvirtuellenȱMaschineȱRechnerȱhinzuzufügenȱundȱzuȱentȬ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ fernen.ȱAußerdemȱprotokolliertȱderȱMasterȱalleȱPVMȬFehlermeldungenȱ inȱeineȱLogȬDatei.ȱ Dasȱ Startenȱ vonȱ remoteȱ Tasksȱ geschiehtȱ mitȱ sshȱ (secureȱ Shell)ȱ mitȱ DSA/RSAȱ Authentifizierungȱ viaȱ privateȱ oderȱ publicȱ Schlüssel.ȱ Diesȱ kannȱ auchȱ aufȱ unsichereȱ Artȱ geschehenȱ mitȱ rshȱ (remoteȱ shell)ȱ undȱ EinträgenȱfürȱalleȱRechnerȱinȱderȱDateiȱ.rhosts.ȱȱ ÜberȱdenȱZustandȱderȱDämoneȱundȱderȱTasksȱkannȱmanȱsichȱmitȱderȱ PVMȬKonsoleȱ informieren.ȱ Einigeȱ Beispielkommandosȱ sind:ȱ help,ȱ conf,ȱ ps, add , delete , spawn undȱhalt.ȱ

3.4.3.3.2 Task Erzeugung und Start BeimȱPVMȬModellȱbestehtȱdieȱApplikationȱausȱTasks.ȱDieȱTasksȱerlauȬ benȱeineȱParallelisierungȱdesȱProblemsȱentwederȱ x

durchȱ eineȱ funktionaleȱ Zerlegungȱ (Jedeȱ Taskȱ führtȱ eineȱ andereȱ Funktionȱaus,ȱsieheȱAbschnittȱ4.2.2.1ȱFunktionaleȱZerlegung)ȱoderȱȱ

x

durchȱeineȱDatenzerlegungȱ(DieȱTasksȱsindȱgleich,ȱaberȱjedeȱTasksȱ bearbeitetȱnurȱeinȱTeilȱderȱDaten,ȱsieheȱAbschnittȱ4.2.2.2ȱDatenzerȬ legung)ȱoderȱ

x

durchȱ eineȱ Mischungȱ derȱ beidenȱ obigenȱ Methodenȱ (sieheȱ AbȬ schnittȱ4.2.2.3ȱFunktionsȬȱundȱDatenzerlegung).ȱ

Alleȱ Tasksȱ werdenȱ identifiziertȱ durchȱ einenȱ Taskȱ Identifierȱ (tid)ȱ vomȱ Typȱ 32Bitȱ Integer.ȱ Nachrichtenȱ werdenȱ vonȱ einerȱ tidȱ gesendetȱ undȱ empfangen.ȱ Dieȱ tidsȱ sindȱ eindeutigȱ überȱ dieȱ kompletteȱ Virtuelleȱ MaȬ schineȱundȱsindȱnichtȱdurchȱdenȱBenutzerȱwählbar.ȱEinȱlokalerȱDämonȱ erzeugtȱ dieȱ tid.ȱ Dieȱ tidȱ bestehtȱ ausȱ mehrerenȱ Feldernȱ undȱ enthältȱ verschiedensteȱ Informationen,ȱ wieȱ z.B.ȱ dieȱ Adresseȱ desȱ lokalenȱ DäȬ monsȱundȱdieȱNummerȱderȱzugewiesenenȱCPU.ȱȱ

tidȱ

Zurȱ Laufzeitȱ kannȱ eineȱ Taskȱ erzeugtȱ undȱ gestartetȱ werdenȱ mitȱ derȱ Routineȱȱ int numt = pvm_spawn (char *task, char **argv, int flag, char *where, int ntask, int *tids)

pvm_spawn

DieȱRoutineȱstartetȱntaskȱKopienȱdesȱausführbarenȱProgrammsȱtask (NamenȱderȱausführbarenȱDatei).ȱȱZumȱStartenȱaufȱeinemȱspezifischenȱ

227ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ Rechnerȱ mussȱ inȱ derȱ Variablenȱ flagȱ derȱ Wertȱ PvmTaskHostȱ undȱ inȱ derȱ Variablenȱ whereȱ derȱ Hostnameȱ desȱ Rechnersȱ stehen.ȱ Entscheidetȱ PVMȱ selbst,ȱ welcherȱ Prozessȱ dieȱ Taskȱ erhält,ȱ mussȱ flagȱ denȱ Wertȱ PvmTaskDefaultȱ erhalten.ȱ tidsȱ enthaltenȱ dieȱeinzelnenȱ TaskidentiȬ fikatoren.ȱ Derȱ Rückgabewertȱ numtȱ enthältȱ dieȱ Anzhalȱderȱ gestartetenȱ ȱȱ Tasks.ȱIstȱderȱWertȱnegativ,ȱkamȱesȱzuȱeinemȱFehler.ȱȱ ȱ pvm_killȱ

EineȱvonȱUnixȱübernommeneȱMethodeȱistȱdasȱSendenȱvonȱSignalenȱanȱ Prozesse.ȱSoȱkannȱeineȱTaskȱmitȱeinemȱKillȬSignalȱterminiertȱwerden:ȱ int info = pvm_kill (int tid)

pvm_sendsigȱ

DasȱSendenȱeinesȱbeliebigenȱSignalsȱanȱeineȱandereȱTaskȱgeschiehtȱmitȱ int info = pvm_sendsig (int tid, int signum) DabeiȱistȱsignumȱdieȱIntegerȱSignalȬNummer.ȱ Dieȱ Beendigungȱ derȱ eigenenȱ Taskȱ undȱ dieȱ Mitteilungȱ anȱ denȱ Dämonȱ geschiehtȱmitȱ

pvm_exitȱ

int info = pvm_exit (void) Demȱpvm_exitȱmussȱnatürlichȱnochȱeinȱexit()ȱzurȱBeendigungȱderȱ Taskȱfolgen.ȱȱ ZurȱErmittelungȱderȱtidȱderȱeigenenȱTaskȱdientȱ

pvm_mytidȱ

int tid = pvm_mytid (void) Istȱ dieȱ Taskȱ nichtȱ durchȱ pvm_spawnȱ erzeugtȱ worden,ȱ soȱ generiertȱ pvm-mytidȱ eineȱ neueȱ eindeutigeȱ tidȱ undȱ übergibtȱ Sieȱ demȱ PVMȬ System.ȱȱ

pvm_parentȱ

ZurȱErmittelungȱderȱtidȱderȱTask,ȱwelcheȱdieȱTaskȱgestartetȱhat,ȱdientȱ int tid = pvm_parent (void)

3.4.3.3.3 Hinzufügen und Entfernen von Rechnern

pvm_addhostȱȱ ȱ ȱ pvm_delhostȱ

228ȱ

Durchȱ pvm_spawnȱ undȱ pvm_kill lassenȱ sichȱ Tasksȱ dynamisch,ȱ zurȱ Laufzeit,ȱ zuȱ derȱ PVMȱ hinzufügenȱ undȱ ausȱ dieserȱ entfernen.ȱ Ebensoȱ lassenȱsichȱdynamischȱRechnerȱzuȱderȱPVMȱhinzufügenȱbzw.ȱausȱdieȬ serȱentfernen:ȱ int info = pvm_addhosts (char **hosts, int nhost, int *infos) int info = pvm_delhosts (char **hosts, int nhost, int *infos)

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ DieȱVariableȱhostsȱenthältȱeinȱFeldȱmitȱStrings,ȱinȱdenenȱdieȱNamenȱ derȱRechnerȱstehen,ȱdieȱderȱPVMȱhinzugefügtȱbzw.ȱausȱdieserȱentferntȱ werdenȱ sollen.ȱ Inȱ derȱ Variableȱ nhostȱ stehtȱ dieȱ Anzahlȱ derȱ Rechner,ȱ alsoȱ dieȱ Längeȱ desȱ inȱ hostsȱ übergebenenȱ Feldes.ȱ infosȱ istȱ einȱ Feldȱ mitȱIntegerȬWerten.ȱInȱdiesemȱbefindenȱsichȱdieȱStatusmeldungenȱderȱ neuenȱ bzw.ȱ ehemaligenȱ Hosts.ȱ Positiveȱ Werteȱ sindȱ dieȱ HostȬIdȱ derȱ neuenȱHosts.ȱNegativeȱWerteȱzeigenȱan,ȱdassȱesȱbeiȱderȱAusführungȱzuȱ einemȱFehlerȱgekommenȱist.ȱȱ DieȱHostȬIdȱ(dtid)ȱeinesȱRechners,ȱaufȱdemȱdieȱTaskȱmitȱderȱtidȱläuft,ȱ erhältȱmanȱmitȱ dtid = pvm_tidtohost(tid)

pvm_ȱ tidtohostȱ

3.4.3.3.4 Taskkommunikation PVMȱkenntȱdreiȱverschiedeneȱMethodenȱzurȱTasksynchronisationȱundȱ Kommunikation:ȱȱ 1.ȱSendenȱundȱEmpfangenȱvonȱSignalenȱ(sieheȱAbschnittȱ3.4.3.3.2ȱȱTaskȱ ErzeugungȱundȱStart).ȱ 2.ȱDurchȱSendenȱeinerȱNachrichtȱüberȱeinenȱSendepuffer.ȱ 3.ȱBarrieresynchronisationȱ(sieheȱAbschnittȱ3.4.3.3.6ȱBarrieresynchroniȬ sation).ȱ DieȱeinzelnenȱNachrichtenȱwerdenȱüberȱdieȱvonȱPVMȱvergebeneȱTaskȬ IDȱ(tid)ȱadressiert.ȱEinȱBenutzerȱkannȱaberȱauchȱeinȱselbstȱdefiniertesȱ Kennzeichenȱ (sogenannteȱ mgstags)ȱ vergeben.ȱ Dasȱ Sendenȱ erfolgtȱ inȱ dreiȱSchritten:ȱ

Sendenȱeinerȱ Nachrichtȱ

1.ȱAnlegenȱundȱInitialisierungȱeinesȱSendepuffers,ȱȱ 2.ȱȱSchreibenȱ(Packen)ȱeinerȱNachrichtȱinȱdenȱSendepufferȱundȱ 3.ȱVerschickenȱdesȱSendepufferinhalts.ȱ

AnlegenȱundȱInitialisierungȱdesȱSendepuffersȱȱ DasȱAnlegenȱeinesȱneuenȱSendepuffersȱundȱdieȱFestlegungȱdesȱDatenȬ typsȱgeschiehtȱmitȱ int bufid = pvm_mkbuf (int encoding )

pvm_mkbuf

Einȱ mitȱ pvm_mkbufȱ angelegterȱ Nachrichtenpufferȱ istȱ auchȱ alsȱ SendeȬ pufferȱeinsetzbar.ȱȱ DasȱInitialisierenȱeinesȱSendepuffersȱundȱdieȱFestlegungȱdesȱDatentypsȱ geschiehtȱmitȱ

229ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ pvm_initsendȱ

int bufid = pvm_initsend ( int encoding ) Esȱgenügt,ȱdenȱPufferȱbeimȱmehrmaligenȱSendenȱeinerȱoderȱverschieȬ denerȱNachrichtenȱeinmalȱzuȱinitialisieren.ȱȱ DieȱVariableȱencodingȱlegtȱdenȱNachrichtentypȱfest.ȱMöglicheȱWerteȱ sind:ȱ x

PvmDataDefaultȱ oderȱ 0ȱ fürȱ dasȱ XDRȬFormatȱ (Externalȱ Dataȱ Representation).ȱ Fürȱ heterogeneȱ Rechnerȱ mitȱ unterschiedlichenȱ Datenrepräsentationen,ȱdaȱhierȱKonvertierungenȱstattfindenȱmüsȬ sen.ȱ

x

PvmDataRawȱ oderȱ 1ȱ fürȱ einȱ Hardwareabhängigesȱ Binärformat.ȱ Fürȱ homogeneȱ Rechnerȱ mitȱ gleichenȱ Datenrepräsentationenȱ undȱ somitȱEinsparungȱderȱKonvertierungen.ȱȱ

x

PvmDataInPlaceȱ oderȱ 2, umȱ dieȱ Nachrichtȱ nichtȱ physikalischȱ inȱdenȱSendepufferȱzuȱkopieren,ȱsondernȱnurȱeinenȱZeigerȱaufȱdieȱ NachrichtȱundȱihreȱGrößeȱzuȱsetzen.ȱ

Einȱmitȱpvm_mkbufȱoderȱpvm_initsendȱerzeugterȱNachrichtenpufferȱ entferntȱdieȱRoutineȱ pvm_freebufȱ

int info = pvm_freebuf (int bufid)

Identifikation,ȱ Setzenȱ undȱ Wechselnȱ desȱ SendeȬȱ undȱ EmpȬ fangspuffersȱ ȱ ȱ

Dieȱ Identifikationȱ desȱ aktuellenȱ SendeȬȱ oderȱ Empfangspuffersȱ erhältȱ manȱmitȱȱ

pvmgetsbufȱ pvmgetrbufȱ

int bufid = pvm_getsbuf (void) int bufid = pvm_getrbuf (void)

ȱ ȱ

Existierenȱ mehrereȱ Nachrichtenpuffer,ȱ soȱ kannȱ manȱ denȱ aktivenȱ SenȬ deȬȱbzw.ȱEmpfangspufferȱwechselnȱmitȱ

pvmsetsbufȱ pvmsetrbufȱȱ

int oldbuf = pvm_setsbuf (int bufid) int oldbuf = pvm_setrbuf (int bufid) Dieȱ Variableȱ bufidȱ enthältȱ dieȱ Identifikationȱ desȱ neuenȱ SendeȬȱ bzw.ȱ Empfangspuffers.ȱDerȱRückgabewertȱoldbufȱenthältȱdieȱIdentifikationȱ desȱaltenȱSendeȬȱbzw.ȱEmpfangspuffers.ȱȱ

Pufferverwaltungȱ Bevorȱ eineȱ Nachrichtȱ gesendetȱ bzw.ȱ empfangenȱ werdenȱ kann,ȱ mussȱ dieseȱinȱeinenȱNachrichtenpufferȱgepacktȱwerdenȱbzw.ȱausȱdemȱNachȬ richtenpufferȱ entpacktȱ werden.ȱ Setztȱ manȱ fürȱ TYPEȱ z.B.ȱ dieȱ Typenȱ

230ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ byte, double, float, int, uint, longȱundȱshort,ȱsoȱhabenȱ dieȱ Routinenȱ fürȱ dasȱ Packenȱ fürȱ dieseȱ Typenȱ undȱ denȱ Typȱ stringȱ folgendesȱAussehen:ȱ int info = pvm_pkTYPE (TYPE *xp, int nitem, int stride)

pvm_pkTYPEȱ pvm_pkstrȱ

int info = pvm_pkstr (char *p) Jedeȱ pvm_pkTYPEȬRoutineȱ packtȱ Felderȱ desȱ Datentypsȱ TYPEȱ inȱ denȱ aktuellenȱSendepuffer,ȱnitemsȱElementeȱwerdenȱverpackt.ȱSieȱwerdenȱ einemȱFeldȱ(*xp)ȱentnommen,ȱinȱdemȱsieȱimȱAbstandȱstrideȱaufeinȬ anderȱfolgen.ȱDaȱpvm_pkstr()ȱperȱDefinitionȱeineȱmitȱNULLȱbegrenzȬ teȱ Zeichenketteȱ packt,ȱ benötigtȱ dieserȱ Aufrufȱ nichtȱ dieȱ Argumenteȱ nitemȱundȱstride.ȱȱ Entsprechendȱ zuȱ denȱ Verpackungsroutinenȱ sehenȱ dieȱ EntpackungsȬ routinenȱaus:ȱ int info = pvm_upkTYPE (TYPE *p, int nitem, int stride) int info = pvm_upkstr (char *p)

pvm_upkTYP Eȱpvm_upkstrȱ

Jedeȱ pvm_upkTYPEȬRoutineȱ packtȱ Datenȱ ausȱ demȱ aktivenȱ EmpfangsȬ pufferȱaus.ȱnitemsȱElementeȱwerdenȱausgepacktȱundȱeinemȱFeldȱ(*p)ȱ imȱAbstandȱstrideȱzugewiesen.ȱ Dieȱ Abfolgeȱ derȱ pvm_pkȬAufrufeȱ beimȱ Sendenȱ undȱ derȱ zugehörigenȱ pvm_upkȬAfrufeȱbeimȱEmpfangenȱmussȱunbedingtȱübereinstimmen.ȱȱ

SendenȱundȱEmpfangenȱeinerȱNachrichtȱ Zumȱ Abschickenȱ derȱ verpacktenȱ Nachrichtȱ imȱ aktivenȱ Sendepufferȱ dientȱ int info = pvm_send (int tid, int msgtag)

pvm_sendȱ

DieȱVaraiableȱtidȱgibtȱdieȱTaskȬIDȱdesȱProzessesȱan,ȱfürȱdenȱdieȱNachȬ richtȱ bestimmtȱ ist.ȱ Dieȱ Variableȱ mgstagȱ gibtȱ derȱ Nachrichtȱ eineȱ MarȬ kierungȱ oderȱ einenTagȱ mit,ȱ umȱ denȱ Inhaltȱ derȱNachrichtȱ zuȱ beschreiȬ ben.ȱDieȱNachrichtenkommunikationȱmitȱpvm_sendȱistȱasynchron,ȱd.h.ȱ dieȱsendendeȱTaskȱfährtȱmitȱihrerȱArbeitȱfort,ȱsobaldȱdieȱNachrichtȱaufȱ demȱWegȱzumȱempfangendenȱProzessȱist.ȱȱ Zumȱ Verpackenȱ derȱ Nachrichtȱ inȱ einenȱ Sendepufferȱ undȱ sofortigesȱ Verschickenȱdientȱȱ

231ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ pvm_sendȱ

int info = pvm_psend (int tid, int msgtag, char*buf, int len, int datatype) bufȱenthältȱeinenȱPointerȱaufȱdenȱSendepuffer.ȱlenȱgibtȱdieȱLängeȱdesȱ Sendepuffersȱan.ȱdatatypeȱgibtȱdenȱDatentypȱderȱNachrichtȱan.ȱ

pvm_recvȱ

DerȱEmpfangȱvonȱNachrichtenȱerfolgtȱinȱzweiȱSchritten:ȱ 1.ȱEmpfangenȱderȱNachrichtȱundȱ 2.ȱLesenȱ(Entpacken)ȱderȱNachrichtȱausȱdemȱEmpfangspuffer.ȱ ZumȱEmpfangenȱeinerȱNachrichtȱdientȱȱ int bufid = pvm_recv( int tid, int msgtag) pvm_recvȱ realisiertȱ blockierendesȱ oderȱ synchronesȱ Empfangen,ȱ d.h.ȱ dieȱ Taskȱ blockiertȱ soȱ lange,ȱ bisȱ eineȱ Nachrichtȱ mitȱ demȱ Tagȱ msgtagȱ vonȱ derȱ Taskȱ mitȱ derȱ TaskȬIDȱ tidȱ eintrifft.ȱ Enthaltenȱ dieȱ Variablenȱ tidȱ oderȱ msgtagȱ denȱ Wertȱ -1,ȱ bedeutetȱ dies,ȱ dassȱ allesȱ akzeptiertȱ wird.ȱ Habenȱ tidȱ undȱ msgtagȱ denȱ Wertȱ – 1, soȱ werdenȱ alleȱ NachȬ richtenȱ vonȱ allenȱ Tasksȱ akzeptiert.ȱ Dieȱ Variableȱ bufidȱ enthältȱ denȱ Identifierȱ desȱ neuenȱ aktivenȱ Empfangspuffers.ȱ Nachȱ demȱ Empfangenȱ einerȱNachrichtȱmussȱdieseȱentpacktȱwerdenȱ(sieheȱdazuȱdieȱobenȱbeȬ schriebenenȱEntpackungsroutinen).ȱȱ

3.4.3.3.5 Gruppen FürȱmancheȱApplikationenȱistȱesȱvorteilhaft,ȱdynamischeȱGruppenȱvonȱ Tasksȱzuȱhaben.ȱEinȱPVMȬProgrammȱkannȱdannȱTasksȱdurchȱInstanzȬ nummernȱ 0 – (p-1)ȱ ansprechen,ȱ wobeiȱ pȱ dieȱ Anzahlȱ derȱ Tasksȱ inȱ derȱGruppeȱist.ȱȱ DasȱAufnehmenȱundȱVerlassenȱeinerȱTaskȱinȱbzw.ȱvonȱeinerȱbenutzerȬ benanntenȱGruppeȱgeschiehtȱmitȱ pvm_ȱ

int inum = pvm_joingroup (char *group)

joingroupȱ pvm_lvgroupȱ

int info = pvm_lvgroup (char *group) inum istȱdieȱInstanznummerȱderȱTaskȱinȱdieserȱGruppe.ȱȱ Dieȱ Größeȱ einerȱ Gruppeȱ undȱ dieȱ Instanznummerȱ einerȱ Taskȱ inȱ einerȱ Gruppeȱerhältȱmanȱmitȱ

232ȱ

3.4 Programmiermodelle für verteilten Speicher int size = pvm_gsize (char *group) int inum = pvm_getinst (char *group)

pvm_gsize pvm_getinst

3.4.3.3.6 Barrieresynchronisation und Broadcast Zum Blockieren einer Task, bis eine bestimmte Anzahl (count) von Prozessen einer Gruppe (im Allgemeinen alle Mitglieder einer Gruppe) die Barriere erreicht haben, geschieht mit int info = pvm_barrier (char *group, int count)

pvm_barrier

Jeder Prozess, der pvm_barrier() aufruft, muss den gleichen Zähler count angegeben. Zum Versenden einer Nachricht an alle Gruppenmitglieder dient int info = pvm_bcast ( char *group, int msgtag )

pvm_bcast

pvm-bcast() versieht die Nachricht mit msgtag und sendet sie an alle Tasks in der spezifizierten Gruppe, außer sich selbst. Zur Ausführung einer globalen arithmetischen Operation (z.B. globale Summe oder globales Maximum) über alle Gruppenmitglieder geschieht mit int info = pvm_reduce (void int int int

(*func)(), void *data, nitem, int datatype, msgtag, char *group, root)

pvm_reduce

Das Ergebnis der Reduktionsoperation steht in root. func kann eine vordefinierte Funktion (PvmMax, PvmMin, PvmSum, PvmProduct) oder eine benutzerdefinierte Funktion sein.

3.4.4 Kooperative und nachrichtenbasierte Modelle 3.4.4.1 TCP/IP-Sockets Sockets ermöglichen die Kommunikation zwischen Prozessen, die auf einem System oder zwei getrennten Systemen ablaufen können. Sockets stellen eine Kommunikationsverbindung zwischen Prozessen her. Ein Kommunikationsendpunkt für einen Prozess kann mit dem socket-Aufruf erzeugt werden, der dann einen Deskriptor für den Socket zurückgibt. Da mehrere Kommunikationsprotokolle unterstützt werden, benötigt der socket-Aufruf das zu verwendende Protokoll. Eine Adresse für den Kommunikationsendpunkt lässt sich dann anschließend mit einem bind-Aufruf an den Socket binden. Ein Server-

Kommunikationsstandard unter Unix sind Sockets

Sockets sind Kommunikationsendpunkte

233

3 Programmiermodelle für parallele und verteilte Systeme prozess hört dann an einem Socket mit dem listen-Aufruf das Netz ab. Clientprozesse kommunizieren mit dem Serverprozess über einen weiteren Socket, das andere Ende eines Kommunikationsweges, das sich auf einem anderen Rechner befinden kann. Der Betriebssystemkern hält intern die Verbindungen aufrecht und leitet die Daten vom Client zum Server. Da der Kommunikationsweg zwischen zwei Sockets in beide Richtungen geht, kann auch der Server Daten an den Client senden. Das Senden und Empfangen von Daten geschieht mit write- und read-Systemaufrufen.

Domänen und Socketadressen Das BSD-Unix-System unterstützt verschiedene Kommunikationsnetzwerke, die unterschiedliche Protokolle und verschiedene Adressierungskonventionen benutzen. Sockets, welche die gleiche Protokollfamilie und die gleiche Adressierung benutzen, werden in Domänen (Bereiche) zusammengefasst. BSD-Unix stellt die folgenden Protokollfamilien (Domänen) zur Verfügung: •

Internet-Domain mit den Protokollen TCP, UDP und IP,

•

Xerox-XNS-Domain mit den Protokollen SPP und IDP und

•

Unix-Domain zur Kommunikation von Prozessen auf dem gleichen Rechner (lokale Kommunikation).

Die Adressierungsstruktur in den einzelnen Domänen sieht folgendermaßen aus: Adressierungsstruktur

•

Internet verwendet eine 32-bit-Adresse, welche die Netz-ID und Host-ID angibt, und eine 16-bit-Portnummer, die den Prozess identifiziert.

•

XNS verwendet eine 32-bit-Netz-ID, eine 48-bit-Host-ID und eine 16-bit-Portnummer für die Prozesse.

•

Unix-Domain verwendet zur Identifizierung der Prozesse eindeutige Pfadnamen des UNIX-Dateisystems, die eine Länge von bis zu 108 Bytes aufweisen können.

Viele Socket-Systemaufrufe verlangen einen Zeiger auf eine Adressstruktur, wobei sich diese Strukturen nicht nur dem Aufbau nach, sondern auch der Länge nach unterscheiden. Um mit SocketAdressstrukturen von unterschiedlicher Größe hantieren zu können, wird den Systemaufrufen neben einem Zeiger auf die Struktur auch immer die Größe der Adressstruktur übergeben.

234

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ NichtȱalleȱComputersystemeȱspeichernȱdieȱeinzelnenȱBytesȱvonȱMehrȬ bytegrößenȱinȱderselbenȱReihenfolge.ȱEntwederȱwirdȱmitȱdemȱniederȬ wertigenȱByteȱanȱderȱStartadresseȱbegonnen,ȱwasȱauchȱalsȱlittleȱendianȬ Anordnungȱ bezeichnetȱ wird,ȱ oderȱ manȱ beginntȱ mitȱ demȱ höherwertiȬ genȱByteȱanȱderȱStartadresse,ȱwasȱmanȱauchȱalsȱbigȱendianȬAnordnungȱ bezeichnet.ȱ TCP/IPȱ undȱ XNSȱ verwendenȱ dasȱ bigȱ endianȬFormat.ȱ Zurȱ Transformationȱ derȱ benutzerbezogenenȱ Darstellungȱ inȱ dieȱ NetzwerkȬ darstellungȱstehenȱinȱȱdieȱfolgendenȱFunktionenȱzurȱ Verfügung:ȱ

UmwandȬ lungsȬ funktionenȱ

#include <sys/types.h> u_long htonl (u_long hostlong); u_short htons (u_short hostshort); u_long ntohl (u_long netlong); u_short ntohs (u_short netshort); Dieȱ Buchstabenȱ derȱ Funktionenȱ stehenȱfürȱ dieȱ Bedeutungȱ derȱ jeweiliȬ genȱ Funktion.ȱ Soȱ stehtȱ htonlȱ fürȱ hostȱ toȱ networkȱ longȱ undȱ wandeltȱ einenȱLong-IntegerȬWertȱausȱderȱbenutzerbezogenenȱDarstellungȱinȱ dieȱNetzwerkdarstellungȱum.ȱ Inȱ denȱ verschiedenenȱ SocketȬAdressstrukturenȱ (Internet,ȱ XNS,ȱ UNIX)ȱ existierenȱ unterschiedlicheȱ Bytefelder,ȱ dieȱ alleȱ belegtȱ seinȱ müssen.ȱ Inȱ 4.3ȱ BSDȬUnixȱ stehenȱ deshalbȱ dreiȱ Routinenȱ zurȱ Verfügung,ȱ dieȱ aufȱ benutzerdefiniertenȱ ByteȬStringsȱ basieren.ȱ Unterȱ benutzerdefiniertȱ istȱ zuȱverstehen,ȱdassȱesȱsichȱumȱkeinenȱStandardstringȱinȱCȱhandelt,ȱderȱ bekannterweiseȱ mitȱ einemȱ Nullbyteȱ abschließt.ȱ Dieȱ benutzerdefinierȬ tenȱ ByteȬStringsȱ könnenȱ innerhalbȱ desȱ Stringsȱ durchausȱ Nullbytesȱ besitzen.ȱ Diesȱ beeinflusstȱ jedochȱ nichtȱ dasȱ Endeȱ desȱ Strings.ȱ Deshalbȱ mussȱdieȱLängeȱdesȱStringsȱalsȱArgumentȱmitȱübergebenȱwerden.ȱȱ bcopyȱkopiertȱdieȱangegebeneȱAnzahlȱvonȱBytesȱvonȱeinemȱUrsprungȱ zuȱeinemȱZiel.ȱȱ bzeroȱschreibtȱdieȱangegebeneȱAnzahlȱvonȱNullbytesȱinȱdasȱZiel.ȱȱ Dieȱ Funktionȱ bcmpȱ vergleichtȱ zweiȱ beliebigeȱ ByteȬStringsȱ undȱ liefertȱ null,ȱwennȱbeideȱStringsȱidentischȱsind,ȱansonstenȱungleichȱnull.ȱ bcopy (char *src, char *dest, int nbytes); bzero (char *dest, int nbytes); int bcmp (char *ptr1, char *ptr2, int nbytes);

ȱ ȱ

235ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ

Sockettypenȱ MitȱjedemȱSocketȱassoziiertȱistȱeinȱTyp,ȱderȱdieȱSemantikȱderȱKommuȬ nikationȱ beschreibt.ȱ Derȱ Sockettypȱ bestimmtȱ dieȱ Eigenschaftenȱ derȱ Kommunikation,ȱ wieȱ Zuverlässigkeit,ȱ Ordnungȱ undȱ Duplikationȱ vonȱ Nachrichten.ȱ Folgendeȱ inȱ <sys/socket.h>ȱ definiertenȱ Sockettypenȱ gibtȱes:ȱ #define #define #define #define */

SOCK_DGRAM SOCK_STREAM 2 SOCK_RAW SOCK_SEQPACKET

1 /* datagram */ /* virtual circuit */ 3 /* raw socket */ 4 /* sequenced packet

DatagramȬȱ Socketȱ

SOCK_DGRAMȱ spezifiziertȱ einȱ verbindungslosesȱ Protokoll,ȱ beiȱ demȱ jedeȱNachrichtȱdieȱInformationȱfürȱdenȱTransportȱenthaltenȱmuss.ȱDieȱ übertragenenȱ Nachrichtenȱ heißenȱ dabeiȱ Datagramme.ȱ Einȱ Datagramȱ Socketȱ unterstütztȱ denȱ bidirektionalenȱ Flussȱ derȱ Daten,ȱ sieȱ brauchenȱ jedochȱ nichtȱ inȱ derȱ Reihenfolgeȱ anzukommen,ȱ inȱ derȱ sieȱ abgesendetȱ wurden,ȱ nochȱ müssenȱ sieȱ überhauptȱ denȱ Empfängerȱ erreichen,ȱ nochȱ werdenȱ sieȱ mehrmalsȱ imȱ Fehlerfalleȱ übertragen.ȱ Weiterhinȱ istȱ dieȱ NachrichtenlängeȱbeiȱverbindungslosenȱProtokollenȱaufȱeineȱMaximalȬ längeȱ begrenzt.ȱ Dieserȱ Sockettypȱ wirdȱ deshalbȱ benutztȱ zurȱ ÜbertraȬ gungȱ vonȱ kurzenȱ Nachrichten,ȱ dieȱ keineȱ zuverlässigeȱ Übertragungȱ erfordern.ȱȱ

StreamȬSocketȱ

SOCK_STREAMȱspezifiziertȱeinȱverbindungsorientiertesȱProtokoll,ȱbeiȱ demȱ eineȱ virtuelleȱ Verbindungȱ zwischenȱ zweiȱ Prozessenȱ hergestelltȱ wird.ȱ Einȱ StreamȬSocketȱ erlaubtȱ denȱ bidirektionalenȱ zuverlässigenȱ FlussȱderȱNachrichten,ȱwobeiȱdieȱNachrichtenȱinȱderȱAbsenderreihenȬ folgeȱbeimȱEmpfängerȱankommen.ȱ

RawȬSocketȱȱȱ

SOCK_RAWȱ erlaubtȱ Zugriffȱ aufȱ dasȱ Netzwerkprotokollȱ undȱ seineȱ Schnittstellen.ȱ RawȬSocketsȱ erlaubenȱ damitȱ einerȱ Anwendungȱ denȱ direktenȱZugriffȱaufȱdieȱKommunikationsprotokolle.ȱȱ

PaketȬSocketȱ

SOCK_SEQPACKETȱstelltȱeinenȱzuverlässigenȱPaketȬSocketȱzurȱVerfüȬ gung,ȱbeiȱdemȱdieȱPaketeȱinȱderȱAbsenderreihenfolgeȱankommen.ȱ Nichtȱ alleȱ Kombinationenȱ vonȱ SocketȬFamilieȱ undȱ SocketȬTypȱ sindȱ möglich.ȱ Beiȱ AF_UNIXȱ sindȱ SOCK_DGRAMȱ undȱ SOCK_STREAMȱ erlaubtȱ undȱ beiȱ AF_INETȱ sindȱ SOCK_DGRAMȱ mitȱ demȱ Protokollȱ UDPȱ undȱ SOCK_STREAMȱmitȱdemȱProtokollȱTCPȱundȱSOCK_RAWȱmitȱdemȱProtoȬ kollȱIPȱerlaubt.ȱȱ

236ȱ

3.4 Programmiermodelle für verteilten Speicher Im Folgenden beschränken wir uns auf die Betrachtung von Datagram Sockets (SOCK_DGRAM) und Stream-Sockets (SOCK_STREAM) und das Protokoll AF_INET, d.h. UDP bzw. TCP. Bei der Vorstellung der Systemaufrufe, die im File <sys/socket.h> definiert sind, stellen wir zunächst die Aufrufe für Datagram Sockets vor und anschließend die Aufrufe für Stream-Sockets. Zeit

Prozess 1 (Client)

socket();

Prozess 2 (Server)

socket();

Abb. 3-21: Typische Aufrufabfolge für verbindungslose Kommunikation

bind();

sendto();

recrfrom();

recvfrom();

sendto();

close();

close();

3.3.4.1.1 Datagram Sockets Abbildung 3-21 zeigt eine typische Aufrufabfolge für verbindungslose Client-Server-Kommunikation. Zuerst müssen der Server und der Client mit dem Socket-Systemaufruf einen Kommunikationsendpunkt festlegen. Mit dem Socket-Aufruf wird der Typ des Kommunikationsprotokolls festgelegt, in unserem Fall also SOCK_DGRAM. Im bind-Aufruf des Servers registriert der Server seine Adresse im System, so dass alle Nachrichten mit dieser Adresse an ihn weitergeleitet werden. In dem anschließenden sendto-Aufruf gibt der Client die Adresse des Empfängers (Servers) an, an die er Daten senden will; das bedeutet, der Client kennt die Adresse des Servers. Mit recvfrom auf der Server-Seite erhält der Server die Nachricht und die Adresse des

237

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ Senders,ȱundȱsomitȱdieȱvomȱClientȱabgeschickteȱNachrichtȱundȱdessenȱ Adresse.ȱNebenȱdieserȱAufrufkombinationȱgibtȱesȱnatürlichȱnochȱweiȬ tereȱsinnvolleȱKombinationenȱfürȱverbindungsloseȱKommunikation.ȱ

socketȬSystemaufrufeȱ DerȱersteȱSystemaufrufȱeinesȱProzesses,ȱbevorȱeineȱEinȬȱoderȱAusgabeȱ stattfindet,ȱistȱderȱSocketaufruf.ȱErȱhatȱfolgendesȱAussehen:ȱ socketȱ

#include <sys/types.h> #include <sys/socket.h> int socket (int family, int type, int protocol); Anstelleȱvonȱfamilyȱkannȱstehen:ȱȱ AF_INETȱȱ

fürȱeinȱInternetȬProtokoll,ȱ

AF_NSȱȱȱ

fürȱeinȱXeroxȱNSȬProtokollȱoderȱ

AF_UNIXȱȱ

fürȱeinȱUnixȬinternesȬProtokoll.ȱ

Anstelleȱvonȱtypeȱkannȱstehen:ȱ SOCK_DGRAMȱȱ

fürȱeinenȱDatagramȱSocketȱ(verbindungslos),ȱ

SOCK_STREAMȱ

fürȱeinenȱStreamȱSocketȱ(verbindungsorientiert),ȱ

SOCK_RAWȱ

ȱȱȱȱȱȱȱȱȱfürȱeinenȱRAWȱSocketȱoderȱ

SOCK_SEQPACKETȱȱȱȱȱfürȱeinenȱPacketȱSocket.ȱ protocolȱ wirdȱ benötigt,ȱ fallsȱ spezielleȱ Protokolleȱ benutztȱ werdenȱ sollen.ȱ Dieȱ Konstantenȱ fürȱ dieȱ Protokolleȱ sindȱ inȱ ȱ oderȱ inȱ ȱ definiert.ȱ Inȱ unsererȱ Standardanwendungȱ setzenȱwirȱdenȱWertȱvonȱprotocolȱaufȱNull.ȱȱ Derȱ socketȬAufrufȱ liefertȱ einenȱ kleinenȱ Integerwertȱ zurück,ȱ ähnlichȱ einemȱ Dateideskriptor.ȱ Diesenȱ Wertȱ bezeichnetȱ manȱ deshalbȱ alsȱ sdȱ (socketȱdescriptor)ȱoderȱsockfdȱ(socketȱfileȱdescriptor).ȱȱ

bindȬSystemaufrufȱ Derȱ bindȬSystemaufrufȱ weistȱ einemȱ nochȱ unbekanntenȱ Socketȱ eineȱ Adresseȱzu.ȱȱ bindȱ

238ȱ

#include <sys/types.h> #include <sys/socket.h> int bind (int sockfd, struct sockaddr *myaddr, int addrlen);

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ sockfdȱ istȱ derȱ Socketdeskriptorȱ ausȱ demȱ vorhergehendenȱ socketȬ Systemaufruf.ȱ myaddrȱistȱdieȱmitȱderȱeigenenȱAdresseȱbelegteȱAdressstruktur.ȱȱ addrlenȱgibtȱdieȱLängeȱderȱAdressstrukturȱan.ȱ

sendtoȬȱundȱrecvfromȬSystemaufrufȱ Einȱ Prozess,ȱ derȱ weiß,ȱ anȱ welcheȱ Adresseȱ (Protokoll,ȱ Host,ȱ Port)ȱ undȱ damitȱanȱwelchenȱSocketȱerȱDatenȱsendenȱsoll,ȱverwendetȱdenȱsendtoȬAufruf.ȱIstȱderȱlokaleȱSocketȱvorherȱnichtȱexplizitȱgebundenȱwordenȱ durchȱ bind,ȱ soȱ führtȱ derȱ sendtoȬAufrufȱ einȱ implizitesȱ bindȱ durch.ȱ Dadurchȱ erhältȱ derȱ Socketȱ desȱ Prozessesȱ eineȱ lokaleȱ Adresse.ȱ Einȱ sendtoȱübermitteltȱstetsȱmitȱdenȱDatenȱimplizitȱseineȱlokaleȱAdresse,ȱ dieȱderȱEmpfängerȱmitȱseinemȱzugehörigenȱrecvfromȬAufrufȱinȱeinerȱ geeignetenȱ Strukturȱ ablegt.ȱ sendtoȱ undȱ recvfromȱ sindȱ unsymmetȬ rischȱ inȱ demȱ Sinne,ȱ dassȱ derȱ sendtoȬAufrufȱ denȱ Empfängerȱ kennenȱ muss,ȱ währendȱ derȱ recvfromȬAufrufȱ vonȱ irgendwoherȱ Datenȱ entgeȬ genȱnimmt,ȱundȱanschließendȱdenȱSenderȱkennt.ȱ #include <sys/socket.h> int sendto (int sockfd, char *buff, int nbytes, int flags, struct sockaddr *to, int addrlen); int recvfrom (int sockfd, char *buff, int nbytes, int flags, struct sockaddr *from, int *addrlen);

sendtoȱ

recvfromȱ

sockfdȱistȱderȱSocketdeskriptor.ȱ buffȱistȱeinȱPufferȱzurȱAufnahmeȱderȱzuȱsendendenȱbzw.ȱempfangenȬ denȱDaten.ȱ nbytesȱgibtȱdieȱAnzahlȱderȱBytesȱimȱPufferȱan.ȱ flagsȱ betrifftȱ dasȱ Routingȱ beimȱ sendtoȱ undȱ wirdȱ aufȱ nullȱ gesetzt.ȱ BeimȱrecvfromȱgestattetȱderȱParameterȱeinȱvorausschauendesȱLesen,ȱ einȱLesenȱohneȱdieȱDatenȱausȱdemȱSocketȱzuȱentfernen.ȱDasȱbedeutet,ȱ derȱ nächsteȱ recvfromȬAufrufȱ erhältȱ dieȱ gleichenȱ Datenȱ nochȱ einmalȱ undȱ liestȱ sieȱ so,ȱ alsȱ wärenȱ sieȱ zuvorȱ nichtȱ gelesenȱ worden.ȱ Diesȱ wirdȱ erreichtȱdurchȱSetzenȱdesȱFlagsȱmitȱderȱKonstantenȱMSG_PEEK.ȱȱ toȱenthältȱdieȱvorbesetzteȱAdresseȱdesȱEmpfängers.ȱ fromȱdientȱzurȱAufnahmeȱderȱAdresseȱdesȱSenders.ȱ

239ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ addrlenȱgibtȱdieȱLängeȱderȱAdressstrukturȱdesȱEmpfängersȱan,ȱbzw.ȱ dientȱ zurȱ Aufnahmeȱ derȱ Längeȱ derȱ Adressstrukturȱ desȱ Sendersȱ beimȱ Empfänger.ȱȱȱ DieȱFunktionenȱgebenȱdieȱLängeȱderȱDatenȱzurück,ȱdieȱgesendetȱoderȱ empfangenȱwurden.ȱȱ

closeȬSystemaufrufȱȱ DerȱcloseȱSystemaufrufȱschließtȱeinenȱSocket.ȱ closeȱ

#include <sys/socket.h> int close (int sockfd); sockfdȱistȱderȱSocketdeskriptor.ȱ

NetzwerkȬHilfsfunktionenȱ Mitȱ einerȱ ganzenȱ Reiheȱ vonȱ Hilfsfunktionenȱ könnenȱ Informationenȱ überȱ denȱ Host,ȱ überȱ Netzwerknamenȱ undȱ überȱ Protokollnamenȱ imȱ Internetȱ eingeholtȱ werden.ȱ Dieseȱ Funktionenȱ liegenȱ inȱ ,ȱ dieȱDatenbasisȱfürȱdieseȱFunktionenȱliegenȱinȱdenȱVerwaltungsdateienȱ /etc/hosts,ȱ /etc/networksȱ undȱ /etc/protocols.ȱ Alsȱ Beispielȱ fürȱalleȱanderenȱFunktionenȱbetrachtenȱwirȱimȱFolgendenȱdieȱFunktionȱ gethostbynameȱ genauer.ȱ gethostbynameȱ liefertȱ fürȱ einenȱ HostnaȬ menȱeineȱStrukturȱzurück,ȱwelcheȱdieȱInternetȬAdresseȱenthält.ȱȱ #include struct hostent *gethostbyname (char *host); struct hostent {char *h_name; char *h_aliases[]; int h_addrtype; int h_length; char **h_addr_list; };

gethostbyȬȱ nameȱ

#define h_addr h_addr_list[0] hostȱȱ ȱ

istȱderȱNameȱdesȱHost.ȱ

h_nameȱȱ

ȱ

h_aliasesȱ

enthältȱalleȱAliasnamenȱdesȱHost.ȱ

istȱderȱoffizielleȱNamenȱdesȱHost.ȱ

h_addrtypeȱȱ istȱderȱAdresstypȱdesȱHostȱ(z.B.ȱAF_INET).ȱ h_lengthȱȱȱ

240ȱ

gibtȱ dieȱ Längeȱ derȱ Adresseȱ an;ȱ beiȱ AF_INETȱ istȱ dieȱ AdresslängeȱvierȱBytes.ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ h_addr_listȱȱenthältȱalleȱInternetȬAdressen.ȱ h_addrȱȱ

istȱ dieȱ ersteȱ undȱ meistensȱ auchȱ dieȱ einzigeȱ InternetȬ Adresse.ȱ

3.4.4.1.2 Anwendungsbeispiel echo-serving DatagramȱSocketsȱdienenȱnurȱzumȱVersendenȱvonȱkurzenȱBotschaftenȱ (unzuverlässigeȱ Datenübertragung).ȱ Dasȱ folgendeȱ Beispiel,ȱ dasȱ ausȱ demȱ Buchȱ vonȱ Stevensȱ [Sȱ 92]ȱ entnommenȱ wurde,ȱ zeigtȱ deshalbȱ nur,ȱ wieȱ eineȱ Nachrichtȱ anȱ denȱ Serverȱ geschicktȱ wirdȱ undȱ derȱ Serverȱ dieȱ empfangeneȱ Nachrichtȱ wiederȱ anȱ denȱ Clientȱ zurückschicktȱ (echoȬ serving).ȱȱ DenȱPortȱdesȱServersȱhabenȱwirȱdabeiȱdurchȱeineȱdefineȬDirektiveȱfestȬ gelegt;ȱerȱhatȱdieȱPortnummerȱ7777.ȱ Dieȱ Maschinenadresseȱ fürȱ denȱ Socketȱ kannȱ irgendeineȱ gültigeȱ NetzȬ werkadresseȱsein.ȱBesitztȱdieȱMaschineȱmehrȱalsȱeineȱAdresse,ȱsoȱkannȱ irgendeineȱ mitȱ derȱ „wildcard“ȬAdresseȱ INADDR_ANYȱ (Konstanteȱ inȱ )ȱ gewähltȱ werden.ȱ Fallsȱ eineȱ „wildcard“ȬAdresseȱ gewähltȱ wurde,ȱ soȱ kannȱ nurȱ vonȱ INADRR_ANY,ȱ d.h.ȱ vonȱ irgendeinerȱ Adresseȱ derȱ Maschineȱ empfangenȱ werden,ȱ manȱ kannȱ jedochȱ nichtȱ anȱ irgendeineȱ Adresseȱ etwasȱ senden.ȱ Deshalbȱ bestimmtȱ derȱ Senderȱ (Client)ȱinȱnachfolgendemȱBeispielȱdieȱAdresseȱdesȱSendersȱdurchȱdieȱ Hilfsfunktionȱgethostbyname().ȱȱ EinȱDatagramȬServerȱhatȱdannȱfolgendesȱAussehen:ȱ /* This program creates a datagram socket,binds a name to it, reads from the socket and sends back the data, which was read from socket. */ #include #include #include #include

Programmȱ3Ȭ 22:ȱDatagramȬ Serverȱ

<stdio.h> <sys/types.h> <sys/socket.h>

#define S_PORT 7777

/* server port */

main() { int sd, /* socket descriptor */ addrlen_client; /* length of address(sender) */ struct sockaddr_in client, server;

241ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ char buf[1024]; /* buffer for receiving and sending data */ /* Create socket from which to read. */ sd = socket (AF_INET, SOCK_DGRAM, 0); if (sd < 0) { perror("opening datagram socket"); exit(1); } /* Create name with wildcards */ server.sin_family = AF_INET; server.sin_port = htons(S_PORT); server.sin_addr.s_addr = htonl(INADDR_ANY); if (bind (sd, (struct sockaddr*)&server, sizeof(server)) < 0) { perror ("binding datagram socket"); exit(1); } bzero(buf,sizeof(buf)); /* clear buffer */ addrlen_client = sizeof(client); /* set addrlen */ /* Wait and read from socket. */ if (recvfrom(sd, buf, sizeof(buf), 0, (struct sockaddr*)&client,&addrlen_client) < 0) { perror("receiving datagram message "); exit(1); } /* Send data back (echo). */ if (sendto(sd, buf, sizeof(buf), 0, (struct sockaddr *)&client, sizeof(client)) < 0) { perror("sending datagram message "); exit(1); } /* Close socket. */ close(sd);

242ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ exit(0); } EinȱClient,ȱderȱDatenȱanȱdenȱServerȱschicktȱundȱdannȱdieseȱDatenȱwieȬ derȱvomȱServerȱzurückbekommt,ȱhatȱfolgendesȱAussehen:ȱ /* This program dgramsend sends a datagram to a receiver whose name is retrieved from the command line argument. The form of the command line is: dgramsend hostname portnumber */ #include #include #include #include #include

Programmȱ3Ȭ 23:ȱClientȱfürȱ DatagramȬ Serverȱ

<stdio.h> <sys/types.h> <sys/socket.h>

#define DATA "Please echo the data ..." main(argc, argv) int argc; char *argv[]; { int sd, /* socket descriptor */ addrlen_server; /* length of address (sender) */ struct sockaddr_in server; struct hostent *hp, *gethostbyname(); char buf[1024]; /* buffer for receiving data */ /* Create socket on which to send. */ sd = socket (AF_INET, SOCK_DGRAM, 0); if (sd < 0) { perror("opening datagram socket"); exit(1); } /* Construct name with no wildcards, of the socket to send to. gethostbyname returns a structure including the network address of the specified host. The port number is taken from the command line. */

243ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ hp = gethostbyname(argv[1]); if (hp == 0) { fprintf(stderr, "%s: unknown host\n", argv[1]); exit(2); } server.sin_family = AF_INET; /* Copy network address into server address. */ bcopy((char *)hp->h_addr, (char *)&server.sin_addr, hp->h_length); /* Get port number from command line argument. */ server.sin_port = htons(atoi(argv[2])); /* Send data. */ if (sendto( sd, DATA, sizeof(DATA), 0, (struct sockaddr *)&server, sizeof(server)) < 0) { perror("sending datagram message "); exit(1); } /* Get back data (echo). */ if (recvfrom( sd, buf, sizeof(buf), 0, (struct sockaddr *)&server, &addrlen_server) < 0) { perror("receiving datagram message "); exit(1); } /* Close socket. */ close (sd); exit(0); }ȱ ȱ

244ȱ

3.4 Programmiermodelle für verteilten Speicher

3.4.4.1.3 Stream-Sockets Nachfolgende Abbildung 3-22 zeigt einen typischen Ablauf einer verbindungsorientierten Kommunikation. Der Socket-Aufruf legt wieder den Kommunikationsendpunkt fest, jetzt jedoch mit verbindungsorientierter Kommunikation d.h. mit dem Parameter SOCK_STREAM. Damit ein Prozess zum Server wird und mehrere Clients bedienen kann, muss er den listen-Aufruf absetzen. Mit listen wird der Socket zu einem hörenden Socket und kann damit die Verbindungswünsche der Clients abhören. Abb. 3-22: Typische Aufrufabfolge für verbindungsorientierte Kommunikation

Bevor Daten zwischen Stream-Sockets austauschbar sind, müssen beide Sockets miteinander verbunden werden. Die Aufrufe accept und connect stellen diese Verbindung her. Beide Aufrufe realisieren ein unsymmetrisches Rendezvous. Unsymmetrisch deshalb, weil es nur stattfindet, wenn der Server zeitlich vor dem Client sein accept startet. Am accept wird der Server dann blockiert und er wartet auf den Client. Dessen connect führt das Rendezvous herbei. Startet der

245

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ ClientȱseinȱconnectȱzeitlichȱvorȱdemȱacceptȱdesȱServers,ȱsoȱkommtȱ keinȱRendezvousȱzustande.ȱDasȱconnectȱkommtȱmitȱeinerȱFehlermelȬ dungȱzurück.ȱ Stehtȱ dieȱ Verbindungȱ zwischenȱ Clientȱ undȱServer,ȱkönȬ nenȱ beideȱ mitȱ readȱ undȱ writeȱ Datenȱ austauschen.ȱ Dieȱ Verbindungȱ wirdȱdannȱaufgelöst,ȱwennȱeinerȱderȱSocketsȱgeschlossenȱ(close)ȱwird.ȱȱ

ȱ

listenȬSystemaufrufȱ Derȱ listenȬSystemaufrufȱ zeigtȱ dieȱ Empfangsbereitschaftȱ desȱServersȱ bezüglichȱeinerȱVerbindungȱan,ȱundȱaußerdemȱwirdȱeineȱWarteschlanȬ geȱfürȱdieȱVerbindungenȱvonȱClientsȱeingerichtet.ȱErȱwirdȱgewöhnlichȱ nachȱdemȱsocketȬȱundȱbindȬAufrufȱverwendetȱundȱunmittelbarȱvorȱ denȱacceptsȱfürȱdieȱClients.ȱȱ listenȱ

#include <sys/socket.h> int listen (int sockfd, int backlog); sockfd istȱderȱSocketdeskriptor.ȱ ȱ backlogȱ gibtȱ dieȱ Anzahlȱ derȱ möglichenȱ Verbindungsanforderungenȱ wieder,ȱ dieȱ maximalȱ inȱ dieȱ Warteschlangeȱ gestelltȱ werdenȱ können.ȱ DieserȱWertȱwirdȱnormalerweiseȱmitȱfünfȱangegeben,ȱdemȱderzeitigenȱ Höchstwert.ȱ

acceptȬSystemaufrufȱ NachdemȱderȱServerȱdenȱlistenȬAufrufȱausgeführtȱhat,ȱwartetȱerȱmitȱ einemȱ acceptȬAufrufȱ aufȱ eineȱ aktuelleȱ Verbindungȱ vonȱ einigenȱ Clientprozessen.ȱ acceptȱ nimmtȱ dieȱ ersteȱ Anforderungȱ inȱ derȱ WarteȬ schlange,ȱ dupliziertȱ denȱ alsȱ Parameterȱ angegebenenȱ Socketdeskriptorȱ undȱgibtȱdenȱSocketdeskriptorȱdesȱDuplikatsȱalsȱFunktionswertȱzurück.ȱ ÜberȱdiesenȱneuenȱSocketdeskriptorȱwirdȱdieȱVerbindungȱzumȱClientȱ hergestellt.ȱ Stehenȱ keineȱ Verbindungsanforderungenȱ mehrȱ an,ȱ d.h.ȱ istȱ dieȱ Warteschlangeȱ leer,ȱ wartetȱ derȱ acceptȬausführendeȱ Prozess,ȱ bisȱ eineȱAnforderungȱankommt.ȱȱ acceptȱ ȱ ȱ

#include <sys/types.h> #include <sys/sockets.h> int accept (int sockfd, struct sockaddr *peer, int *addrlen); sockfdȱistȱderȱSocketdeskriptor.ȱ peerȱ dientȱ zurȱ Aufnahmeȱ derȱ Adressstrukturȱ desȱ Clients,ȱ dieȱ beimȱ connectȬAufrufȱdesȱClientsȱgefülltȱwird.ȱMitȱHilfeȱdiesesȱParametersȱ kannȱderȱServerȱdenȱNamenȱdesȱClientsȱherausfinden.ȱInteressiertȱsichȱ

246ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ derȱServerȱnichtȱfürȱdenȱClientȱundȱsomitȱfürȱdenȱNamenȱdesȱClients,ȱ kannȱmanȱeinenȱNullpointerȱfürȱdiesenȱParameterȱangeben.ȱ addrlenȱ dientȱ zurȱ Aufnahmeȱ derȱ Längeȱ derȱ Adressstrukturȱ desȱ Clients.ȱ Istȱ fürȱ denȱ Serverȱ derȱ Clientȱ uninteressant,ȱ kannȱ erȱ ebenfallsȱ hierȱeinenȱNullpointerȱangeben.ȱNormalerweiseȱblockiertȱdasȱacceptȱ denȱServer,ȱundȱesȱwirdȱgewartet,ȱbisȱdieȱVerbindungȱhergestelltȱist.ȱEsȱ gibtȱ beimȱ acceptȬAufrufȱ keineȱ Möglichkeitȱ anzugeben,ȱ dassȱ nurȱ beȬ stimmteȱ Verbindungenȱ akzeptiertȱ werden.ȱ Dadurchȱ obliegtȱ esȱ demȱ Servercode,ȱdieȱVerbindungȱzuȱanalysierenȱundȱdieȱVerbindungȱabzuȬ brechen,ȱfallsȱderȱServerȱnichtȱmitȱdemȱProzessȱsprechenȱmöchte.ȱ

connectȬSystemaufrufȱ MitȱdemȱconnectȬAufrufȱkannȱeinȱClientȱeineȱVerbindungȱmitȱeinemȱ ServerȬSocketȱherstellen.ȱDazuȱmussȱderȱClientȱdieȱAdresseȱ(Protokoll,ȱ Hostname,ȱ Port)ȱ desȱ Serversȱ kennen.ȱ Kommtȱ dieȱ Verbindungȱ nichtȱ zustande,ȱsoȱliefertȱconnectȱeinenȱFehlercodeȱzurück.ȱWirdȱmitȱeinemȱ ungebundenenȱ Socketȱ (vorherȱ wurdeȱ keinȱ bindȱ durchgeführt)ȱ derȱ connectȬAufrufȱausgeführt,ȱsoȱfindetȱdurchȱdasȱconnectȱeineȱlokaleȱ Adressbindungȱ stattȱ (implizitesȱ bind)ȱ mitȱ anschließenderȱ ÜbertraȬ gungȱdieserȱAdresseȱanȱdenȱServer.ȱȱ #include <sys/types.h> #include <sys/sockets.h> int connect(int sockfd, struct sockaddr *servaddr, int addrlen);

connectȱ

sockfdȱistȱderȱSocketdeskriptor.ȱȱ servaddrȱistȱdieȱvorbesetzteȱAdresseȱdesȱServersȱ addrlenȱgibtȱdieȱLängeȱderȱAdressstrukturȱan.ȱ

readȬȱundȱwriteȬSystemaufrufȱȱ Stehtȱ dieȱ Verbindungȱ zwischenȱ einemȱ Serverȱ undȱ einemȱ Client,ȱ könȬ nenȱmitȱreadȱundȱwriteȱDatenȱausgetauschtȱwerden.ȱȱ #include <sys/sockets.h> int read (int sockfd, char *buff, int nbytes);

readȱȱ

int write (int sockfd, char *buff, int nbytes);

writeȱ

sockfdȱistȱderȱSocketdeskriptor.ȱȱ buffȱistȱeinȱPufferȱfürȱdieȱzuȱschreibendenȱbzw.ȱzuȱlesendenȱDaten.ȱ nbytesȱgibtȱdieȱAnzahlȱderȱBytesȱimȱPufferȱan.ȱ

247ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ Zusätzlichȱ zuȱ readȱ undȱ writeȱ könnenȱ dieȱ Aufrufeȱ sendȱ undȱ recvȱ verwendetȱ werden.ȱ Dieseȱ Aufrufeȱ unterscheidenȱ sichȱ vonȱ readȱ undȱ writeȱdurchȱeinȱzusätzlichesȱFlag,ȱdasȱgesetztȱwerdenȱkann.ȱDasȱFlagȱ hatȱdabeiȱdieȱgleicheȱBedeutungȱwieȱbeimȱsendtoȱundȱrecvfromȱfürȱ verbindungsloseȱSockets.ȱ sendȱȱ

recvȱ

#include <sys/sockets.h> int send (int sockfd,char *buff, int nbytes, int flags); int recv (int sockfd, char *buff, int nbytes, int flags);

3.4.4.1.4 Anwendungsbeispiel rlogin Dasȱ folgendeȱ Beispiel,ȱ dasȱ wiederȱ ausȱ demȱ Buchȱ vonȱ Stevensȱ [Sȱ 92]ȱ entnommenȱ wurde,ȱ zeigtȱ einenȱ Client,ȱ derȱ einȱ remoteȱ loginȱ aufȱ einerȱ anderenȱ Maschineȱ ausführt.ȱ Dabeiȱ benutztȱ erȱ dieȱ NetzwerkȬ Hilfsfunktionȱ getservbyname,ȱ welcheȱ denȱ Servicenamenȱ undȱ optioȬ nalȱeinȱqualifizierendesȱProtokoll,ȱaufȱdieȱStrukturȱserventȱabbildet.ȱ Programmȱ3Ȭ25:ȱ remoteȱloginȱ Clientȱ

/* This program rlogin realize a remote login on another machine which is retrieved from the command line argument. The form of the command line is: rlogin hostname */ #include #include #include #include #include

<stdio.h> <sys/types.h> <sys/socket.h>

main(argc, argv) int argc; char *argv[]; { int sd; /* socket descriptor */ struct sockaddr_in server; struct hostent *hp, *gethostbyname(); struct servent *sp, *getservbyname(); /* Create socket. */ sd = socket (AF_INET, SOCK_STREAM, 0); if (sd < 0)

248ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ { perror("rlogin: socket "); exit(1); } /* Get destination host with gethostbyname()call. */ hp = gethostbyname(argv[1]) if (hp == 0) { fprintf(stderr, "%s: unknown host \n", argv[1]); exit(2); } /* Locate the service definition for a remote login with getservbyname() call */ sp = getservbyname("login", "tcp"); if (sp == 0) { fprintf(stderr, "tcp login: unknown service \n"); exit(3); } server.sin_family = AF_INET; /* Copy network address into server address. bcopy((char *) hp->h_addr, (char*)&server.sin_addr, hp->h_length); /* Set port-number of server. */ server.sin_port = sp->s_port;

*/

/* Connect to server; connect does bind for us. */ if (connect(sd, (struct sockaddr *)&server, sizeof(server)) < 0) { perror ("rlogin: connect "); exit(4); } /* Details of the remote login protocol will not be considered here.*/ /* ... */

249ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ close(sd); exit(0); } EinȱServerȱfürȱmehrereȱremoteȱloginȬClientsȱhatȱfolgendenȱCode:ȱ Programmȱ3Ȭ 26:ȱremoteȱ loginȱServerȱ

#include #include #include #include #include

<stdio.h> <sys/types.h> <sys/socket.h>

main() { int sd; /* socket descriptor */ struct sockaddr_in server, client; struct servent * sp, *getservbyname(); /* Create socket. */ sd = socket (AF_INET, SOCK_STREAM, 0); if (sd < 0) { perror("rlogin: socket "); exit(1); } /* Locate the service definition for a remote login with getservbyname() call */ sp = getservbyname("login", "tcp"); if (sp == 0) { fprintf(stderr, "tcp login: unknown service \n"); exit(2); } /* Details to disassociate server from controlling terminal will not be considered here. */ /* ... */ server.sin_family = AF_INET; server.sin_addr.s_addr = htonl(INADDR_ANY); server.sin_port = sp->s_port;

250ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ /* Server-Socket gets address. */ if bind(sd, (struct sockaddr*)&server, sizeof(server)) < 0) { syslog(LOG_ERR, "rlogin: bind"); exit(3); } listen (sd, 5); for (;;) { int nsd;/* new socket descriptor for accept */ int addrlen_client = sizeof(client); nsd = accept(sd, (struct sockaddr *) &client, &addrlen_client); if (nsd < 0) { syslog(LOG_ERR, "rlogin: accept "); continue; } /* Parallel server, create child */ if (fork() == 0) { /* child */ close(sd); /* close socket of parent */ doit(nsd, &client); /* Does details of the remote login protocol. */ } /* parent */ close(nsd); } exit(0); }

3.4.4.2 Java Message Service (JMS) DasȱApplicationȱProgrammingȱInterfaceȱ(API)ȱfürȱdenȱMessageȬServerȱ istȱvonȱSunȱMicrosystemsȱspezifiziertȱundȱdieȱWeiterentwicklungȱundȱ VersionsverwaltungȱliegtȱebenfallsȱinȱdenȱHändenȱvonȱSun.ȱEinȱQuickȱ Referenceȱ Guideȱ fürȱ dieȱ JMSȱ APIȱ istȱ inȱ MonsonȬHaefelȱ undȱ Chappelȱ [MCȱ01]ȱimȱAnhangȱenthaltenȱoderȱkannȱvonȱSunȱMicrosystemsȱdirektȱ bezogenȱ werden.ȱ Dieȱ nachfolgendeȱ Beschreibungȱ derȱ JMSȱ APIȱ unterȬ teiltȱ sieȱ zunächstȱ inȱ dieȱ fürȱ Nachrichtenȱ (Message)ȱ zuständigeȱ APIȱ

251ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ undȱdannȱinȱeinemȱzweitenȱSchrittȱinȱdieȱAPIȱfürȱJMSȬClientsȱ(ProduȬ cerȱundȱConsumer).ȱȱ

3.4.4.2.1 Message API PTPȬȱ oderȱ Pub/SubȬNachrichtenȱ werdenȱ inȱ einerȱ Warteschlangeȱ (QueueȱoderȱTopic)ȱbeimȱMessageȬServerȱabgelegtȱundȱsindȱvomȱTypȱ javax.jms.Message.ȱEineȱNachrichtȱ(Message)ȱhatȱdreiȱTeile:ȱ headerȱ

252ȱ

1.

Nachrichtenkopfȱ (header):ȱ Erȱ enthältȱ Datenȱ überȱ denȱ NachrichȬ tenȬErzeuger,ȱ wannȱ wurdeȱ dieȱ Nachrichtȱ angelegt,ȱ wieȱ langeȱ istȱ dieȱNachrichtȱgültig,ȱeindeutigerȱIdentifikatorȱderȱNachricht,ȱusw.ȱ Einȱ Nachrichtenkopf,ȱ derȱ seinenȱ Wertȱ automatischȱ vomȱ JMSȱ ProȬ viderȱzugewiesenȱbekommt,ȱkannȱvonȱeinerȱApplikationȱmitȱgetȬ Methodenȱ abgefragtȱ undȱ mitȱ setȬMethodenȱ gesetztȱ werden.ȱ AuȬ tomatischȱzugewieseneȱNachrichtenköpfeȱsind:ȱȱ x

JMSDestination:ȱIdentifiziertȱdasȱZielȱ(QueueȱoderȱTopic).ȱ

x

JMSDeliveryMode:ȱ PERSISTENTȱ oderȱ NON_PERSISTENTȱ Speicherungȱ derȱ Nachricht;ȱ dientȱ zurȱ Unterscheidungȱ derȱ exactlyȱonceȱoderȱatȱmostȱonceȬSemantik.ȱ

x

JMSMessageID:ȱEindeutigeȱIdentifikationȱderȱNachricht.ȱȱ

x

JMSTimestamp:ȱZeitpunktȱdesȱAufrufesȱderȱsendȬMethode.ȱ

x

JMSExpiration:ȱVerfallszeitȱderȱNachrichtȱinȱMillisekunden;ȱ kannȱmitȱsetTimeToLive()ȱgesetztȱwerden.ȱ

x

JMSRedelivered:ȱ Boolescherȱ Wertȱ fürȱ erneutesȱ Sendenȱ derȱ NachrichtȱanȱdenȱConsumer.ȱ

x

JMSPriority:ȱ Wertȱ vonȱ 0ȱ –ȱ 9ȱ zumȱ Setzenȱ derȱ Prioritätȱ derȱ AuslieferungȱderȱNachrichtȱanȱdenȱConsumer.ȱȱ

x

Nebenȱ denȱ automatischȱ gesetztenȱ Nachrichtenköpfenȱ gibtȱ esȱ dieȱfolgendenȱNachrichtenköpfe,ȱdieȱdurchȱdenȱAnwenderȱmitȱ derȱsetȬMethodeȱexplizitȱzuȱsetzenȱsind:ȱȱ

x

JMSReplyTo: Ziel,ȱ anȱ dasȱ derȱ Consumerȱ eineȱ Rückantwortȱ anȱdenȱProducerȱschickenȱkann. ȱ

x

JMSCorrelationID: Assoziationȱ derȱ Nachrichtȱ mitȱ einerȱ vorhergehendenȱ Nachrichtȱ oderȱ einemȱ applikationsspezifiȬ schenȱIdentifier.ȱȱ

x

JMSType:ȱ Dientȱ zurȱ Identifikationȱ derȱ Nachrichtenstrukturȱ undȱlegtȱdenȱTypȱderȱNutzdatenȱfest.ȱȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ 2.

Eigenschaftenȱ (property): Eigenschaftenȱ sindȱ zusätzlicheȱ Header,ȱ dieȱ einerȱ Nachrichtȱ zugewiesenȱ werdenȱ können.ȱ Sieȱ lieȬ fernȱ genauereȱ Informationȱ überȱ eineȱ Nachricht.ȱ Mitȱ ZugriffsmeȬ thodenȱ (get)ȱ könnenȱ sieȱ gelesenȱ undȱ mitȱ Änderungsoperationenȱ (set, clear)ȱkönnenȱsieȱgeschriebenȱwerden.ȱDerȱWertȱeinerȱEiȬ genschaftȱ kannȱ vomȱ Typȱ String, boolean, byte, double, int, longȱoderȱfloatȱsein.ȱ

3.

Nutzdatenȱ (payload):ȱ Sieȱ könnenȱ abhängigȱ vomȱ transportiertenȱ InhaltȱunterschiedlichenȱTypȱhaben.ȱȱ DieȱsechsȱMessageȬInterfacesȱsind:ȱȱ x

MessageȱistȱdieȱeinfachsteȱFormȱeinerȱNachrichtȱundȱdientȱalsȱ BasisȱfürȱdieȱanderenȱNachrichtentypen.ȱDieȱNachrichtȱenthältȱ keineȱ Nutzdatenȱ undȱ kannȱ somitȱ nurȱ zurȱ EreignisübermitȬ telungȱ benutztȱ werden,ȱ undȱ einȱ Consumerȱ kannȱ mitȱ OnMessage(Message message)ȱdaraufȱreagieren.ȱȱ

x

TextMessageȱ beinhaltetȱ eineȱ einfacheȱ Zeichenkette,ȱ welcheȱ überȱ dieȱ Methodenȱ setText(String payload)ȱ undȱ Stringȱ getText()ȱ verwaltetȱ wird.ȱ Sieȱ dientȱ zurȱ ÜbertraȬ gungȱ vonȱ Textnachrichtenȱ undȱ auchȱ komplexerenȱ CharacterȬ Daten,ȱwieȱbeispielsweiseȱXMLȬDokumente.ȱ

x

ObjectMessageȱ kannȱ serialisierbareȱ JavaȬObjekteȱ transporȬ tieren.ȱ Dieȱ entsprechendenȱ Zugriffsfunktionenȱ sindȱ setObject(java.io.serializable payload)ȱ undȱ java.io.serializable getObject().ȱȱ

x

BytesMessageȱ transportiertȱ einenȱ Bytestrom,ȱ derȱ typischerȬ weiseȱzumȱUmverpackenȱbestehenderȱNachrichtenformateȱgeȬ nutztȱwird.ȱDieȱMethodenȱdesȱBytesMessageȬInterfaceȱentspreȬ chenȱ denȱ Methodenȱ inȱ denȱ I/OȬKlassenȱ java.io.DataInputStream undȱ java.io.DataOutputStream.ȱȱ

x

StreamMessageȱ arbeitetȱ mitȱ einemȱ Stromȱ primitiverȱ DatenȬ typenȱ (int,ȱdouble, char,ȱ etc.).ȱ DieȱMethodenȱ desȱ StreamȬ MessageȬInterfaceȱsindȱwrite()ȱundȱread().ȱ

x

MapMessageȱ kannȱ keyȬvalueȬPaareȱ unterschiedlichenȱ Typsȱ transportieren,ȱwelcheȱüberȱeinȱSchlüsselȬWertȬPaarȱlokalisiertȱ werden.ȱEsȱexistierenȱZugriffsmethodenȱfürȱdieȱmeistenȱDatenȬ typen,ȱwieȱbeispielsweiseȱfloat getFloat (String key) und setFloat(String key, float value).ȱ

propertyȱȱ

payloadȱ

MessageȬȱ Interfacesȱ

ȱ

253ȱ

3 Programmiermodelle für parallele und verteilte Systeme Abb. 3-23: Interfaces für PtP und Pub/Sub

PtP

Pub/Sub ConnectionFactory

QueueConnectionFactory

TopicConnectionFactory Connection

ConnectionMetaData

QueueConnection

TopicConnection

Session QueueSession

TopicSession

Message

Destination Queue

TemporaryQueue

Topic

TemporaryTopic

MessageProducer

QueueSender

TopicPubisher MessageConsumer

QueueReceiver

TopicSubscriber MessageListener

QueueBrowser

254

ExceptionListener

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ

3.4.4.2.2 Producer Consumer API Nebenȱ derȱ obenȱ beschriebenenȱ MessageȬAPIȱ istȱ dieȱ restlicheȱ JMSȬAPIȱ zweigeteiltȱ fürȱ PTPȬȱ undȱ Pub/SubȬKommunikation,ȱ wieȱ nachfolgendeȱ Abbildungȱ 3Ȭ23ȱ zeigt.ȱ Durchgezogeneȱ Pfeileȱ zeigenȱ dieȱ Erweiterungȱ desȱInterfaceȱanȱ(extends)ȱundȱdieȱgestricheltenȱPfeileȱzeigen,ȱwelchesȱ Interfaceȱ welchesȱ Objektȱ (createȬ)ȱ erzeugt.ȱ Dieȱ gepunkteteȱ undȱ geȬ strichtelteȱ Linieȱ zeigenȱ an,ȱ dassȱ dieȱ createȬFunktionȱ einȱ QueueȬ Objektȱ zurückgibt.ȱ Dieȱ dickereȱ Umrandungȱ fürȱ denȱMessageListenerȱ undȱ denȱ ExceptionListenerȱ zeigenȱ an,ȱ dassȱ dieseȱ Interfacesȱ durchȱdenȱEntwicklerȱimplementiertȱwerdenȱmüssenȱ(implements).ȱ

ConnectionFactory,ȱ QueueConnectionFactory,ȱ TopicConnectiȬ onFactoryȱ DasȱInterfaceȱConnectionFactoryȱistȱleerȱundȱkannȱvonȱeinemȱJMSȬȱ Providerȱunterschiedlichȱimplementiertȱwerden,ȱz.ȱB.ȱfürȱeinȱspeziellesȱ Protokollȱ dasȱ benutztȱ wird,ȱ oderȱ fürȱ eineȱ Verbindung,ȱ derȱ einȱ beȬ stimmtesȱSicherheitsprotokollȱzuȱGrundeȱliegt.ȱConnectionFactoryȱ dientȱalsȱBasisinterfaceȱfürȱQueueConnectionFactoryȱundȱTopicConnectionFactory. QueueConnectionFactory besitztȱzweiȱüberlagerteȱFunktionenȱ QueueConnection createQueueConnection() und QueueConnection createQueueConnection ( String username, String password) zumȱAnlegenȱeinerȱPTPȬVerbindung.ȱ

createQueue Connectionȱ

Wieȱ beiȱ PTPȬVerbindungenȱ besitztȱ TopicConnectionFactoryȱ dieȱ zweiȱüberlagertenȱFunktionenȱ TopicConnection createTopicConnection() und TopicConnection createTopicConnection (String username, String password)

CreateTopic Connectionȱ

zumȱAnlegenȱeinerȱPub/SubȬVerbindung.ȱ

Connectionȱ Einȱ ConnectionȬObjektȱ repräsentiertȱ eineȱ physikalischeȱ Verbindungȱ einerȱ PTPȬȱ (QueueConnection)ȱ oderȱ Pub/SubȬVerbindungȱ (TopicConnection).ȱ Einȱ JMSȬClientȱ kannȱ vieleȱ Verbindungenȱ vonȱ einerȱ ConnectionFactoryȱanlegen.ȱJedochȱistȱdiesesȱVerfahrenȱaufwändig,ȱ daȱ jedeȱ Verbindungȱ einenȱ eigenenȱ Socketȱ benötigt,ȱ I/OȬStreams,ȱ SpeiȬ cher,ȱ etc.ȱ Esȱ istȱ effizienter,ȱ mehrereȱ SessionȬObjekteȱ vomȱ gleichenȱ

255ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ ConnectionȬObjektȱ anzulegen,ȱ daȱ eineȱ Sitzungȱ dieȱ gleicheȱ VerbinȬ dungȱgemeinsamȱbenutzenȱkann.ȱȱ ConnectionȱdefiniertȱeinigeȱallgemeineȱMethoden,ȱdieȱeinȱJMSȬClientȱ benutzenȱkann.ȱUnterȱanderemȱdieȱMethodenȱȱ GetMetaData,ȱ start,ȱȱȱȱȱȱȱȱȱȱ stop,ȱȱȱȱȱȱȱȱȱ closeȱ

ConnectionMetaData getMetadata(), void start(), void stop() und void close(). Mitȱ einerȱ Connectionȱ lässtȱ sichȱ einȱ ExceptionListenerȱ assoziieȬ ren.ȱDazuȱdienenȱdieȱfolgendenȱgetȬȱundȱsetȬFunktionenȱ

getȬ,ȱ setExceptionȱ Listenerȱ

ExceptionListener getExceptionListener() und setExceptionListener(ExceptionListener listener).

getȬ,ȱ setClientIDȱ

String getClientID() und setClientID(String ClientID).

NebenȱeinemȱExceptionListenerȱkannȱmitȱeinerȱConnectionȱeinȱ IdentifierȱfürȱdenȱClientȱmitȱgetȬȱundȱsetȬFunktionenȱassoziiertȱwerden:ȱ

ConnectionMetaDataȱ ConnectionMetaDataȱ stelltȱ getȬMethodenȱ zurȱ Gewinnungȱ vonȱ Informationȱ bereit,ȱ welcheȱ dieȱ JMSȬVersionȱ undȱ denȱ JMSȬProviderȱ beschreiben.ȱ Dieȱ Informationȱ enthältȱ beispielsweiseȱ dieȱ Identitätȱ desȱ JMSȬProvider,ȱ dieȱ unterstützteȱ JMSȬVersionȱ undȱ dieȱ JMSȬProviderȬ Versionsnummer.ȱȱ

QueueConnectionȱ QueueConnectionȱ repräsentiertȱ eineȱ eindeutigeȱ Verbindungȱ desȱ ProducersȱzumȱMessageȬServer.ȱDieȱMethodeȱ createQueueȱ Sessionȱ

QueueSession createQueueSession (boolean transacted, int acknowledgeMode) erzeugtȱeineȱSessionȱundȱ

createConnect ionConsumerȱ

ConnectionConsumer createConnectionConsumer (Queue queue, String messageSelector, ServerSessionPool sessionPool, int maxMessages) erzeugtȱeineȱVerbindungȱfürȱdenȱConsumer.ȱ ȱ

256ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ

TopicConnectionȱ TopicConnectionȱ repräsentiertȱ eineȱ eindeutigeȱ Verbindungȱ zumȱ MessageȬServer.ȱDieȱMethodeȱȱ TopicSession createTopicSession (boolean transacted, int acknowledgeMode)

createTopic Sessionȱ

erzeugtȱeineȱTopicSessionȱundȱ ȱ ConnectionConsumer createConnectionConsumer (Topic topic, String messageSelector, ServerSessionPool sessionPool, int maxMessages)

createConnect ionConsumerȱ

erzeugtȱeineȱVerbindungȱfürȱdenȱConsumer.ȱZumȱAnlegenȱeinerȱdauȬ erhaftenȱVerbindungȱ(überlebtȱdieȱLebenszeitȱdesȱConsumerȱundȱwirdȱ dauerhaftȱbeimȱJMSȬServerȱgespeichert)ȱdient:ȱ ConnectionConsumer createDurableConnectionConsumer (Topic topic, String subscriptionsName, String messageSelector, ServerSessionPool sessionPool, int maxMessages)

createDurable Connectionȱ Consumerȱ

Sessionȱ EinȱSessionȬObjektȱistȱeinȱKontextȱbestehendȱausȱeinemȱThreadȱzumȱ ProduzierenȱundȱzumȱKonsumierenȱderȱNachricht.ȱSessionȱerweitertȱ somitȱdasȱjava.lang.Runnable-Interface.ȱSessionȱlegtȱMessageȬ ObjekteȱfürȱdenȱConsumerȱundȱProducerȱan.ȱDieȱMethodenȱumfassenȱ sechsȱ createMessage()ȬMethodenȱ ȱ (eineȱ fürȱ jedenȱ Typȱ einesȱ MessageȬObjekts).ȱImȱEinzelnenȱsindȱdasȱdieȱfolgendenȱMethoden:ȱ Message createMessage (), BytesMessage createBytesMessage (), MapMessage createMapMessage (), ObjectMessage createObjectMessage(), ObjectMessage createObjectMessage( Serializable object), StreamMessage createStreamMessage (), TextMessage createTextMessage () und TextMessage createTextMessage (String Text).

Create...ȱ Messageȱ

257ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ DerȱSessionȬManagerȱüberwachtȱdenȱBereichȱderȱTransaktionenȱumȱ dieȱsendȬȱundȱreceiveȬOperationenȱmitȱdenȱMethodenȱȱ getTransacted,ȱ commit,ȱ rollback,ȱȱ close,ȱȱȱȱ recoverȱ

getȬ,ȱ setMessageȬ Listenerȱ

boolean getTransacted (), void commit (), void rollback (), void close () und void recover (). FürȱasynchronesȱEmpfangenȱkannȱeineȱSessionȱeinȱMessageListenerȱaufsetzenȱmitȱdenȱMethodenȱ MessageListener getMessageListener () und setMessageListener (MessageListener listener). Derȱ SessionȬManagerȱ serialisiertȱ dannȱ dasȱ Ausliefernȱ derȱ NachrichȬ tenȱ anȱ einȱ MessageListenerȬObjekt.ȱ Bezüglichȱ Serialisierenȱ vonȱ ObjektenȱsieheȱAbschnittȱ3.3.5.7.4.ȱ

QueueSessionȱ EinȱClientȱkannȱmehrereȱQueueSessionȬObjekteȱzurȱfeinerenȱGranuȬ laritätȱvonȱSendernȱundȱEmpfängernȱanlegen.ȱQueueSessionȱenthältȱ eineȱMethodeȱzumȱInspizierenȱeinerȱQueueȱ createQueueȱ

Queue createQueue (String queueName) undȱzumȱAnlegenȱeinerȱtemporärenȱQueueȱmitȱ

CreateȬ TemporaryȬ Queueȱ

TemporaryQueue createTemporaryQueue (). Dieȱ obigeȱ Funktionȱ createQueueȱ dientȱ nichtȱ zumȱ Anlegenȱ einerȱ Queueȱ beimȱ MessageȬServer,ȱ sondernȱ esȱ wirdȱ einȱ QueueȬObjekt,ȱ dasȱ eineȱ bestehendeȱ Queueȱ beimȱ MessageȬServerȱ repräsentiert,ȱ zurückgeȬ geben.ȱDieȱQueueȱselbstȱmussȱdurchȱeinȱVerwaltungsȬToolȱdesȱProviȬ dersȱ beimȱ Setupȱ oderȱ Konfigurierenȱ desȱ MessageȬȱ Serverȱ angelegtȱ werden.ȱȱ Zumȱ Anlegenȱ einesȱ QueueSenderȬObjektsȱ undȱ einesȱ QueueReceiverȬObjektsȱstehenȱdieȱfolgendenȱMethodenȱbereit:ȱ

CreateSenderȱȱ ȬReceiverȱ

QueueSender createSender (Queue queue), QueueReceiver createReceiver (Queue queue) und QueueReceiver createReceiver (Queue queue, String messageSelector). EineȱQueueȱkannȱmitȱeinenȱBrowserȱinspiziertȱwerden.ȱDieȱMethoden,ȱ welcheȱeineȱQueueBrowserȱerzeugen,ȱsind:ȱ

258ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ QueueBrowser createBrowser(Queue queue) undȱ QueueBrowser createBrowser (Queue queue, String messageSelector).

CreateȬ Browserȱ

TopicSessionȱ EinȱClientȱkann,ȱwieȱbeiȱQueueSession,ȱwiederȱmehrereȱTopicSessionȬObjekteȱanlegenȱfürȱmehrereȱPublisherȱundȱSubscriber.ȱ Die MethodenȱzumȱAnlegenȱeinesȱTopic sind: Topic createTopic (String TopicName) undȱeinesȱtemporärenȱTopic TemporaryTopic createTemporaryTopic().

createTopic createȬ TemporaryȬ Topicȱ

ZumȱAnlegenȱeinesȱTopicPublisherȬObjektsȱdientȱ TopicPublisher createPublisher(Topic topic), DieȱMethodenȱzumȱAnlegenȱeinesȱTopicSubscriberȬObjekts sind: TopicSubscriber createSubscriber (Topic topic), TopicSubscriber createSubscriber(Topic topic, String messageSelector, boolean nolocal)

createȬ Publisherȱ CreateȬ Subscriberȱ

undȱfürȱdauerhafteȱSubscriberȱȱ TopicSubscriber createDurableSubscriber (Topic topic, String name) undȱȱ

createDurable ȬSubscriberȱ

TopicSubscriber createDurableSubscriber(Topic topic, String name, String messageSelector, boolean Nolocal). MitȱunscribeȱwirdȱdasȱInteresseȱanȱdemȱTopicȱgelöscht.ȱ void unscribe (String name);

unscribeȱ

Destination,ȱQueue,ȱTopicȱȱ Destinationȱ istȱ einȱleeresȱ Interface,ȱwelchesȱ durchȱ Queueȱundȱ Topicȱerweitertȱwird.ȱQueueȱundȱTopicȱsindȱdurchȱdenȱMessageȬServerȱ verwalteteȱObjekte.ȱSieȱdienenȱalsȱHandleȱoderȱIdentifierȱfürȱeineȱaktuȬ elleȱQueueȱ(physicalȱqueue,ȱphysicalȱtopic)ȱbeimȱMessageȬServer.ȱ

259ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ Eineȱ Physicalȱ Queueȱ istȱ einȱ Kanalȱ vonȱ demȱ vieleȱ Clientsȱ Nachrichtenȱ empfangenȱ undȱ sendenȱ können.ȱ Mehrereȱ Empfängerȱ könnenȱ sichȱ zuȱ einerȱ Queueȱ verbinden,ȱ aberȱ eineȱ Nachrichtȱ inȱ derȱ Queueȱ kannȱ nurȱ vonȱeinemȱEmpfängerȱkonsumiertȱwerden.ȱNachrichtenȱinȱderȱQueueȱ sindȱgeordnet,ȱundȱConsumerȱerhaltenȱdieȱNachrichtȱinȱderȱvomȱMesȬ sageȬServerȱfestgelegtenȱOrdnung.ȱ DasȱInterfaceȱQueueȱbesitztȱdieȱfolgendenȱbeidenȱMethoden:ȱ getQueueȬ Name,ȱ toStringȱ

String getQueueName () undȱ String toString (). Einȱ Physicalȱ Topicȱ istȱ einȱ Kanal,ȱ vonȱ demȱ vieleȱ Clientsȱ Nachrichtenȱ beziehenȱ(subscribe)ȱundȱsieȱabonnierenȱkönnen.ȱLiefertȱeinȱClientȱeineȱ NachrichtȱbeimȱTopicȱabȱ(publish),ȱsoȱerhaltenȱalleȱClientsȱdieȱNachȬ richt,ȱdieȱsieȱabonniertȱhaben.ȱȱ DasȱInterfaceȱTopicȱbesitztȱdieȱfolgendenȱbeidenȱMethoden:ȱ

getTopicȬȱ Name,ȱ toStringȱ

String getTopicName () undȱ String toString ().

TemporaryQueue,ȱTemporaryTopicȱ TemporaryQueueȱ undȱ TemporaryTopicȱ sindȱ nurȱ aktivȱ währendȱ eineȱSessionȱzuȱihrȱverbundenȱist,ȱalsoȱsoȱlangeȱnochȱeineȱVerbindungȱ derȱQueueȱoderȱdesȱTopicȱzuȱeinemȱClientȱbesteht.ȱDaȱeineȱtemporäreȱ Queueȱ oderȱ Topicȱ vonȱ einemȱ JMSȬClientȱ angelegtȱ wird,ȱ istȱ eineȱ Queueȱbzw.ȱeinȱTopicȱnichtȱfürȱandereȱJMSȬClientsȱverfügbar.ȱUmȱsieȱ fürȱeinenȱanderenȱJMSȬClientȱverfügbarȱzuȱmachen,ȱmussȱerȱdieȱIdentiȬ tätȱderȱQueueȱoderȱdesȱTopicȱimȱJMSReplyToȱHeaderȱerhalten.ȱȱ Dieȱ beidenȱ Interfacesȱ TemporayQueueȱ undȱ TemporaryTopicȱ besitȬ zenȱnurȱeineȱMethodeȱȱ deleteȱ

void delete ()ȱȱ zumȱLöschenȱderȱQueueȱbzw.ȱdesȱTopic.ȱ

MessageProducerȱ DerȱMessageProducerȱsendetȱeineȱNachrichtȱanȱeinȱTopicȱoderȱeineȱ Queue.ȱ Dasȱ Interfaceȱ definiertȱ dieȱ folgendenȱ getȬMethodenȱ undȱ dieȱ dazuȱkorrespondierendenȱsetȬMethoden:ȱȱ get...ȱ

260ȱ

boolean getDisableMessageID(), boolean getDisableMessageTimestamp(), int getDeliveryMode (),

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ int getPriority (), long getTimeToLive () und void setDisableMessageID (boolean value), void setDisableMessageTimestamp (boolean value), void setDeliveryMode (int deliveryMode), void setPriority (int defaultPriority), setTimeToLive (long timetolive).

setȱ...ȱ

ZumȱBeendenȱdesȱSendensȱdientȱȱ

closeȱ

void close ().ȱ

QueueSenderȱ Nachrichten,ȱ dieȱ vonȱ einemȱ QueueSenderȱ anȱ eineȱ Queueȱ gesendetȱ werden,ȱ erhältȱ derȱ Client,ȱ derȱ mitȱ dieserȱ Queueȱ verbundenȱ ist.ȱ Dasȱ InterfaceȱQueueSenderȱenhältȱeineȱMethode:ȱ Queue getQueue()

getQueueȱ

WeiterhinȱdieȱfolgendenȱvierȱüberlagertenȱsendȬMethoden:ȱȱ void send (Message message), void send(Queue queue, Message message), void send(Message message, int deliveryMode, int priority, long timeToLive), void send(Queue queue, Message message, int deliveryMode, int Priority, long timeToLive),

sendȱ

TopicPublisherȱ Nachrichten,ȱdieȱvonȱeinenȱTopicPublisherȱanȱeinȱTopicȱgesendetȱ werden,ȱwerdenȱkopiertȱundȱanȱalleȱClientsȱgesendet,ȱdieȱsichȱmitȱdieȬ semȱTopicȱverbundenȱhaben.ȱȱ DasȱInterfaceȱTopicPublisherȱenhältȱeineȱMethodeȱ Topic getTopic().

getTopicȱ

WeiterhinȱdieȱfolgendenȱvierȱüberlagertenȱpublishȬMethoden:ȱ void publish(Message message), void publish(Topic topic, Message message), void publish(Message message,

publishȱ

261ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ int deliveryMode, int priority, long timeToLive), void publish(Topic topic, Message message, int deliveryMode, int Priority, long timeToLive),

MessageConsumerȱ MessageConsumerȱ könnenȱ dieȱ Nachrichtȱ asynchronȱ oderȱ synchronȱ konsumieren.ȱUmȱsieȱasynchronȱzuȱkonsumieren,ȱmussȱeinȱJMSȬClientȱ einȱMessageListenerȬObjektȱzurȱVerfügungȱstellen,ȱd.h.ȱerȱmussȱdasȱ InterfaceȱMessageListenerȱimplementieren.ȱȱ Mitȱȱ getMessageȬ Listenerȱ

MessageListener getMessageListener()

setMessageȬ Listenerȱ

setMessageListener(MessageListener listener)ȱȱ

kannȱ derȱ Consumerȱ sichȱ denȱ MessageListenerȱ gebenȱ lassenȱ undȱ mitȱȱ

kannȱerȱihnȱsetzen.ȱȱ Zumȱ synchronenȱ Konsumierenȱ einerȱ Messageȱ kannȱ einȱ JMSȬClientȱ einerȱderȱMethodenȱȱ

receiveȱ

Message receive(), Message receive(long timeout) oderȱ Message receiveNoWait() aufrufen.ȱ ZumȱBeendenȱdesȱEmpfangensȱdientȱȱ

closeȱ

void close().ȱ

QueueReceiverȱ Jedeȱ Messageȱ inȱ einerȱ Queueȱ wirdȱ nurȱ anȱ einenȱ QueueReceiverȱ ausgeliefert.ȱVieleȱEmpfängerȱkönnenȱsichȱmitȱeinerȱQueueȱverbinden,ȱ jedochȱ kannȱ jedeȱ Nachrichtȱ inȱ einerȱ Queueȱ nurȱ vonȱ einemȱ derȱ EmpȬ fängerȱkonsumiertȱwerden.ȱQueueReceiverȱenthältȱeineȱMethodeȱ getQueueȱȱ

262ȱ

Queue getQueue ().

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ

TopicSubscriberȱ SobaldȱeineȱNachrichtȱvorliegt,ȱwirdȱsieȱanȱdenȱTopSubscriberȱausȬ geliefert.ȱTopicSubscriberȱenthältȱdieȱbeidenȱMethodenȱ Topic getTopic () und boolean getNoLocal ().

getTopicȱȱ getNoLocalȱ

MessageListenerȱ DerȱMessageListenerȱwirdȱdurchȱeinȱJMSȱClientȱimplementiert,ȱd.h.ȱ erȱmussȱdieȱeinzigeȱMethodeȱȱ void onMessage (Message message)ȱȱȱ

onMessage

desȱMessageListenerȱimplementieren.ȱȱ ErȱempfängtȱasynchronȱNachrichtenȱvonȱeinemȱQueueReceiverȱoderȱ einemȱ TopicSubscriber.ȱ Dieȱ Sessionȱ mussȱ sicherstellen,ȱ dassȱ dieȱ NachrichtenȱseriellȱanȱdenȱMessageListener übergebenȱwerden,ȱsoȱ dassȱsieȱeinzelnȱbearbeitbarȱsind.ȱEinȱMessageListenerȬObjektȱkannȱ vonȱvielenȱVerbrauchernȱangelegtȱwerden,ȱjedochȱistȱdieȱserielleȱAusȬ lieferungȱnurȱgarantiert,ȱwennȱalleȱVerbraucherȱvonȱderȱgleichenȱSessionȱangelegtȱwurden.ȱ

QueueBrowserȱ Derȱ QueueBrowserȱ ermöglichtȱ es,ȱ Nachrichtenȱ inȱ einerȱ Queueȱ zuȱ inspizieren,ȱ ohneȱ sieȱ zuȱ konsumieren.ȱ Dazuȱ bietetȱ dasȱ Interfaceȱ dieȱ folgendenȱFunktionen:ȱ Queue getQueue (), String getMessageSelector (), Enumeration getEnumeration (). ZumȱBeendenȱdesȱBrowserȱdientȱ void close ().

getQueue,ȱ getMessageȬ Selector,ȱ getEnumeraȬ tionȱ closeȱ

JMSExceptionȱ Alleȱ Funktioenȱ desȱ JMSȱ APIȱ lösenȱ beiȱ Fehlernȱ undȱ Ausnahmenȱ dieȱ AusnahmeȱvomȱTypȱJMSExceptionȱaus.ȱDieȱKlasseȱJMSExceptionȱ erweitertȱ dieȱ Klasseȱ java.lang.Exception umȱ dieȱ folgendenȱ ProȬ zedurenȱundȱFunktionen:ȱ JMSException(String reason), JMSException(String reason, String errorCode), String getErrorCode (), Exception getLinkedException () und

classȱȱ JMSExceptionȱ

263ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ void setLinkedException (java.lang.Exception ex). Dieȱ JMSȱ APIȬDokumentationȱ vonȱ Sunȱ Microsystemsȱ beschreibtȱ nochȱ zwölfȱ weitereȱ Ausnahmenȱ vomȱ Typȱ JMSException.ȱ Beispielhaftȱ seiȱ dieȱ MessageEOFExceptionȱ genannt,ȱ dieȱ ausgelöstȱ wird,ȱ wennȱ einȱ Stromȱ unerwartetȱ währendȱ desȱ Lesensȱ einerȱ StreamMessageȱ oderȱ ByteMessage endet.ȱȱ

ExceptionListenerȱ JMSȬProviderȱstellenȱeinenȱExceptionListenerȱzurȱVerfügung,ȱumȱ zusammengebrocheneȱVerbindungenȱwiederherzustellenȱundȱumȱdenȱ JMSȬClientȱdarüberȱzuȱinformieren.ȱȱ Derȱ ExceptionListenerȱ wirdȱ durchȱ einȱ JMSȬClientȱ implementiert,ȱ d.h.ȱerȱmussȱdieȱeinzigeȱMethodeȱȱ onExceptionȱ

void onException (JMSException exception)ȱȱȱ desȱExceptionListenerȱimplementieren.ȱ

3.4.4.2.3 Anwendungsbeispiel Erzeuger-Verbraucher-Problem (Pipe) Dieȱ nachfolgendenȱ Programmeȱ 3Ȭ25ȱ undȱ 3Ȭ26ȱ zeigenȱ eineȱ PointȬtoȬ PointȬKommunikationȱ(QueueConnection)ȱzwischenȱeinemȱErzeugerȱ undȱ einemȱ Verbraucher.ȱ Derȱ Erzeugerȱ produziertȱ einfachheitshalberȱ eineȱeinzigeȱNachrichtȱundȱschicktȱdieseȱNachrichtȱanȱeinenȱMessageȬ Server.ȱDerȱVerbraucherȱkonsumiertȱdannȱasynchronȱdieseȱNachricht.ȱȱȱ InitialContextȱ

Dieȱ Aufruffolgeȱ desȱ Erzeugersȱ befindetȱ sichȱ imȱ Konstruktorȱ desȱ ProȬ ducersȱundȱwirdȱbeimȱAnlegenȱdesȱErzeugersȱ(imȱmain)ȱdurchlaufen.ȱ Dieȱ Aufruffolgeȱ beginntȱ mitȱ demȱ Anlegenȱ einerȱ Verbindungȱ zuȱ demȱ Javaȱ Namingȱ andȱ Directoryȱ Interfaceȱ (JNDI)ȱ dasȱ vonȱ demȱ MessageȬ Serverȱ benutztȱ wird.ȱ Durchȱ Anlegenȱ desȱ javax.naming.InitialContextȬObjektsȱ wirdȱ eineȱ solcheȱ Verbindungȱ geschaffen.ȱ InitialContextȱ istȱ eineȱ Netzwerkverbindungȱ zuȱ demȱ NamensserȬ verȱ undȱ dientȱ zumȱ Zugriffȱ aufȱ dieȱ vomȱ MessageȬServerȱ verwaltetenȱ Objekte.ȱȱ

ConnectionȬ Factoryȱ

Mitȱ demȱ JNDIȱ InitialContextȬObjektȱ kannȱ dannȱ nachȱ einerȱ QueueConnectionFactoryȱ gesuchtȱ werdenȱ (lookup),ȱ dieȱ dannȱ zumȱ Herstellenȱ einerȱ Verbindungȱ zumȱ MessageȬServerȱ dient.ȱ Dieȱ ConnectionFactoryȱ konfiguriertȱ derȱ Systemadministrator,ȱ derȱ zuȬ ständigȱȱfürȱdenȱMessageȬServerȱist,ȱundȱsieȱistȱbeiȱverschiedenenȱProȬ vidernȱ unterschiedlichȱ implementiert.ȱBeispielsweiseȱ kannȱ sieȱ soȱ konȬ figuriertȱ werden,ȱ dassȱ dieȱ hergestellteȱ Verbindungȱ einȱ speziellesȱ ProȬ tokoll,ȱ einȱ bestimmtesȱ Sicherheitsschemaȱ oderȱ irgendeineȱ ClusterstraȬ

264ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ tegieȱbenutzt.ȱEsȱkönnenȱsogarȱmehrereȱObjekteȱvomȱTypȱConnectionFactoryȱ existieren,ȱ wobeiȱ jedesȱ ihrenȱ eigenenȱ JNDIȱ lookupȬ Namenȱbesitzt.ȱȱ Mitȱ derȱ ConnectionFactoryȱ lässtȱ sichȱ dannȱ eineȱ Verbindungȱ (QueueConnection)ȱ fürȱ eineȱ Queueȱ zumȱ MessageȬServerȱ anlegen.ȱ DieȱVerbindungȱistȱeindeutigȱfürȱdenȱMessageȬServer.ȱJedeȱsoȱangelegȬ teȱ Verbindungȱ benötigtȱ vieleȱ Ressourcen,ȱ wieȱ beispielsweiseȱ einȱ TCP/IPȬSocketȬPaar,ȱ I/Oȱ Streamsȱ undȱ Speicher;ȱ deshalbȱ solltenȱ dieȱ VerbindungȱmehrfachȱdurchȱverschiedeneȱSessionsȱbenutztȱwerden.ȱ

Connection

Fürȱ dieȱ Verbindungȱ könnenȱ beliebigȱ vieleȱ SessionȬObjekteȱ angelegtȱ werden,ȱ wasȱ ressourcenschonenderȱ ist,ȱ alsȱ dasȱ Anlegenȱ vonȱ weiterenȱ Verbindungen.ȱ Dasȱ SessionȬObjektȱ istȱ eineȱ Factoryȱ zumȱ Anlegenȱ einerȱ Nachrichtȱ (MessageȬObjekt)ȱ undȱ zumȱ Anlegenȱ einesȱ QueueSender.ȱȱȱ

Sessionȱȱ

QeueSenderȱ istȱ einȱ vomȱ MessageȬServerȱ verwaltetesȱ Objekt,ȱ wieȱ dieȱ ConnectionFactory,ȱundȱesȱwirdȱwiederȱdieȱlookupȬMethodeȱvonȱ JNDIȱbenutzt,ȱumȱeinenȱHandleȱaufȱdiesesȱObjektȱzuȱerhalten.ȱMitȱdemȱ QueueSenderȱ lassenȱ sichȱ dannȱ durchȱ send(Message)ȱ Nachrichtenȱ anȱdenȱMessageȬServerȱsenden.ȱȱ

QueueSender

Mitȱ start(), stop() und close()ȱ lässtȱ sichȱ eineȱ Verbindungȱ manipulieren.ȱMitȱstart()ȱkönnenȱClientsȱNachrichtenȱüberȱdieȱVerȬ bindungȱgebenȱundȱbeimȱMessageȬServerȱablegen.ȱstop()ȱstopptȱdenȱ eingehendenȱ Nachrichtenstromȱ bisȱ dieȱ start()ȬMethodeȱ wiederȱ aufgerufenȱ wird.ȱ close()ȱ zerstörtȱ dieȱ Verbindungȱ undȱ löschtȱ alleȱ Objekteȱ (QueueSession, QueueSender),ȱ dieȱ mitȱ derȱ Verbindungȱ assoziiertȱsind.ȱȱ

start(),ȱstop(),ȱ close()ȱ

import javax.jms.*; import javax.naming.*; import java.util.Properties;

Programmȱ3Ȭ27:ȱ Messageȱ Producerȱ

public class Producer private QueueConnectionFactory qFactory = null; private QueueConnection qConnect = null; private QueueSession qSession = null; private Queue sQueue = null; private QeueueSender qSender = null; /* Constructor. Establish the Producer */ public Producer (String broker, String username, String password) throws Exception {

265ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ // Obtain a JNDI connection Properties env = new Properties(); // ... specify the JNDI properties sprecific // to the provider InitialContext jndi = new InitialContext(env); // Look up a JMS QueueConnectionFactory qFactory = (QueueConnectionFactory)jndi.lookup(broker); // Create a JMS QueueConnection object qConnect = qFactory.createQueueConnection ( username,password); // Create one JMS QueueSession object qSession = qConnect.createQueueSession( false, Session.AUTO_ACKNOWLEDGE); // Look up for a JMS Queue hello sQueue = (Queue)jndi.lookup(“hello“); // Create a sender qSender = qSession.createSender(sQueue); // Start the Connection qConnect.start(); } /* Create and send message using qSender */ protected void SendMessage() throws JMSException { // Create message TextMessage message = qSession.createTextMessage (); // Set payload Message.setText(username+“ Hello“); // Send Message qSender.send(message); } /* Close the JMS connection */ public void close() throws JMSException { qConnect.close(); }

266ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ /* Run the Producer */ public static void main(String argv[]) { String broker, username, password; if (argv.length == 3) { broker = argv[0]; username = argv[1]; password = argv[2]; } else { return; } // Create Producer Producer producer = new Producer ( broker, username, password); SendMessage(); // Close connection producer.close(); } } Derȱ nachfolgendeȱ Verbraucherȱ (Programmȱ 3Ȭ26)ȱ istȱ vollständigȱ symȬ metrischȱ zumȱ Erzeugerȱ aufgebaut:ȱ Überȱ dieȱ ConnectionFactoryȱ erhältȱ manȱ eineȱ Verbindungȱ (Connection),ȱ dieȱ vonȱ einerȱ Sessionȱ genutztȱwird,ȱundȱdieȱSessionȱerzeugtȱdannȱdenȱReceiver.ȱDaȱderȱVerȬ braucherȱ jedochȱ dieȱ Nachrichtȱ asynchronȱ verarbeitenȱ soll,ȱ mussȱ derȱ VerbraucherȱdenȱMessageListenerȱimplementieren.ȱDazuȱmussȱdieȱ Methodeȱ OnMessageȱ implementiertȱ werden,ȱ undȱ amȱ Endeȱ derȱ KonȬ struktorȬAufruffolgeȱ mussȱ derȱ Empfängerȱ denȱ MessageListenerȱ setzenȱ(setMessageListener).ȱȱ

Messageȱ Listenerȱ

import import import import

Programmȱ3Ȭ28:ȱ Messageȱ Consumerȱȱȱ

javax.jms.*; javax.naming.*; java.util.Properties; java.io.*;

public class Consumer implements MessageListener { private QueueConnectionFactory qFactory = null; private QueueConnection qConnect = null; private QueueSession qSession = null; private Queue rQueue = null; private QeueueReceiver qReceiver = null; /* Constructor. Establish the Consumer */ public Consumer (String broker, String username, String password)

267ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ throws Exception{ // Obtain a JNDI connection Properties env = new Properties(); // ... specify the JNDI properties sprecific // to the provider InitialContext jndi = new InitialContext(env); // Look up a JMS QueueConnectionFactory qFactory = (QueueConnectionFactory)jndi.lookup(broker); // Create a JMS QueueConnection object qConnect = qFactory.createQueueConnection ( username,password); // Create one JMS QueueSession object qSession = qConnect.createQueueSession ( false, Session.AUTO_ACKNOWLEDGE); // Look up for a JMS Queue hello rQueue = (Queue)jndi.lookup(“hello“); // Create a receiver qReceiver = qSession.createReceiver(rQueue); // set a JMS message listener qReceiver.setMessageListener(this); // Start the Connection qConnect.start(); } /* Receive message from qReceiver */ public void onMessage (Message message){ try { TextMessage textMessage = (TextMessage) message; String text = textMessage.getText(); System.outprintln (“Message received – “ + text + “ from“ + message.getJMSCorrelationID()); }

268ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ catch (java.lang.Exception rte) { rte.printStackTrace(); } } /* Close the JMS connection */ public void close() throws JMSException { qConnect.close(); } /* Run the Consumer */ public static void main(String argv[]) { String broker, username, password; if (argv.length == 3) { broker = argv[0]; username = argv[1]; password = argv[2]; } else { return; } // Create Consumer Consumer consumer = new Consumer (broker, username, password); System.out.println (“\Consumer started: \n“); // Close connection consumer.close(); } } Fürȱ eineȱ Pub/SubȬKommunikationȱ muss,ȱ wieȱ beiȱ derȱ obenȱ beschrieȬ benenȱ PTPȬKommunikation,ȱ dieȱ entsprechendeȱ TopicȬAufruffolgeȱ (TopicConnectionFactory, TopicConnection, TopicSession, lookup Topic, Publisher oder Subscriber)ȱ durchȬ laufenȱwerden.ȱAufȱeinȱkonkretesȱTopicȬAnwendungsbeispielȱverzichȬ tenȱwirȱhierȱundȱverweisenȱaufȱMonsonȬHaefelȱundȱChappelȱ[MCȱ01],ȱ dasȱeinȱeinführendesȱChatȬBeispielȱ(derȱChatȬȱundȱdamitȱJMSȬClientȱistȱ hierȱgleichzeitigȱeinȱProducerȱundȱConsumer)ȱenthältȱundȱdenȱUnterȬ schiedȱ zwischenȱ PTPȬȱ undȱ Pub/SubȬKommunikationȱ anȱ einemȱ Groß/EinzelhandelȬSzenarioȱerläutert.ȱȱ

3.4.4.2.4 JMS-Provider FührendesȱProduktȱbeiȱEnterpriseȬMOMȱistȱIBM’sȱMQSeries.ȱEsȱwurdeȱ 1993ȱ eingeführt,ȱ alsoȱ vorȱ denȱ Zeitenȱ vonȱ Javaȱ undȱ JMS.ȱ Ursprünglichȱ basierteȱMQSeriesȱaufȱdemȱPTPȬModell,ȱundȱmitȱderȱVersionȱ5ȱwurdeȱ

IBMȱ MQSeriesȱ

269ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ dasȱ Pub/SubȬModellȱ eingeführt.ȱ MQSeriesȱ unterstütztȱ dasȱ JMSȱ APIȱ undȱistȱsomitȱeinȱJMSȬProvider.ȱȱ JavaȱMessageȱ Queueȱ(JMQ)ȱ

Sunȱ Microsystemsȱ istȱ nichtȱ nurȱ fürȱ dieȱ JMSȱ APIȱ verantwortlich,ȱ sonȬ dernȱ liefertȱauchȱ mitȱ Javaȱ Messageȱ Queueȱ (JMQ)ȱ eineȱ ReferenzimpleȬ mentierung.ȱJMQȱentsprichtȱderȱJMSȱ1.0.2ȬSpezifikation.ȱDerȱMessageȬ Serverȱ istȱ inȱ Cȱ geschriebenȱ undȱ läuftȱ aufȱ SolarisȬSparc,ȱ Windows/NTȱ undȱ Windowsȱ 2000.ȱ Zurȱ Erhöhungȱ derȱ Anzahlȱ derȱ Plattformenȱ wirdȱ JMQȱinȱderȱVersionȱ2.0ȱinȱJavaȱimplementiert.ȱȱ

3.4.5 Kooperative Modelle mit entfernten Aufrufen 3.4.5.1 Ablauf von entfernten Aufrufen RuftȱeinȱProzessȱaufȱeinerȱMaschineȱAȱeinenȱDienstȱaufȱeinerȱMaschineȱ Bȱ auf,ȱ soȱ wirdȱ derȱ aufrufendeȱ Prozessȱ suspendiertȱ undȱ dieȱ AbarbeiȬ tungȱ derȱ aufgerufenenȱ Prozedurȱ findetȱ aufȱ derȱ Maschineȱ Bȱ statt.ȱ InȬ formationȱ vomȱ Aufruferȱ zumȱ Aufgerufenenȱ kannȱ überȱ dieȱ Parameterȱ transportiertȱ werden,ȱ undȱ Informationȱ kannȱ überȱ dasȱ Ergebnisȱ derȱ Prozedurȱzurücktransportiertȱwerden.ȱDurchȱdiesesȱVorgehenȱzeigtȱeinȱ RemoteȱProcedureȱCallȱdasȱvertrauteȱVerhaltenȱvonȱlokalenȱProzedurȬ aufrufen.ȱ ȱ Abb.ȱ3Ȭ24:ȱ Aufrufȱeinerȱ entferntenȱ Prozedurȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ

ȱ

ȱ ȱ ȱ ȱ ȱ ȱ

270ȱ

3.4 Programmiermodelle für verteilten Speicher

3.4.5.2 Abbildung des entfernten Aufrufes auf Nachrichten Mit dem entfernten Prozeduraufruf lassen sich Anwendungen gut in das Client-Server-Modell überführen: Verschiedene Server stellen Schnittstellenprozeduren zur Verfügung, die dann entfernte Clients mit Hilfe von RPCs aufrufen. Das RPC-System übernimmt dabei die Kodierung und Übertragung der Aufrufe einschließlich der Parameter und des Ergebnisses. Teilweise wird auch die Lokalisierung von Servern, die Übertragung komplexer Parameter- und Ergebnisstrukturen, die Behandlung von Übertragungsfehlern und die Behandlung von möglichen Rechnerausfällen durch das System übernommen. Generell lässt sich ein RPC-System, wie in Abbildung 3-25 gezeigt, realisieren:

Client

Server

Anwendungsprogramm

Server-Programm

Prozeduraufruf

Ereignisrückgabe

Prozeduraufruf

Ereignisrückgabe

Client-Stub

Server-Stub

AufrufEreigniskodierung dekodierung

AufrufEreignisdekodierung kodierung

Kommunikationskomponente

Kommunikationskomponente

AufrufEreignisübertragung empfang

AufrufEreignisempfang übertragung

Abb. 3-25: Komponenten und Ablaufstruktur eines RPCSystems

Netzwerknachricht Ein Anwendungsprogramm ruft eine Prozedur auf und blockiert. Die Implementierung der Prozedur steht jedoch nicht lokal zur Verfügung, sondern wird von einem entfernten Server angeboten; dies ist aber für das aufrufende Programm transparent.

271

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ

3.4.5.3 Stubs ClientȬStubȱ

DasȱlokaleȱSystemȱaufȱderȱSeiteȱdesȱAufrufersȱtransformiertȱdazuȱdenȱ entferntenȱAufrufȱinȱdenȱAufrufȱeinerȱlokalenȱSystemprozedur,ȱdenȱsoȱ genanntenȱClientȬStubȱ(Stubȱ–ȱStummel).ȱInȱderȱStubȬKomponenteȱmussȱ Informationȱ vorliegenȱ oderȱ Informationȱ beschafftȱ werden,ȱ welcherȱ Serverȱ dieȱ gewünschteȱ Prozedurȱ anbietet;ȱ dieserȱ Serverȱ kannȱ sichȱ soȬ garȱ aufȱdemȱgleichenȱ physikalischenȱRechnerȱ befinden.ȱ Imȱ Gegensatzȱ zuȱ einerȱ konventionellenȱ Prozedurȱ werdenȱ vomȱ ClientȬStubȱ nichtȱ dieȱ ParameterȱinȱRegisternȱoderȱaufȱdemȱKellerȱabgelegt,ȱsondernȱdieȱPaȬ rameterȱ werdenȱ inȱ eineȱ Nachrichtȱ verpackt.ȱ Derȱ ClientȬStubȱ kodiertȱ somitȱdieȱSpezifikationȱderȱaufgerufenenȱProzedur,ȱd.h.ȱordnetȱihrȱeineȱ eindeutigeȱAufrufkennungȱzu,ȱbestimmtȱdieȱAdresseȱdesȱZielrechnersȱ undȱ verpacktȱ dieȱ Parameterȱ inȱ einȱ vereinbartesȱ Übertragungsformatȱ fürȱNachrichten.ȱAnschließendȱbeauftragtȱderȱStubȱeineȱKommunikatiȬ onskomponenteȱmitȱdemȱVersendenȱderȱNachricht.ȱNachȱdemȱSendenȱ blockiertȱderȱStubȱundȱwartet,ȱbisȱeineȱNachrichtȱzurückkommt.ȱ Dieȱ Kommunikationskomponenteȱ überträgtȱ denȱ kodiertenȱ Aufrufȱ anȱ denȱ Zielrechner.ȱ Dabeiȱ istȱ dieseȱ Komponenteȱ verantwortlichȱ fürȱ dasȱ Routing,ȱ dieȱ Quittierungȱ undȱ imȱ Fehlerfalleȱ dieȱ Wiederholungȱ vonȱ Übertragungspaketen.ȱȱ

ServerȬStubȱ

Kommtȱ dieȱ Nachrichtȱ dannȱ beiȱ derȱ Kommunikationskomponenteȱ desȱ Serversȱan,ȱwirdȱsieȱzuȱdemȱServerȬStub,ȱderȱmitȱdemȱServerȱassoziiertȱ ist,ȱ weitergeleitet.ȱ Typischerweiseȱ führtȱ derȱ ServerȬStubȱ eineȱ EndlosȬ schleifeȱ ausȱ undȱ wartetȱ amȱ Anfangȱ derȱ Schleifeȱ aufȱ einkommendeȱ Nachrichten.ȱ Nachȱ Empfangȱ einerȱ Nachrichtȱ entpacktȱ derȱ Serverȱ denȱ Aufrufȱ undȱ dieȱ Parameter,ȱ bestimmtȱ dieȱ entsprechendeȱ aufzurufendeȱ ProzedurȱdesȱServersȱundȱruftȱsieȱauf.ȱAusȱderȱSichtȱdesȱServersȱhanȬ deltȱesȱsichȱumȱeineȱkonventionelleȱProzedur,ȱdieȱderȱClientȱaufgerufenȱ hat.ȱNachȱderȱProzedurausführungȱerhältȱderȱServerȬStubȱdasȱErgebnisȱ derȱProzedur.ȱErȱverpacktȱdieȱRückgabeparameterȱmitȱderȱAufrufkenȬ nungȱinȱeineȱNachrichtȱundȱversendetȱsieȱmitȱHilfeȱderȱKommunikatiȬ onskomponenteȱdesȱServersȱanȱdenȱClient.ȱNachȱdemȱVersendenȱgehtȱ derȱServerȬStubȱwiederȱanȱdenȱAnfangȱderȱSchleifeȱzurückȱundȱwartetȱ aufȱdieȱnächsteȱNachricht.ȱȱ DieȱKommunikationskomponenteȱdesȱClientsȱempfängtȱdieȱNachricht,ȱ leitetȱ sieȱ anȱ denȱ ClientȬStubȱ weiter,ȱ derȱ dieȱ entsprechendeȱ DekodieȬ rungȱundȱdasȱEntpackenȱvornimmt,ȱundȱübergibtȱdasȱResultatȱanȱdasȱ Anwendungsprogramm.ȱDasȱAnwendungsprogrammȱdeblockiertȱundȱ setztȱ seineȱ lokaleȱ Programmabarbeitungȱ fort.ȱ Ausȱ derȱ Sichtȱ desȱ AnȬ

272ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ wendungsprogrammsȱ siehtȱ dabeiȱ dieȱ entfernteȱ Prozedurausführungȱ wieȱeineȱlokaleȱProzedurausführungȱaufȱdemȱgleichenȱRechnerȱaus.ȱ

3.4.5.4 Parameter- und Ergebnisübertragung Dieȱ Aufgabeȱ desȱ ClientȬStubȱ ist,ȱ dieȱ Prozedurparameterȱ zuȱ übernehȬ menȱundȱinȱeineȱNachrichtȱzuȱverpackenȱundȱsieȱdemȱServerȬStubȱzuȬ zusenden.ȱ Dieserȱ Vorgangȱ wirdȱ Parameterȱ marshallingȱ (anordnen,ȱ arȬ rangieren)ȱ genannt.ȱ Zurȱ Betrachtungȱ diesesȱ Vorgangsȱ sehenȱ wirȱ unsȱ zunächstȱ dieȱ Parameterübergabeȱ inȱ konventionellenȱ Prozedurenȱ anȱ undȱwieȱsieȱsichȱaufȱentfernteȱProzedurenȱübertragenȱlässt.ȱ InȱCȱkönnenȱdieȱParameterȱbyȱvalueȱoderȱbyȱreferenceȱübergebenȱwerȬ den.ȱ Dieȱ Wertübergabeȱ bereitetȱ dabeiȱ fürȱ einenȱ entferntenȱ ProzedurȬ aufrufȱkeineȱSchwierigkeit,ȱdaȱderȱentferntenȱProzedurȱeinȱWertȱüberȬ gebenȱ wird.ȱFürȱ dieȱaufgerufeneȱ Prozedurȱistȱeinȱ Wertparameterȱeineȱ initialisierteȱlokaleȱVariable,ȱdieȱbeliebigȱmodifizierbarȱist.ȱDieȱModifiȬ kationȱ desȱ Wertparametersȱ hatȱ dabeiȱ keineȱ Auswirkungȱ aufȱ dieȱ derȱ ProzedurȱübergebenenȱVariablen.ȱȱ Einȱ Referenzparameterȱ inȱ Cȱ istȱ einȱ Zeigerȱ aufȱ eineȱ Variableȱ (Adresseȱ einerȱ Variablen)ȱundȱ keinȱ Wertȱ einerȱVariablen.ȱ Daȱdieȱ entfernteȱ ProȬ zedurȱinȱeinemȱanderenȱAdressraumȱalsȱdieȱaufrufendeȱProzedurȱläuft,ȱ kannȱdieȱAdresseȱeinerȱVariablenȱnichtȱübergebenȱwerden.ȱEineȱmögliȬ che,ȱjedochȱsehrȱeinschränkendeȱLösungȱistȱdasȱVerbietenȱvonȱPointernȱ undȱ Referenzübergaben.ȱ Sollȱ dieseȱ einschränkendeȱ Lösungȱ nichtȱ geȬ wähltȱ werden,ȱ soȱ mussȱ dieȱ callȱ byȱ referenceȬSemantikȱ nachgebildetȱ werden,ȱwasȱdurchȱdieȱParameterübergabeartȱcallȬbyȬcopy/restoreȱmögȬ lichȱ ist.ȱ callȬbyȬcopy/restoreȱ kopiertȱ dieȱ Variablenȱ aufȱ denȱ Kellerȱ desȱ Aufgerufenen,ȱwieȱbeiȱcallȱbyȱvalue.ȱBeiȱProzedurrückkehrȱwerdenȱdieȱ Parameterȱ zurückkopiertȱ inȱ dieȱ Variablen,ȱ wodurchȱ dieȱ Werteȱ derȱ Variablenȱ desȱ Aufrufesȱ überschriebenȱ werden.ȱ Diesesȱ Vorgehenȱ entȬ sprichtȱdannȱeinemȱcallȱbyȱreferenceȱmitȱderȱAusnahmeȱvonȱdemȱFall,ȱ inȱ demȱ derȱ gleicheȱ Parameterȱ mehrfachȱ inȱ derȱ Parameterlisteȱ auftritt.ȱ DazuȱbetrachteȱmanȱdasȱfolgendeȱProgrammbeispielȱinȱC:ȱ f(int *x, int *y) { *x = *x + 1; *y = *y + 1; }

ParameterȬ übergabeartenȱȱ

CallȬbyȬ copy/ȱrestoreȱ

Programmȱ3Ȭ 29:ȱParameterȬ übergabeartȱȱ callȬbyȬcopy/ȱ restoreȱ

main() { int a;

273ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ a = 0; f(&a, &a); printf("%d", a); } Eineȱ lokaleȱ Prozedurabwicklungȱ liefertȱ alsȱ Ergebnisȱ denȱ Wertȱ 2,ȱ weilȱ dieȱ beidenȱ Additionenȱ sequenziellȱ abgewickeltȱ werden.ȱ Beiȱ einemȱ RemoteȱProcedureȱCallȱwirdȱjedochȱzweimalȱkopiert.ȱJedeȱKopieȱwirdȱ unabhängigȱvonȱderȱanderenȱaufȱeinsȱgesetzt.ȱAmȱEndeȱderȱProzedurȱ wirdȱaȱ(=ȱ1)ȱzurückkopiert.ȱDasȱzweiteȱKopierenȱüberschreibtȱdasȱErstȬ kopierte.ȱ Dadurchȱ liefertȱ inȱ diesemȱ Fallȱ dieȱ callȬbyȬcopy/restoreȬ Semantikȱ denȱ Wertȱ vonȱ einsȱ undȱ unterscheidetȱ sichȱ dadurchȱ vonȱ derȱ callȱbyȱreferenceȬSemantik.ȱȱ inȱoutȱ Parameterȱ

EffizienterȱkönnenȱdieȱParameterȱgehandhabtȱwerden,ȱwennȱsieȱwieȱinȱ derȱ Programmierspracheȱ Adaȱ alsȱ Eingangsparameterȱ (in)ȱ oderȱ AusȬ gangsparameterȱ(out)ȱspezifiziertȱsind.ȱLiegtȱeinȱinȬParameterȱvor,ȱsoȱ kannȱ derȱ Parameterȱ wieȱ beiȱ derȱ Wertübergabeȱ kopiertȱ werden.ȱ Liegtȱ einȱoutȬParameterȱvor,ȱsoȱbrauchtȱderȱParameterȱnichtȱkopiertȱzuȱwerȬ den,ȱd.h.ȱderȱaufgerufenenȱProzedurȱübergebenȱzuȱwerden.ȱNachȱProȬ zedurausführungȱwirdȱderȱWertȱdesȱoutȬParametersȱvonȱderȱAusfühȬ rungsumgebungȱ zumȱ Aufruferȱ transportiertȱ undȱ inȱ derȱ AufrufumgeȬ bungȱ inȱ denȱ Parameterȱ undȱ somitȱ derȱ Variablenȱ kopiert.ȱ In-outParameterȱkönnenȱdannȱdurchȱcallȬbyȬcopy/restoreȱbehandeltȱwerden.ȱȱ

Zeigerȱaufȱ komplexeȱ DatenstruktuȬ renȱ

Obigesȱ beschriebenesȱ Vorgehenȱ behandeltȱ Zeigerȱ aufȱ einfacheȱ Felderȱ undȱStrukturen.ȱWasȱjedochȱnichtȱabgedecktȱist,ȱsindȱZeigerȱaufȱkomȬ plexeȱDatenstrukturen,ȱwieȱbeispielsweiseȱListen,ȱBäumeȱundȱGraphen.ȱ MancheȱSystemeȱ versuchenȱ auchȱ diesenȱ Fallȱ abzudecken,ȱindemȱ manȱ einenȱZeigerȱeinemȱServerȬStubȱübergibtȱundȱeinenȱspeziellenȱCodeȱinȱ derȱ ServerȬProzedurȱ generiertȱ zurȱ Behandlungȱ vonȱ Zugriffenȱ durchȱ Zeiger.ȱ Dieȱ Adresseȱ (Zeiger)ȱ wirdȱ dabeiȱ inȱ derȱ Serverprozedurȱ abgeȬ legt;ȱ fallsȱ derȱ Inhaltȱ derȱ Adresseȱ vomȱ Serverȱ gewünschtȱ wird,ȱ sendetȱ derȱServerȱeineȱNachrichtȱanȱdenȱClientȱzumȱLesenȱderȱSpeicherzelle,ȱ aufȱ welcherȱ dieȱ Adresseȱ zeigt.ȱ Derȱ Clientȱ kannȱ dannȱ denȱ Inhaltȱ derȱ Adresse,ȱalsoȱdenȱWert,ȱlesenȱundȱanȱdenȱServerȱzurückschicken.ȱDieseȱ Methodeȱistȱjedochȱsehrȱineffizient,ȱdaȱbeiȱjedemȱZugriffȱaufȱeineȱSpeiȬ cherzelleȱüberȱeinenȱZeigerȱBotschaftenȱausgetauschtȱwerdenȱmüssen.ȱȱ Eineȱ andereȱ Möglichkeitȱ bestehtȱ darin,ȱ dieȱ komplette,ȱ komplexeȱ DaȬ tenstrukturȱ vomȱ Adressraumȱ desȱ Clientsȱ inȱ denȱ Adressraumȱ desȱSerȬ versȱzuȱkopieren.ȱȱ

274ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ DieȱentfernteȱProzedurȱläuftȱimȱAdressraumȱdesȱServersȱab.ȱDerȱAufȬ rufȱ derȱ Prozedurȱ liegtȱ jedochȱ imȱ Adressraumȱ desȱ Clients.ȱ Deshalbȱ könnenȱnurȱdiejenigenȱProzedurenȱauchȱentfernteȱProzedurenȱsein,ȱdieȱ keineȱZugriffeȱaufȱglobaleȱVariablenȱimȱProzedurkörperȱenthalten.ȱ

Behandlungȱ vonȱglobalenȱ Variablenȱ

3.4.5.5 Remote Procedure Calls (ONC RPCs, DCE RPCs, DCOM) Amȱ Marktȱ existierenȱ mehrereȱ miteinanderȱ inkompatibleȱ Versionenȱ vonȱRPCȬSystemen:ȱ 1.ȱ Dasȱ bekannteste,ȱ mitȱ jederȱ LinuxȬDistributionȱ ausgelieferteȱ RPCȬ Systemȱ istȱ ONCȱ (Openȱ Networkȱ Computing)ȱ RPCȱ oderȱ auchȱ Sunȱ RPCȱ genannt.ȱ Zurȱ Generierungȱ derȱ Stubsȱ stehtȱ einȱ Generatorȱ rpcgenȱzurȱVerfügung.ȱEingabespracheȱfürȱdenȱrpcgenȱistȱsprachuȬ nabhängigȱ undȱ geschiehtȱ mitȱ RPCLȱ (Remoteȱ Procedureȱ Callȱ LanȬ guage).ȱ DerȱBrokerȱ oderȱPortmapper,ȱderȱalsȱ Dämonȱ aufȱdemȱSerȬ verȱläuft,ȱlauschtȱanȱdemȱUDPȬȱundȱTCPȬPortȱ111.ȱȱ ȱ

Dieȱ maschinenunabhängigeȱ Datenrepräsentationȱ istȱ XDRȱ (eXternalȱ Dataȱ Representation).ȱ Beiȱ dieserȱ Datenrepräsentationȱ mussȱ derȱ SenderȱimmerȱseineȱDatenȱinȱXDRȱumwandelnȱundȱimȱXDRȬFormatȱ übertragen,ȱ undȱ derȱ Empfängerȱ mussȱ dannȱ dieȱ Datenȱ vomȱ XDRȬ FormatȱinȱseineȱeigeneȱDatenrepräsentationȱzurückwandeln.ȱ

ȱ

Sunȱ RPCsȱ wurdeȱ ursprünglichȱ vonȱ Sunȱ fürȱ dasȱ Networkȱ Fileȱ SysȬ temȱ (NFS)ȱ entwickelt.ȱ Derȱ Networkȱ Informationȱ Serviceȱ (NIS)ȱ baȬ siertȱgrößtenteilsȱauchȱaufȱSunȬRPCs.ȱȱ

2.ȱ ȱ Dieȱ vonȱ Microsoftȱ mitȱ Windowsȱ NTȱ ausgeliefertenȱ DCEȬRPCsȱ wurdenȱvonȱderȱDistributedȱComputingȱEnvironmentȱ(DCE)ȱ[Pȱ95]ȱ abgeleitet.ȱ Dasȱ Herzstückȱ vonȱ dieserȱ Umgebungȱ undȱ dasȱ ProȬ grammiermodellȱ zurȱ Festlegungȱ vonȱ ClientȬServerȬBeziehungenȱ sindȱ RPCs.ȱ Derȱ Brokerȱ oderȱ EndPointMapperȱ lauschtȱ aufȱ demȱ UDPȬȱ undȱ TCPȬPortȱ 135.ȱ Anwendungenȱ werdenȱ mitȱ Hilfeȱ derȱ InȬ terfaceȱDefinitionȱLanguageȱ(IDL)ȱprogrammiert.ȱȱ ȱ

AnȱStelleȱeinesȱeinzigenȱNetzstandardsȱwieȱbeiȱXDRȱundȱsomitȱbeiȱ SunȬRPCs,ȱ verwendenȱ DCEȬRPCsȱ dieȱ Datenrepräsentationȱ NDRȱ (NetworkȱDataȱRepresentation).ȱNDRȱermöglichtȱdemȱSender,ȱseinȱ eigenesȱ internesȱ Formatȱ zuȱ benutzen,ȱ fallsȱ esȱ einesȱ derȱ unterstütȬ zendenȱ Formateȱ ist.ȱ Derȱ Empfängerȱ muss,ȱ fallsȱ sichȱ seinȱ eigenesȱ Formatȱ vonȱ demȱ desȱ Sendersȱ unterscheidet,ȱ dieseȱ inȱ seinȱ eigenesȱ Formatȱumwandeln.ȱ

ȱ

Umȱ dieȱ COMȬTechnologieȱ vonȱ Microsoftȱ überȱ einȱ Netzwerkȱ komȬ munizierenȱ zuȱ lassen,ȱ setzteȱ Microsoftȱ DCEȬRPCsȱ ein.ȱ Diesesȱ obȬ jektorientierteȱ RPCȬSystemȱ nannteȱ Microsoftȱ DCOMȱ (Distributedȱ

SunȱRPCȱ

DCEȬRPCȱ

275ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ Componentȱ Objectȱ Model).ȱ Sieheȱ dazuȱ auchȱ Abschnittȱ 3.4.5.8ȱ EntȬ fernteȱKomponentenaufrufe).ȱȱ ISOȱRPCȱ

3.ȱȱEinȱVersuchȱderȱISO,ȱȱeinȱstandardisiertesȱISOȱRPCȱzuȱetablieren,ȱistȱ fehlgeschlagen,ȱ undȱ davonȱ gibtȱ esȱ kaumȱ Implementierungen.ȱ Dasȱ Transferformatȱ derȱ Datenȱ beiȱ ISOȱ RPCsȱ benutztȱ explizitesȱ Typing,ȱ d.h.ȱderȱTypȱderȱDatenȱmussȱexplizitȱmitȱangegebenȱwerden.ȱXDRȱ undȱ NDRȱ benötigenȱ keineȱ Typangaben,ȱ sondernȱ benutzenȱ einȱ imȬ plizitesȱTyping.ȱDieȱBeschreibungsspracheȱfürȱdasȱexpliziteȱTypingȱ istȱASN.1ȱ(AbstractȱSyntaxȱNotationȱ1).ȱȱ

RFCȱ

4.ȱ ȱ Inȱ derȱ SAPȬSoftwareȱ bezeichnetȱ RFCȱ denȱ Remoteȱ Functionȱ Call.ȱ DamitȱlassenȱsichȱFunktionsbausteineȱinnerhalbȱvonȱSAPȱR/3ȱaufruȬ fen.ȱ Diesȱ ermöglichtȱ externenȱ Subsystemen,ȱ Datenȱ inȱ einȱ SAPȬ SystemȱhineinȱoderȱausȱeinemȱSAPȬSystemȱhinausȱzuȱtransportieren.ȱȱ

3.4.5.6 Entfernte Methodenaufrufe (CORBA) Einerȱ derȱ eifrigstenȱ undȱ auchȱ rechtȱ erfolgreichenȱ Verfechterȱ derȱ obȬ jektorientiertenȱModellierungȱundȱihrerȱVerbindungȱmitȱverteilterȱProȬ grammierungȱ istȱ dieȱ ObjectȱManagementȱGroupȱ(OMG)ȱ [OMGȱ 07].ȱ Dieȱ OMGȱ wurdeȱ 1989ȱ gegründetȱ undȱ istȱ einȱ internationalesȱ Konsortium,ȱ dasȱvonȱursprünglichȱachtȱMitgliedernȱaufȱüberȱ700ȱMitgliederȱ(Apple,ȱ AT&T,ȱDEC,ȱHP,ȱIBM,ȱNeXT,ȱSiemensȱNixdorf,ȱSun,ȱXeroxȱundȱandeȬ re)ȱangewachsenȱist.ȱDieȱOMGȱimplementiertȱkeineȱProdukte,ȱsondernȱ ihreȱ Aufgabeȱ liegtȱ inȱ derȱ Festlegungȱ vonȱ Spezifikationenȱ fürȱ SchnittȬ stellenȱundȱProtokolle.ȱDieȱMitgliederȱreichenȱSpezifikationenȱein,ȱdieȱ vonȱderȱOMGȱveröffentlichtȱundȱmitȱinteressiertenȱMitgliedernȱdiskuȬ tiertȱ werdenȱ undȱ anschließendȱ einerȱ Abstimmungȱ durchȱ dieȱ OMGȱ unterliegen.ȱ Imȱ Zugeȱ diesesȱ Verfahrensȱ hatȱ dieȱ OMGȱ einȱ abstraktesȱ Objektmodellȱ undȱ eineȱ objektorientierteȱ Referenzarchitekturȱ definiert,ȱ dieȱObjectȱManagementȱArchitectureȱ(OMA)[OMAȱ07].ȱ Commonȱ Objectȱ Requestȱ Brokerȱ Architectureȱ (CORBA)ȱ

Einȱ wesentlicherȱ Bestandteilȱ dieserȱ Referenzarchitekturȱ istȱ derȱ Objectȱ Requestȱ Brokerȱ (ORB),ȱ worausȱ sichȱ dieȱ geläufigereȱ Bezeichnungȱ ComȬ monȱObjectȱRequestȱBrokerȱArchitectureȱ(CORBA)ȱ[Pȱ98]ȱfürȱdieȱArchitekȬ turȱableitet.ȱDerȱORBȱermöglichtȱdieȱKommunikationȱundȱKoordinatiȬ onȱzwischenȱbeliebigenȱCORBAȬObjektenȱundȱistȱeineȱTechnologie,ȱdieȱ bekanntȱ istȱ unterȱ Distributedȱ Objectȱ Managementȱ (DOM)ȱ [MRȱ 97].ȱ Dieȱ DOMȬTechnologieȱstelltȱaufȱhoherȱEbeneȱeineȱobjektorientierteȱSchnittȬ stelleȱaufȱBasisȱvonȱverteiltenȱServicesȱzurȱVerfügung.ȱȱ

IDLȬCompilerȱ

Mitȱ einerȱ InterfaceȱDefinitionȱLanguageȱ (IDL)ȱ [IDLȱ07] (OMGȱ IDLȱ istȱ einȱ ISOȱ Internationalȱ Standard,ȱ Nummerȱ 14750)ȱ erstelltȱ einȱ ProgramȬ miererȱ eineȱ formaleȱ Spezifikationȱ derȱ Schnittstelle,ȱ dieȱ eineȱ ServeranȬ wendungȱ zurȱ Verfügungȱ stellt.ȱ Dieseȱ Schnittstellenbeschreibungȱ setztȱ

276ȱ

3.4 Programmiermodelle für verteilten Speicher ein IDL-Compiler in ein Objektmodell der verwendeten Programmiersprache um; d. h. er erzeugt die (Client-) Stubs und (Server-) Skeletons. Die Stubs und Skeletons verbinden die sprachenunabhängigen IDLSchnittstellenspezifikationen mit dem sprachspezifischen Implementierungsquelltext. Den IDL-Compiler liefert der Hersteller des ORB.

3.4.5.6.1 Object Management Architecture (OMA) Die Object Management Architecture (OMA) enthält vier Architekturelemente, die um den Object Request Broker (ORB) gruppiert sind (Abbildung 3-26). Der ORB schafft die Kommunikationsinfrastruktur, zum Weiterleiten von Anfragen an andere Architekturkomponenten und ist somit in Abbildung 3-25 als allgemeiner Kommunikationsbus dargestellt. Die Objekte, die Anforderungen versenden und empfangen können, sind durch Kreise repräsentiert. Abb. 3-26: Object Management Architecture

Das Fundament der Architektur bilden die Objektdienste (CORBAservices). Objektdienste sind Services auf Systemebene, die Basisoperationen auf Objekten anbieten. Alle CORBAservices besitzen ein in der Interface Definition Language (IDL) spezifiziertes Interface. Die folgenden verschiedenen Services zeigen die Vielfalt der möglichen Services, von denen die CORBA-Hersteller nur wenige implementiert haben: •

Das Instanzenmanagement (Lifecycle Services) von Objekten, wozu z.B. Operationen wie create, delete, copy und move zählen.

CORBAservices

277

3 Programmiermodelle für parallele und verteilte Systeme

CORBA facility

278

•

Verwaltung von Objektnamen (Naming Service), so dass Komponenten andere Komponenten über ihren Namen lokalisieren können.

•

Der Event Service erlaubt Komponenten, ihr Interesse an speziellen Ereignissen dynamisch zu registrieren und zu deregistrieren. Der Service definiert einen Ereigniskanal, der Ereignisse sammelt und unter den Komponenten verteilt.

•

Der Concurrency Control Service stellt einen Lock Manager zur Verfügung.

•

Der Time Service dient zur Synchronisation der Zeit in verteilten Umgebungen.

•

Der Transaction Service stellt ein Zwei-Phasen-Commit-Protokoll zur Verfügung.

•

Der Security Service ist ein Rahmenwerk für verteilte Objektsicherheit.

•

Der Persistence Service erlaubt die dauerhafte Speicherung von Komponenten auf verschiedenen Speicher-Servern, wie ObjektDatenbanken (ODBMSs), relationale Datenbanken (RDBMSs) oder einfache Files.

•

Der Relationship Service speichert die Beziehungen zwischen Objekten und stellt Metadaten über die Objekte bereit.

•

Der Externalization Service bietet einen Ein-/Ausgabestrom für Komponenten.

•

Der Query Service ist eine Obermenge von SQL und bietet Datenbankanfragen und -abfragen.

•

Mit dem Properties Service können zu den Komponenten benannte Werte oder Eigenschaften, wie z.B. Titel oder Datum, assoziiert werden.

•

Der Trader Service erlaubt Objekten, ihren Service anzubieten und um Kunden für diesen Service zu werben.

•

Der Collection Service ist ein Interface zum Anlegen und Manipulieren von Kollektion von Objekten.

CORBAfacility sind Kollektionen von in IDL spezifizierten Rahmenwerken, welche Services bieten, die direkt von den Applikationsobjekten benutzt werden können. Die CORBAfacilities können die CORBAservices benutzen, von ihnen erben oder sie erweitern. Die CORBAfacilities umfassen folgende Facilities:

3.4 Programmiermodelle für verteilten Speicher •

Distributed Document Component Facility.

•

System Management Facility.

•

Internationalization and Time Operation Facilities.

•

Data Interchange Facility.

Die CORBAdomain umfasst bereichsspezifische Rahmenwerke. Beispiele für solche sich zurzeit in Entwicklung befindlichen Bereiche sind: Business Object Framework, Manufacturing, Transportation, Finanzen, Gesundheitswesen, Telecombereich.

CORBA domain

3.4.5.6.2 Object Request Broker (ORB) Der Object Request Broker ist das Herz beim CORBARefererenzmodell und ermöglicht einem Client das Senden einer Anforderung an eine Objektimplementierung, wobei unter Objektimplementierung der Code und die Daten, welche das aktuelle Objekt implementieren, verstanden wird. Das Interface, welches der Client sieht, ist unabhängig von der Lokalisierung der Objektimplementierung und von der Programmiersprache, in der das Objekt implementiert ist, oder irgendwelchen anderen Aspekten, die nicht durch das Interface spezifiziert sind. Zwischen dem Client und dem Objekt ist bei CORBA ein forwarding Broker [B 04] zwischengeschaltet.

ORB forwarding Broker

Client-Stubs für jede Schnittstelle werden zur Einbindung von Clients zur Verfügung gestellt, die diese Schnittstellen nutzen. Der Client-Stub für eine bestimmte Schnittstelle stellt eine Pseudoimplementierung für jede Methode in der Schnittstelle zur Verfügung. Anstatt ServerMethoden direkt auszuführen, kommunizieren die Methoden des Stubs mit dem ORB, damit für die benötigten Parameter eine Formatübertragung bzw. eine umgekehrte Formatübertragung durchgeführt werden kann. Auf der anderen Seite stehen die Skeletons, die das Gerüst bilden, auf dem der Server erzeugt wird.Für jede Methode einer Schnittstelle generiert der IDL-Compiler eine leere Methode im ServerSkeleton. Der Entwickler stellt dann für jede dieser Methoden die Implementierung zur Verfügung. Abbildung 3-27 definiert eine Architektur von Interfaces, bestehend aus drei Komponenten: 1. Interface für den Client, 2. Interface für die Objektimplementierung und 3. Interface für das ORB.

279

3 Programmiermodelle für parallele und verteilte Systeme Abb. 3-27: Struktur des CORBAInterface

Interfaces auf der Seite des Clients Die clientseitige Architektur stellt Clients das folgende Interface zum ORB und zu Serverobjekten zur Verfügung: IDL Stubs

280

1. IDL Stubs. Das IDL Stub-Interface enthält Funktionen, die aus einer IDL-Interface-Definition generiert und zum Clientprogramm hinzugebunden werden. Dies ist das statische Interface, das die Sprache des Clients in die ORB-Implementierung abbildet. Das IDL Stub-Interface erlaubt die Interaktion eines Clients mit einem Objekt, das auf einem anderen Rechner liegt, indem die Methoden des Objekts aufgerufen werden, als ob das Objekt lokal vorliegen würde.

3.4 Programmiermodelle für verteilten Speicher 2. Dynamic Invocation Interface (DII). Das DII–Interface erlaubt das Absetzen einer Anforderung an ein Objekt zur Laufzeit. Dieses Interface ist notwendig, wenn das Interface des Objekts bei der Konstruktion der Clientsoftware und somit zur Kompilierungszeit nicht bekannt ist; daher kann es auch nicht wie bei IDL-Stubs zum Clientcode hinzugebunden werden. Mit dem DII-Mechanismus kann durch einen Aufruf an das ORB auf ein Objekt zugegriffen werden, das eine Spezifikation für die Methoden und deren Parameter besitzt. Diese Spezifikation ist in einem Implementation Repository abgelegt, so dass das ORB die Objektimplementierung lokalisieren und aktivieren kann.

Dynamic Invocation Interface

3. ORB-Interface. Das ORB-Interface gestattet einen direkten Zugriff durch Client- oder Servercode zu den Funktionen des ORB. In der gegenwärtigen Spezifikation für CORBA enthält dieses Interface nur wenige Operationen, wie beispielsweise die Umwandlung einer Objektreferenz in einen String.

ORB-Interface

Interfaces auf der Implementierungsseite Das implementierungsseitige Interface besteht aus den folgenden upcall Interfaces, welche Aufrufe vom ORB zu der Objektimplementierung durchführen. 1. IDL Skeleton. Das IDL Skeleton-Interface ist das serverseitige Gegenstück zum IDL-Stub-Interface. Das IDL-Skeleton wird aus der IDLInterface-Definition generiert.

IDL Sekeleton

2. Dynamic Skeleton Interface (DSI). Das DSI ist das Gegenstück vom Dynamic Invocation Interface auf der Serverseite. Es bindet zur Laufzeit Anfragen vom ORB zu einer Objektimplementierung. Das Dynamic Skeleton inspiziert dazu die Parameter einer vom ORB eingehenden Anfrage, bestimmt das Zielobjekt und die Methode mit Hilfe des Implementation Repository und nimmt die Rückantwort von der Objektimplementierung entgegen.

Dynamic Sekeleton Interface

Das DSI ist weiterhin geeignet zum Bau von Brücken zwischen verschiedenen ORBs. Ruft ein Client von einem ORB einen Server eines anderen ORBs auf, so geht die Anfrage an das andere ORB, das es nun mit Hilfe des DSI an den Server weiterleitet. 3. Object Adapter. Die eigentliche Kommunikationsanbindung an die Objektimplementierung übernimmt dabei der Object Adapter. Der Object Adapter liefert die Laufzeitumgebung zur Instantiierung von Serverobjekten zum Weiterleiten der Anforderungen an die

Object Adapter

281

3 Programmiermodelle für parallele und verteilte Systeme Serverobjekte und dient zum Abbilden der Objektreferenzen auf die Serverobjekte. Der Object Adapter hat drei verschiedene Interfaces:

−

Ein privates Interface zum IDL Skeleton.

−

Ein privates Interface zu dem ORB Core.

−

Ein public Interface, das durch die Objektimplementierung genutzt wird.

Durch diese drei Interfaces ist der Adapter von der Objektimplementierung und von dem ORB Core so weit wie möglich isoliert und abgeschottet. Basic Object Adapter

Der Adapter kann ausgetauscht werden und spezielle Funktionalität anbieten, um zum Beispiel Serverobjekte nicht als Prozesse, sondern als Datenbankobjekte realisieren zu können. Um ein Ausufern bei den Objektadaptern zu vermeiden, spezifiziert CORBA einen Standard-Adapter, den so genannten Basic Object Adapter (BOA). Der BOA muss mit jedem ORB mitgeliefert werden und kann für die meisten CORBA-Objekte eingesetzt werden. Der BOA enthält Interfaces zur Generierung von Objektreferenzen, zur Registrierung von Objektimplementierungen, zur Aktivierung von Objektimplementierungen und einige sicherheitsrelevante Anfragen, z.B. zur Authentifizierung. Bei der Aktivierung von Objektimplementierungen kann nach der Methode Shared, Unshared, Per Request oder Persistent Server vorgegangen werden [B 04].

ORB Core Der ORB Core repräsentiert die Objekte und die Anfragen. Er leitet die Anfragen vom Client zu einem Objektadapter, der zu dem Zielobjekt gehört. Da CORBA ein weites Feld von Objektmechanismen, Objektlebenszeiten, Strategien und Implementierungssprachen unterstützt, kann der ORB Core kein einzelnes Interface anbieten. Stattdessen wurde der ORB mit Komponenten versehen, die diese Unterschiede dem ORB Core gegenüber maskieren. Ein Beispiel und die wichtigste Komponente ist dabei der Objektadapter.

Repositories Der Broker-Mechanismus wird unterstützt durch einen Speicher für Schnittstellenbeschreibungen (Interface Repository) und eine Ablage für die dahinterstehende Implementierung (Implementation Repository). Das Interface Repository ermöglicht den Zugriff auf Typinformati-

282

3.4 Programmiermodelle für verteilten Speicher onen einer Schnittstelle zur Laufzeit und kann zur Unterstützung des DII eingesetzt werden. Das Implementation Repository dient dem Broker zur bedarfsweisen Aktivierung der Objektimplementierung, wenn also ein Aufruf dafür vorliegt. Nachfolgende Abbildung 3-28 zeigt, wie Interface und Implementationsinformation den Clients und der Objektimplementierung zur Verfügung gestellt werden. Das Interface ist definiert in der Interface Definition Language (IDL) oder im Interface Repository; aus der IDL-Definition wird der Stub des Clients oder das Skeleton der Objektimplementation generiert. Die Information zur Objektimplementierung wird zur Installationszeit aufgebaut und im Implementation Repository gespeichert; sie dient zur Weiterleitung einer Abfrage an die Objektimplementierung. Abb. 3-28: Interface und Implementation Repository

ORB-Interoperabilität CORBA ist ein offener Standard und nur eine Referenzarchitektur und beschreibt nicht irgendwelche Implementierungstechnologien. Verschiedene Anbieter und Organisationen können ihre eigene Version des CORBA-Standards implementieren. Zur Herstellung der Interoperabilität zwischen verschiedenen CORBA-Produkten ist in CORBA das Interface zwischen den Clients und dem ORB beibehalten und die Verantwortung für die Interoperabilität an den ORB delegiert. Die den verschiedenen ORBs unterliegende Kommunikation und Koordination ist festgelegt durch das General Inter-ORB Protocol (GIOP). Das GIOP definiert eine Transfer-Syntax, die bekannt ist unter Common Data Representation (CDR) und sieben verschiedene Nachrichten-

283

3 Programmiermodelle für parallele und verteilte Systeme typen. Die Abbildung von GIOP auf TCP/IP ist beschrieben im Internet Inter-ORB Protocol (IIOP). Die interoperable Objektreferenz (IOR) ist der Mechanismus, mit dem auf die Objekte zugegriffen wird, durch das IIOP und zwischen verschiedenen ORB-Anbietern. Die IOR enthält die ORBs-interne Objektreferenz, die Internetadresse und eine Portnummer. Die IOR wird verwaltet durch die ORB und ist nicht sichtbar für einen Anwendungsprogrammierer. Zusätzlich zum IIOP liefert das DCE Environment Specfic Inter-ORB Protocol (DCE ESIOP) Unterstützung für den DCE-RPC-Mechanismus, so dass ein CORBA-System mit DCE-basierten Systemen zusammenarbeiten kann. Für RMI-Systeme kann die Anbindung an CORBA mit RMI-IIOP [IIOP 07] erfolgen.

3.4.5.6.3 CORBA Component Model (CCM) CCM basiert auf EJBs

Das CORBA Component Model (CCM) [CCM 07], [NRS 04] stellt die wesentlichste Erweiterung der Version 3.0 [S 01] der CORBASpezifikation dar und erweitert die CORBA 2 Spezifikation um Komponenten. Das CORBA Component Model basiert konzeptionell in vielen Bereichen auf dem Java Enterprise Beans (EJB)-Ansatz [BR 07], siehe auch [B 04], und erweitert diesen u.a. hinsichtlich der Unterstützung anderer Sprachen außer Java. Die Laufzeitumgebung von CORBA-Komponenten ist wie bei EJBs der Container, der die Heterogenität der benutzten Hard- und Software verbirgt. Ähnlich wie bei den EJBs werden unterschiedliche Arten von Bausteinen unterschieden: Session- und Entity-Bausteine, die ihrem jeweiligen Äquivalent in der EJB-Architektur entsprechen; darüber hinaus Service-Komponenten, die einen zustandslosen Dienst bereitsstellen, sowie Process-Komponenten zur Modellierung von Abläufen. Eine Komponente kapselt ihren inneren Aufbau durch Interfaces Das Interface wird durch folgende Ports angeboten:

Portarten

284

•

Facets sind Interfaces, welche die Komponente anbietet. Die Interfaces sind voneinander verschieden und benannt.

•

Receptable sind Schnittstellen, so dass eine Komponente auf andere Komponenten zugreifen kann.

•

Event Source (Ereignisproduzent) bietet die Möglichkeit, ein Ereignis zu senden.

•

Event Sink (Ereigniskonsument) kann ein Ereignis empfangen.

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ x

StreamȱSourceȱdientȱzurȱÜbertragungȱvonȱStreams.

x

StreamȱSinkȱempfängtȱStreams.ȱ

Wieȱ einȱ Objektȱ kannȱ eineȱ Komponenteȱ Attributeȱ besitzen.ȱ Sieȱ dienenȱ wenigerȱ alsȱ Zustandsmerkmaleȱ wieȱ beiȱ Objekten,ȱ sondernȱ sindȱ fürȱ Konfigurationszweckeȱgedacht.ȱ ȱ

3.4.5.7 Remote Method Invocation (RMI) Remoteȱ Methodȱ Invocationȱ (RMI)ȱ [RMIȱ 07]ȱ ermöglichtȱ es,ȱ Methodenȱ entferntesȱ fürȱ JavaȬObjekteȱ aufzurufen,ȱ dieȱ vonȱ einerȱ anderenȱ Javaȱ Virtuellenȱ Objektȱ Maschineȱ (JVM)ȱ erzeugtȱ undȱ verwaltetȱ werdenȱ –ȱ wobeiȱ dieseȱ inȱ derȱ RegelȱaufȱeinemȱanderenȱRechnerȱlaufen.ȱEinȱsolchesȱObjektȱeinerȱanȬ derenȱJVMȱnenntȱmanȱdementsprechendȱentferntesȱObjektȱ(remoteȱobject).ȱ RMIȱ istȱ eineȱ reinȱ JavaȬbasierteȱ Lösung,ȱ deshalbȱ mussȱ nichtȱ aufȱ eineȱ rmicȱ eigeneȱSpracheȱzurȱDefinitionȱderȱSchnittstelleȱzurückgegriffenȱwerden.ȱ Derȱ Compilerȱrmicȱ generiertȱ denȱ Stubȱ fürȱ denȱ Clientȱ undȱ denȱ Serverȱ direktȱausȱdenȱexistierendenȱKlassenȱfürȱdasȱProgramm.ȱȱ Derȱ ServerȬStubȱ heißtȱ beiȱ Javaȱ Skeletonȱ undȱ stelltȱ nurȱ einȱ Skelettȱ fürȱ denȱAufrufȱdar.ȱImȱGegensatzȱdazuȱistȱderȱClientȬStubȱeinȱStellverteterȱ (Proxy)ȱ fürȱ dasȱ aufzurufendeȱ Objekt.ȱ Dadurchȱ unterscheidetȱ sichȱ ausȱ SichtȱdesȱClientsȱeinȱentfernterȱAufrufȱnichtȱvonȱeinemȱlokalenȱAufruf.ȱ DemȱClientȱliegtȱjaȱeinȱStellvertreterȱdesȱentferntenȱObjektesȱvor.ȱȱȱ

ClientȬStubȱ=ȱ Proxyȱ

Dieȱ Anspracheȱ einesȱ entferntenȱ Objektsȱ vonȱ derȱ ClientȬSeiteȱ ausȱ geȬ schiehtȱüberȱeinenȱhandleȬdrivenȱBroker.ȱAlleȱentferntenȱObjekteȱsindȱ beimȱ Brokerȱ oderȱ derȱ Registryȱ registiert.ȱ Dieȱ Adresseȱ derȱ Registryȱ istȱ standardmäßigȱdieȱPortnummerȱ1099.ȱȱ

Registryȱ

MöchteȱnunȱeinȱClientȱeineȱMethodeȱeinesȱentferntenȱObjektsȱaufrufen,ȱ soȱmussȱerȱzunächtȱinȱderȱRegistryȱnachschauen,ȱobȱdasȱentfernteȱObȬ jektȱ registriertȱ ist.ȱ Istȱ esȱ registriert,ȱ kannȱ derȱ Clientȱ anschließendȱ denȱ Stubȱ fürȱ dieȱ entfernteȱ Methodeȱ anfordern.ȱ Mitȱ demȱ erhaltenenȱ Stubȱ kannȱdannȱdieȱentfernteȱMethodeȱaufgerufenȱwerden.ȱ Zurȱ Implementierungȱ derȱ Anspracheȱ einesȱ entferntenȱ Objektsȱ undȱ damitȱ einesȱ Servers,ȱ aufȱ demȱ dasȱ entfernteȱ Objektȱ liegt,ȱ stehenȱ vierȱ PackagesȱzurȱVerfügung:ȱ x

java.rmiȱ definiertȱ dieȱ Klassen,ȱ Interfacesȱ undȱ Ausnahmen,ȱ wieȱ sieȱ aufȱ derȱ Seiteȱ desȱ Clientsȱ (Objekte,ȱ welcheȱ entfernteȱ Methodenȱ aufrufen)ȱgesehenȱwerden.ȱ

x

java.rmi.registryȱ istȱ dieȱ Registryȱ undȱ definiertȱ dieȱ Klassen,ȱ InterfacesȱundȱAusnahmenȱzurȱBenennungȱvonȱentferntenȱObjektenȱ undȱdientȱzurȱLokalisierungȱderȱObjekte.ȱȱ

285ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ x

java.rmi.serverȱ definiertȱ dieȱ Klassen,ȱ Interfacesȱ undȱ AusnahȬ men,ȱdieȱaufȱderȱServerseiteȱsichtbarȱsind.ȱȱ

x

java.rmi.dgcȱ behandeltȱ dieȱ verteilteȱ Speicherbereinigungȱ (distȬ ributedȱgarbageȱcollection).ȱ

ȱ Abb.ȱ3Ȭ29:ȱ Aufrufȱeinerȱ entferntenȱ Methodeȱmitȱ Hilfeȱderȱ Registryȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

3.4.5.7.1 Package java.rmi Clients,ȱ welcheȱ dieȱ entfernteȱ Methodeȱ aufrufen,ȱ undȱ ebenfallsȱ Serverȱ benutzenȱ dieȱ Klassenȱ desȱ Packagesȱ java.rmi,ȱ undȱ müssenȱ sieȱ desȬ halbȱimportieren.ȱDasȱPackageȱenthältȱȱ

286ȱ

x

dasȱInterfaceȱRemote,ȱȱ

x

dieȱKlasseȱrmi.Naming,ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ x

dieȱKlasseȱRMISecurityManagerȱundȱ

x

einigeȱAusnahmen.ȱ

InterfaceȱRemoteȱ ZurȱFestlegungȱeinesȱentferntenȱInterfacesȱdientȱdasȱInterfaceȱRemoteȱ ausȱdemȱPackageȱjava.rmi.ȱDasȱInterfaceȱRemoteȱistȱeinȱkennzeichȬ nendesȱ Interfaceȱ undȱ deklariertȱ keineȱ Methoden.ȱ Aufȱ einȱ Objektȱ derȱ Klasse,ȱwelcheȱdasȱInterfcaeȱRemoteȱdirektȱoderȱindirektȱalsȱentferntesȱ Objektȱ implementiert,ȱ kannȱ vonȱ jederȱ JavaȬvirtuellenȱ Maschineȱ zugeȬ griffenȱwerden,ȱdieȱeineȱVerbindungȱmitȱdemȱRechnerȱhat,ȱaufȱderȱdasȱ entfernteȱObjektȱausgeführtȱwird.ȱȱ

java.rmi.Namingȱ Dieȱ Klasseȱ java.rmi.Namingȱ istȱ dieȱ Implementierungȱ derȱ Registry.ȱ Dieȱ Registryȱbildetȱ denȱ UniformȱResourceȱ Locatorȱ (URL)ȱ aufȱ dasȱ entȬ fernteȱObjektȱab.ȱȱ JederȱEintragȱinȱdieȱRegistryȱhatȱeinenȱNamenȱundȱeineȱObjektreferenz.ȱ Dieȱ Clientsȱ gebenȱ denȱ URLȱ anȱ undȱ bekommenȱ eineȱ Objektreferenzȱ zurück.ȱDieȱKlasseȱNamingȱimplementiertȱkeinenȱhierarchischen,ȱsonȬ dernȱ einenȱ flachenȱ Namensraum.ȱ Mitȱ derȱ bind()ȬMethodeȱ kannȱ einȱ ServerȱeinenȱNamenȱfürȱeinȱentferntesȱObjektȱeintragen.ȱ public static void bind (String url, Remote ro) throws RemoteException, AlreadyBoundException, AccessException, UnknownHostException;

bindȱ

IstȱdasȱBindenȱerfolgreich,ȱsoȱerhältȱderȱClientȱdenȱNamenȱdesȱentfernȬ tenȱObjektsȱmitȱHilfeȱderȱURL.ȱȱ IstȱanȱdieȱURLȱschonȱeinȱNameȱgebunden,ȱkannȱmitȱrebindȱeinȱneuerȱ NameȱanȱdieȱURLȱgebundenȱwerden.ȱ public static void rebind (String url,Remote obj) throws RemoteException, AccessException, UnknownHostException;

rebindȱ

Zumȱ Entfernenȱ einesȱ Objektsȱ ausȱ derȱ Registryȱ stehtȱ dieȱ unbindȬ MethodeȱzurȱVerfügung.ȱ public static void unbind (String url) throws NotBoundException, AccessException; unknownHostexception;

unbindȱ

DerȱmitȱeinemȱURLȱassoziierteȱNameȱkannȱsichȱeinȱClientȱmitȱderȱMeȬ thodeȱlookupȱgebenȱlassen:ȱ

287ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ lookupȱ

public static Remote lookup (String url) throws RemoteException, NotBoundException, AccessException, UnknownHostException; Zumȱ Auflistenȱ allerȱ Namensbindungenȱ anȱ einenȱ URLȱ dientȱ dieȱ MeȬ thodeȱlist.ȱ

listȱ

public static String[] list (String url) throws RemoteException, AccessException, UnknownHostException;

REGISTRY_ȱ

Schließlichȱ besitztȱ dasȱ Namingȱ Interfaceȱ nebenȱ diesenȱ fünfȱ Methodenȱ nochȱ einȱ öffentliches,ȱ alsȱ finalȱ deklariertes,ȱ statischesȱ Feldȱ REGISTRY_PORT.ȱ Derȱ standardmäßigeȱPort,ȱ denȱ dieȱRegistryȱ abhört,ȱ istȱ derȱPortȱ1099.ȱ

PORTȱ

RMISecurityManagerȱ Einȱ Clientȱ lädtȱ einenȱ Stubȱ vonȱ einemȱ möglicherweiseȱ nichtȱ vertrauȬ enswürdigenȱ Server.ȱ Normalerweiseȱ verpacktȱ einȱ Stubȱ nurȱ dieȱ ParaȬ meterȱundȱsendetȱsieȱüberȱdasȱNetz,ȱempfängtȱdieȱRückgabewerteȱundȱ entpacktȱ sieȱ dannȱ wieder.ȱ Einȱ vomȱ rmicȬCompilerȱ generierterȱ Stubȱ verhältȱsichȱgutmütig,ȱjedochȱkannȱderȱStubȱabgefangenȱundȱmanipuȬ liertȱwerden,ȱsoȱdassȱeinȱSicherheitslochȱentsteht.ȱWeiterhinȱistȱfürȱdieȱ Javaȱ Virtuelleȱ Maschineȱ derȱ Stubȱ nurȱ eineȱ Klasseȱ mitȱ Methoden,ȱ dieȱ irgendetwasȱtunȱkönnen.ȱDieȱJavaȱVirtuelleȱMaschineȱerlaubtȱdasȱHerȬ unterladenȱ vonȱ Klassenȱ nur,ȱ wennȱ einȱ SecurityȬManagerȱ zwischengeȬ schaltetȱist.ȱIstȱkeinȱSecurityȬManagerȱzwischengeschaltet,ȱsoȱkannȱeineȱ StubȬKlasseȱnurȱvonȱderȱlokalenȱMaschineȱgeladenȱwerden.ȱ Derȱ RMISecurityManagerȱ istȱ eineȱ Unterklasseȱ vonȱ java.lang.SecurityManagerȱ undȱ besitztȱ einenȱ Konstruktorȱ ohneȱ Argumente.ȱ RMISecurity Managerȱ

public RMISecurityManager(); Zumȱ Setzenȱ desȱ SecurityȬManagersȱ kannȱ dieȱ statischeȱ Methodeȱ System.setSecurityManager()ȱ eingesetztȱ werden.ȱ Dasȱ Programmȱ 3Ȭ 29ȱ (sieheȱ Abschnittȱ 3.4.3.7.5)ȱ undȱ dasȱ Programmfragmentȱ zeigen,ȱ wieȱ einȱneuerȱSecurityȬManagerȱinnerhalbȱdieserȱMethodeȱangelegtȱwird:ȱ System.setSecurityManager (newRMISecurityManager());

3.4.5.7.2 Package java.rmi.registry Dieȱ Registryȱ fürȱ entfernteȱ Objekteȱ wirdȱ durchȱ dasȱ Packageȱ rmi.registryȱverwaltet.ȱDieȱClientsȱkönnenȱdurchȱAnfragenȱanȱdieȱ

288ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ Registryȱ herausfinden,ȱ welcheȱ entferntenȱ Objekteȱ zurȱ Verfügungȱ steȬ hen,ȱundȱerhaltenȱdannȱeineȱentfernteȱReferenzȱaufȱdieseȱObjekte.ȱȱ EineȱImplementierungȱderȱRegistryȱoderȱgenauerȱgesagtȱdesȱInterfacesȱ java.rmi.registry.Registry,ȱ habenȱ wirȱ bereitsȱ kennengelernt,ȱ esȱ warȱ dieȱ Klasseȱ java.rmi.Namingȱ (sieheȱ vorhergehendenȱ AbȬ schnitt).ȱ Alleȱ öffentlichenȱ Methodenȱ vonȱ java.rmi.Namingȱ sindȱ dadurchȱöffentlicheȱMethodenȱvonȱjava.rmi.registry.Registry.ȱȱ Sollȱ nichtȱ dieȱ vorhandeneȱ Implementierungȱ derȱ Registryȱ java.rmi.Namingȱ benutztȱ werden,ȱ sondernȱ eineȱ eigeneȱ Registryȱ geȬ schriebenȱ werden,ȱ soȱ stehtȱ dasȱ Interfaceȱ java.rmi.registry.RegistryHandlerȱ zurȱ Verfügung.ȱ Esȱ besitztȱ dieȱMethodeȱȱ public abstract Registry registryStub ( String Host, int port) throws RemoteException, UnknownHostException;

ȱ registryStubȱ

welcheȱ einȱ StubȬObjektȱ zurückgibt,ȱ dasȱ zurȱ Kommunikationȱ mitȱ derȱ Registryȱ aufȱ einemȱ bestimmtenȱ Rechnerȱ anȱ einemȱ bestimmtenȱ Portȱ dient.ȱȱ EineȱweitereȱMethodeȱ public abstract Registry registryImpl (int port) throws RemoteException;

registryImpl

konstruiertȱ eineȱ Registryȱ anȱ einemȱ bestimmtenȱ Portȱ undȱ gibtȱ sieȱ zuȬ rück.ȱ ZurȱLokalisierungȱeinerȱRegistryȱfürȱdenȱClientȱdientȱeineȱKlasseȱjava.rmi.registry.LocateRegistry.ȱ Sieȱ besitztȱ vierȱ polymorpheȱ MethodenȱgetRegistry().ȱ public static Registry getRegistry() throws RemoteException;

getRegistry

public static Registry getRegistry(int port) throws RemoteException; public static Registry getRegistry(String host) throws RemoteException, UnknownHostException; public static Registry getRegistry (String host,int port) throws RemoteException, UnknownHostException;

289ȱ

3 Programmiermodelle für parallele und verteilte Systeme Es ist vollkommen egal, wo die Registry läuft, auf dem lokalen Host und dem standardmäßigen Port 1099, oder auf dem lokalen Host und einem speziellen Port, oder auf einem speziellen Host und dem Port 1099, oder auf einem speziellen Host und einem speziellen Port, in jedem Fall liefert getRegistry() die Registry zurück. Eine weitere und letzte Methode in java.rmi.registry.LocateRegistry dient zum Anlegen und Starten der Registry an einem bestimmten Port. createRegistry

public static Registry createRegistry (int port) throws RemoteException;

3.4.5.7.3 Package java.rmi.server Das Package java.rmi.server enthält das Gerüst zur Bildung von entfernten Objekten. Neben weiteren Ausnahmen, Interfaces und Klassen, die dieses Package enthält, benötigt man zur Implementierung von entfernten Objekten die folgenden Klassen: •

Die Basisklasse RemoteObject für entfernte Objekte,

•

die Klasse RemoteServer, die RemoteObject erweitert, und

•

die Klasse UnicastRemoteObject, die RemoteServer erweitert.

Kommt eine Applikation mit einer Unicast-Kommunikation (Eins-zueins-Kommunikation basierend auf Sockets) aus und benötigt sie keine Multicast-Kommunikation (Eins-zu-viele-Kommunikation), so muss man nur die Klasse UnicastRemoteObject erweitern und braucht sich nicht um die darüber liegenden Klassen RemoteServer und RemoteObject zu kümmern.

RemoteObject Die Klasse RemoteObject ist eine spezielle Version von der Klasse java.lang.Object aus dem Package java.lang. java.lang.Object ist hier also ausgelegt für entfernte Objekte. Die Klasse RemoteObject bietet toString() und hashCode().

die

Methoden

equals(),

Die Methode equals() dient zum Vergleich von zwei entfernten Objekten. equals

public boolean equals(Object obj); Die Methode toString() liefert den Hostnamen, die Portnummer und eine Referenznummer für das entfernte Objekt.

290

3.4 Programmiermodelle für verteilten Speicher public String toString();

toString

Die Funktion hashCode() liefert einen Hashcode-Wert für das entfernte Objekt. public native int hashCode ();

hashCode

RemoteServer Die Klasse RemoteServer erweitert die Klasse RemoteObject. RemoteServer ist eine abstrakte Klasse und dient zur Implementierung von Servern. Ein solcher spezieller Server ist beispielsweise das nachfolgend beschriebene UnicastRemoteObject. Das UnicastRemoteObject ist die einzige Unterklasse von RemoteServer. Die Klasse RemoteServer besitzt eine Methode zur Lokalisierung des Clients, mit dem der Server kommuniziert. getClientHost liefert den Hostnamen des Clients, der die gerade laufende Methode aufgerufen hat. public static String getClientHost() throws ServerNotActiveException;

getClientHost

getClientPort() liefert die Portnummer des Clients, der die gerade laufende Methode aufgerufen hat. public int getClientPort () throws ServerNotActiveException;

getClientPort

Zu Testzwecken ist es nützlich, die Aufrufe an das entfernte Objekt zu kennen. Übergibt man setlog eine Null, anstatt eines Ausgabestroms, so wird das Logging abgeschaltet. public static void setLog (OutputStream os);

setLog

Soll dem Ausgabestrom noch mehr Information hinzugefügt werden, so muss der PrintStream manipuliert werden. public static PrintStream getLog();

getLog

UnicastRemoteObject Zum Anlegen eines entfernten Objekts muss die Klasse UnicastRemoteObject in einer eigenen Unterklasse erweitert werden, und die Unterklasse muss eine Unterklasse von java.rmi.Remote implementieren:

291

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ public class OwnclassImpl extends UnicastRemoteObject implements Ownclass{ ... Dasȱ UnicastRemoteObjectȱ läuftȱ aufȱ einemȱ Hostȱ undȱ übernimmtȱ dasȱ Verpackenȱ undȱ Entpackenȱ derȱ Argumenteȱ undȱ Rückgabewerte.ȱ DasȱVersendenȱderȱPaketeȱgeschiehtȱdannȱüberȱTCPȬSockets.ȱEineȱAnȬ wendungȱbrauchtȱsichȱdarumȱjedochȱnichtȱzuȱkümmern,ȱsieȱkannȱeinȬ fachȱdieȱKlasseȱUnicastRemoteObjectȱȱbenutzen.ȱȱȱ Dieȱ Klasseȱ UnicastRemoteObjectȱ istȱ somitȱ einȱ Rahmenwerkȱ fürȱ entfernteȱObjekte.ȱBenötigtȱmanȱbeispielsweiseȱentfernteȱObjekte,ȱwelȬ cheȱ UDPȱ benutzen,ȱ oderȱ Objekte,ȱ welcheȱ dieȱ Arbeitslastȱ aufȱ mehrereȱ Serverȱ verteilen,ȱ soȱ mussȱdieȱ Klasseȱ RemoteServerȱ erweitertȱundȱ esȱ müssenȱdieȱabstraktenȱMethodenȱdieserȱKlasseȱimplementiertȱwerden.ȱ FürȱgewöhnlicheȱAufgabenȱreichtȱjedochȱdieȱUnterklasseȱUnicastRemoteObjectȱaus,ȱundȱesȱkannȱeinfachȱdieseȱUnterklasseȱbenutztȱwerȬ den.ȱȱȱ

3.4.5.7.4 Serialisieren von Objekten ImȱVergleichȱzuȱanderenȱSystemenȱwieȱRPCsȱundȱCORBAȱerlaubtȱRMIȱ nichtȱ nur,ȱ Parameter,ȱ Ausnahmenȱ undȱ Ergebnisse,ȱ alsoȱ irgendwelcheȱ primitiveȱ Datentypenȱ anȱ Objekteȱ zuȱ versenden,ȱ sondernȱ auchȱ ganzeȱ JavaȬObjekteȱ mitȱ derenȱ Methoden.ȱ Umȱ dieȱ Kopieȱ einesȱ Objektsȱ vonȱ einerȱ Maschineȱaufȱ eineȱ entfernteȱ Maschineȱzuȱ verschicken,ȱ mussȱ dasȱ Objektȱ inȱ einenȱ Stromȱ vonȱ Bytesȱ konvertiertȱ werden.ȱ Dabeiȱ istȱ zuȱ beȬ achten,ȱ dassȱ einȱ Objektȱ andereȱ Objekteȱ enthaltenȱ kannȱ undȱ dieseȱ ObȬ jekteȱebenfallsȱinȱeinenȱByteȬStromȱkonvertiertȱwerdenȱmüssen.ȱ Objectȱ Serializationȱȱ

DasȱSerialisierenȱvonȱObjektenȱ(ObjectȱSerialization)ȱistȱeinȱVerfahren,ȱ dasȱObjekteȱinȱeinenȱByteȬStromȱumwandelnȱundȱausȱdemȱByteȬStromȱ wiederȱ dasȱ ursprünglicheȱ Objektȱ rekonstruierenȱ kann.ȱ Derȱ HerstelȬ lungsprozessȱerzeugtȱeinȱneuesȱJavaȬObjekt,ȱdasȱidentischȱistȱmitȱdemȱ ursprünglichenȱObjekt.ȱȱ Derȱ ByteȬStromȱ kannȱ dannȱ überȱ dasȱ Netzȱ anȱ andereȱ Maschinenȱ geȬ schicktȱwerden,ȱoderȱerȱkannȱinȱeineȱDateiȱgeschriebenȱundȱzuȱeinemȱ späterenȱZeitpunktȱwiederȱvonȱderȱDateiȱgelesenȱwerden.ȱDiesȱermögȬ lichtȱeineȱpermanenteȱSpeicherungȱdesȱZustandesȱeinesȱObjekts.ȱȱȱ Ausȱ Sicherheitsgründenȱ besitztȱ Javaȱ Einschränkungenȱ bezüglichȱ derȱ Objekte,ȱ dieȱ serialisiertȱ werdenȱ können.ȱ Alleȱ primitivenȱ Typenȱ vonȱ JavaȱundȱentfernteȱObjekteȱkönnenȱserialisiertȱwerden.ȱNichtȱentfernteȱ Objekteȱ müssenȱ zumȱ Serialisierenȱ dasȱ Interfaceȱ java.io.Serializableȱimplementieren:ȱ

292ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ import java.io.Serializiable; public class Serial_Class implements Serializable { ...

3.4.5.7.5 RMI-Programmierung DieȱErstellungȱeinesȱRMIȬProgrammsȱgeschiehtȱinȱfolgendenȱSchritten:ȱȱ 1.

DefiniereȱdasȱentfernteȱInterfaceȱ(InterfaceȱDefinitionȱFile),ȱdasȱdieȱ entferntenȱMethodenȱbeschreibt,ȱwelcheȱderȱClientȱbenutzt,ȱumȱmitȱ demȱentferntenȱServerȱinȱInteraktionȱzuȱtreten.ȱȱ

2.

Definiereȱ dieȱ ServerȬApplikation,ȱ welcheȱ dasȱ entfernteȱ Interfaceȱ implementiertȱ(InterfaceȱImplementationȱFile).ȱ

3.

Ausȱ demȱ Interfaceȱ Implementationȱ Fileȱ kannȱ mitȱ Hilfeȱ desȱ rmicȬ CompilersȱderȱStubȬClassȬFileȱ(Impl_Stub.class)ȱgeneriertȱwerden.ȱȱ

4.

StarteȱdieȱRegistryȱundȱdenȱServer.ȱ

5.

Definiereȱ denȱ Client,ȱ derȱ dieȱ entferntenȱ Methodenȱ desȱ Serversȱ aufruft,ȱundȱstarteȱdenȱClient.ȱ

DiesesȱVorgehenȱillustrierenȱwirȱanȱeinemȱBeispiel,ȱbeiȱdemȱderȱClientȱ vomȱServerȱundȱsomitȱvonȱderȱentferntenȱMethodeȱeinenȱStringȱ„Hello World“ȱzurückbekommt.ȱDasȱBeispielȱistȱausȱdemȱBuchȱüberȱJavaȱ Netzwerkprogrammierungȱ[Hȱ97]ȱentnommen.ȱȱ

InterfaceȱDefinitionȱFileȱ Zumȱ Anlegenȱ einesȱ entferntenȱ Objektsȱ mussȱ einȱ Interfaceȱ definiertȱ werden,ȱ welchesȱ dasȱ Interfaceȱ java.rmi.Remoteȱ erweitert.ȱ Dieȱ UnȬ terklasseȱvonȱRemoteȱgibtȱan,ȱwelcheȱMethodenȱdesȱentferntenȱObjektsȱ durchȱeinenȱClientȱaufgerufenȱwerdenȱkönnen.ȱȱ InȱunseremȱeinfachenȱBeispielȱhatȱdasȱentfernteȱObjektȱnurȱeineȱeinzigeȱ Methodeȱ sayHello(),ȱ welcheȱ einen Stringȱ zurückgibtȱ undȱ mögliȬ cherweiseȱeineȱAusnahmeȱRemoteExceptionȱauslöst.ȱ // Hello interface definition import java.rmi.*;

Programmȱ3Ȭ30: ȱȱȱȱ Interfaceȱ Hello.javaȱ

public interface Hello extends Remote { public String sayHello() throws RemoteException; }

293ȱ

3 Programmiermodelle für parallele und verteilte Systeme

Interface Implementation File Die Klasse HelloImpl implementiert das Remote Interface Hello und erweitert die Klasse UnicastRemoteObject. Diese Klasse besitzt einen Konstruktor, eine main()-Methode und eine sayHello()Methode. Nur die sayHello()-Methode ist für den Client verfügbar, da nur sie im Hello-Interface definiert ist. Die beiden anderen Methoden main() und HelloImpl() werden von der Server-Seite benutzt und sind nicht für den Client benutzbar. Programm 331: HelloImpl. java

// HelloImpl definition import java.rmi.*; import java.rmi.server.*; import java.net.*; public class HelloImpl extends UnicastRemoteObject implements Hello { public HelloImpl() throws RemoteException { super(); } public String sayHello() throwsRemoteException { return “Hello World!“; } public static void main(String args[]) { try { // create server object HelloImpl h = new HelloImpl(); String serverObjectName= “//localhost/hello“; // bind HelloImpl to the rmi.registry Naming.rebind(serverObjectName, h); System.out.println (“hello Server ready.“); } catch (RemoteException re) { System.out.println ( “Exception in HelloImpl.Main: “ + re); } catch (malformedURLException e) { system.out.println ( “MalformedURLException in HelloImpl.Main: “ + e); } } }

294

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ Derȱ Konstruktorȱ HelloImpl()ȱ ruftȱ denȱ standardmäßigenȱ KonstrukȬ torȱderȱSuperklasseȱauf.ȱȱ Dieȱ Methodeȱ sayHello()ȱ gibtȱ denȱ Stringȱ „Hello World!“ȱ anȱ denȱ Clientȱ zurück,ȱ derȱ dasȱ entfernteȱ Objektȱ aufgerufenȱ hat.ȱ Dieȱ Methodeȱ unterscheidetȱ sichȱ vonȱ derȱ lokalenȱ Methodeȱ nurȱ dadurch,ȱ dassȱ eineȱ entfernteȱ Methodeȱ inȱ einemȱ entferntenȱ Interfaceȱ deklariertȱ werdenȱ muss.ȱDieȱMethodeȱselberȱbleibtȱjedochȱdavonȱunberührtȱundȱsiehtȱwieȱ imȱlokalenȱFallȱaus.ȱȱ Dieȱ Methodeȱ main()ȱ enthältȱ denȱ Codeȱ fürȱ denȱ Server.ȱ Derȱ Serverȱ kannȱvonȱderȱKommandozeileȱausȱoderȱdurchȱeinenȱHTTPȬServerȱoderȱ durchȱeinenȱanderenȱProzessȱgestartetȱwerden.ȱȱ Daȱ dieȱ Methodeȱ main()ȱ statisch ist,ȱ wirdȱ nochȱ keineȱ Instanzȱ vonȱ HelloImplȱangelegt,ȱwennȱmain()ȱläuft.ȱDeshalbȱlegenȱwirȱeinȱHelloImplȬObjektȱ anȱ undȱ bindenȱ denȱ Namenȱ „hello“ȱ inȱ derȱ Namingȱ Registryȱ anȱ dasȱ Objekt.ȱ Diesȱ geschieht,ȱ indemȱ wirȱ dieȱ Methodeȱ rebindȱausȱdemȱPackageȱjava.rmi.Namingȱbenutzen.ȱNormalerweiseȱ benutztȱ manȱ rebindȱ anstattȱ bind,ȱ da,ȱ fallsȱ derȱ Nameȱ schonȱ vorherȱ gebundenȱwurde,ȱderȱneueȱNameȱdesȱObjektsȱdannȱdenȱaltenȱNamenȱ überschreibt.ȱȱȱ NachȱderȱRegistrierungȱgibtȱderȱServerȱaufȱSystem.outȱdieȱNachrichtȱ aus,ȱdassȱerȱbereitȱistȱundȱnunȱentfernteȱAufrufeȱentgegennimmt.ȱȱ Gehtȱ beiȱ derȱ Serverinitialisierungȱ etwasȱ schief,ȱ gibtȱ derȱ catchȬBlockȱ eineȱeinfacheȱFehlermeldungȱaus.ȱȱ

GenerierungȱdesȱStubȱundȱSkeletonȱ BisȱhierhinȱwurdeȱderȱServercodeȱfestgelegt.ȱBevorȱderȱServerȱentfernteȱ Aufrufeȱ entgegennehmenȱ kann,ȱ müssenȱ derȱ vomȱ Clientȱ benötigteȱ StubȬCodeȱ undȱ derȱ vomȱ Serverȱ benötigteȱ SkeletonȬCodeȱ generiertȱ werden.ȱDieseȱAufgabeȱübernimmtȱderȱimȱJavaȱDevelopmentȱKitȱ(JDK)ȱ enthalteneȱRMIȬCompilerȱrmic.ȱȱ rmicȱ mussȱ fürȱ jedeȱ UnicastRemoteObjectȬSubklasseȱ aufgerufenȱ werden.ȱDieȱKommandofolgeȱ $javac HelloImpl.java $rmic HelloImpl compiliertȱ HelloImpl.javaȱ undȱ anschließendȱ generiertȱ sieȱ dieȱ classȬDateienȱ HelloImpl_Stub.class undȱ HelloImpl_Skel.class.

295ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ Dieȱ HelloImpl_Stub.classȱ mussȱ fürȱ denȱ Clientȱ verfügbarȱ seinȱ (entwederȱ lokalȱ oderȱdurchȱ Download),ȱ umȱ eineȱentfernteȱ KommuniȬ kationȱmitȱdemȱServerȬObjektȱzuȱbewerkstelligen.ȱȱ VerwendetȱmanȱdasȱJavaȱSoftwareȱDevelopmentȱKitȱinȱderȱVersionȱ1.2ȱ (J2SDK),ȱsoȱwirdȱdieȱSkeletonȬClassȱ(HelloImpl_Skel.class)ȱnichtȱ mehrȱbenötigt,ȱundȱesȱmussȱnurȱnochȱdieȱStubȬClassȱangelegtȱwerden.ȱ BeimȱJ2SDKȱkannȱdiesȱdemȱrmic-CompilerȱdurchȱdieȱOptionȱ–v1.2ȱ mitgeteiltȱwerden.ȱȱ Abȱ derȱ Javaȱ Standardȱ Editionȱ 5.0ȱ werdenȱ Stubsȱ zurȱ Laufzeitȱ dynaȬ mischȱ generiert,ȱ sodassȱ rmicȱ nichtȱ mehrȱ gebrauchtȱ wird.ȱ rmicȱ stehtȱ aberȱ weiterhinȱ zurȱ Verfügung,ȱ umȱ Clientsȱ unterȱ früherenȱ JavaȬ Versionenȱzuȱuntertsützenȱ[Aȱ07].ȱȱ

StartenȱderȱRegistryȱ LäuftȱimȱSystemȱnichtȱpermanentȱdieȱRMIȬRegistry,ȱsoȱmussȱsieȱunterȱ Unixȱgestartetȱwerdenȱdurchȱ $rmiregistry& Eineȱ RMIȬRegistryȱ wirdȱ nurȱ einmalȱ gestartetȱ undȱ kannȱ beliebigȱ vieleȱ entfernteȱ Objekteȱ verwaltenȱ undȱ beliebigȱ vieleȱ Clientsȱ bedienen.ȱ Dieȱ RMIȬRegistryȱhörtȱstandardmäßigȱdenȱPortȱ1099ȱaufȱderȱMaschineȱab,ȱ aufȱderȱsieȱgestartetȱwurde.ȱȱȱ NachdemȱdannȱdieȱRMIȬRegistryȱläuft,ȱstartenȱwirȱdenȱServer:ȱ $java HelloImpl& Hello Server ready $ Nunȱ istȱ derȱ Serverȱ undȱ dieȱ RMIȬRegistryȱ bereit,ȱ umȱ entfernteȱ MethoȬ denaufrufeȱvonȱClientsȱentgegenzunehmen.ȱ

DefinitionȱdesȱClientsȱundȱdessenȱStartȱ DasȱLadenȱvonȱStubȬKlassenȱüberȱdasȱNetzȱistȱeineȱpotenziellȱunsicheȬ reȱ Aktivität,ȱ dieȱ einȱ SecurityManagerȱ überwacht.ȱ Dazuȱ mussȱ imȱ ClientȱzuȱBeginnȱderȱmain()ȬMethodeȱeinȱderartigerȱerzeugtȱwerden.ȱȱ Bevorȱ einȱ Clientȱ eineȱ entfernteȱ Methodeȱ aufrufenȱ kann,ȱ mussȱ erȱ eineȱ entfernteȱ Referenzȱ aufȱ dasȱ Objektȱ besitzen.ȱ Dazuȱ mussȱ erȱ beiȱ derȱ ReȬ gistryȱaufȱderȱServermaschineȱnachȱdemȱentferntenȱObjektȱnachfragen.ȱ Zumȱ Nachfragenȱ kannȱ erȱ dieȱ NamingȬMethodeȱ lookup()ȱ derȱ ReȬ gistryȱ benutzen.ȱ Umȱ nachȱ einemȱ Objektȱ aufȱ einemȱ entferntenȱ Hostȱ nachzufragen,ȱ mussȱ lookup()ȱ eineȱ rmiȬURLȱ mitgegebenȱ werden,ȱ

296ȱ

3.4 Programmiermodelle für verteilten Speicher beispielsweise „rmi://minnie.bts.fh-mannheim.de/hello“. Nach dem lookup() ruft der Client das entfernte Objekt sayHello genau so auf wie ein lokales Objekt. Das Ergebnis des Aufrufes wird im String message gespeichert und anschließend auf System.out ausgegeben. // HelloClient definition import java.rmi.*; public class HelloClient {

Programm 332: HelloClient. java

public static void main (String args[]) { System.setSecurityManager( new RMISecurityManager()); try { Hello h = (Hello) Naming.lookup ( “rmi://minnie.bts.fh-mannheim.de/hello“); // call remote method sayHello String message = h.sayHello(); System.out.println(“HelloClient: “ + message); } catch (Exception e) { System.out.println(“Exception in main:“ + e); } } } Damit liegt nun der HelloClient für den HelloServer vor. Mit dem nachfolgenden Kommando kann der Client nun gestartet werden: $java HelloClient HelloClient: Hello World! $

3.4.5.8 Entfernte Komponentenaufrufe 3.4.5.8.1 .NET Plattform .NET ist keine offene Plattform wie beispielsweise CORBA oder die nachfolgend beschriebene Web-Service-Plattform, sondern ausschließlich in den Händen von Microsoft liegende Plattformentwicklung für verteilte Umgebungen. Durch die Unterstützung offener WebserviceStandards wie HTTP, SOAP und WSDL ist .NET interoperabel mit anderen Plattformen.

.NET = MiddlewarePlattform von Microsoft

297

3 Programmiermodelle für parallele und verteilte Systeme Mit .NET steigt Microsoft vom Anbieter von Desktop-Software zum Anbieter von Server-Software auf. Geprägt ist .NET durch eine historisch gewachsene Sammlung von Microsoft-Technologien. Die historische Entwicklung verlief dabei in folgenden Schritten: 1. Object Linking and Embedding (OLE) basiert auf dem Clipbord aus den 80er Jahren und somit der Windows-Zwischenablage. Die Zwischenablage erlaubt es, mit ihren elementaren Funktionen Kopieren und Einfügen komplexe Dokumente zu erzeugen und zu verarbeiten. OLE erlaubt verschiedene Klassen von Dokumenten miteinander zu verknüpfen. Ersetzt man nun für die Dokumente Komponenten, dann führt dies Entwicklung zu COM. 2. Component Object Model (COM) ist ein Komponentenmodell für lokale Komponenten und deren Interaktion und Komposition. COM definiert einen Binärstandard für Komponenten, die als Blackbox agieren und ihre Funktionalität an genormten Schnittstellen publizieren. 3. Distributed Component Object Model (DCOM) [EE 98] erweitert COM um die Fähigkeit, Rechnergrenzen zu überwinden und somit um entfernte Komponentenaufrufe. Der Ort der Komponenten ist dabei unerheblich. Die Umsetzung der Ortstransparenz und damit die Brokeraufgabe übernimmt das Betriebssystem. Dazu werden weltweit eindeutige Identifikatoren (Globally Unique Identifier (GUID)) eingesetzt, die von der Distrubuted Computing Environment (DCE) von der Open Software Foundation (OSF) übernommen wurden. Sicherheitsmechanismen überwachen die Verwaltung und den Zugriff auf die Komponenten. Zum Verpacken mehrerer Komponenten dienen Komponenten-Server, die seit Windows NT als Dienste angemeldet werden. Basis von DCOM ist das seit 1992 für Windows verfügbare DCE-RPC-Protokoll. 4. COM+ [EE 00]: DCOM definiert nur entfernte Methodenaufrufe, und es fehlen die Dienste für verteilte Transaktionen und Kommunikation mit Nachrichten. COM+ fasst diese fehlenden Dienste in Form von vorliegenden separaten Microsoft-Produkten zusammen. Diese Produkte für Transaktionen waren der Distributed Transaction Coordinator (DTC) und der Microsoft Transaction Server (MTS). Für die nachrichtenbasierte Kommunikation kam der Message Queue Server (MSMQ) hinzu. Die .NET-Plattform besteht aus dem Betriebssystem dem darüberliegenden .NET Framework, bestehend aus einer Laufzeitumgebung und einer Klassenbibliothek, den Diensten von COM+ und den Enterprise

298

3.4 Programmiermodelle für verteilten Speicher Server. Enterprise Server sind viele der bekannten Microsoft Server; z.B. der Exchange Server, der SQL Server oder auch der BizTalk Server. Abb. 3-30: .NETPlattform

3.4.5.8.2 .NET Framework Das .NET Framework [R 02] besitzt die drei folgenden Bestandteile: 1. Eine Laufzeitumgebung, die Common Language Runtime (CLR). 2. Eine Klassenbibliothek, die Framework Class Library (FCL). 3. Eine Menge von Programmiersprachen, was durch die CLR ermöglicht wird. Neben den Standard-Microsoft-Sprachen wie C#, Visual C++, Visual Basic und der Microsoft-Variante von Java unterstützt CLR ebenso Sprachen, wie Smalltalk, COBOL, Tcl/TK, Perl oder Phyton. Ein kurzer Überblick und eine Beschreibung der einzelnen .NET-Sprachen C#, Visual Basic .Net, J#, JScript .NET, C++ .NET ist in [R 04] enthalten.

Zusammensetzung von .NET Framework

Laufzeitumgebung: Common Language Runtime (CLR) Ein Compiler für .NET-Sprachen erzeugt keinen Maschinencode, der direkt vom Betriebssystem ausführbar ist. Stattdessen wird, wie bei Java, Zwischencode erzeugt, der eine virtuelle Maschine ausführt. Die Common Language Runtime (CLR) ist die virtuelle Maschine (VM) von .NET. Die CLR führt den standardisierten (ECMA-Standard 335) Zwischencode der Common Intermediate Language (CIL) aus. Die Zwischensprache wird erst zur Laufzeit kompiliert und für die konkrete Basismaschine angepasst und optimiert. Sie stellt weiterhin Mechanismen zur Speicher- und Typverwaltung (automatische Garbage Collection und Typüberprüfung), sowie für Ausnahmebehandlung bereit.

CLR = VM

299

3 Programmiermodelle für parallele und verteilte Systeme Sie besitzt eine COM-, DCOM-, und COM+-Schnittstelle, so dass die Interoperabilität zwischen .NET und diesen Systemen gegeben ist. Zur Unterstützung der Parallelität stellt sie virtuelle Prozesse zur Verfügung und bietet somit ein Multithreading an. Abb. 3-31: Common Language Runtime

Common Type System (CTS)

Im Gegensatz zur Java Virtual Machine, die nur Java Bytecode akzeptiert, wurde die CLR von Anfang an für den Betrieb mit mehreren Programmiersprachen konzipiert. Ziel war nicht nur die Unterstützung von verschiedenen Sprachen, sondern auch die Interoperabilität zwischen den Sprachen. Dieses Ziel wird erreicht durch das für alle Sprachen verbindliche Typsystem, dem Common Type System (CTS).

Common Language Specification (CLS)

Die Interoperabilität wurde durch Vereinbarungen, der Common Language Specification (CLS) erreicht, welche das Typsystem von verschiedenen Programmiersprachen einschränken und auf einen gemeinsamen Nenner bringen. Die Bibliothek, welche den Code enthält, der die Vorgaben der CLS erfüllt und gewährleistet, heißt CLS Frameworks. Dieses Framework gewährleistet die Zusammenarbeit und Interoperabilität von verschiedenen Programmiersprachen. Die auschließliche Verwendung von Typen des eingeschränkten Typsystems CLS bringt zwei Vorteile:

Vorteile der CLS

1. Interoperabilität zwischen Klassen, in verschiedenen Sprachen formuliert, ist bereits zur Compilierzeit möglich. Jede Klasse wird auf die gemeinsame Zwischensprache CIL abgebildet. Damit kann eine Klasse in einer Programmiersprache von einer anderen Klasse in einer anderen Programmiersprache erben oder kann deren Methoden aufrufen. 2. Interoperabilität über Rechnergrenzen zwischen Klassen in verschiedenen Sprachen ist zur Laufzeit möglich. Voraussetzung dabei

300

3.4 Programmiermodelle für verteilten Speicher ist natürlich dass der Kommunikationspartner auf der Laufzeitumgebung CLR läuft und nicht auf einer anderen virtuellen Maschine, z. B. der Java Virtual Machine.

Klassenbibliothek: Framework Class Library (FCL) Die Klassenbibliothek ist eine von Grund auf neu konstruierte, homogene, polymorphiebasierte Klassenbibliothek. Sie deckt ein breites Spektrum von komplexen Anwendungssystemen ab und heißt deshalb Framework Class Library (FCL). Bedingt durch die Größe der Klassenbibliothek mit über 3000 Klassen ist diese in Namensräume organisiert. Ein Namensraum enthält alle Klassen, die logisch und funktional zusammengehören. Namensräume sind hierarchisch als Baum organisiert. Die Klassenbibliothek umfasst zwei Bäume und somit zwei Wurzelelemente System und Microsoft. Microsoft enthält Microsoft-spezifische Dinge, wie beispielsweise Zugriff auf die Windows-Registry. Der Baum System ist unabhängig von der Microsoft-Umgebung und kann auf andere Umgebungen portiert werden. Im Namensraum System liegen beispielsweise Klassen zur Ereignis- und Ausnahmebehandlung und für einfache und komplexe Datentypen. Der Namansraum System.Web enthält die Webtechnologien. Der Namensraum System.XML bietet Funktionalitäten zum Bearbeiten von XML-Dokumenten.

Organisation der FCL als Baum

Der Teil der Klassenbibliothek, der für die Konstruktion Verteilter Systeme relevant ist und die Klassen, Datenstrukturen und Ereignisse dazu zusammenfasst, ist das .NET Remoting Framework. Die zu diesem Framework gehörenden Klassen liegen in System.Runtime.Remoting.

3.4.5.8.3 .NET-Remoting Die .NET-Plattform unterstützt die nachfolgenden, teilweise inkompatiblen Technologien für die Kommunikation von Programmen: 1. ASP.NET [HS 04] aus der Framework Class Library für Webanwendungen, und zusätzlich wird eine Webservice-Umgebung ASP.NET Runtime zur Verfügung gestellt. 2. Die DCOM-Technologie für entfernte Prozeduraufrufe, die nicht auf den Mechanismen der CLR aufsetzt.

.NET Kommunikationstechnologien

3. MS Message Queue ist ein nachrichtenbasierter Message Server. Message Queue ist Bestandteil von COM+ und ist ein Enterprise Server.

301

3 Programmiermodelle für parallele und verteilte Systeme 4. .NET-Remoting [KCH 04] ist eine Technologie für TCP- und HTTPbasierte entfernte Methoden/Serviceaufrufe, die ähnlich wie der Java RMI arbeitet und wie schon erwähnt die Kommunikationsinfrastruktur des .NET Frameworks ist. Channels

Kernkonzept von .NET-Remoting sind Kommunikationskanäle (Channels), die den Transport von Nachrichten an und von RemoteAnwendungen regeln. Für die entfernte Kommunikation stehen TCP und HTTP zur Verfügung, und für die lokale Kommunikation auf einem Rechner, ohne Verwendung eines Netzwerkprotokoll-Stacks, gibt es den Kanal Inter Process Communication (IPC) [MDN 07]. IPC basiert auf den Named Pipes. Entfernte Prozeduraufrufe laufen über den TCP-Kanal und Webservice-Aufrufe über den HTTP-Kanal.

Formatter

Vor dem Transport wandelt ein Formatierungsobjekt (Formatter) die Nachrichten in das entsprechende Protokollformat (TCP oder HTTTP). Bei einem TCP-Kanal kommt ein Binär-Formatierer (BinaryFormatter) zum Einsatz. Bei einem HTTP-Kanal geschieht die Umwandlung mit einem SOAP-Formatierer (SOAPFormatter).

Abb. 3-32: .NETRemoting ChannelArchitektur

302

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ Dieȱ Aktivierungȱ vonȱ entferntenȱ Objektenȱ geschiehtȱ aufȱ zweiȱ unterȬ schiedlicheȱArtenȱ[MDNȱ07]ȱ:ȱ 1.ȱBeiȱClientȱActivatedȱObjectsȱ(CAO)ȱbesitztȱderȱClientȱdieȱKontrolleȱ überȱArtȱundȱAnzahlȱderȱServerobjekte.ȱBeiȱjederȱInstanziierungȱimȱ ClientȱwirdȱeinȱzugehörigesȱObjektȱaufȱdemȱServerȱerzeugt.ȱȱȱȱ 2.ȱ Beiȱ Serverȱ Activatedȱ Objectsȱ (SAO)ȱ übernimmtȱ derȱ Serverȱ ȱ transȬ parentȱfürȱdenȱClientȱȱdieȱInstanziierungȱundȱVerwaltungȱdesȱentȬ ferntenȱObjekts.ȱEsȱgibtȱzweiȱAktivierungsmodi:ȱ x

SingleCall:ȱDasȱentfernteȱObjektȱlebtȱgenauȱfürȱdieȱDauerȱdesȱAufȬ rufes,ȱdanachȱgibtȱesȱderȱGarbageȱCollectorȱfrei.ȱ

x

Singleton:ȱDasȱentfernteȱObjektȱgibtȱesȱnurȱeinmalȱundȱesȱbearbeiȬ tetȱ Aufrufeȱ innerhalbȱ vonȱ parallelenȱ Threads,ȱ d.h.ȱ esȱ existiertȱ nurȱ eineȱInstanzȱfürȱalleȱClientsȱundȱalleȱAufrufe.ȱȱ

3.4.5.8.4 .NET 3.0 DieȱWindowsȱCommunicationȱFoundationȱ(WCF)ȱ[KBȱ07]ȱumfasstȱeineȱ Kommunikationsinfrastrukturȱ durchȱ Nachrichtenaustauchȱ (.NETȱ SoȬ ckets,ȱ .Netȱ Remotingȱ (sieheȱ Abschnittȱ 3.4.5.8.3),ȱ derȱ Messageȱ Queueȱ Server,ȱ sowieȱ dieȱ Standardsȱ ausȱ demȱ Webȱ Serviceȱ Umfeldȱ (sieheȱ AbȬ schnittȱ3.4.5.9))ȱundȱistȱTeilȱvonȱ.NETȱ3.0.ȱȱ Nebenȱ derȱ Kommunikationsinfrastrukturȱ WCFȱ istȱ inȱ .NETȱ 3.0ȱ dieȱ Windowsȱ Presentationȱ Foundationȱ (WPF)ȱ enthalten.ȱ Sieȱ trägtȱ beiȱ zurȱ Vereinheitlichungȱ derȱ Programmierungȱ vonȱ Benutzeroberflächenȱ inȱ WindowsȬȱ undȱ Webanwendungen.ȱ Dasȱ dritteȱ Frameworkȱ vonȱ .NETȱ 3.0ȱ istȱ dieȱ Windowsȱ Workflowȱ Foundationȱ (WF).ȱ Sieȱ bietetȱ eineȱ APIȱ undȱ eineȱ Laufzeitumgebungȱ zurȱ Definitionȱ undȱ Ausführungȱ vonȱ Workflows.ȱȱ

AktivierungsȬ artenȱvonȱ entferntenȱ Objektenȱ

Windowsȱ CommunicatiȬ onȱ Foundationȱȱ

.NETȱ3.0ȱ

3.4.5.9 Entfernte Serviceaufrufe (Web Services) Dasȱ WorldȱWideȱ Webȱ Consortiumȱ (kurz:ȱW3C)ȱ[W3Cȱ07]ȱ istȱdasȱ GreȬ miumȱ zurȱ Standardisierungȱ dasȱ WWWȱ betreffenderȱ Techniken.ȱ Dieȱ Grundlageȱ vonȱ Webȱ Servicesȱ bildenȱ dreiȱ Standardsȱderȱ W3C,ȱ dieȱ alleȱ aufȱXMLȱ(ExtendedȱMarkȱUpȱLanguage)ȱ[XMLȱ06]ȱbasieren:ȱ

W3Cȱ

1.ȱȱ SOAPȱ(ursprünglichȱfürȱSimpleȱObjectȱAccessȱProtocolȱoderȱServiceȱ Orientedȱ Architectureȱ Protocol,ȱ dieȱ beideȱ nichtȱ denȱ vollständigenȱ SinnȱvonȱSOAPȱtreffen)ȱdasȱzumȱAustauschȱvonȱXMLȬNachrichten.ȱ Beiȱ derȱ W3Cȱ liegtȱ SOAPȱ alsȱ W3CȬNoteȱ inȱ derȱ Versionȱ 1.2ȱ vorȱ [SOȱ 07].ȱ

SOAPȱ

303ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ ȱ

SOAPȱ verpacktȱ dieȱ XMLȬDatenȱ undȱ verschicktȱ sieȱ überȱ einȱ TransȬ portprotokollȱ(wieȱHTTPȱoderȱSMTP).ȱSOAPȱarbeitetȱnachȱdemȱReȬ quest/ResponseȬPrinzip.ȱ Eineȱ Applikationȱ sendetȱ eineȱ SOAPȬ NachrichtȱanȱeineȱandereȱApplikationȱalsȱRequest.ȱDieȱApplikationȱ antwortetȱ dannȱ mitȱ einerȱ SOAPȬNachrichtȱ alsȱ Response.ȱ Diesȱ entȬ sprichtȱ genauȱ demȱ HTTPȬProtokollȱ undȱ istȱ einȱ Grund,ȱ HTTPȱ fürȱ denȱTransportȱvonȱSOAPȬNachrichtenȱeinzusetzen.ȱȱ 2.ȱȱUDDIȱ(UniversalȱDescription,ȱDiscoveryȱandȱIntegration)ȱ UDDIȱȱ istȱ eineȱ weltweiteȱ webȬbasierteȱ Regisitrierungsstelleȱ fürȱ Webȱ Services.ȱ Dieȱ UDDIȬSpezifikationȱ [UDDȱ 04}ȱ beȬ schreibtȱ eineȱ Vorgehensweise,ȱ umȱ Informationȱ überȱ Webȱ Servicesȱ zuȱpublizierenȱ(registrieren)ȱundȱzuȱfinden.ȱDerȱZugriffȱerfolgtȱdaȬ beiȱüberȱeinenȱWebȬBrowserȱoderȱprogrammgesteuertȱüberȱSOAP.ȱȱ 3.ȱȱWSDLȱ(WebȱServiceȱDescriptionȱLanguage)ȱdientȱzurȱvollȬ WSDLȱ ständigenȱXMLȬBeschreibungȱderȱSchnittstelleȱundȱdamitȱ derȱFunktionȱeinesȱWebȬService.ȱDanebenȱlegtȱWSDLȱfest,ȱ wieȱaufȱeinȱWebȱServiceȱzugegriffenȱwird,ȱalsoȱmitȱwelchemȱProtoȬ kollȱ(HTTP,ȱSMTP,ȱ…).ȱUmȱdieȱFunktionȱnutzenȱzuȱkönnen,ȱbenöȬ tigtȱmanȱseineȱLokationȱundȱsomitȱdieȱURLȱderȱFunktion.ȱȱ ȱ WSDLȱnimmtȱeineȱähnlicheȱRolleȱbeiȱWebȱServicesȱein,ȱwieȱdieȱInȬ terfaceȱ Definitionȱ Langugaeȱ (IDL)ȱ beiȱ CORBA.ȱ Allerdingsȱ erfolgtȱ beiȱ IDLȱ vonȱ CORBAȱ eineȱ Bindungȱ anȱ eineȱ Programmiersprache;ȱ dagegenȱistȱWSDLȱanȱdasȱSOAPȬProtokollȱgebunden.ȱȱ ȱ

3.4.5.9.1 Web Service-Architektur Umȱ nunȱ eineȱ einheitlicheȱEntwicklungȱderȱ WebȱServicesȱzuȱ erreichenȱ undȱ dieȱ Interoperabilitätȱ zwischenȱ verschiedenenȱ Softwareherstellerȱ zuȱ erreichen,ȱ hatȱ dasȱ W3Cȱ eineȱ Webȱ ServiceȬArchitekturȱ [WSAȱ 04]ȱ festgelegt,ȱdieȱfolgendeȱKomponentenȱenthält:ȱ WebȱServiceȱ Architekturȱ

x Dienstanbieterȱ(ServiceȱProvider)ȱstelltȱdenȱDienstȱbereitȱundȱpubliȬ ziertȱihnȱbeiȱderȱUDDIȱServiceȱRegistry.ȱ x ServiceȱRegistryȱ(UDDI)ȱdieȱBeschreibungȱfürȱdieȱDienste.ȱ x Dienstbenutzerȱ (Serviceȱ Requestor)ȱ nutztȱ denȱ Webȱ Service.ȱ Einȱ Dienstbenutzerȱ einesȱ Webȱ Serviceȱ istȱ eineȱ Anwendung,ȱ auchȱ Webȱ ServiceȱClientȱgenannt.ȱȱ ȱ ȱ

304ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ ȱ ȱ ȱ

Abb.ȱ3Ȭ33:ȱ WebȱServiceȱ Architekturȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ DieȱNutzungȱeinesȱWebȱServiceȱgeschiehtȱinȱfolgendenȱSchritten:ȱ 1.ȱ Einȱ Benutzerȱ suchtȱ mitȱ Hilfeȱ einesȱ WebȬBrowsersȱ oderȱ einesȱ SoftȬ wareȬSystemsȱeinenȱgewünschtenȱDienstȱbeiȱderȱUDDIȬServiceȱReȬ gistry.ȱVonȱdieserȱbekommtȱerȱdieȱURLȱdesȱdortȱregistriertenȱDiensȬ tesȱzurück.ȱȱ 2.ȱ Derȱ Webȱ ServiceȬClientȱ ruftȱ beiȱ derȱ UDDIȬServiceȱ Registryȱ dieȱ Schnittstelleȱ desȱ Webȱ Serviceȱ ab.ȱ Hierfürȱ sendetȱ derȱ Clientȱ einenȱ SOAPȬRequestȱmitȱderȱURLȱanȱdieȱUDDIȬServiceȱRegistry.ȱ 3.ȱDieȱgewünschteȱSpezifikationȱderȱSchnittstelleȱdesȱWebȱServiceȱwirdȱ alsȱ WSDLȬDateiȱ anȱ denȱ Webȱ Serviceȱ Clientȱ inȱ einemȱ SOAPȬ Responseȱ übermittelt.ȱ Einȱ WSDLȬCompilerȱ generiertȱ ausȱ dieserȱ

305ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ WSDLȬDateiȱ einenȱ passendenȱ Stub.ȱ Dieserȱ Stubȱ wirdȱ anȱ denȱ Webȱ ServiceȱClientȱangebunden.ȱȱ 4.ȱDerȱWebȱServiceȱClientȱruftȱnunȱdenȱWebȱServiceȱbeimȱDienstanbieȬ terȱ auf.ȱ Hierfürȱ sendetȱ erȱ einȱ SOAPȬRequestȱ mitȱ denȱ entsprechenȬ denȱAngabenȱinȱXMLȱanȱdenȱDienstanbieter.ȱȱ 1.

DerȱWebȱServiceȱwirdȱbeimȱDienstanbieterȱausgeführt.ȱȱ

2.

DasȱErgebnisȱdesȱWebȱServiceȱwirdȱalsȱSOAPȬResponseȱinȱXMLȱ anȱdenȱWebȱServiceȱClientȱübermittelt.ȱȱ

ȱ

3.4.5.10 XML-RPC ProzeduraufȬ rufeȱüberȱdasȱ Internetȱ

XMLȬRPCȱ(ExentsibleȱMarkupȱLanguageȱȬȱRemoteȱProcedureȱCall)ȱistȱ eineȱ Spezifikationȱ undȱ eineȱ Mengeȱ vonȱ Implementierungenȱ fürȱ verȬ schiedeneȱ Betriebssysteme,ȱ Sprachenȱ undȱ Umgebungenȱ fürȱ entfernteȱ Prozeduraufrufeȱ überȱ dasȱ Internetȱ [XRȱ 07].ȱ Dasȱ dazugehörigeȱ ProtoȬ kollȱ basiertȱ aufȱ demȱ Transportprotokollȱ HTTP,ȱ undȱ dieȱ Darstellungȱ derȱübertragenenȱDatenȱgeschiehtȱinȱderȱExtensibleȱMarkupȱLanguageȱ (XML).ȱȱ

MethodenȬ aufrufeȱmitȱ dynamischenȱ Proxyȱ

XMLȬRPCȱrealisiertȱursprünglichȱnurȱdieȱAufrufeȱvonȱProzedurenȱundȱ keineȱ Methodenaufrufe,ȱ daȱ fürȱ denȱ Aufrufȱ einerȱ Methodeȱ auchȱ einȱ Objekt,ȱ aufȱ demȱ dieȱ Methodeȱ ausgeführtȱ wird,ȱ übergebenȱ werdenȱ mussȱ(vergleicheȱdazuȱRMI,ȱAbschnittȱ3.4.5.7).ȱDynamischeȱProxiesȱinȱ JavaȱerlaubenȱauchȱdieȱAufrufeȱvonȱMethodenȱ[Aȱ07].ȱEinȱdynamischerȱ ProxyȱistȱeineȱKlasse,ȱdieȱnichtȱvorȱProgrammlaufȱdurchȱeinenȱCompiȬ lerȱoderȱGenerator,ȱsondernȱerstȱzurȱLaufzeitȱdynamischȱgeneriertȱwird.ȱȱ Einigeȱ Beispieleȱ fürȱ dieȱ zahlreichenȱ Implementierungenȱ vonȱ XML_RPCsȱsind:ȱASP,ȱC,ȱC++,ȱDelphi,ȱFlash.ȱHaskell,ȱJava,ȱJavascript,ȱ Lua,ȱ.NET,ȱOCaml,ȱPerlȱPHP,ȱPython,ȱRuby,ȱTCL.ȱDieȱBekanntesteȱundȱ Gebräuchlichteȱ davonȱ istȱ dieȱ vonȱ Apacheȱ Softwareȱ Foundation:ȱ Javaȱ Apacheȱ XMLȬRPCȱ Versionȱ 3.0ȱ [Apȱ 07].ȱ Dieseȱ XMLȬPRCȬ ImplementierungȱsetzenȱwirȱinȱnachfolgendemȱBeispielȱein.ȱȱȱ XMLȬRPCȱistȱeinȱVorgängerȱvonȱSOAP.ȱImȱGegensatzȱzuȱSOAPȱistȱderȱ XMLȬRPCȱwesentlichȱeinfacherȱundȱschlanker:ȱ

Einfachheitȱ vonȱXMLȬ RPCȱ

x KeinȱBrokerȱwieȱdieȱUDDI:ȱEsȱbrauchtȱkeineȱRegistierungȱundȱSuȬ cheȱ desȱ Clientsȱ beiȱ derȱ UDDIȱ stattzufinden,ȱ sondernȱ dieȱ Prozedurȱ kannȱdirektȱüberȱdieȱURLȱaufgerufenȱwerden.ȱ x Esȱ istȱ keineȱ Schnittstellenbeschreibung,ȱ imȱ Stilȱ vonȱ WSDLȱ undȱ beiȱ COBRAȱdieȱIDL,ȱvorhanden.ȱ

306ȱ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ x EsȱgenügtȱeinȱeinfacherȱminimalerȱParser,ȱz.B.ȱXMLȬParserȱMinMLȱ [Wȱ07].ȱȱ x Einfachheitȱ vonȱ XMLȬRPCȱ Datentypen:ȱ Esȱ stehenȱ ȱ bzw.ȱ ȱ fürȱ einenȱ 4ȱ ByteȬInteger,ȱ ,ȱ <string>,ȱ <double>,ȱ ȱ undȱ ȱ alsȱ Base64Ȭcodierteȱ Datenȱ (Bytes)ȱ zurȱ Verfügung.ȱ Mitȱ einemȱ <array>ȱ lassenȱ sichȱ mehrereȱ Variableȱ zuȬ sammenfassen.ȱDerȱTypȱ<struct>ȱdientȱfürȱkomplexereȱAnwendunȬ gen,ȱ derȱ mehrereȱ <member>ȱ enthält,ȱ dieȱ jeweilsȱ einȱ Ȭȱ undȱ ȬElementȱ beinhalten.ȱ <struct>ȱ istȱ mitȱ denȱ Mapsȱ undȱ HashȬ tablesȱinȱjava.util.Mapȱvergleichbar.ȱȱ Eineȱ einfacheȱ XMLȬRPCȬAnwendungȱ inȱ Javaȱ demonstriertȱ dasȱ nachȬ folgendeȱBeispiel,ȱdasȱausȱAbtsȱentnommenȱistȱ[Aȱ07].ȱȱ ZurȱImplementierungȱeinesȱXMLȬRPCȬServersȱstelltȱApacheȱXMLȬRPCȱ Klassenȱbereit:ȱ x org.apache.xmlrpc.webserver.WebServer: Sieȱ implemenȬ tiertȱeinenȱspeziellȱfürȱdieȱBehandlungȱvonȱXMLȬRPCȬAnfragenȱgeȬ eignetenȱ HTTPȬServer,ȱ derȱ inȱ dieȱ eigeneȱ Applikationȱ eingebettetȱ wird.ȱ Fürȱ Testzweckeȱ istȱ diesȱ geeignet.ȱ Beiȱ höherenȱ Ansprüchenȱ könnenȱdafürȱausgereifteȱServletȱContainer,ȱwieȱbeispielsweiseȱvonȱ ApacheȱTomcat,ȱeingesetztȱwerden.ȱȱ

WebServer

x org.apache.xmlrpc.server.XmlRpcServer: Sieȱ verarbeitetȱ dieȱXMLȬRPCȬAnfrage.ȱSieȱdientȱzumȱErzeugenȱ(WebServer (int port)),ȱ Startenȱ (start())ȱ undȱ Stoppenȱ (shutdown())ȱ einesȱ HTTPȬServers.ȱ Dieȱ Methodeȱ getXmlRpcServer()ȱ liefertȱ einȱ XmlRpcServerȬObjekt.ȱsetHandlerMappingȱregistiertȱdieȱHandȬ lerȱfürȱdasȱXmlRpcServerȬObjekt.ȱ

XmlRpcServer

x org.apche.xmlrpc.server.PropertyHandlerMappingȱ istȱ einȱ Handlerȱ fürȱ eineȱ entferntȱ aufrufbareȱ Methode.ȱ addhandler (String key, Class typ)ȱ fügtȱ eineȱ Handlerklasseȱ typȱ mitȱ demȱ Namenȱ keyȱ hinzu.ȱ Dasȱ Gegenstückȱ removeHandler (String key)ȱentferntȱalleȱHandlerȱmitȱdemȱNamenȱkey.ȱ

PropertyHandȬ lerMappingȱ

Dieȱ Klasseȱ Echoȱ implementiertȱ dieȱ Methodenȱ getEchoȱ undȱ getEchoWithDate,ȱdieȱeinȱ„Echo“ȱohneȱbzw.ȱmitȱServerdatumȱzurückgeȬ ben.ȱDieȱMethodeȱgetEchoȱsollȱentferntȱaufgerufennȱwerden.ȱ import java.util.*; import java.text.*;

Programmȱ3Ȭ33:ȱ KlasseȱEchoȱ

public class Echo {

307ȱ

3ȱProgrammiermodelleȱfürȱparalleleȱundȱverteilteȱSystemeȱ public String getEcho(String s) { return s; } public String getEchoWithDate(String s) { Simple DateFormat f = new SimpleDateFormat( “dd.mm.yyy hh:mm:ss”); return”[“ + f.format(new Date()) + “]” + s; } } Programmȱ3Ȭ 34:ȱKlasseȱ EchoȬserverȱ

DieȱnachfolgendeȱKlasseȱEchoserverȱerzeugtȱeineȱInstanzȱderȱKlasseȱ WebServer,ȱ registiertȱ denȱ EchoȬDienstȱ mitȱ demȱ Namenȱ echoȱ undȱ startetȱschließlichȱdenȱServer.ȱȱȱ import org.apche.xmlrpc.server.*; import org.apche.xmlrpc.webserver.*; public class EchoServer { public static void main (String[] args) throws Exception { int port = Integer.parseInt(args[0]); PropertyHandlerMapping phm = new PropertyHandlerMapping(); phm.addHandler (“echo”, Echo.class); WebServer webServer = new WebServer(port); XmlRpcServer server = WebServer.getXmlRpcServer(); Server.setHandlerMapping(phm); WebServer.start(); } } Zurȱ Implementierungȱ einesȱ XMLȬRPCȬClientȱ stelltȱ Apacheȱ XMLȬRPCȱ dieȱfolgendenȱKlassenȱzurȱVerfügung:ȱ

XmlRpcClientȱ

XmlRpcClient ConfigImplȱ

308ȱ

x

ȱ x

org.apache.xmlrpc.client.XmlRpcClient:ȱ Sieȱ implemenȬ tiertȱ einenȱ speziellȱ fürȱ dieȱ Versendungȱ XMLȬRPCȬAnfragenȱ geȬ eignetenȱ HTTPȬClient.ȱ setConfig(config)ȱ setztȱ dieȱ KonfiguȬ rationȱconfigȱfürȱdenȱClient.ȱȱ org.apache.xmlrpc.client.XmlRpcClientConfigImpl zurȱ Konfigurationȱ eines XmlRpcClient-Objekts.ȱ Dieȱ Methodeȱ setServerURL(Java.net.URL url)ȱlegtȱdenȱURLȱdesȱServersȱ fest.ȱ execute (string method, Object [] params)ȱ erȬ

3.4ȱProgrammiermodelleȱfürȱverteiltenȱSpeicherȱ zeugtȱeinenȱXMLȬRPCȬAbfrageȱundȱsendetȱsieȱmittelsȱHTTTPȱzumȱ ServerȱDieȱzurückgeschickteȱXMLȬRPCȬAntwortȱwirdȱgeparstȱundȱ alsȱObjektȱvomȱTypȱObjectȱzurückgegegeben.ȱDerȱStringȱmethodȱ hatȱ denȱ Aufbauȱ Dienstname.Methodenname.ȱ Dienstnameȱ istȱ derȱName,ȱunterȱdemȱderȱDienstȱaufȱderȱServerseiteȱregistiertȱist.ȱ Methodennameȱ istȱ derȱ Nameȱ derȱ Methode,ȱ dieȱ denȱ Dienstȱ impȬ lementiertȱ hat.ȱ ȱ Dasȱ Arrayȱ paramsȱ enthältȱ dieȱ erforderlichenȱ PaȬ rameter.ȱ ȱ EchoClientȱ ruftȱ dieȱ beidenȱ Methodenȱ get.Echoȱ undȱ getEchoWithDateȱmitȱdemȱArgumentȱ„Hallo“ȱauf.ȱ ȱ import java.net.*; import org.apche.xmlrpc.client.*;

Programmȱ3Ȭ 35:ȱEchoClientȱ

public class EchoClient { public static void main (String[] args) throws Exception { URL url = new URL (args[0]); XmlRpcClientConfigImpl Config = New XmlRpcClientConfigImpl(); Config.setServerURL(url); XmlRpcClient client = new XmlRpcClient(); Client.SetConfig(config) Object [] params = {“Hallo”}; String s = (String) client.execute( “echo.getEcho”, params); System.out.println(S); Object [] params = {“Hallo”}; String s = (String) client.execute( “echo.getEchoWithDate”, params); System.out.println(S); } } DieȱgetechoȬMethodeȱderȱKlasseȱEchoȱsollȱentferntȱvonȱeinemȱClientȱ aufgerufenȱ werden.ȱ Derȱ Clientȱ undȱ Serverȱ führtȱ beimȱ entferntenȱ MeȬ thodenaufrufȱfolgendeȱSchritteȱaus.ȱȱ C1.ȱ Derȱ Clientȱ importiertȱ org.apache.xmlrpc.client.*.ȱ Damitȱ erzeugtȱderȱClientȱeineȱXMLRpcClientȬInstanz.ȱErȱkonfiguriertȱSieȱ undȱsetztȱdieȱURLȱdesȱServersȱ(setServerURL).ȱ

309ȱ

3 Programmiermodelle für parallele und verteilte Systeme C2. Mit Object execute (string method, Object[] params) erzeugt der Client eine XML-RPC-Anfrage. Der string method hat den Aufbau Dienstname.Methodenname Das Array params enthält die erforderlichen Parameter. Diese Angaben werden in folgendes XML-Dokument verpackt: Programm 336: XMLRequest

<methodCall> <methodName>echo.getecho <params> <param> <string>Hallo C3. Mit HTTTP-Post wird das XML-Dokument an den Server geschickt. S1. Der Server empfängt die HTTP-Anfrage und leitet die Verarbeitung des XML-Dokumentes ein. S2. Das XML-Dokument wird geparst und anschließend die angegebene Methode des Dienstes aufgerufen. S3. Die Methode wird ausgeführt und das Ergebnis an den XMLVerarbeitungsprozess übergeben. S4. Der Verarbeitungsprozess verpackt das Ergebnis in ein XMLDokument. Das XML-Dokument hat folgendes Aussehen: <methodResponse> <params> <param> <string>Hallo

310

3.4 Programmiermodelle für verteilten Speicher S5. Der Server schickt das XML-Dokument als Antwort auf die HTTPAnfrage zurück. C4. Der XML-RPC-Client empfängt das XML-Dokument. C5. Der XML-RPC-Client parst den Rückgabewert. C6. Übergabe als Objekt an das Client-Programm. Abb. 3-34: Kommunikation zwischen XML-RPCClient und XML-RPCServer

Obiges Beispiel benutzt die Klasse WebServer, die einen einfachen HTTP-Server implementiert, der zudem XML-RPC-Anfragen verarbeiten kann. Soll der Webserver und die XML-RPC-Verarbeitung getrennt laufen, so bietet Apache Tomcat mit der Klasse org.apache.xmlrpc.webserver.XmlRpcServletServer einen Servlet-Container, als Ablaufumgebung für Webanwendungen. Die Programmierung von XML-RPCs mit Servlet ist in Abts [A 07] beschrieben.

XmlRpcServletServer

311

4 Parallelisierung 4.1 Leistungsmaße für parallele Programme Hauptzielȱ beiȱ derȱ Parallelverarbeitungȱ einesȱ Problemsȱ mitȱ MultiproȬ Zieleȱderȱ zessoren,ȱ Clusterȱ oderȱ Gridȱ istȱ dieȱ Reduktionȱ derȱ Laufzeitȱ desȱ ProbȬ ParallelisieȬ lemsȱoderȱderȱAufgabeȱ[RRȱ00]ȱ[Jȱ92].ȱDieȱReduktionȱderȱLaufzeitȱzieltȱȱ rungȱ aufȱgeforderteȱschnellereȱLösungȱeinesȱProblems.ȱDieȱLaufzeitreduktiȬ onȱ kannȱ aberȱ auchȱ dazuȱ genutztȱ werden,ȱ genauereȱ undȱ exaktereȱ LöȬ sungenȱ zuȱ erreichenȱ oderȱ ermöglichtȱ es,ȱ Problemeȱ mitȱ gleichartigenȱ größerenȱDatenmengenȱzuȱbearbeiten.ȱAlsȱVorlageȱfürȱdieȱnachfolgendȱ erläutertenȱLeistungsmetrikenȱdienteȱdieȱArbeitȱvonȱBilekȱ[Bȱ06].ȱ

4.1.1 Laufzeit Beiȱ derȱ Bewertungȱ parallelerȱ Algorithmenȱ oderȱ derenȱ ImplementieȬ rungȱ alsȱ Programmȱ wirdȱ dieȱ Laufzeitȱ durchȱ einenȱ Programmlaufȱ aufȱ derȱZielplattformȱermittelt.ȱȱ DieȱLaufzeitȱdesȱparallelenȱProgrammsȱȱ Tp (n ) ȱ

Laufzeitȱ

istȱ dieȱ Zeitȱ zwischenȱ demȱ Startȱ derȱ Abarbeitungȱ desȱ parallelenȱ ProȬ grammsȱundȱderȱBeendigungȱderȱAbarbeitungȱallerȱbeteiligtenȱProzesȬ soren.ȱDieȱLaufzeitȱwirdȱinȱAbhängigkeitȱvonȱderȱAnzahlȱpȱderȱbeteiȬ ligtenȱProzessorenȱundȱderȱProblemgrößeȱnȱangegeben.ȱȱ DieȱLaufzeitȱ Tp (n ) einesȱparallelenȱProgrammsȱsetztȱsichȱausȱfolgendenȱ Zeitenȱzusammenȱ[RRȱ00]ȱ[Uȱ97]:ȱ x Rechenzeitȱ (TCPU):ȱ Zeitȱ fürȱ dieȱ Durchführungȱ vonȱ Berechnungenȱ unterȱ Verwendungȱ vonȱ Datenȱ imȱ lokalenȱ Speicherȱ derȱ einzelnenȱ Prozessoren.ȱ x Kommunikationszeitȱ (TCOM):ȱ Zeitȱ fürȱ denȱ Austauschȱ vonȱ Datenȱ zwischenȱdenȱProzessoren.ȱ x Wartezeitȱ (TWAIT):ȱ Z.B.ȱ wegenȱ ungleicherȱ Verteilungȱ derȱ Lastȱ zwiȬ schenȱdenȱProzessoren,ȱDatenabhängigkeitenȱimȱAlgorithmusȱoderȱ EinȬȱAusgabe.ȱ x Synchronisationszeitȱ(TSYN):ȱZeitȱfürȱdieȱSynchronisationȱbeteiligterȱ Prozesseȱbzw.ȱProzessoren.ȱ

313ȱ

4ȱȱParallelisierungȱ x Platzierungszeitȱ (TPlace):ȱ Zeitȱ fürȱ dieȱ Allokationȱ derȱ Tasksȱ aufȱ dieȱ einzelnenȱProzessoren,ȱsowieȱeineȱmöglicheȱdynamischeȱLastverteiȬ lungȱzurȱProgrammlaufzeit.ȱ x Startzeitȱ (TStart):ȱ Zeitȱ zumȱ Startenȱ derȱ parallelenȱ Tasksȱ aufȱ allenȱ Prozessoren.ȱȱ ZurȱReduktionȱderȱLaufzeitȱ Tp (n ) ȱdesȱparallelenȱProgrammsȱmussȱdieȱ Overheadzeitȱ TCWSȱ=ȱTCOMȱ+ȱTWAITȱ+ȱTSYNȱȱ reduziertȱwerden,ȱindemȱdieȱKommunikationszeit,ȱWartezeitȱund/oderȱ Synchronisationszeitȱvermindertȱwird.ȱȱ DieȱSummationȱderȱPlatzierungszeitȱundȱStartzeitȱistȱdieȱRüstzeitȱȱ x Mausȱoderȱ Elefant?ȱ

TSetupȱ=ȱTPlaceȱ+ȱTStartȱ

BeiȱderȱDurchführungȱvonȱLaufzeitmessungenȱgiltȱderȱRatschlag:ȱȱ x Vermesseȱ mitȱ einerȱ Mausȱ einenȱ Elefantenȱ undȱ vermesseȱ nieȱ mitȱ einemȱElefantenȱeineȱMaus.ȱ Derȱ Ratschlagȱ besagt,ȱ dassȱ dieȱ Laufzeitȱ desȱ Messprogrammsȱ soȱ miniȬ malȱ wieȱ möglichȱ seinȱ sollte,ȱ imȱ Vergleichȱ desȱ zuȱ vermessendenȱ ProȬ gramms.ȱ Dadurchȱ istȱ dieȱ Laufzeitȱ desȱ Messprogrammsȱ soȱ kleinȱ imȱ VergleichȱzumȱvermessendenȱProgramm,ȱsoȱdassȱsieȱvernachlässigbarȱ ist.ȱIstȱdieȱLaufzeitȱdesȱMessprogrammsȱnichtȱkleinȱgenug,ȱsoȱmussȱdieȱ Problemgrößeȱ desȱ zuȱ vermessendenȱ Programmsȱ erhöhtȱ werden,ȱ soȱ dassȱ sichȱ dessenȱ Laufzeitȱ vergrößert.ȱ Istȱ dieȱ Laufzeitȱ desȱ MessproȬ grammsȱ ausȱ technischenȱ Gründenȱ nichtȱ kleinȱ zuȱ halten,ȱ soȱ mussȱ dieȱ Laufzeitȱ desȱ Messprogrammsȱ ermitteltȱ werdenȱ undȱ vonȱ derȱ Laufzeitȱ desȱzuȱmessendenȱProgrammsȱabgezogenȱwerden.ȱȱ

4.1.2 Speedup DieȱReduktionȱderȱLaufzeitȱfürȱdasȱGesamtproblemȱbeiȱeinerȱParalleliȬ sierung,ȱ gibtȱ derȱ Speedup,ȱ dieȱ Beschleunigungȱ oderȱ dieȱ LeistungssteiȬ gerungȱan:ȱ Speedupȱ

Sp(n)

T '(n) Tp(n)

ȱ

T ' ( n) istȱ dabeiȱ dieȱ Laufzeitȱ desȱ schnellstenȱ bekanntenȱ sequentiellenȱ Algorithmus.ȱ T 1 ( n ) istȱ dieȱ Laufzeitȱ desȱ parallelenȱ Programmsȱ aufȱ eiȬ nemȱ Prozessor,ȱ dieȱ nichtȱ mitȱ T ' ( n) ȱübereinstimmenȱ muss.ȱ Derȱ SpeeȬ dupȱgibtȱdieȱGrößeȱdesȱErfolgsȱanȱbeiȱeinerȱParallelisierung.ȱȱ

314ȱ

4.1 Leistungsmaße für parallele Programme Der Speedup ist normalerweise nach oben beschränkt durch die Anzahl p der Prozessoren: Sp ( n) d p

Ist der Speedup gleich p, so spricht man von einem linearen Speedup: Ist der Speedup > p so liegt superlinearer Speedup vor (siehe Abschnitt 4.2.1, wo bei den Monte-Carlo-Simulationen superlinearer Speedup erreicht wurde). Abb. 4-1: Realer, idealer und superlinearer Speedup

4.1.3 Kosten und Overhead Die Kosten eines parallelen Programms sind ein Maß für die von allen Prozessoren bei der Problemlösung durchgeführte Arbeit [RR 00]. Sie werden angegeben als: Cp

Tp ( n ) * p

Kosten sind ein Maß für die von allen Prozessoren durchgeführte Arbeit. Setzt man den Faktor Laufzeit des parallelen Programms als Anzahl der durchgeführten Operationen in dieser Laufzeit an, so lässt sich Folgendes definieren: Ein paralleles Programm ist kostenoptimal, wenn dies zur Problemlösung genau so viele Operationen ausführt wie ein sequentielles Programm mit der Laufzeit T’(n) (Anzahl der durchgeführten Operation). Bei Kostenoptimalität gilt:

Cp(n)

Kosten

kostenoptimal

T ' (n)

315

4 Parallelisierung Kostenoptimalität besagt, dass im parallelen Fall von den einzelnen parallelen Prozessen die gleiche Anzahl von Operationen ausgeführt wird wie im sequentiellen Fall. Der Overhead gibt die Differenz zwischen den Kosten des parallelen Programms und des sequentiellen Programms an und ist definiert als: Overhead

Hp(n)

Cp(n)  T ' (n)

p * Tp (n )  T ' (n )

Ist ein paralleles Programm kostenoptimal, so ist sein Overhead Null (Hp(n) = 0). Beim Übergang von der sequentiellen Lösung zur parallelen Lösung sind also keine zusätzlichen Operationen und Redundanzen hinzugekommen, da ja die Laufzeiten gleich sind.

4.1.4 Effizienz Die Effizienz eines parallelen Programms gibt die relative Verbesserung der Verarbeitungsgeschwindigkeit bezogen auf die Anzahl eingesetzter Prozessoren an. Dazu wird die Leistungssteigerung (Speedup) mit der Anzahl p der Prozessoren normiert. Demgemäß ergibt sich:

Ep ( n ) Effizienz

Sp ( n )

T ' (n)

T ' (n)

p

p * Tp ( n )

Cp ( n )

Die Effizienz zeigt somit an, wie effizient wurde der ursprünglich sequentielle Algorithmus parallelisiert und wie effizient werden die p Prozessoren für einen vorgegebenen parallelen Algorithmus ausgenutzt. Die Effizienz bewertet somit die Zusatzlast und Redundanz (Overhead Hp(n)), die mit der Parallelisierung einhergeht. Für die Effizienz sind die drei Fälle [A 97] zu unterscheiden: 1. Ep(n) < 1: Der Algorithmus ist suboptimal bezüglich seiner Kosten. Dies ist in der Praxis der Normalfall, wobei Werte nahe 1 anzustreben sind. 2. Ep(n) = 1: Der Algorithmus ist kostenoptimal. 3. Ep(n) > 1: Es liegt ein superlinearer Speedup vor, oder aber der parallele Algorithmus ist optimaler bzgl. seiner Laufzeit als der zum Vergleich herangezogene sequentielle Algorithmus. Anders ausgedrückt: Der parallele Algorithmus ist optimaler bzgl. der Laufzeit als der beste, bzgl. der Laufzeit, bekannte sequentielle Algorithmus.

316

4.1 Leistungsmaße für parallele Programme Effizienz

Abb. 4-2: Ideale und reale Effizienz

1.3 1.2 Ideale Effizienz

1.1 1.0 0.9

Overhead

0.8

Reale Effizienz

0.7 0.6 0.5 1 2

4

6

8

10

12

14

16

Anzahl der Prozessoren 4.1.5 Amdahls Gesetz Amdahls Gesetz [A 67], benannt nach dem Computer-Architekten Gene Amdahl, wird benutzt um für ein Gesamtsystem die maximal zu erwartenden Verbesserungen vorherzusagen, wobei von dem Gesamtsystem nur Teilsysteme verbessert werden. Das Gesetz wird im Bereich des parallelen Rechnens benutzt zur Festlegung des theoretisch maximal erreichbaren Speedup, bei p Prozessoren und in den Programm vorhandenen sequentiellen, nicht parallelisierbaren Anteilen Bei einer Implementierung eines parallelen Algorithmus existiert für jede Problemgröße ein bestimmter sequentieller Anteil f, der nicht parallelisiert werden kann und daher sequentiell (von einem einzigen Prozessor) ausgeführt werden muss. Für f gilt: 0 d f d1

Ist der sequentielle Anteil gleich null, so ist der Algorithmus vollständig parallel ausführbar. Ist der sequentielle Anteil gleich eins so ist kein Teil des Algorithmus parallel ausführbar. Der parallel ausführbare Anteil des Algorithmus ergibt sich entsprechend zu (1  f )

Die Zeit, die zur sequentiellen Ausführung des Algorithmus unter Verwendung eines einzigen Prozessors benötigt wird, sei T*(n). Die gesamte Laufzeit des Algorithmus ergibt sich aus dem sequentiellen

seq. Anteil + par. Anteil / p

317

4ȱȱParallelisierungȱ Anteilȱ plusȱ desȱ parallelenȱ Anteils.ȱ Dieȱ gesamteȱ paralleleȱ Laufzeitȱ istȱ dannȱgrößerȱgleichȱderȱSummationȱderȱZeitȱfürȱdenȱsequentiellenȱTeilȱ undȱdenȱparallelenȱTeilenȱdividiertȱdurchȱAnzahlȱpȱderȱProzessoren:ȱ ȱ ȱTp ( n) t f * T ' ( n) 

(1  f ) T ' ( n ) p

ȱ

FürȱdenȱmaximalȱmöglichenȱSpeedupȱfolgt:ȱ T ' ( n)

ȱSp ( n)

Tp ( n )

ȱ

T ' (n)

ȱȱȱȱȱȱȱȱ ȱ

f * T ' ( n) 

ȱȱȱȱ Gesetzȱvonȱ Amdahlȱȱȱȱȱ

1

ȱȱ

ȱ

ȱ

f 

ȱ Nichtȱ parallelisierȬ bareȱAnteileȱ begrenzenȱ Speedupȱȱ

(1  f ) T ' ( n)

ȱȱȱȱȱȱȱȱ (1  f )

p

(AmdahlschesȱGesetz)ȱ

p

AusȱAmdahlsȱGesetzȱgehtȱhervor,ȱdassȱbereitsȱeinȱrelativȱkleiner,ȱnichtȱ parallelisierbarerȱ Anteilȱ einesȱ Algorithmusȱ denȱ maximalȱ erreichbarenȱ Speedupȱ begrenzt.ȱ Liegtȱ beispielsweiseȱ fürȱ einenȱ bestimmtenȱ AlgoȬ rithmusȱ undȱ eineȱ gegebeneȱ Problemgrößeȱ derȱ parallelisierbareȱ Anteilȱ beiȱ95,ȱgiltȱalsoȱfȱ=ȱ0.05,ȱsoȱistȱderȱmaximalȱerreichbareȱSpeedupȱaufȱ 20ȱbeschränkt.ȱȱ Fürȱ fȱ >ȱ 0ȱ undȱ eineȱ großeȱ Anzahlȱ vonȱ Prozessorenȱ ( p o f ) ȱfolgtȱ ausȱ demȱAmdahlschenȱGesetzȱnäherungsweise:ȱ ȱ ȱSp ( n) d ȱ

EmbarrassingȬ lyȱparallelȱ problemsȱ

318ȱ

1 f

Beträgtȱderȱ sequentielleȱ Anteilȱ fȱ nurȱ10ȱ Prozent,ȱ soȱkannȱ dasȱProblemȱ nurȱ umȱ denȱ Faktorȱ 10ȱ beschleunigtȱ werden,ȱ egalȱ wieȱ großȱ derȱ Wertȱ vonȱnȱgewähltȱwurde.ȱAusȱdiesemȱGrundȱsindȱparalleleȱBerechnungenȱ nurȱfürȱeineȱkleineȱAnzahlȱvonȱProzessorenȱoderȱnurȱmitȱsehrȱkleinenȱ Wertenȱ vonȱ fȱ sinnvoll,ȱ undȱ massiveȱ Parallelitätȱ lohntȱ sichȱ nicht.ȱ Esȱ lohntȱsichȱalsoȱnurȱfürȱProbleme,ȱdieȱohneȱgroßenȱAufwandȱparalleliȬ sierbarȱ sindȱ undȱ inȱ denenȱ keineȱ sequentiellenȱ Anteileȱ vorkommen.ȱ DieseȱProblemeȱbesitzenȱeinenȱvorgegebenenȱundȱsomitȱdemȱProblemȱ inneȱ wohnendenȱ inhärentenȱ Parallelismus.ȱ Dieseȱ Problemeȱ heißenȱ

4.1ȱLeistungsmaßeȱfürȱparalleleȱProgrammeȱ embarrassinglyȱ parallelȱ problemsȱ (embarrassinglyȱ –ȱ beschämend).ȱ Inȱ Abschnittȱ4.2.1ȱgehenȱwirȱaufȱsolcheȱbeschämendȱeinfachȱzuȱparalleliȬ sierendeȱProblemeȱein.ȱȱ

4.1.6 Gustafsons Gesetz AmdahlȱhatȱbeiȱeinerȱAusführungȱdesȱparallelenȱProgrammsȱdieȱProbȬ lemgrößeȱkonstantȱgehaltenȱundȱdieseȱüberȱpȱProzessorenȱverteilt.ȱDasȱ Gesetzȱ vonȱ Amdahlȱ kannȱ jedochȱ keineȱ Aussageȱ überȱ denȱ Speedupȱ machenȱbeiȱeinerȱfestenȱLaufzeitȱundȱeinerȱErhöhungȱderȱProblemgröȬ ßeȱundȱderȱProzessoren.ȱJonȱL.Gustafsonȱ[Gȱ88]ȱnimmtȱdazuȱan,ȱdassȱinȱ derȱ Praxisȱ dieȱ Problemgrößeȱ mitȱ derȱ Prozessoranzahlȱ ebenfallsȱ anȬ wächst,ȱalsoȱderȱverteilbareȱAnteilȱdesȱProblemsȱwächstȱdagegenȱlinearȱ mitȱderȱProblemgrößeȱundȱderȱProzessoranzahl.ȱȱ

steigendeȱ ProzessoranȬ zahlȱundȱ steigendeȱ Problemgrößeȱ senktȱdenȱ seriellenȱ Anteilȱȱ

Seiȱf1ȱderȱsequentielleȱAnteilȱdesȱProblemsȱbeiȱeinerȱfestenȱProblemgröȬ ße,ȱ dieȱ inȱ einerȱ festenȱ Zeitȱ aufȱ einemȱ Prozessorȱ abgearbeitetȱ werdenȱ kann.ȱ Dieȱ Verringerungȱ desȱ sequentiellenȱ Anteilsȱ beiȱ größerenȱ ProbȬ lemgrößenȱ undȱ Erhöhungȱ derȱ Anzahlȱ derȱ Prozessorenȱ pȱ lässtȱ sichȱ durchȱfolgendeȱFormelȱausdrücken:ȱȱ ȱ ȱf ȱ

f1 p (1  f 1)  f 1

MitȱAmdahlsȱGesetzȱfolgt:ȱ ȱ

1 1 f f  p

ȱSp ( n) ȱ ȱȱȱȱȱȱȱȱȱȱȱ ȱȱ

1

ȱȱȱȱȱȱȱȱȱȱȱ

1

f1  p (1  f 1)  f 1

ȱ ȱ ȱȱ

ȱ

ȱ

ȱ

p (1  f 1)  f 1

f1 p (1  f 1)  f 1 p

Gesetzȱvonȱ Gustafsonȱ

ȱ (GustafsonsȱGesetz)ȱ

ȱ Ausȱ demȱ Gesetzȱ vonȱ Gustafsonȱ ergibtȱ sichȱ demnachȱ (unterȱ derȱ VorȬ aussetzungȱeinerȱfestenȱLaufzeitȱf1ȱundȱeinerȱBegrenzungȱderȱProblemȬ größeȱ durchȱ dieȱ Prozessoranzahl),ȱ dassȱ derȱ Speedupȱ mitȱ einemȱ konȬ

319ȱ

4ȱȱParallelisierungȱ stantenȱ sequentiellenȱ Teilȱ annäherndȱ linearȱ mitȱ derȱ Prozessorzahlȱ wächst.ȱ Damitȱ istȱ beiȱ massivȱ parallelenȱ Maschinenȱ oderȱ Clusterȱ undȱ großemȱpȱundȱentsprechendȱhohenȱProblemgrößenȱeinȱSpeedupȱnaheȱpȱ möglich.ȱȱ Skalierbarkeitȱ

EineȱAnwendungȱheißtȱskalierbar,ȱfallsȱeineȱwachsendeȱProblemgrößeȱ durchȱdenȱEinsatzȱeinerȱwachsendenȱAnzahlȱvonȱProzessorenȱsoȱkomȬ pensiertȱwerdenȱkann,ȱdassȱdieȱzurȱProblemlösungȱbenötigteȱZeitȱkonȬ stantȱ bleibt.ȱ Dieȱ Effizienzȱ einesȱ parallelenȱ Programmsȱ wirdȱ inȱ einemȱ solchenȱ Fall,ȱ beiȱ gleichzeitigemȱ Ansteigenȱ derȱ Prozessorzahlȱ undȱ derȱ Problemgröße,ȱkonstantȱgehaltenȱ[RRȱ00].ȱȱ

Amdahlȱoderȱ Gustafson?ȱ

Welchesȱ Gesetzȱ giltȱ nun?ȱ Dasȱ vonȱ Amdahlȱ oderȱ dasȱ vonȱ Gustafson?ȱ DieseȱFrageȱlässtȱsichȱaufȱdieȱeinfacheȱFormȱbringen:ȱ x IstȱdieȱAnwendungȱnichtȱskalierbar,ȱsoȱgiltȱdasȱGesetzȱvonȱAmdahl.ȱ x Istȱ dieȱAnwendungȱ perfektȱ skalierbar,ȱ soȱ giltȱ dasȱ Gesetzȱ vonȱ GusȬ tafson.ȱ

4.1.7 Karp-Flatt-Metrik BeiȱdenȱGesetzenȱvonȱAmdahlȱundȱGustafsonȱspieltȱdieȱOverheadzeitȱ TCWS,ȱ keineȱ Rolle,ȱ undȱ derȱ sequentielleȱ Anteilȱ fȱ istȱ dabeiȱ unabhängigȱ vonȱ derȱ Anzahlȱ derȱ Prozesseȱ p.ȱ Dieȱ Verlusteȱ durchȱ Kommunikationȱ TCOMȱundȱdieȱungleicheȱLastverteilungȱundȱdarausȱentstehendeȱWarteȬ zeitȱTWAITȱundȱSynchronisationszeitȱTSYN.ȱalsoȱderȱOverheadȱderȱParalȬ lelisierung,ȱ bleibtȱ dabeiȱ unberücksichtigt.ȱ Zurȱ Bestimmungȱ desȱ OverȬ headsȱderȱParallelisierungȱistȱderȱSpeedupȱnachȱGustafsonȱungeeignet,ȱ stattdessenȱ wirdȱ erȱ fürȱ mehrereȱ Werteȱvonȱ pȱ experimentellȱ bestimmt,ȱ undȱ durchȱ Auflösungȱ desȱ Gesetzesȱ vonȱ Amdahlȱ nachȱ fȱ kannȱ erȱ beȬ stimmtȱwerden.ȱȱ NachȱAmdahlsȱGesetzȱgilt:ȱ ȱ

1 Sp ( n ) ȱ

ȱ

f 

1 f p

DieseȱGleichungȱlässtȱsichȱnachȱdemȱsequentiellenȱAnteilȱfȱauflösen:ȱ ȱ Metrikȱvonȱ KarpȬFlattȱȱ

ȱȱ ȱ ȱ

320ȱ

f

1 Sp ( n )  1 p 11 p

ȱ(KarpȬFlattȬȱMetrik)ȱ

4.2ȱParallelisierungstechnikenȱ DerȱexperimentellȱbestimmbareȱserielleȱAnteilȱistȱdieȱKarpȬFlattȬMetrikȱ [KFȱ90].ȱSieȱerlaubtȱdieȱBerechnungȱdesȱempirischenȱsequentiellenȱAnȬ teilsȱf.ȱȱ Daȱ fȱ abhängigȱ vonȱ pȱ ist,ȱlassenȱsichȱ Aussagenȱ machenȱ überȱ dieȱOverȬ headȬZeitȱ TCWS.ȱ Dieȱ KarpȬFlattȬMetrikȱ zeigtȱ alsoȱ an,ȱ obȱ dieȱ Effizienzȱ einesȱparallelenȱProgrammsȱdurchȱdenȱinhärentenȱsequentiellenȱAnteilȱ oderȱ durchȱ denȱ parallelenȱ Overheadȱ dominiertȱ wird.ȱ Durchȱ dieȱ AbȬ hängigkeitȱ derȱ KarpȬFlattȬMetrikȱ vonȱ derȱ Anzahlȱ derȱ Prozessorenȱ pȱ lassenȱ sichȱ weitergehendeȱ Schlüsseȱ ziehen,ȱ wieȱ z.B.ȱ obȱ dieȱ Effizienzȱ vonȱ einerȱ ungleichenȱ Lastverteilungȱ undȱ somitȱ durchȱ dieȱ Wartezeitȱ TWAITȱundȱSynchronisationszeitȱTSYNȱbegrenztȱwirdȱoderȱvonȱderȱKomȬ munikationszeitȱTCOM.ȱ

4.2 Parallelisierungstechniken Derȱ Übergangȱ vonȱ einemȱ vorliegendenȱ Problemȱ aufȱ eineȱ paralleleȱ ProblemlösungȱistȱstarkȱbeeinflusstȱvonȱderȱStrukturȱdesȱProblemsȱundȱ derȱzuȱverarbeitendenȱDaten.ȱDeshalbȱbetrachtenȱwirȱdieȱStrukturȱdesȱ ProblemsȱundȱderȱDaten,ȱumȱzuȱeinerȱZerlegungȱdesȱProblemsȱinȱTeilȬ problemeȱzuȱkommenȱundȱeineȱparalleleȱLösungȱzuȱerhalten.ȱȱ

4.2.1 Inhärenter Parallelismus Bestehtȱ dasȱ Problemȱ ausȱ vielenȱ Teilproblemen,ȱ dieȱ voneinanderȱ totalȱ unabhängigȱsind,ȱd.h.ȱzwischenȱdenȱTeilproblemenȱbestehtȱkeineȱfunkȬ tionaleȱ Abhängigkeitȱ undȱ dieȱ Datenbereicheȱ derȱ Teilproblemeȱ sindȱ nichtȱ gemeinsamȱundȱ getrennt,ȱ soȱ besitztȱ dasȱ Problemȱ einenȱ inhärenȬ tenȱParallelismus.ȱȱ DaȱbeiȱinhärentemȱParallelismusȱdasȱAusgangsproblemȱinȱnȱunabhänȬ gigeȱTeilproblemeȱzerfällt,ȱkannȱmanȱbeiȱderȱVerwendungȱvonȱpȱRechȬ nerknotenȱ oderȱ Prozessorenȱ dasȱ Problemȱ effizientȱ lösen,ȱ indemȱ n/pȱ Teilproblemeȱ aufȱ dieȱ Knotenȱ einesȱ Rechnernetzesȱ oderȱ Prozessorenȱ verteiltȱ undȱ anschließendȱ parallelȱ bearbeitet.ȱ Inhärentȱ paralleleȱ ProbȬ lemeȱ lassenȱ sichȱ (fast)ȱ ohneȱ jedeȱ Kommunikationȱ zwischenȱ denȱ TeilȬ problemenȱ lösenȱ [BMȱ 06].ȱ Lediglichȱ vorȱ oderȱ nachȱ derȱ eigentlichenȱ BerechnungȱistȱKommunikationȱnötig.ȱVorȱderȱBerechnungȱmüssenȱdieȱ DatenȱanȱdieȱKnotenȱverteiltȱundȱnachȱderȱBerechnungȱdieȱErgebnisseȱ eingesammeltȱ werden.ȱ Durchȱ dieȱ fehlendeȱ oderȱ nurȱ minimalȱ vorhanȬ deneȱKommunikationȱistȱeinȱ(fast)ȱlinearerȱSpeedupȱmöglich.ȱȱ

Perfekteȱ ParallelisieȬ rungȱȱ

ȱ ȱ

321ȱ

4ȱȱParallelisierungȱ BeiȱinhärentemȱParallelismusȱkönnenȱdieȱbeidenȱFälleȱauftreten:ȱ Langsamsteȱ CPUȱoderȱ größtesȱ Teilproblemȱ bestimmtȱdieȱ GesamtȬ rechenzeitȱ

MonteȬCarloȬ Simulationenȱȱ

1.ȱ Dieȱ Anzahlȱ derȱ Rechenoperationenȱ zurȱ Lösungȱ derȱ Teilproblemeȱ kannȱstarkȱvariierenȱundȱnichtȱkonstantȱsein.ȱ 2.ȱDieȱProzesseȱkönnenȱaufȱunterschiedlichȱschnellenȱCPUsȱlaufen.ȱȱ SindȱPunktȱeinsȱundȱzweiȱerfüllt,ȱsoȱhängtȱdieȱGesamtlaufzeitȱdesȱpaȬ rallelenȱ Programmsȱ beiȱ einerȱ statischenȱ Lastverteilungȱ vomȱ aufwenȬ digstenȱTeilproblemȱoderȱvonȱderȱlangsamtenȱCPUȱab.ȱWährendȱeinigeȱ Prozesseȱnochȱrechnen,ȱsindȱdieȱanderenȱschonȱmitȱihremȱTeilproblemȱ fertigȱundȱmüssenȱwarten.ȱȱȱ Nebenȱ einerȱ Vielzahlȱ vonȱ Problemen,ȱ sieheȱ [BMȱ 06],ȱ dieȱ solchȱ eineȱ perfekteȱParallelisierungȱerlauben,ȱsindȱweitereȱtypischeȱProblemeȱdasȱ allgemeinȱ bekannteȱ SetiȬProjektȱ [ACKȱ 02]ȱ undȱ dieȱ MonteȬCarloȬ Simulationen.ȱ Ergebnisseȱ vonȱ MonteȬCarloȬSimulationenȱ sindȱ immerȱ mitȱ einemȱstatistischenȱ Fehlerȱ behaftet.ȱ Dieȱ Größeȱ diesesȱ Fehlersȱlässtȱ sichȱ leichtȱ abschätzen,ȱ wennȱ manȱ eineȱ MonteȬCarloȬSimulationȱ mehrȬ fachȱwiederholtȱundȱdieȱStreuungȱderȱEinzelergebnisseȱanalysiert.ȱDieȱ mehrfachenȱ MonteȬCarloȬSimulationenȱ sindȱ natürlichȱ voneinanderȱ vollkommenȱunabhängigȱundȱkönnenȱparallelȱausgeführtȱwerden.ȱDieȱ Landesbankȱ BadenȬWürttembergȱ inȱ Stuttgartȱ hatȱ dieȱ MonteȬCarloȬ Simulationenȱ eingesetztȱ zurȱ Risikoanalyseȱ [Bȱ 01].ȱ Fürȱ dieseȱ MonteȬ CarloȬSimulationenȱ standenȱ 16ȱ Windowsȱ NTȬRechnerȱ zurȱ Verfügung.ȱ Dabeiȱ wurdeȱ mehrȱ alsȱ linearerȱ Speedupȱ (superlinearerȱ Speedup)ȱ erȬ reicht!ȱDiesȱistȱnurȱverständlich,ȱwennȱmanȱdasȱSeitenaustauschverhalȬ tenȱ derȱ virtuellenȱ Speicherverwaltungȱ betrachtet:ȱ Mitȱ jedemȱ weiterenȱ Rechner,ȱderȱhinzukam,ȱreduziertȱsichȱdieȱDatenȱfürȱdieȱMonteȬCarloȬ Simulationen.ȱMitȱderȱReduktionȱderȱDatenȱgehtȱeinherȱeineȱReduktionȱ desȱ AusȬȱ undȱ Einlagernȱ derȱ Seitenȱ undȱ somitȱ eineȱ Reduktionȱ desȱ OverheadsȱderȱvirtuellenȱSpeicherverwaltung.ȱȱ

4.2.2 Zerlegungsmethoden EineȱvorherrschendeȱTechnikȱzurȱEntdeckungȱvonȱParallelitätȱinȱAlgoȬ rithmenȱ istȱ dieȱ „TeileȬundȬHerrscheȬStrategie“ȱ (Divideȱ andȱ Conquer).ȱ Zurȱ Lösungȱ einesȱ komplexenȱ Problemsȱ zerlegtȱ manȱ dasȱ Problemȱ inȱ zweiȱ oderȱ mehrereȱ einfachereȱ Unterproblemeȱ vonȱ ungefährȱ gleicherȱ Größe.ȱDieȱbeidenȱUnterproblemeȱsindȱunabhängigȱvoneinander.ȱDieȬ serȱProzessȱwirdȱrekursivȱdannȱaufȱdieȱUnterproblemeȱangewandt.ȱDieȱ Rekursionȱendet,ȱwennȱdasȱUnterproblemȱnichtȱweiterȱzerlegtȱwerdenȱ kann.ȱDerȱnachfolgendeȱAlgorithmusȱ[Fȱ95]ȱbeschreibtȱdieȱStrategie:ȱ

322ȱ

4.2ȱParallelisierungstechnikenȱ procedure Divide_and_Conquer (problem) begin if base_case then solve problem else partition problem into subproblems L and R; Divide_and_Conquer(L); Divide_and_Conquer(R); combine solutions to problems L and R; end if; end;

Programmȱ4Ȭ1:ȱ Divideȱandȱ Conquerȱ

DasȱdurchȱDivideȱandȱConquerȱzuȱlösendeȱProblemȱhabeȱdieȱGrößeȱn.ȱ VernachlässigenȱwirȱdasȱAufteilenȱdesȱProblemsȱundȱdasȱKombinierenȱ vonȱTeillösungenȱzuȱeinerȱGesamtlösungȱundȱgehenȱwirȱnochȱzusätzȬ lichȱ vonȱeinemȱ binärenȱ Baumȱaus,ȱ beiȱdemȱaufȱderȱunterstenȱEbeneȱpȱ Unterproblemeȱzuȱlösenȱsind,ȱsoȱergebenȱsichȱfolgendeȱLaufzeiten:ȱ ȱ

T ' (n) n ȱ

ȱ

Tp (n)

n ȱ p

ȱ DiesȱergibtȱfolgendenȱSpeedupȱ ȱ

Sp(n)

ȱȱȱȱȱ ȱ ȱ ȱ

T ' (n) ȱ Tp (n ) n n p

ȱ

pȱ

DivideȱandȱConquerȱliefertȱalsoȱeinenȱnichtȱganzȱlinearerȱSpeedup,ȱdaȱ wirȱ dasȱ Aufteilenȱ derȱ Problemeȱ undȱ dasȱ Kombinierenȱ derȱ Ergebnisseȱ vernachlässigtȱhaben.ȱȱ Umȱ einȱ sequentiellesȱ Problemȱ einerȱ parallelenȱ Lösungȱ zuzuführen,ȱ stehenȱdieȱfolgendenȱgrundsätzlichenȱZerlegungsmöglichkeitenȱoffen:ȱ

323ȱ

4ȱȱParallelisierungȱ 1.ȱ Funktionaleȱ Zerlegungȱ mitȱ einhergehenderȱ Zerlegungȱ desȱ ProȬ grammcodes,ȱoderȱ 2.ȱȱDatenzerlegungȱundȱsomitȱeinerȱAufteilungȱderȱDaten.ȱ 3.ȱȱEineȱKombinationȱvonȱbeidenȱMethoden.ȱȱ

4.2.2.1 Funktionale Zerlegung Pipelineȱ

FließbandȬ verȬ arbeitungȱ

Eineȱ funktionaleȱ Zerlegungȱ (functionȱ decomposition,ȱ functionȱ demarȬ cation)ȱ unterteiltȱ dasȱ Problemȱ inȱ mehrereȱ Arbeitsschritte,ȱ Aufgabenȱ oderȱFunktionen.ȱDieseȱFunktionenȱkönnenȱanȱmehrerenȱvoneinanderȱ unabhängigenȱTeilenȱdesȱGesamtproblemsȱarbeiten,ȱwasȱdemȱinhärenȬ tenȱParallelismusȱnaheȱkommt,ȱdaȱdieȱeinzelnenȱFunktionenȱproblemȬ losȱ parallelȱ ausführbarȱ sind.ȱ Bestehenȱ aberȱ zwischenȱ denȱ VerarbeiȬ tungsschrittenȱDatenabhängigkeiten,ȱoderȱandersȱgesagt,ȱdieȱeinzelnenȱ Verarbeitungsschritteȱ durchfließtȱ einȱ Datenstrom,ȱ soȱ führtȱ diesȱ zuȱ eiȬ nerȱPipelineȱoderȱzurȱFließbandverarbeitung.ȱȱ BeiȱFließbandverarbeitungȱzerfälltȱdasȱAusgangsproblemȱinȱnȱvoneinȬ anderȱ abhängigeȱ Teilprobleme.ȱ Dieȱ Teilproblemeȱ kannȱ manȱ beiȱ derȱ VerwendungȱvonȱpȱRechnerknotenȱoderȱProzessorenȱlösen,ȱindemȱmanȱ dieȱn/pȱTeilproblemeȱaufȱdieȱKnotenȱeinesȱRechnernetzesȱoderȱProzesȬ sorenȱ verteilt.ȱ Daȱ jedesȱ Teilproblemȱ dieȱ Datenȱ desȱ vorhergehendenȱ Teilproblemsȱ weiterȱ verarbeitet,ȱ müssenȱ dieseȱ Datenabhängigkeitenȱ durchȱSynchronisationȱundȱKommunikationȱgelöstȱwerden.ȱȱ DurchȱstatischeȱAllokationȱderȱn/pȱTeilproblemeȱaufȱpȱProzessorenȱlässtȱ sichȱ dasȱ Gesamtproblemȱ parallelȱ lösen.ȱ Amȱ Anfangȱ derȱ Pipeȱ werdenȱ dieȱDatenȱeingefüttertȱundȱamȱEndeȱderȱPipeȱerhältȱmanȱdasȱErgebnis.ȱȱ DieȱeinzelnenȱTeilproblemeȱinȱeinerȱPipeȱkönnenȱentwederȱalleȱgleichȬ artigȱsein,ȱd.h.ȱsieȱführenȱalleȱdieȱgleichenȱRechenoperationenȱaus,ȱoderȱ dieȱeinzelnenȱTeilproblemeȱsindȱvonȱunterschiedlicherȱArt,ȱȱd.h.ȱjedesȱ Teilproblemȱ löstȱ eineȱ andereȱ Aufgabe,ȱ undȱ dieȱ Anzahlȱ derȱ durchgeȬ führtenȱRechenoperationenȱistȱunterschiedlich.ȱDieȱLaufzeitȱderȱgesamȬ tenȱPipeȱhängtȱnatürlichȱdannȱstarkȱvonȱderȱLaufzeitȱdesȱElementesȱmitȱ denȱmeistenȱdurchgeführtenȱRechenoparationenȱundȱdamitȱderȱlängsȬ tenȱLaufzeitȱvonȱallenȱElementen,ȱab.ȱȱ Esȱ seiȱ pȱ dieȱ Stufenȱ derȱ Pipelineȱ oderȱ dieȱ Längeȱ derȱ Pipelineȱ oderȱ dieȱ PipelineȱbesitztȱpȱElemente.ȱnȱistȱdieȱProblemgrößeȱoderȱdieȱAnzahlȱderȱ Elemente,ȱdieȱamȱlinkenȱEndeȱinȱdieȱPipeȱeingefüttertȱwerdenȱundȱamȱ rechtenȱ Endeȱ dieȱ Pipeȱ verlassen.ȱ Dieȱ Laufzeitȱ fürȱ dasȱ sequentielleȱ Problem,ȱalsoȱohneȱPipelineȱistȱ ȱȱȱ T ' (n)

324ȱ

p n

4.2ȱParallelisierungstechnikenȱ DieȱLaufzeitȱimȱparallelenȱFall,ȱalsoȱmitȱderȱPipelineȱistȱ ȱTp ( n)

pn

ȱ SomitȱerbringtȱeineȱPipelineȱfolgendeȱLeistungssteigerung:ȱ ȱ ȱȱSp ( n) ȱ ȱ ȱ ȱȱȱȱȱȱȱȱȱȱ ȱȱȱȱȱȱȱȱȱ ȱȱȱȱȱ ȱ ȱ

Speedupȱ einerȱPipelineȱ

T ' ( n) Tp ( n ) p n pn p n p n (  1) n

p

p 1 ȱ n Fürȱgroßeȱnȱ n o f ȱfolgtȱdarausȱ Sp(n) p ȱ ȱ

BeiȱeinerȱPipelineȱmitȱgleichenȱAufgabenȱistȱsomitȱeinȱlinearerȱSpeedupȱ zuȱerwarten.ȱȱȱ NegativȱbeiȱeinerȱPipelineȱistȱnatürlichȱderȱAusfallȱeinesȱElementesȱderȱ Pipeline.ȱFälltȱeinȱeinzigesȱElementȱderȱPipelineȱaus,ȱsoȱistȱderȱBearbeiȬ tungsstromȱ unterbrochenȱ undȱ dasȱ vorhergehendeȱ PipelineȬElementȱ wirdȱseinȱTeilergebnisȱnichtȱmehrȱlosȱundȱdieȱnachfolgendenȱElementeȱ bekommenȱkeineȱTeilergebnisseȱzurȱBearbeitungȱübergeben.ȱȱ

Ausfallȱeinesȱ Elementesȱderȱ Pipelineȱführtȱ zumȱ Totalausfallȱ

Einȱ Beispielȱ fürȱ eineȱ Pipelineȱ mitȱ unterschiedlichenȱ Aufgabenȱ istȱ dieȱ Befehlspipeline,ȱ wieȱ sieȱ inȱ Abschnittȱ 2.2.1ȱ besprochenȱ wurde.ȱ Beiȱ SuȬ perskalarȬArchitekturenȱ teiltȱ sichȱ dieȱ Pipelineȱ beiȱ derȱ BefehlsausfühȬ rungȱinȱmehrereȱZweigeȱauf.ȱZurȱUnterscheidungȱeinerȱBefehlspipelineȱ vonȱeinerȱPipeline,ȱdieȱaufȱderȱfunktionalenȱZerlegungȱmitȱeinemȱDaȬ tenstromȱ beruht,ȱ sprichtȱ manȱ imȱ zweitenȱ Fallȱ auchȱ vonȱ einerȱ MakroȬ Pipelineȱ[Uȱ97].ȱ

BefehlspipeȬ lineȱ

4.2.2.2 Datenzerlegung Beiȱ einerȱ einmaligenȱ Zerlegungȱ derȱ Datenȱ oderȱ desȱ Eingabebereichsȱ (Domainȱ decompostion)ȱ undȱ Zuführungȱ derȱ Bereicheȱ aufȱ mehrereȱ

325ȱ

4ȱȱParallelisierungȱ paralleleȱProzessorenȱaufȱdenenȱderȱgleicheȱAlgorithmusȱläuft,ȱführenȱ aufȱ dasȱ Masterȱ WorkerȬSchema.ȱ Führtȱ manȱ dieȱ Zerlegungȱ derȱ Datenȱ rekursivȱmehrfachȱdurch,ȱsoȱergebenȱsichȱBerechnungsbäume.ȱȱȱ

4.2.2.2.1 Master Worker-Schema Beiȱ Masterȱ Workerȱ verteiltȱ einȱ Masterȱ dieȱ verschiedenenȱ DatenbereiȬ cheȱanȱeineȱbestimmteȱAnzahlȱvonȱWorkersȱundȱnimmtȱdieȱErgebnisseȱ vonȱdenȱWorkersȱentgegen.ȱȱ Nachȱ Programmstartȱ fragenȱ alleȱ Workersȱ beimȱ Masterȱ nachȱ einemȱ unerledigtenȱDatenbereichȱan.ȱDerȱMasterȱnimmtȱvonȱeinemȱStapelȱdieȱ unerledigtenȱ Datenbereicheȱ undȱ weistȱ sieȱ denȱ einzelnenȱ Workerȱ zu.ȱ Nachdemȱ derȱ Workerȱ denȱ aktuellenȱ Datenbereichȱ bearbeitetȱ hat,ȱ schicktȱ erȱ dasȱ Ergebnisȱ anȱ denȱ Masterȱ zurückȱ undȱ fragtȱ nachȱ einemȱ nächstenȱ zuȱ bearbeitendenȱ Datenbereich.ȱ Derȱ Overheadȱ derȱ ParalleliȬ sierungȱ istȱ hierȱ dieȱ Rüstzeit,ȱ alsoȱ dieȱ Zeitȱ zumȱ Startȱ desȱ Programmsȱ undȱdasȱVerteilenȱderȱDatenbereicheȱundȱdasȱEinsammelnȱderȱ ErgebȬ nisse.ȱ Abb.ȱ4Ȭ3:ȱ Masterȱ WorkerȬȱ Schemaȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ InȱeinemȱerstenȱAnsatzȱsetzenȱwirȱeineȱRegularitätȱderȱDatenȱundȱUniȬ formitätȱderȱArbeitȱvoraus,ȱd.h.ȱfürȱalleȱTeildatenȱwirdȱdieȱgleicheȱAnȬ zahlȱ vonȱ Rechenoperationenȱ benötigt,ȱ undȱ alleȱ Algorithmenȱ sindȱ gleichȱ undȱ laufenȱ aufȱ gleichȱ schnellenȱ CPUs.ȱ Vernachlässigtȱ manȱ dieȱ Kommunikationȱzwischenȱ demȱ Masterȱundȱ denȱ Workersȱ undȱdieȱArȬ beitȱdesȱWorkers,ȱsoȱistȱmitȱfolgendemȱSpeedupȱzuȱrechnen:ȱ Dabeiȱ seiȱ nȱ seiȱ dieȱ Größeȱ derȱ einzelnenȱ Datenzerlegungenȱ undȱ pȱ dieȱ AnzahlȱderȱWorkersȱȱ

326ȱ

4.2ȱParallelisierungstechnikenȱ

T ' (n)

p n ȱȱȱ

DieȱLaufzeitȱimȱparallelenȱFall,ȱalsoȱdieȱLaufzeitȱeinesȱeinzelnenȱWorȬ kersȱist:ȱ

Tp(n)

nȱ

Somitȱ erbringtȱ dasȱ Masterȱ WorkerȬSchemaȱ folgendeȱ LeistungssteigeȬ rung:ȱ ȱ ȱȱSp ( n) ȱȱȱȱȱȱȱȱȱȱ ȱȱȱȱȱȱȱȱȱȱ ȱ ȱ ȱ

T ' ( n) Tp ( n ) p n n

Speedupȱfürȱ Masterȱ Workerȱ

p

BeiȱdenȱSpeedupȬBetrachtungenȱwurdeȱdieȱKommunikationȱzwischenȱ demȱ Masterȱ undȱ denȱ Workerȱ außerȱ Achtȱ gelassen.ȱ Jeȱ feinerȱ manȱ dieȱ Granularitätȱ derȱ Datenzerlegungȱ wählt,ȱ umsoȱ mehrȱ steigtȱ dieȱ KomȬ munikationȱ zwischenȱ demȱ Masterȱ undȱ denȱ Workersȱ an,ȱ dieȱ zuȱ überȬ tragendenȱ Datenȱ nehmenȱ jedochȱ abȱ undȱ dieȱ Arbeitslastȱ desȱ Mastersȱ steigtȱ an.ȱ Diesȱ kannȱ beiȱ sehrȱ feinerȱ Granularitätȱ derȱ Datenȱ sogarȱ aufȱ eineȱ Überlastungȱ desȱ Mastersȱ führenȱ undȱ derȱ Masterȱ wirdȱ zuȱ einemȱ leistungsbeschränkendenȱFlaschenhals.ȱȱ Eineȱ CȬBibliothekȱ zurȱ Realisierungȱ undȱ Implementierungȱ desȱ Masterȱ WorkerȬSchemasȱistȱbeiȱBaukeȱundȱMertensȱ[BMȱ06]ȱbeschrieben.ȱBeiȬ spieleȱfürȱdasȱMasterȱWorkerȬSchemaȱsindȱdortȱebenfallsȱenthalten.ȱ

4.2.2.2.2 Berechnungsbäume Nimmtȱ manȱ dieȱ Datenzerlegungȱ mehrmaligȱ undȱ rekursivȱ nachȱ demȱ DivideȱandȱConquerȬSchemaȱvor,ȱsoȱentstehenȱBerechnungsbäume.ȱȱȱ Soȱ führtȱ dieȱ mehrfacheȱ Zerlegungȱ einesȱ zuȱ sortierendenȱ Feldesȱ zuȱ eiȬ MergeȱSortȱ nemȱbinärenȱBaum.ȱEinȱBeispielȱdafürȱistȱderȱMergeȬSortieralgorithmus.ȱ Parallelȱ BeimȱAbsteigenȱdesȱBaumesȱwirdȱdasȱFeldȱinȱzweiȱgleichȱgroßeȱFelderȱ Quicksortȱ aufgeteilt.ȱ Dieȱ Blätterȱ sortierenȱ dannȱ parallelȱ dieȱ einzelnenȱ Teilfelder.ȱ Undȱ nachȱ demȱ Sortierenȱ werdenȱ immerȱ zweiȱ gleichȱ großeȱ Teilfelderȱ zusammengeschmolzenȱ (merge).ȱ Nichtȱ ganzȱ soȱ symmetrischȱ undȱ soȬ mitȱ zuȱ einemȱ unausgeglichenenȱ Baumȱ führtȱ dieȱ Parallelisierungȱ desȱ QuicksortȬAlgorithmus.ȱ Derȱ QuicksortȬAlgorithmusȱ vertauschtȱ dieȱ Feldelemente,ȱ bisȱ esȱ fürȱ dieȱ Lageȱ desȱ sortiertenȱ Elementesȱ keineȱ VerȬ änderungenȱmehrȱgibt.ȱDieȱListeȱistȱsomitȱinȱzweiȱmöglicherweiseȱunȬ

327ȱ

4ȱȱParallelisierungȱ terschiedlichȱ großeȱ Teillistenȱ aufgespaltet.ȱ Dieȱ beidenȱ Teillistenȱ könȬ nenȱ dannȱ mitȱ zweiȱ rekursivenȱ Aufrufenȱ undȱ somitȱ parallelȱ inȱ zweiȱ weitereȱungleichȱgroßeȱTeillistenȱaufgeteiltȱwerden.ȱ Dieȱ Algorithmenȱ zurȱ parallelenȱ Bearbeitungȱ vonȱ Datenȱ nenntȱ Hillisȱ undȱSteeleȱ[HSȱ86]ȱDataȱParallelȱAlgorithms.ȱSieȱgebenȱinȱihremȱArtikelȱ eineȱ Vielzahlȱ vonȱ Beispielenȱ vonȱ parallelenȱ Algorithmenȱ gemäßȱ DaȬ tenzerlegung:ȱ x SummationȱeinesȱFeldesȱvonȱZahlen,ȱȱ x alleȱpartiellenȱSummenȱeinesȱFeldes,ȱȱȱ x ZählenȱvonȱaktivenȱProzessorenȱundȱderenȱDurchnummerierung,ȱȱ x lexikalischeȱAnalyseȱeinesȱString,ȱȱ x RadixȱSortȱundȱȱ x parallelesȱ Bearbeitenȱ vonȱ Pointersȱ undȱ daraufȱ basierendeȱ ListenȬ operationen.ȱ Dieseȱ Algorithmenȱ sindȱ aufȱ denȱ erstenȱ Blickȱ sequentiellerȱ Natur.ȱ Fürȱ großeȱDatenmengenȱlohntȱsichȱhierȱjedochȱeineȱparalleleȱBearbeitung.ȱȱ

4.2.2.3 Funktions- und Datenzerlegung DieȱZerlegungȱdesȱProblemsȱkannȱnachȱGesichtspunktenȱeinerȱfunktiȬ onalenȱZerlegungȱund/oderȱeinerȱDatenzerlegungȱvorgenommenȱwerȬ den.ȱDieȱdabeiȱentstehendenȱTeilproblemeȱlassenȱsichȱȱ 1.ȱ vorȱ derȱ Laufzeitȱ aufȱ dieȱ Prozessorenȱ abbildenȱ undȱ somitȱ statischȱ allokieren,ȱȱoderȱ 2.ȱeinȱLastausgleicherȱbestimmtȱdynamischȱzurȱLaufzeitȱeinenȱProzesȬ sorȱoderȱServerȱundȱübergibtȱihmȱdasȱTeilproblemȱzurȱBearbeitung.ȱȱ

4.2.2.3.1 Methodisches Vorgehen Fosterȱ[Fȱ95]ȱbeschreibtȱeinenȱWeg,ȱwieȱmanȱvonȱeinerȱZerlegungȱdesȱ Problemsȱ zuȱ einerȱ Allokationȱ derȱ Teilproblemeȱ aufȱ Prozessorenȱ kommt,ȱinȱvierȱSchritten:ȱ Methodikȱzurȱ Entwicklungȱ parallelerȱ Softwareȱ

328ȱ

1.ȱ Partitionierung,ȱ Zerlegung:ȱ DerȱersteȱSchrittȱzerlegtȱ dasȱ Problemȱ inȱ mehrereȱ Teilproblemeȱ oderȱ Teilaufgaben.ȱ Dieȱ Unterteilungȱ geȬ schiehtȱdabeiȱdurchȱFunktionsȬȱundȱDatenzerlegung.ȱZurȱVerringeȬ rungȱ desȱ Kommunikationsaufwandesȱ sollenȱ identischeȱ Datenȱ aufȱ mehrerenȱKnotenȱgespeichertȱundȱsomitȱrepliziertȱwerden.ȱZielȱdieȬ serȱ Phaseȱ ist,ȱ alleȱ Möglichkeitenȱ derȱ Parallelausführungȱ zuȱ erkenȬ nen.ȱ

4.2ȱParallelisierungstechnikenȱ 2.ȱ Auslegungȱ derȱ Kommunikation:ȱ Zurȱ Koordinationȱ derȱ Prozesseȱ mussȱ dieȱ benötigteȱ Kommunikationȱ undȱ dieȱ dazugehörigenȱ AlgoȬ rithmenȱfestgelegtȱwerden.ȱZielȱdesȱzweitenȱSchrittesȱist,ȱdieȱKomȬ munikationȱsoȱzuȱgestalten,ȱdassȱsieȱmöglichstȱeffizientȱistȱundȱeineȱ BlockierungȱderȱProzesseȱvermiedenȱwird.ȱȱ 3.ȱ Agglomerationȱ (Zusammenballung):ȱ Dieȱ erstenȱ beidenȱ Schritteȱ lieȬ fernȱ eineȱ effizienteȱ Parallelisierung.ȱ Dieȱ Leistungsfähigkeitȱ undȱ KostenȱderȱeingesetztenȱHardwareȱführenȱinȱdiesemȱSchrittȱzuȱeinerȱ Bündelungȱ derȱ Aufgaben.ȱ Wurdeȱ dasȱ Problemȱ inȱ zuȱ vieleȱ TeilaufȬ gabenȱbezüglichȱderȱvorhandenenȱProzessorenȱzerlegt,ȱsoȱkannȱdiesȱ durchȱBündelungȱderȱTeilaufgabenȱkorrigiertȱwerden.ȱ 4.ȱ Mapping:ȱ Jedeȱ Taskȱ wirdȱ einemȱ Prozessorȱ zugewiesen.ȱ Tasks,ȱ dieȱ konkurrentȱundȱohneȱKommunikationȱuntereinanderȱablaufen,ȱlauȬ fenȱ aufȱ verschiedenenȱ Prozessoren.ȱ Tasks,ȱ dieȱ häufigȱ miteinanderȱ kommunizieren,ȱ laufenȱ möglichstȱ aufȱ demȱ gleichenȱ Prozessor.ȱ MappingȱkannȱstatischȱseinȱoderȱdynamischȱzurȱLaufzeitȱdurchȱeiȬ nenȱLastausgleicherȱstattfinden.ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

329ȱ

4 Parallelisierung Abb. 4-4: Entwurfsmethodik für parallele Programme

Problem 1. Partitionierung

Teilprobleme

2. Partitionierung auslegen

3. Agglomeration

4. Mapping

Rechner 1 Rechner 2 Rechner 3

330

4.2ȱParallelisierungstechnikenȱ

4.2.2.3.2 Dynamische Allokation Dieȱ beiȱ einerȱ Problemzerlegungȱ entstehendenȱ Teilproblemeȱ könnenȱ dynamischȱzurȱLaufzeitȱmehrerenȱServernȱzurȱBearbeitungȱübergebenȱ werden.ȱDieȱzuȱbearbeitendenȱDatenȱentstehenȱdabeiȱmeistȱdynamischȱ undȱ möglicherweiseȱ parallelȱ undȱ meistensȱ zurȱ Laufzeitȱ durchȱ AnfraȬ genȱ vonȱ Clientsȱ anȱ denȱ Server.ȱ Zurȱ Bearbeitungȱ derȱ Datenȱ oderȱ derȱ Anfragenȱ benutztȱ manȱ einȱ Serverȱ Cluster,ȱ eineȱ Computerȱ Farmȱ oderȱ eineȱ Serverȱ Farm.ȱ Unterȱ einerȱ Serverȱ Farmȱ verstehtȱ manȱ eineȱ Gruppeȱ vonȱvernetztenȱServern,ȱdieȱsichȱanȱeinerȱLokationȱbefinden.ȱ

ServerȱFarm

ȱ ȱ ȱ ȱ ȱ ȱ

Abb.ȱ4Ȭ5:ȱ Dynamischeȱ Allokationȱ derȱ Teilproblemeȱ aufȱeineȱ ServerȱFarmȱȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ Eineȱ Serverȱ Farmȱ enthältȱ verschiedeneȱ oderȱ gleichartigeȱ Server,ȱ undȱ dieȱ Arbeitslastȱ wirdȱ dabeiȱ aufȱ dieȱ verschiedenenȱ Serverȱ verteilt.ȱ Diesȱ bedingtȱeinȱLastausgleicher,ȱderȱdieȱAnfrageȱnachȱRechenleistungȱoderȱ Serviceȱ einemȱ Serverȱ dynamischȱ zuordnetȱ undȱ einȱ Schedulingȱ derȱ AnfragenȱnachȱPrioritätȱvornehmenȱkann.ȱFälltȱeinȱServerȱinȱderȱFarmȱ aus,ȱkannȱeinȱandererȱServerȱderȱFarmȱeinspringenȱundȱdessenȱArbeitȱ mitȱ übernehmen.ȱ Zurȱ Erreichungȱ derȱ Ausfalltoleranzȱ sindȱ dieȱ Serverȱ alsȱPrimaryȱundȱBackupȱausgelegt.ȱȱ

331ȱ

4ȱȱParallelisierungȱ WebȱFarmȱ

EineȱWebȱServerȱFarmȱoderȱWebȱFarmȱistȱeineȱWebȬSeite,ȱdieȱmehrȱalsȱ einenȱServerȱzurȱBefriedigungȱderȱAnfragenȱzurȱVerfügungȱstelltȱoderȱ einȱInternetȱServiceȱProviderȱderȱWebȱHostingȱServicesȱdurchȱmehrereȱ Serverȱ betreibt.ȱ Einȱ typischesȱ Beispielȱ fürȱ eineȱ Webȱ Farmȱ istȱ dasȱ inȱ Abschnittȱ2.4ȱbeschriebeneȱGoogleȱCluster.ȱ

4.2.3 Weitere parallele Verfahren und Algorithmen NebenȱdenȱhierȱvorgeschlagenenȱSchemataȱoderȱVerfahrenȱzurȱGewinȬ nungȱ einerȱ parallelenȱ Lösung,ȱ stehenȱ nochȱ eineȱ Vielzahlȱ vonȱ AlgoȬ rithmenȱzurȱVerfügung,ȱdieȱteilweiseȱvonȱdenȱhierȱbeschriebenenȱVerȬ fahrenȱ abstammenȱ oderȱ ihnenȱ ähneln,ȱ eineȱ Kombinationȱ derȱ obigenȱ VerfahrenȱoderȱteilweiseȱvonȱoriginärerȱNaturȱsind.ȱSieȱalleȱhierȱvorzuȬ stellen,ȱ würdeȱ denȱ Rahmenȱ desȱ Buchesȱ sprengen.ȱ Dieȱ nachfolgendenȱ Literaturhinweise,ȱ geordnetȱ nachȱ unterschiedlichenȱ AnwendungsgeȬ bieten,ȱmögenȱhierȱausreichen:ȱȱ x AllgemeinȱparalleleȱAlgorithmenȱ[Aȱ00],ȱ{Aȱ97],ȱ[Bȱ94],ȱ[CRQRȱ89],ȱ [GGKȱ03],ȱ[GOȱ96],ȱ[GRȱ88],ȱ[Hȱ83],ȱ[Qȱ87],ȱ[Qȱ94],ȱ[RRȱ00],ȱ[MBȱ05]ȱ undȱ[Jȱ92].ȱ x ParalleleȱSortierȬȱundȱSuchalgorithmenȱ[Aȱ85],ȱ[BDHȱ84]ȱundȱ[Mȱ79].ȱȱ x ParalleleȱGraphȱAlgorithmenȱ[QDȱ84].ȱ x ParalleleȱNumerikȱ[Fȱ90],ȱ[GOȱ96]ȱundȱ[Sȱ03].ȱ x ParalleleȱMetaheuristikenȱ[Aȱ05].ȱ ȱ ȱ

332ȱ

5 Verteilte Algorithmen 5.1 Verteilt versus zentralisiert Einȱ verteiltesȱ Systemȱ unterscheidetȱ sichȱ vonȱ einemȱ zentralisiertenȱ (EinprozessorȬ)ȱSystemȱinȱdenȱnachfolgendȱdiskutiertenȱdreiȱPunkten:ȱ 1.ȱȱ DasȱNichtvorhandenseinȱeinesȱglobalenȱZustandesȱȱ BeiȱeinemȱzentralisiertenȱAlgorithmusȱwerdenȱEntscheidungenȱgeȬ troffen,ȱdieȱaufȱderȱbisherigenȱBeobachtungȱdesȱZustandesȱdesȱSysȬ temsȱbasieren.ȱNichtȱderȱkompletteȱZustandȱderȱMaschineȱwirdȱinȱ einerȱ Maschinenoperationȱ herangezogen,ȱ sondernȱ dieȱ Variablenȱ werdenȱnacheinanderȱbetrachtet.ȱNachdemȱalleȱrelevanteȱInformaȬ tionȱvorliegt,ȱwirdȱeineȱEntscheidungȱgefällt.ȱZwischenȱderȱInspekȬ tionȱ undȱ derȱ Entscheidungȱ werdenȱ keineȱ Datenȱ modifiziert,ȱ wasȱ dieȱIntegritätȱderȱEntscheidungȱgarantiert.ȱȱ

Keinȱ gemeinsamerȱ Zustandȱ

KnotenȱinȱeinemȱverteiltenȱSystemȱhabenȱnurȱZugriffȱaufȱihrenȱeiȬ genenȱ Zustandȱ undȱ nichtȱ aufȱ denȱ globalenȱ Zustandȱ desȱ GesamtȬ systems.ȱ Demzufolgeȱ istȱ esȱ nichtȱ möglich,ȱ eineȱ Entscheidungȱ zuȱ treffen,ȱdieȱaufȱdemȱglobalenȱZustandȱdesȱGesamtsystemsȱbasiert.ȱ Manȱ könnteȱ nunȱ davonȱ ausgehen,ȱ dassȱ einȱ Knotenȱ Informationȱ überȱdenȱZustandȱderȱanderenȱKnotenȱeinholtȱundȱdannȱeineȱEntȬ scheidungȱdaraufȱbasierendȱgefälltȱwird.ȱImȱGegensatzȱzuȱzentraliȬ siertenȱSystemenȱkannȱsichȱjedochȱbeiȱeinemȱverteiltenȱSystemȱderȱ ZustandȱderȱanderenȱMaschinenȱgeändertȱhabenȱvorȱdemȱEintrefȬ fenȱ derȱ Rückantwortenȱ vonȱ denȱ anderenȱ Maschinen.ȱ Dieȱ KonseȬ quenzȱdarausȱist,ȱdassȱdieȱgefällteȱEntscheidungȱaufȱaltenȱundȱsoȬ mitȱungültigenȱDatenȱberuht.ȱ EineȱnachfolgendeȱanschaulicheȱÜberlegungȱzeigt,ȱdassȱeinȱglobaȬ lerȱZustandȱbeiȱeinemȱverteiltenȱSystemȱnichtȱerreichbarȱist.ȱȱ NehmenȱSieȱan,ȱxȱseiȱeineȱVariable,ȱdieȱaufȱeinerȱMaschineȱBȱvorȬ liegt.ȱ Einȱ Prozessȱ aufȱ Maschineȱ Aȱ liestȱ xȱ zumȱ Zeitpunktȱ T1.ȱ Dazuȱ sendetȱMaschineȱAȱeineȱAnforderungsnachrichtȱfürȱxȱzuȱMaschineȱ B.ȱKurzeȱZeitȱspäterȱzumȱZeitpunktȱT2ȱschreibtȱeinȱProzessȱaufȱMaȬ schineȱBȱinȱdieȱVariableȱx.ȱDieȱHerstellungȱeinesȱglobalenȱZustanȬ desȱ erfordertȱ nun,ȱ dassȱ dasȱ Lesenȱ aufȱ derȱ Maschineȱ Aȱ denȱ altenȱ Wertȱ vonȱ xȱ liest,ȱ unabhängigȱ davon,ȱ wieȱ weitȱ dieȱ Maschinenȱ Aȱ

333ȱ

5 Verteilte Algorithmen und B örtlich auseinander liegen und wie eng T2 und T1 zeitlich zusammen liegen. Abb. 5-1: Überlegungen zur Nichterreichung eines globalen Systemzustandes

Maschine B

Maschine A 3m

Variable x := 0

Anforderung für x T 1 read(x) T 2 – T1 = 1nanosec T 2 x := 1

Nehmen wir nun folgende Werte an: T2 – T1 sei eine Nanosekunde (10-9sec) und die Maschinen stehen 3 m entfernt voneinander; die Lichtgeschwindigkeit ist 3*108 m/sec. Damit nun die Anforderung für x von der Maschine A vor dem Setzen der Variablen x auf 1 bei der Maschine B ankommt (in der Zeit T2 – T1 = 10-9 sec), benötigt man eine Signalgeschwindigkeit von 3*109 m/sec. Dies entspricht der zehnfachen Lichtgeschwindigkeit und ist nach Einsteins Relativitätstheorie unmöglich. Keine gemeinsame Zeit

334

2. Das Nichtvorhandensein eines globalen Zeitrahmens Die Ereignisse, welche mit der Ausführung eines zentralisierten Algorithmus assoziiert sind, sind total geordnet durch ihre zeitliche Reihenfolge; für jedes Paar von Ereignissen gilt: Ein Ereignis ist früher oder später als ein anderes Ereignis. Die Zeitrelation der Ereignisse eines verteilten Algorithmus sind nicht total; für Ereignisse auf der gleichen Maschine kann entschieden werden, dass ein Ereignis vor einem anderen liegt. Bei Ereignissen auf zwei verschiedenen Maschinen, die nicht in einer Ursache-Wirkungsrelation zueinander stehen, kann nicht entschieden werden, ob ein Ereignis vor einem anderen eintrat. Diese Ereignisse lassen sich auch nicht in eine Ursache-Wirkungsrelation bringen durch ein Senden und

5.1 Verteilt versus zentralisiert Empfangen von Nachrichten, wo die Wirkung des Empfangens der Nachricht der Ursache des Sendens der Nachricht vorausgeht. Dann könnte die Ausführung wieder als eine Folge von globalen Zuständen betrachtet werden, und es läge die unter 1. beschriebene Problemstellung für die Plausibilitätsbetrachtung vor. 3.

Das nicht deterministische Verhalten Bei einem zentralisierten System ist die Berechnung basierend auf Eingabewerten eindeutig; bei einem gegebenen Programm und einer Eingabe ist nur eine Berechnung möglich. Im Gegensatz dazu ist bei einem verteilten System, mit Ausnahme von Synchronisationsoperationen, die globale Reihenfolge der Ereignisse nicht deterministisch. Jeder Programmlauf hat die Möglichkeit, eine andere Reihenfolge der Ereignisse zu liefern als seine Vorgänger und Nachfolger. Dennoch muss jeder korrekte Programmlauf das gleiche Ergebnis liefern.

Unvorhersehbare Abläufe

Betrachten Sie dazu die Situation, in der ein Server-Prozess viele Anfragen von einer unbekannten Anzahl von Clients erhält. Der Server kann die Bearbeitung der Anfragen nicht aussetzen, bis alle Anfragen eingetroffen sind, und sie dann in einer bestimmten Reihenfolge bearbeiten, da für ihn unbekannt ist, wie viel Anfragen er bekommt. Die Konsequenz daraus ist, er muss jede Anfrage sofort bearbeiten und die Reihenfolge, in der er sie bearbeitet, ist die Reihenfolge, in der die Anfragen eintreffen. Die Reihenfolge, in welcher die Clients ihre Abfragen senden, sei bekannt, da jedoch die Übertragungszeiten unterschiedlich sind, können die Abfragen in einer anderen Reihenfolge eintreffen. Diese Unüberschaubarkeiten führen bei der Programmierung von verteilten Systemen zu fehlerhaften Anwendungen der Kommunikationsdienste. Hierunter fallen neben fehlerhaftem Inhalt der transformierten Information vor allem das Vergessen nötiger Synchronisationspunkte oder eine Anwendung der falschen Reihenfolge derselben. Zur Entdeckung derselben ist ein Monitorsystem nützlich, das die zeitliche Reihenfolge der Aktionen oder Ereignisse widerspiegelt.

335

5ȱȱVerteilteȱAlgorithmenȱ

5.2 Logische Ordnung von Ereignissen 5.2.1 Lamport-Zeit Logischeȱ Uhrenȱversusȱ physikalischeȱ Uhrenȱ

FürȱvieleȱZweckeȱistȱesȱausreichend,ȱdassȱalleȱMaschinenȱsichȱaufȱeineȱ gemeinsameȱ Zeitȱ einigen,ȱ wobeiȱ dieseȱ Zeitȱ nichtȱ mitȱ derȱ realenȱ Zeitȱ übereinstimmenȱmuss.ȱD.h.ȱdieȱZeitȱaufȱallenȱMaschinenȱistȱinternȱkonȬ sistentȱ undȱ brauchtȱ nichtȱ mitȱ derȱ externenȱ realenȱ Zeitȱ übereinzustimȬ men.ȱInȱdiesemȱFallȱsprechenȱwirȱvonȱlogischenȱUhrenȱ(logicalȱclocks).ȱ WirdȱnebenȱderȱKonsistenzȱderȱinternenȱUhrenȱzusätzlichȱnochȱgeforȬ dert,ȱdassȱsichȱdieȱUhrenȱnurȱumȱeineȱgewisseȱkleineȱZeitdifferenzȱvonȱ derȱrealenȱUhrzeitȱunterscheiden,ȱsoȱsprechenȱwirȱvonȱphysikalischenȱ Uhrenȱ(physicalȱclocks).ȱ

liegtȬvorȬȱ Relationȱ (happensȱ before)ȱȱ

ZurȱlogischenȱUhrensynchronisationȱbrauchenȱsichȱnichtȱalleȱProzesseȱ aufȱ eineȱ gemeinsameȱ festeȱ Zeitȱ zuȱ einigen,ȱ sondernȱ esȱ reichtȱ dieȱ BeȬ stimmung,ȱinȱwelcherȱzeitlichenȱRelationȱzweiȱEreignisseȱmiteinanderȱ stehen.ȱBeiȱzweiȱEreignissenȱaȱundȱbȱmussȱalsoȱbestimmtȱwerden,ȱliegtȱ EreignisȱaȱzeitlichȱvorȱEreignisȱbȱoderȱumgekehrt.ȱDazuȱdefinierenȱwirȱ eineȱRelationo,ȱgenanntȱliegtȬvorȱ(happensȱbefore).ȱDerȱAusdruckȱaȱoȱ bȱ bedeutet,ȱ dassȱ alleȱ Prozesseȱ übereinstimmen,ȱ dassȱ erstȱ Ereignisȱ a,ȱ dannȱ dasȱ Ereignisȱ bȱ auftritt.ȱ Dieȱ liegtȬvorȬRelationȱ kannȱ inȱ folgendenȱ beidenȱSituationenȱbeobachtetȱwerden:ȱ 1.ȱȱ SindȱaȱundȱbȱEreignisseȱdesȱgleichenȱProzessesȱundȱaȱtrittȱvorȱbȱauf,ȱ dannȱgiltȱdieȱRelationȱaȱoȱb.ȱ 2.ȱ Istȱ aȱ dasȱ Ereignisȱ desȱ Sendensȱ einerȱ Botschaftȱ vonȱ einemȱ Prozessȱ undȱbȱdasȱEreignisȱdesȱEmpfangensȱderȱBotschaftȱvonȱeinemȱandeȬ renȱ Prozess,ȱ soȱ giltȱ aȱ oȱ b.ȱ Eineȱ Nachrichtȱ kannȱ nichtȱ empfangenȱ werden,ȱbevorȱsieȱabgeschicktȱwurdeȱoderȱkannȱnichtȱzurȱgleichenȱ Zeitȱempfangenȱwerden,ȱzuȱderȱsieȱabgeschicktȱwurde,ȱdaȱsieȱeineȱ endlicheȱZeitȱbraucht,ȱbisȱsieȱankommt.ȱȱ LiegtȬvorȱistȱeineȱtransitiveȱRelation;ȱausȱaȱoȱbȱundȱbȱoȱcȱfolgtȱȱaȱoȱc.ȱ Daȱ einȱ Ereignisȱ nichtȱ vorȱ sichȱ selbstȱ liegenȱ kann,ȱ hatȱ dieȱ Relationȱ oȱ eineȱirreflexive,ȱpartielleȱOrdnung.ȱ

Konkurrenteȱ Ereignisseȱ

336ȱ

Fallsȱ zweiȱ Ereignisseȱ aȱ undȱ bȱ inȱ verschiedenenȱ Prozessenȱ liegenȱ undȱ keinȱ Nachrichtenaustauschȱ vorliegtȱ (sogarȱ indirektȱ überȱ einenȱ drittenȱ Prozess),ȱ dannȱ stehenȱ aȱ undȱ bȱ nichtȱ miteinanderȱ inȱ derȱ liegtȬvorȬ Relationȱ(esȱgiltȱwederȱaȱoȱbȱnochȱbȱoȱa).ȱManȱsagt,ȱdieseȱEreignisseȱ sindȱkonkurrent,ȱwasȱbedeutet,ȱdassȱnichtsȱausgesagtȱwerdenȱkann,ȱaberȱ auchȱ nichtsȱ ausgesagtȱ werdenȱ muss,ȱ wannȱ dieȱ Ereignisseȱ aufgetretenȱ sindȱundȱwelchesȱEreignisȱzuerstȱaufgetretenȱist.ȱȱ

5.2ȱLogischeȱOrdnungȱvonȱEreignissenȱ Umȱzuȱbestimmen,ȱobȱeinȱEreignisȱaȱvorȱeinemȱEreignisȱbȱliegt,ȱbrauȬ chenȱ wirȱ keineȱ gemeinsameȱ Uhrȱ oderȱ eineȱ Mengeȱ vonȱ perfektȱ synȬ chronisiertenȱ Uhren.ȱ Dieȱ Bestimmungȱ derȱ liegtȬvorȬȱ Relationȱ kannȱ folgendermaßenȱohneȱeineȱphysikalischeȱUhrȱvorgenommenȱwerden:ȱ Mitȱ jedemȱ Ereignisȱaȱassoziierenȱ wirȱ einenȱ Zeitstempelȱ oderȱ Zeitwertȱ C(a).ȱFürȱjedesȱPaarȱvonȱEreignissenȱaȱundȱb,ȱfürȱdasȱaȱoȱbȱgilt,ȱmussȱ derȱ Zeitstempelȱ vonȱ aȱ kleinerȱ seinȱ alsȱ derȱ Zeitstempelȱ vonȱ bȱ (C(a)ȱ <ȱ C(b)).ȱSindȱalsoȱaȱundȱbȱEreignisseȱdesȱgleichenȱProzessesȱundȱaȱliegtȱ vorȱb,ȱsoȱmussȱC(a)ȱ<ȱC(b)ȱsein.ȱFallsȱaȱdasȱSendenȱeinerȱNachrichtȱistȱ undȱbȱdasȱEmpfangenȱeinerȱNachrichtȱdurchȱeinenȱanderenȱProzess,ȱsoȱ mussȱgeltenȱC(a)ȱ<ȱC(b).ȱZusätzlichȱgilt,ȱderȱZeitstempelȱCȱmussȱimmerȱ anwachsenȱ undȱ kannȱ nichtȱ dekrementiertȱ werden.ȱ Zeitkorrekturenȱ könnenȱnurȱdurchȱAdditionȱvonȱpositivenȱWertenȱvorgenommenȱwerȬ denȱundȱnichtȱdurchȱSubtraktion.ȱȱ

Ereignisseȱmitȱ Zeitstempelȱ

Umȱ nunȱ denȱ einzelnenȱ Ereignissenȱ Zeitenȱ zuzuordnen,ȱ ordnenȱ wirȱ jedemȱ Prozessȱ Piȱ eineȱ logischeȱ Uhrȱ Ciȱ zu.ȱ Dieȱ logischeȱ Uhrȱ kannȱ alsȱ einfacherȱZählerȱimplementiertȱwerden,ȱderȱbeiȱjedemȱEreignisȱinȱProȬ zessȱPiȱumȱeinsȱinkrementiertȱwird.ȱDaȱdieȱlogischeȱUhrȱmonotonȱanȬ steigendeȱWerteȱerhält,ȱwirdȱjedemȱEreignisȱinȱProzessȱPiȱeineȱeindeuȬ tigeȱZahlȱzugeordnet.ȱȱ

logischeȱUhr

LiegtȱEreignisȱaȱvorȱEreignisȱb,ȱsoȱgiltȱCi(a)ȱ<ȱCi(b).ȱȱ DerȱZeitstempelȱCȱfürȱeinȱEreignisȱistȱdannȱderȱWertȱderȱlogischenȱUhrȱ Ci.ȱDieȱEreignisseȱinnerhalbȱeinesȱProzessesȱPiȱbesitzenȱdamitȱeineȱgloȬ baleȱOrdnung.ȱȱ DieȱglobaleȱOrdnungȱgiltȱjedochȱnochȱnichtȱfürȱmehrereȱProzesse.ȱUmȱ dasȱzuȱzeigen,ȱbetrachtenȱwirȱzweiȱProzesseȱP1ȱundȱP2,ȱdieȱmiteinanderȱ kommunizieren.ȱ Nehmenȱ wirȱ an,ȱ P1ȱ sendetȱ eineȱ Nachrichtȱ anȱ P2ȱ (ErȬ eignisȱ a)ȱ zurȱ Zeitȱ C1(a)ȱ =ȱ 200.ȱ P2ȱ erhältȱ dieȱ Nachrichtȱ (Ereignisȱ b)ȱ zurȱ ZeitȱC2(b)ȱ=ȱ195.ȱDieseȱSituationȱverletztȱunsereȱBedingung,ȱdassȱbeiȱaȱ oȱbȱderȱZeitstempelȱvonȱaȱkleinerȱseinȱmussȱalsȱderȱZeitstempelȱvonȱb.ȱȱ ZurȱEinhaltungȱderȱkleinerȬRelationȱzwischenȱzweiȱZeitstempeln,ȱstelȬ lenȱ wirȱ dieȱ logischeȱ Uhrȱ desȱ empfangenenȱ Prozessesȱ vor,ȱ wennȱ derȱ ZeitstempelȱderȱNachrichtȱgrößerȱistȱalsȱderȱZeitstempelȱdesȱProzesses.ȱ ErhältȱeinȱProzessȱPiȱeineȱNachrichtȱ(Ereignisȱb)ȱmitȱZeitstempelȱtȱundȱ esȱgiltȱ

Vorstellenȱderȱ logischenȱUhrȱ

Ci(b)ȱ<ȱt,ȱȱ soȱstellenȱwirȱdieȱUhrȱdesȱProzessesȱPiȱvor,ȱsoȱdassȱȱ Ci(b)ȱ=ȱtȱ+ȱ1.ȱȱ

337ȱ

5ȱȱVerteilteȱAlgorithmenȱ InȱunseremȱobigenȱBeispielȱwirdȱalsoȱbeimȱEmpfangȱderȱNachrichtȱvonȱ ProzessȱP1ȱ(Ereignisȱb)ȱdieȱUhrȱC2ȱdesȱProzessesȱP2ȱvorgestelltȱaufȱȱȱ C2(b)ȱ=ȱ200ȱ+ȱ1ȱ=ȱ201.ȱȱ Abb.ȱ5Ȭ2:ȱ Ereignisseȱmitȱ Zeitstempelnȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ UmȱdieȱpartielleȱOrdnungȱderȱEreignisseȱ(o)ȱaufȱeineȱtotaleȱOrdnungȱ zuȱ erweitern,ȱ könnenȱ wirȱ eineȱ totaleȱ Ordnungȱ Îȱ folgendermaßenȱ definieren:ȱȱ

Totalordnungȱ derȱEreignisseȱ

Istȱ aȱ einȱ Ereignisȱ inȱ Prozessȱ Piȱ undȱ bȱ einȱ Ereignisȱ inȱ Prozessȱ Pj,ȱ dannȱ giltȱaȱÎȱbȱgenauȱdannȱwennȱ (i)ȱCi(a)ȱ<ȱCj(b)ȱoderȱ (ii)ȱCi(a)ȱ=ȱCj(b)ȱundȱPiȱ<ȱPj.ȱȱ DieȱBedingungȱ(ii)ȱbehandeltȱdabeiȱdenȱFall,ȱdassȱdieȱZeitstempelȱvonȱ zweiȱ Ereignissenȱ aȱ undȱ bȱ gleichȱ sind,ȱ d.h.ȱ dieȱ beidenȱ Ereignisseȱ sindȱ konkurrent.ȱ Inȱ diesemȱ Fallȱ benutzenȱ wirȱ dieȱ Identifikationsnummerȱ derȱProzesse,ȱumȱeineȱtotaleȱOrdnungȱfestzulegen.ȱ

Ergebnisȱderȱ Totalordnungȱ

DurchȱdiesesȱVerfahrenȱhabenȱwirȱallenȱEreignissenȱinȱeinemȱverteiltenȱ Systemȱ eineȱ Zeitȱ zugeordnet,ȱ welcheȱ dieȱ folgendenȱ Bedingungenȱ erȬ füllt:ȱ 1.ȱ LiegtȱeinȱEreignisȱaȱvorȱeinemȱEreignisȱbȱimȱgleichenȱProzess,ȱsoȱgiltȱ C(a)ȱ<ȱC(b).ȱ

338ȱ

5.2ȱLogischeȱOrdnungȱvonȱEreignissenȱ ȱ2.ȱ Istȱ aȱ dasȱ Ereignisȱ desȱ Sendensȱ einerȱ Nachrichtȱ undȱ bȱ dasȱ Ereignisȱ desȱEmpfangensȱeinerȱNachricht,ȱsoȱgiltȱC(a)ȱ<ȱC(b).ȱ 3.ȱȱFürȱalleȱEreignisseȱaȱundȱbȱgiltȱC(a)ȱ C(b).ȱ DieserȱAlgorithmusȱstammtȱvonȱLamportȱ[Lȱ78]ȱundȱliefertȱeineȱtotaleȱ OrdnungȱallerȱEreignisseȱeinesȱverteiltenȱSystems.ȱȱ EinsatzȱfindetȱderȱLamportȬAlgorithmusȱbeiȱderȱGenerierungȱvonȱZeitȬ stempelnȱundȱfallsȱdieȱZeitstempelȱeindeutigȱseinȱmüssen.ȱDamitȱbildetȱ dieserȱ Algorithmusȱ dieȱ Basisȱ fürȱ einȱ MonitorȬȱ undȱ Debuggingsystemȱ fürȱverteilteȱSysteme.ȱWeiterhinȱfindetȱderȱAlgorithmusȱseinenȱEinsatzȱ beiȱ derȱ Lösungȱ desȱ Konkurrenzproblemsȱ beiȱ Transaktionenȱ (sieheȱ [Bȱ 04])ȱ undȱ beiȱ einemȱ verteiltenȱ Algorithmusȱ fürȱ denȱ wechselseitigenȱ Ausschlussȱ(sieheȱwiederȱ[Bȱ04]).ȱ

5.2.2 Vektoruhren DieȱLamportȬZeitȱhatȱeinenȱgravierendenȱNachteil,ȱnämlichȱdieȱTatsaȬ che,ȱdassȱausȱC(a)ȱ<ȱC(b)ȱnichtȱaufȱaȱÎbȱgeschlossenȱwerdenȱkannȱ[PFȱ 06].ȱDiesȱliegtȱanȱdenȱkonkurrentenȱEreignissen,ȱdieȱbeideȱdenȱgleichenȱ Zeistempelȱ besitzenȱ undȱ beiȱ derȱ Totalordnungȱ überȱ denȱ Indexȱ desȱ Prozessesȱgegangenȱwird.ȱȱ

Nachteileȱderȱ LamportȬZeitȱ

Zurȱ Umgehungȱ diesesȱ Nachteilsȱ hatȱ Matternȱ [Mȱ 89]ȱ dieȱ Vektoruhrenȱ entwickelt.ȱ Dabeiȱ besitztȱ jederȱ Prozessȱ Piȱ eineȱ einfacheȱ lokaleȱ Uhrȱ Ci.ȱ Einȱ idealisierterȱ externerȱ Beobachter,ȱ derȱ Zugriffȱ hatȱ aufȱ alleȱ lokalenȱ Uhren,ȱweißȱdamitȱdieȱlokaleȱZeitȱvonȱallenȱProzessen.ȱDieseȱZeitenȱfürȱ alleȱProzesseȱlassenȱsichȱzuȱeinemȱVektorȱmitȱderȱlokalenȱZeitȱfürȱjedenȱ Prozessȱ zuȱ einerȱ sogenanntenȱ Vektoruhrȱ Vȱ zusammenfassen.ȱ Dieȱ Vektoruhrenȱ derȱ Prozesseȱ repräsentierenȱ somitȱ dieȱ lokaleȱ Zeitȱ desȱ Prozessesȱ undȱ eineȱ Abschätzungȱ derȱ lokalenȱ Zeitenȱ derȱ anderenȱ Prozesse.ȱ Beiȱ nȱ Prozessenȱ geltenȱ fürȱ dieȱ Vektoruhrenȱ dieȱ folgendeȱ Regeln:ȱ 1.ȱ Jedesȱ Ereignisȱ vonȱ Piȱ dekrementiertȱ dieȱ lokaleȱ Uhrȱ Ciȱ umȱ einsȱ undȱ damitȱdasȱiȬteȱElementȱdesȱVektorsȱVi (Vi[i]):ȱ

339ȱ

5ȱȱVerteilteȱAlgorithmenȱ

Vi

=

Vi[1] . . . Vi[i-1] Vi[i] + 1 Vi[i+1] . . . Vi[n]

ȱȱȱȱȱ ȱȱȱȱȱ 1. Sendetȱ einȱ Prozessȱ Piȱ eineȱ Nachrichtȱ anȱ denȱ Prozessȱ Pj,ȱ soȱ inkrementiertȱPiȱseineȱlokaleȱUhrȱCiȱ(Vi[i] + 1)ȱ.ȱErȱsendetȱdannȱdieȱ NachrichtȱundȱzusätzlichȱdenȱStandȱseinerȱlokalenȱUhrenȱVi[1]ȱbisȱ Vi[n].ȱ ȱ Empfängtȱ Pjȱ dieȱ Nachricht,ȱ soȱ setztȱ erȱ seineȱ Uhrȱ Vj aufȱ folgendeȱWerte:ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

340ȱ

Vj

=

m a x(V j[1 ], V i [1 ]) . . . m a x(V j[j-1 ], V i[j-1 ]) V j[i] + 1 m a x(V j[j+ 1 ], V i [j+ 1 ]) . . . m a x(V j[n ], V i [n ])

5.2ȱLogischeȱOrdnungȱvonȱEreignissenȱ Dieȱ nachfolgendeȱ Abbildungȱ erläutertȱ anȱ einemȱ Beispielȱ dasȱ FortschaltenȱderȱUhren:ȱ ȱ ȱ ȱ ȱ

Abb.ȱ5Ȭ3:ȱ Fortschaltenȱ derȱ Vektoruhrenȱȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ Wieȱ beimȱ LamportȬAlgorithmusȱ kannȱ nunȱ eineȱ Ordnungȱ derȱ EreignisseȱdurchȱdieȱVektoruhrenȱangegebenȱwerden.ȱDazuȱvergleichtȱ manȱdieȱZeitstempelȱderȱVektoruhrenȱmiteinander:ȱ 1.ȱV1ȱ=ȱV2ȱœȱV1[i]ȱ=ȱV2[i],ȱȱiȱ=ȱ1,ȱ…,ȱnȱ 2.ȱV1ȱdȱV2ȱœȱV1[i]ȱdȱV2[i],ȱȱiȱ=ȱ1,ȱ…,ȱnȱȱ 3.ȱV1ȱȱV2ȱœȱV1ȱȱdȱV2ȱšȱV1ȱȱzȱȱV2ȱȱȱ Fürȱ zweiȱ Ereignisseȱ aȱ undȱ bȱ giltȱ beiȱ Vektoruhrenȱ dasȱ gleicheȱ wieȱ beiȱ Lamportuhren:ȱ 1.ȱaȱÎȱbȱŸȱV(a)ȱ<ȱV(b)ȱ 2.ȱ™ȱ(V(a)ȱ<ȱV(b))ȱšȱ™ȱ(V(b)ȱ<ȱV(a))ȱŸȱaȱundȱbȱsindȱkonkurrentȱ Imȱ Gegensatzȱ zuȱ Lamportuhrenȱ giltȱ aberȱ fürȱ Vektoruhrenȱ auchȱ dieȱ folgendeȱImplikation:ȱ

341ȱ

5ȱȱVerteilteȱAlgorithmenȱ 3.ȱV(a)ȱ<ȱV(b)ȱŸȱaȱÎȱbȱȱ Dieȱ Realisierungȱ derȱ Vektoruhrenȱ benötigenȱ mehrȱ SpeicherȬȱ undȱ verursachenȱ mehrȱ Netzlastȱ alsȱ dieȱ Lamportuhren.ȱ Imȱ Gegensatzȱ zuȱ denȱ Lamportuhrenȱ lassenȱ sichȱ mitȱ Vektoruhrenȱ vonȱ zweiȱ Ereignissenȱ feststellen,ȱ obȱ dieseȱ gleichzeitigȱ undȱ somitȱ parallelȱ aufgetretenȱ sind.ȱ FürȱMonitorȬȱundȱDebugsystemeȱsindȱsieȱsomitȱbesserȱeinsetzbar.ȱȱ

5.3 Auswahlalgorithmen VieleȱverteilteȱAlgorithmenȱsindȱsoȱangelegt,ȱdassȱeinȱzentralerȱServerȱ (Ȭprozess)ȱ vorhandenȱ istȱ undȱ dieȱ restlichenȱ Prozesseȱ nurȱ Clientsȱ vonȱ diesemȱ Serverȱ sind.ȱ Fälltȱ dannȱ dieserȱ zentraleȱ Serverȱ aus,ȱ soȱ istȱ dasȱ Systemȱlahmȱgelegt.ȱDeshalbȱrepliziertȱmanȱgerneȱdenȱServer,ȱsoȱdassȱ beiȱ Ausfallȱ desȱ Serversȱ einȱ andererȱ Serverȱ dessenȱ Funktionȱ übernehȬ menȱkann.ȱDazuȱmussȱjedochȱderȱAusfallȱerkanntȱwerden,ȱundȱesȱmussȱ ausȱdenȱReplikatenȱeinȱneuerȱServerȱbestimmtȱwerden.ȱDeshalbȱbenöȬ tigenȱwirȱVerfahren,ȱdieȱbeiȱAusfallȱeinesȱzentralenȱServersȱeinenȱneuȬ enȱ Serverȱ bestimmen.ȱ Voraussetzungȱ hierfürȱ ist,ȱ dassȱ aufȱ nȱ Rechnernȱ eineȱ Kopieȱ desȱ ServerȬAlgorithmusȱ läuft.ȱ Vonȱ denȱ nȱ Prozessenȱ istȱ jeȬ dochȱnurȱeinȱProzessȱtätig,ȱderȱsoȱgenannteȱMaster;ȱalleȱrestlichenȱProȬ zesseȱ dienenȱ alsȱ Reserveȱ undȱ leitenȱ dieȱ Nachrichtenȱ anȱ denȱ Masterȱ weiter.ȱDerȱAusfallȱdesȱMastersȱwirdȱdurchȱTimeoutȬKontrolleȱvonȱdenȱ untergeordnetenȱProzessenȱbemerkt.ȱVerfahren,ȱdieȱdannȱeinenȱneuenȱ Masterȱ bestimmenȱ oderȱ wählen,ȱ heißenȱ Auswahlalgorithmen,ȱ ȱ oderȱ LeaderȱElectionȱ[Lȱ96],ȱdaȱnachȱderȱWahlȱalleȱProzesseȱübereinstimmen,ȱ werȱderȱneueȱMasterȱist.ȱȱ

5.3.1 Bully-Algorithmus EinȱverteilterȱAuswahlalgorithmus,ȱderȱsoȱgenannteȱBullyȬAlgorithmusȱ [Gȱ82],ȱwähltȱvonȱnȱProzessenȱP1,ȱP2,ȱ...,ȱPn,ȱstetsȱdenjenigenȱProzessȱmitȱ demȱhöchstenȱIndexȱalsȱMasterȱaus,ȱd.h.ȱderȱMasterȱistȱȱ Pmȱmitȱmȱ=ȱmaxȱ{iȱ|1ȱdȱiȱdȱn,ȱPiȱistȱaktiv}.ȱ DerȱIndexȱbestimmtȱdamitȱdenȱbulligstenȱProzess.ȱ BemerktȱeinȱProzessȱPi,ȱdassȱderȱMasterȱausgefallenȱist,ȱdannȱwirdȱeineȱ WahlȱundȱsomitȱderȱBullyȬAlgorithmusȱgestartet:ȱ 1.ȱȱ PiȱschicktȱeineȱWahlnachrichtȱanȱalleȱPjȱmitȱjȱ>ȱiȱundȱwartetȱeinȱZeitȬ intervallȱTȱaufȱeineȱAntwort.ȱDieȱWahlnachrichtȱwirdȱauchȱanȱdenȱ altenȱMasterȱgeschickt,ȱumȱausgefalleneȱProzesseȱvonȱüberlastetenȱ Prozessenȱzuȱunterscheiden.ȱȱ

342ȱ

5.3ȱAuswahlalgorithmenȱ 2.ȱ ȱ Erhältȱ einȱ Prozessȱ Pjȱ eineȱ Wahlnachrichtȱ vonȱ Pi,ȱ wobeiȱ jȱ >ȱ iȱ ist,ȱ schicktȱerȱeineȱRückantwortȱanȱPi,ȱumȱPiȱzuȱberuhigen,ȱundȱstartetȱ seinenȱeigenenȱAuswahlalgorithmusȱ(Schrittȱ1).ȱ 3a.ȱ Erhältȱ Piȱ innerhalbȱ desȱ Zeitintervallsȱ Tȱ keineȱ Rückantwort,ȱ soȱ beȬ stimmtȱsichȱPiȱzumȱneuenȱMasterȱundȱsetztȱdavonȱalleȱProzesseȱPj,ȱ jȱ<ȱi,ȱinȱKenntnis,ȱd.ȱh.ȱerȱsendetȱihnenȱeineȱKoordinatornachricht.ȱ Damitȱ wirdȱ sichergestellt,ȱ dassȱ immerȱ derjenigeȱ Prozessȱ mitȱ demȱ größtenȱIndexȱMasterȱwird.ȱDerȱstärkste,ȱbulligsteȱProzessȱgewinnt,ȱ daherȱderȱNameȱBullyȬAlgorithmus.ȱȱ 3b.ȱErhältȱProzessȱPiȱmindestensȱeineȱRückantwortȱinnerhalbȱvonȱT,ȱsoȱ wartetȱerȱeinȱweiteresȱZeitintervallȱT’ȱaufȱdieȱBestätigung,ȱdassȱeinȱ ProzessȱPj,ȱjȱ>ȱiȱneuerȱMasterȱist.ȱIstȱinnerhalbȱvonȱT’ȱeinȱneuerȱKoȬ ordinatorȱgefunden,ȱdannȱistȱdieȱAuswahlȱbeendet.ȱTrifftȱinnerhalbȱ vonȱT’ȱkeineȱRückantwortȱein,ȱsoȱwirdȱwiederȱmitȱdemȱAuswahlȬ algorithmusȱbeiȱSchrittȱ1ȱbegonnen.ȱȱ Wirdȱ einȱ ausgefallenerȱ Prozess,ȱ welcherȱ vorȱ demȱ Ausfallȱ derȱ Masterȱ war,ȱwiederȱgestartet,ȱsoȱhältȱerȱeineȱWahlȱabȱundȱsendetȱdannȱanȱalleȱ ProzesseȱeineȱKoordinatornachricht.ȱErȱwirdȱwiederȱzumȱMaster,ȱfallsȱ erȱ dieȱ höchsteȱ Nummerȱ vonȱ allenȱ zuȱ diesemȱ Zeitpunktȱ ausgeführtenȱ Prozessenȱbesitzt.ȱ Nachfolgendeȱ Abbildungȱ 5Ȭ4ȱ zeigtȱ dieȱ Arbeitsweiseȱ desȱ BullyȬ Algorithmusȱ anȱ siebenȱ Prozessen,ȱ dieȱ vonȱ einsȱ bisȱ siebenȱ durchnumȬ meriertȱ sind.ȱ Zuerstȱ istȱ Prozessȱ siebenȱ derȱ Koordinator,ȱ derȱ geradeȱ ausgefallenȱist.ȱDieserȱAusfallȱwirdȱalsȱerstesȱvonȱProzessȱvierȱbemerkt,ȱ derȱdaraufhinȱdenȱAuswahlalgorithmusȱstartet.ȱȱ ȱ

ȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

343ȱ

5ȱȱVerteilteȱAlgorithmenȱ Abb.ȱ5Ȭ4:ȱ Arbeitsweiseȱȱ desȱBullyȬ Algorithmusȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ Derȱ BullyȬAlgorithmusȱ erhöhtȱ zwarȱ dieȱ Fehlertoleranzȱ desȱ zentralenȱ Ansatzes,ȱ jedochȱ mussȱ dieserȱ Vorteilȱ mitȱ einemȱ hohenȱ KommunikatiȬ onsaufwandȱ bezahltȱ werden.ȱ Beiȱ nȱ Prozessenȱ liegtȱ derȱ KommunikatiȬ

344ȱ

5.3ȱAuswahlalgorithmenȱ onsaufwandȱimȱschlechtestenȱFalleȱbeiȱO(n ).ȱDieserȱAufwandȱberechȬ netȱsichȱwieȱfolgt:ȱ 2

Dieȱ größtmöglicheȱ Anzahlȱ vonȱ Nachrichtenȱ wirdȱ verschickt,ȱ wennȱ Prozessȱ Pnȱ ausfälltȱ undȱ diesȱ vonȱ Prozessȱ P1ȱ bemerktȱ wird.ȱ ȱ Inȱ diesemȱ FallȱverschicktȱP1ȱanȱdieȱProzesseȱP2,ȱP3,ȱ..ȱPnȱeineȱWahlnachricht,ȱalsoȱ insgesamtȱ nȬ1ȱ Stück.ȱ Dadurchȱ startetȱ jederȱ derȱ Prozesseȱ P2,ȱ P3,ȱ ..ȱ PnȬ1ȱȱ erneutȱ denȱ Auswahlalgorithmus,ȱ undȱ jederȱ Prozessȱ Piȱ versendetȱ (nȬi)ȱ Auswahlnachrichten.ȱ Dieȱ Summeȱ derȱ Auswahlnachrichtenȱ ergibtȱ soȬ mit:ȱ

Berechnungȱ desȱZeitaufȬ wandesȱO(n2)ȱ

n 1

¦niȱ i 1

NachȱEmpfangȱderȱAuswahlnachrichtȱversendetȱjederȱProzessȱPiȱnochȱ (iȬ1)ȱRückantworten:ȱDieȱSummeȱderȱRückantwortenȱergibtȱsomit:ȱ n 1

¦ i  1ȱ i 1

DieȱSummeȱderȱAuswahlnachrichtenȱundȱRückantwortenȱergibtȱsomit:ȱ n 1

n 1

n 1

i 1

i 1

i 1

¦ n  i  ¦ i 1 ¦

2

n 1

n  1

ȱ

DerȱneueȱKoordinatorȱPnȬ1ȱverschicktȱzusätzlichȱnochȱBenachrichtigunȬ gen,ȱ dassȱ erȱ derȱ neueȱ Koordinatorȱ ist,ȱ anȱ dieȱ Prozesseȱ P1,ȱ P2,ȱ ...ȱ PnȬ2,ȱ insgesamtȱalsoȱnȬ2ȱNachrichten.ȱ DieȱGesamtanzahlȱderȱNachrichtenȱergibtȱsichȱzu:ȱ ȱn  1 2  n  2

n2  n 1



O n2

Dieserȱ hoheȱ Nachrichtenaufwandȱ fürȱ denȱ BullyȬAlgorithmusȱ istȱ nurȱ vertretbarȱ unterȱ derȱ Voraussetzung,ȱ dassȱ derȱ Algorithmusȱ nurȱ inȱ selȬ tenenȱFehlerfällenȱaufgerufenȱwird.ȱȱ

5.3.2 Ring-Algorithmus Derȱ folgendeȱ Auswahlalgorithmusȱ basiertȱ aufȱ einemȱ logischenȱ Ringȱ vonȱ zusammengeschlossenenȱ Prozessen.ȱ Derȱ Ringȱ derȱ Prozesseȱ istȱ inȱ eineȱ Richtungȱ ausgelegt;ȱ dieȱ Nachrichtenȱ desȱ Auswahlalgorithmusȱ werdenȱ immerȱ nurȱ inȱ eineȱ Richtungȱ gesendet.ȱ Jederȱ Prozessȱ imȱ Ringȱ kenntȱseinenȱmöglichenȱNachfolger,ȱanȱdenȱerȱeineȱNachrichtȱschickenȱ

345ȱ

5ȱȱVerteilteȱAlgorithmenȱ muss.ȱ Istȱ derȱ Nachfolgeprozessȱ ausgefallen,ȱ kannȱ derȱ Senderȱ übergeȬ henȱ zuȱ dessenȱ Nachfolgerȱ undȱ fallsȱ dieserȱ ausgefallenȱ ist,ȱ aufȱ dessenȱ Nachfolger,ȱundȱsoȱweiter,ȱbisȱerȱeinenȱnichtȱausgefallenenȱNachfolgerȱ vorfindet.ȱȱȱ BemerktȱeinȱProzessȱPi,ȱdassȱderȱMasterȱausgefallenȱist,ȱdannȱstartetȱerȱ dieȱWahl:ȱ 1.

ProzessȱPiȱlegtȱeineȱAktivenlisteȱanȱundȱträgtȱsichȱselbstȱalsȱaktiverȱ ProzessȱmitȱseinemȱIndexȱinȱdieseȱListeȱein.ȱErȱsendetȱanschließendȱ dieȱListeȱderȱaktivenȱProzesseȱanȱseinenȱNachfolger.ȱ

ȱ

Erhältȱ einȱ Prozessȱ Pjȱ vonȱ seinemȱ Vorgängerȱ dieȱ Aktivenliste,ȱ soȱ sindȱzweiȱFälleȱzuȱunterscheiden:ȱ a) ProzessȱPjȱerhältȱzumȱerstenȱMalȱdieȱAktivenliste,ȱundȱerȱselbstȱ befindetȱsichȱnochȱnichtȱinȱderȱAktivenliste.ȱErȱträgtȱsichȱinȱdieȱ Aktivenlisteȱ einȱ (möglicherweiseȱ auchȱ nurȱ seinenȱ Index)ȱ undȱ sendetȱdieȱAktivenlisteȱanȱseinenȱNachfolger.ȱȱ b) Prozessȱ Pjȱ istȱ inȱ derȱ Aktivenliste,ȱ undȱ erȱ selbstȱ stehtȱ amȱ Kopfȱ derȱListe.ȱDerȱProzessȱweißȱjetzt,ȱdassȱdieȱListeȱeinmalȱimȱRingȱ zirkuliertȱistȱundȱimȱMomentȱalleȱaktivenȱProzesseȱenthält.ȱErȱ kannȱ dieȱ Wahlȱ beenden,ȱ undȱ erȱ kannȱ einenȱ bestimmtenȱ ProȬ zessȱ wählenȱ (beiȱ Indizesȱ denjenigenȱ Prozessȱ mitȱ demȱ größtenȱ Index)ȱ undȱ ihnȱ alsȱ neuenȱ Koordinatorȱ bestimmen.ȱ Erȱ nimmtȱ dieȱ Aktivenlisteȱ vomȱ Ringȱ undȱ sendetȱ stattdessenȱ dieȱ NachȬ richtȱmitȱdemȱneuenȱKoordinatorȱanȱseinenȱNachfolger.ȱ

2.ȱȱ IstȱdieȱKoordinatornachrichtȱeinmalȱimȱRingȱzirkuliert,ȱkenntȱjederȱ Prozessȱ imȱ Ringȱ denȱ neuenȱ Koordinator.ȱ Erhältȱ derȱ Prozessȱ zumȱ zweitenȱ Malȱ dieȱ Koordinatornachricht,ȱ soȱ kannȱ erȱ sieȱ vomȱ Ringȱ nehmen,ȱ undȱ erȱ brauchtȱ sieȱ nichtȱ mehrȱ anȱ seinenȱ Nachfolgerȱ zuȱ senden.ȱȱ Imȱ Vergleichȱ zumȱ BullyȬAlgorithmus,ȱ dessenȱ Zeitaufwandȱ O(n2)ȱ war,ȱ benötigtȱ derȱ RingȬAlgorithmusȱ nurȱ 2nȱ Nachrichten:ȱ nȱ Nachrichtenȱ zumȱ Versendenȱ derȱ Wahlnachrichtȱ imȱ Ringȱ undȱ nȱ Nachrichtenȱ zumȱ VersendenȱderȱKoordinatornachricht.ȱȱ

5.4 Übereinstimmungsalgorithmen Fürȱ einȱ verteiltesȱ Systemȱ benötigenȱ wirȱ einenȱ Mechanismus,ȱ derȱ esȱ einerȱMengeȱvonȱProzessenȱerlaubt,ȱdassȱsieȱüberȱeinenȱ„gemeinsamenȱ Wert“ȱ übereinstimmen.ȱ Solcheȱ Übereinstimmungenȱ sindȱ leichtȱ zuȱ erȬ reichen,ȱ undȱ sieȱ sindȱ perȱ seȱ gegeben,ȱ wennȱ vonȱ Fehlerfreiheitȱ desȱ

346ȱ

5.4ȱȱÜbereinstimmungsalgorithmenȱ KommunikationsmediumsȱundȱdesȱProzessesȱoderȱdesȱProzessors,ȱaufȱ demȱderȱProzessȱläuft,ȱausgegangenȱwird.ȱKommtȱkeineȱÜbereinstimȬ mungȱzustande,ȱdannȱliegtȱdasȱanȱmehrerenȱGründen:ȱ 1.ȱ DasȱKommunikationsmediumȱkannȱfehlerhaftȱsein,ȱundȱesȱkönnenȱ NachrichtenȱverlorenȱgehenȱoderȱdieȱNachrichtȱistȱkorrumpiert.ȱ 2.ȱ DieȱProzesseȱselberȱkönnenȱfehlerhaftȱsein,ȱwasȱdannȱeinȱunvorherȬ sehbaresȱ Prozessverhaltenȱ hervorruft.ȱ Imȱ bestenȱ Fallȱ könnenȱ dieȱ Prozesseȱeinȱ„failȬstopȱfailure“ȱaufweisen.ȱBeiȱdiesemȱFehlerȱstopptȱ derȱProzessȱundȱderȱFehlerȱkannȱentdecktȱwerden.ȱImȱschlechtestenȱ Fallȱ weistȱ derȱ Prozessȱ einȱ „byzantineȱ failure“ȱ auf,ȱ woȱ derȱ Prozessȱ weiterȱarbeitet,ȱaberȱeinȱfehlerhaftesȱErgebnisȱliefert.ȱInȱdiesemȱFallȱ kannȱ derȱ Prozessȱ inkorrekteȱ Nachrichtenȱ anȱ andereȱ Prozesseȱ schiȬ cken,ȱoderȱnochȱschlimmer,ȱerȱkannȱmitȱanderenȱausgefallenenȱProȬ zessenȱ kooperierenȱ undȱ versuchen,ȱ dieȱ Integritätȱ desȱ Systemsȱ zuȱ zerstören.ȱ Dieseȱ Fehlerfälleȱ lassenȱ sichȱ durchȱ dasȱ „Byzantineȱ Generalsȱ ProbȬ lem“ȱ[LSPȱ82]ȱveranschaulichen:ȱ MehrereȱDivisionenȱderȱbyzantischenȱArmeeȱumgebenȱeinȱfeindlichesȱ Lager.ȱEinȱGeneralȱkommandiertȱjeȱeineȱdieserȱDivisionen.ȱDieȱGeneräȬ leȱ müssenȱ zuȱ einerȱ gemeinsamenȱ Übereinstimmungȱ kommen,ȱ obȱ imȱ Morgengrauenȱ derȱ Feindȱ angegriffenȱ wirdȱ oderȱ nicht.ȱ Esȱ istȱ wichtig,ȱ dassȱ alleȱ Generäleȱ übereinstimmen,ȱ daȱ einȱ Angriffȱ vonȱ nurȱ einigenȱ Divisionenȱ zuȱ einerȱ Niederlageȱ führt.ȱ Dieȱ verschiedenenȱ Divisionenȱ sindȱgeographischȱzerstreut,ȱundȱdieȱGeneräleȱkönnenȱnurȱmiteinanderȱ kommunizierenȱdurchȱBotschafter,ȱdieȱvonȱeinemȱLagerȱzumȱanderenȱ laufen.ȱ Zweiȱ Gründeȱ könnenȱ eineȱ Übereinstimmungȱ derȱ Generäleȱ verhindernȱundȱnichtȱzustandeȱkommenȱlassen:ȱ 1.

Botschafterȱ könnenȱ vomȱ Feindȱ gefangenȱ genommenȱ werdenȱ undȱ damitȱistȱeinȱÜberbringenȱderȱBotschaftȱnichtȱmöglich.ȱDieserȱFallȱ korrespondiertȱzuȱeinerȱunzuverlässigenȱKommunikationȱinȱeinemȱ verteiltenȱ System.ȱ Wirȱ behandelnȱ diesenȱ Fallȱ nachfolgendȱ unterȱ unzuverlässigeȱKommunikation.ȱ

2.

Unterȱ denȱ Generälenȱ könnenȱ Verräterȱ sein,ȱ dieȱ eineȱ ÜbereinstimȬ mungȱ verhindernȱ wollen.ȱ Dieseȱ Situationȱ korrespondiertȱ mitȱ fehȬ lerhaftenȱ Prozessenȱ inȱ einemȱ verteiltenȱ System.ȱ Wirȱ behandelnȱ diesenȱFallȱunterȱdemȱPunktȱbyzantinischeȱfehlerhafteȱProzesse.ȱ

Byzantineȱ Generalsȱ Problemȱ

347ȱ

5ȱȱVerteilteȱAlgorithmenȱ

5.4.1 Unzuverlässige Kommunikation Wirȱ nehmenȱ an,ȱ wennȱ einȱ Prozessȱ ausfällt,ȱ dassȱ erȱ stopptȱ undȱ nichtȱ mehrȱweiterȱarbeitetȱ(failȬstopȱfailure),ȱundȱwirȱsetzenȱeineȱunzuverläsȬ sigeȱKommunikationȱzwischenȱdenȱProzessenȱvoraus.ȱȱ Nehmenȱwirȱan,ȱeinȱProzessȱPiȱaufȱeinerȱMaschineȱAȱsendetȱeineȱNachȬ richtȱanȱProzessȱPjȱaufȱeinerȱMaschineȱB.ȱPiȱaufȱderȱMaschineȱAȱmöchteȱ wissen,ȱ obȱ seineȱ Nachrichtȱ beiȱ Pjȱ angekommenȱ ist.ȱ Diesesȱ Wissenȱ istȱ notwendig,ȱdamitȱProzessȱPiȱmitȱseinerȱweiterenȱVerarbeitungȱfortfahȬ renȱ kann.ȱ Beispielsweiseȱ entscheidetȱ sichȱ Piȱ fürȱ dieȱ Ausführungȱ einerȱ Funktionȱ Success,ȱ fallsȱ dieȱ Nachrichtȱ angekommenȱ ist,ȱ undȱ fürȱ eineȱ FunktionȱFailure,ȱfallsȱdieȱNachrichtȱnichtȱangekommenȱist.ȱȱ Zurȱ Entdeckungȱ vonȱ Übertragungsfehlernȱ könnenȱ wirȱ einȱ timeȬoutȬ SchemaȱaufȱfolgendeȱWeiseȱbenutzen:ȱMitȱderȱNachrichtȱsetztȱderȱProȬ zessȱPiȱeinȱZeitintervall,ȱinȱdemȱerȱbereitȱist,ȱdieȱQuittierungȱderȱNachȬ richtȱ anzunehmen.ȱ Wennȱ Pjȱ dieȱ Nachrichtȱ empfängt,ȱ sendetȱ erȱ sofortȱ eineȱQuittierungsnachrichtȱanȱPi.ȱErreichtȱPiȱdieȱQuittierungsnachrichtȱ innerhalbȱ desȱ Zeitintervalls,ȱ soȱ istȱ Piȱ sichȱ sicher,ȱ dassȱ seineȱ Nachrichtȱ empfangenȱ wurde;ȱ trittȱ jedochȱ einȱ TimeOutȱ auf,ȱ soȱ überträgtȱ Piȱ dieȱ Nachrichtȱ erneutȱ undȱ erȱwartetȱ wiederȱ aufȱ dieȱ Quittierungsnachricht.ȱ Diesȱ führtȱ derȱ Prozessȱ Piȱ soȱ langeȱ aus,ȱ bisȱ erȱ entwederȱ dieȱ QuittieȬ rungsnachrichtȱerhältȱoderȱvonȱdemȱSystemȱaufȱderȱMaschineȱBȱinforȬ miertȱwird,ȱdassȱderȱProzessȱPjȱnichtȱmehrȱläuft.ȱImȱerstenȱFallȱführtȱerȱ dieȱFunktionȱSuccessȱausȱundȱimȱzweitenȱFallȱdieȱFunktionȱFailure.ȱDaȱ ProzessȱPiȱsichȱnurȱfürȱeinenȱderȱbeidenȱFälleȱentscheidenȱkann,ȱmussȱ erȱ soȱ langeȱ dieȱ Nachrichtȱ übertragen,ȱ bisȱ eineȱ derȱ beidenȱ Fälleȱ aufgeȬ tretenȱist.ȱȱ Nehmenȱwirȱnunȱnochȱzusätzlichȱan,ȱdassȱProzessȱPjȱebenfallsȱwissenȱ möchte,ȱ obȱ seineȱ Quittierungsnachrichtȱ angekommenȱ ist.ȱ Diesesȱ WisȬ senȱbrauchtȱPjȱzumȱgleichenȱZweckȱwieȱPi,ȱumȱnämlichȱentscheidenȱzuȱ können,ȱ wieȱ erȱ mitȱ seinerȱ Bearbeitungȱ fortfährt.ȱ Z.ȱ B.ȱ möchteȱ Pjȱ eineȱ Funktionȱ Successȱ aufrufen,ȱ wennȱ erȱ sicherȱ ist,ȱ dassȱ dieȱ QuittierungsȬ nachrichtȱangekommenȱist.ȱMitȱanderenȱWortenȱformuliert,ȱbeideȱProȬ zesseȱ Piȱ undȱ Pjȱ möchtenȱ eineȱ Funktionȱ Successȱ aufrufen,ȱ genauȱ dann,ȱ wennȱsieȱdarüberȱübereinstimmen.ȱEsȱwirdȱsichȱzeigen,ȱdassȱbeiȱunzuȬ verlässigerȱKommunikationȱdieseȱAufgabeȱnichtȱzuȱbewerkstelligenȱist.ȱ Dazuȱ formulierenȱ wirȱ dieȱ Problemstellungȱ allgemeiner:ȱ Beiȱ einerȱ verȬ teiltenȱ Umgebungȱ mitȱ unzuverlässigerȱ Kommunikationȱ istȱ esȱ nichtȱ möglichȱ fürȱ Prozesseȱ Piȱ undȱ Pj,ȱ dassȱ sieȱ überȱ ihreȱ gegenwärtigenȱ ZuȬ ständeȱübereinstimmen.ȱ

348ȱ

5.4ȱȱÜbereinstimmungsalgorithmenȱ Zumȱ Beweisȱ derȱ obigenȱ Behauptungȱ nehmenȱ wirȱ an,ȱ dassȱ eineȱ miniȬ maleȱSequenzȱvonȱNachrichtenaustauschenȱexistiert,ȱsoȱdassȱnachȱdemȱ Nachrichtenaustauschȱ beideȱ Prozesseȱ übereinstimmen,ȱ dassȱ sieȱ dieȱ Funktionȱ Successȱ ausführen.ȱ Seiȱ m‘ȱ dieȱ letzteȱ Nachricht,ȱ dieȱ Piȱ anȱ Pjȱ sendet.ȱ Daȱ Piȱ nichtȱ weiß,ȱ obȱ seineȱ Nachrichtȱ beiȱ Pjȱ ankommtȱ (daȱ dieȱ Nachrichtȱ verlorenȱ gehenȱ kann),ȱ führtȱ Piȱ dieȱ Funktionȱ Successȱ aus,ȱ unabhängigȱ vomȱ Ergebnisȱ desȱ Nachrichtenversandes.ȱ Somitȱ kannȱ m‘ȱausȱderȱNachrichtensequenzȱgestrichenȱwerden,ȱohneȱdieȱEntscheiȬ dungsprozedurȱ zuȱ beeinflussen.ȱ Damitȱ istȱ dieȱ ursprünglicheȱ Sequenzȱ nichtȱ minimalȱ gewesen,ȱundȱ wirȱ kommenȱ zuȱeinemȱ Widerspruchȱ derȱ Annahme.ȱEsȱexistiertȱalsoȱkeineȱsolcheȱSequenzȱvonȱNachrichten,ȱundȱ beideȱ Prozesseȱ kommenȱ niemalsȱ zurȱ Übereinstimmungȱ derȱ AusfühȬ rungȱderȱFunktionȱSuccess.ȱ

5.4.2 Byzantinische fehlerhafte Prozesse Nehmenȱwirȱnunȱan,ȱdassȱdasȱKommunikationssystemȱzuverlässigȱist,ȱ jedochȱ dieȱ Prozesseȱ fehlerhaftȱ undȱ mitȱ unvorhersehbaremȱ Verhaltenȱ arbeitenȱ(ByzantineȱFailure).ȱ Betrachtenȱ wirȱ einȱSystemȱ vonȱ nȱ ProzesȬ sen,ȱbeiȱdenenȱnichtȱmehrȱalsȱfȱProzesseȱfehlerhaftȱsind.ȱJederȱderȱProȬ zesseȱPiȱbesitztȱeinenȱprivatenȱWertȱVi.ȱWirȱbenötigenȱnunȱeinenȱAlgoȬ rithmus,ȱ derȱ fürȱ jedenȱ nichtȱ fehlerhaftenȱ Prozessȱ Piȱ einenȱ Vektorȱ Xi=(Ai,1,ȱAi,2,ȱ...,ȱAi,n)ȱkonstruiertȱmitȱdenȱbeidenȱfolgendenȱEigenschafȬ ten:ȱ 1.ȱIstȱPiȱeinȱfehlerfreierȱProzess,ȱsoȱistȱAi,j=Vj.ȱ 2.ȱSindȱPiȱundȱPjȱfehlerfreieȱProzesse,ȱsoȱgiltȱXi=Xj.ȱ Fürȱ diesesȱ Problemȱ gibtȱ esȱ mehrereȱ Lösungenȱ [Lȱ 96].ȱ Alleȱ Lösungenȱ besitzenȱjedochȱdieȱfolgendenȱEigenschaften:ȱ 1.

EinȱLösungsalgorithmusȱzurȱÜbereinstimmungȱkannȱnurȱgefundenȱ werden,ȱwennȱnȱ tȱ3*f+1ȱist;ȱoderȱandersȱausgedrückt,ȱesȱgibtȱkeineȱ LösungȱzurȱÜbereinstimmung,ȱwennȱȱȱȱ2ȱdȱnȱdȱ3f.ȱȱ

2.

Dieȱ Anzahlȱ derȱ Kommunikationsrundenȱ zurȱ Erreichungȱ einerȱ Übereinstimmungȱistȱproportionalȱzuȱf+1.ȱ

3.

DieȱAnzahlȱderȱzuȱversendendenȱNachrichtenȱzurȱErreichungȱderȱ Übereinstimmungȱ istȱ hoch.ȱ Keinemȱ einzelnenȱ Prozessȱ kannȱ verȬ trautȱ werden,ȱ soȱ dassȱ alleȱProzesseȱ dieȱgesamteȱ Informationȱ samȬ melnȱmüssen,ȱumȱeineȱeigeneȱEntscheidungȱzuȱtreffen.ȱ

Anstelleȱ einesȱ allgemeinenȱ undȱ zuȱ komplexenȱ Algorithmusȱ zurȱ LöȬ sungȱ derȱ Übereinstimmungȱ stellenȱ wirȱ einenȱ Lösungsalgorithmusȱ fürȱ

349ȱ

5ȱȱVerteilteȱAlgorithmenȱ denȱeinfachenȱFallȱvor,ȱbeiȱdemȱf=1ȱundȱn=4ȱist.ȱDerȱAlgorithmusȱbenöȬ tigtȱzweiȱKommunikationsrunden:ȱ 1.

JederȱProzessȱsendetȱseinenȱeigenenȱWertȱzuȱallenȱanderenȱProzesȬ sen.ȱ

2.

JederȱProzessȱsendetȱseineȱinȱderȱerstenȱRundeȱerhaltenenȱInformaȬ tionenȱzuȱallenȱanderenȱProzessen.ȱȱ

EinȱfehlerhafterȱProzessȱkannȱdasȱSendenȱeinerȱNachrichtȱverweigern.ȱ InȱdiesemȱFallȱkannȱeinȱfehlerfreierȱProzessȱirgendeinenȱwillkürlichenȱ Wertȱ wählenȱ undȱ annehmen,ȱ dassȱ dieserȱ Wertȱ vonȱ demȱ fehlerhaftenȱ Prozessȱgesendetȱwurde.ȱ Nachȱ Beendigungȱ derȱ zweiȱ Rundenȱ kannȱ einȱ fehlerfreierȱ Prozessȱ Piȱ seinenȱVektorȱXi=(Ai,1,ȱAi,2,ȱAi,3,ȱAi,4)ȱwieȱfolgtȱkonstruieren:ȱ 1.ȱ ȱ

Ai,i=Vi.ȱ Fürȱjȱ zȱiȱgehenȱwirȱwieȱfolgtȱvor:ȱWennȱwenigstensȱzweiȱvonȱdenȱ dreiȱ vonȱ Prozessȱ Pjȱ gesendetenȱ Werteȱ (inȱ zweiȱ KommunikationsȬ runden)ȱübereinstimmen,ȱdannȱwirdȱdieȱMajoritätȱderȱzweiȱWerteȱ genommenȱundȱAi,jȱaufȱdiesenȱWertȱgesetzt.ȱImȱanderenȱFallȱwirdȱ einȱ defaultȬWertȱ genommen,ȱ z.B.ȱ nil,ȱ undȱ Ai,jȱ aufȱ diesenȱ Wertȱ geȬ setzt.ȱ

ZurȱErreichungȱeinerȱÜbereinstimmungȱbenötigtȱmanȱmindestensȱvierȱ Prozesse,ȱ beiȱ denenȱ einerȱ byzantinischesȱ Verhaltenȱ zeigenȱ kann.ȱ Beiȱ dreiȱ Prozessenȱ mitȱ einemȱ byzantinischenȱ Prozessȱ istȱ keineȱ ÜbereinȬ stimmungȱ zuȱ erreichen.ȱ Diesȱ bedeutet,ȱ dassȱ beiȱ derȱ FehlertoleranzȬ technikȱtripleȬmodularȱredundancy,ȱ mitȱ dreifachȱ redundantenȱ Prozessenȱ undȱeinerȱEntscheidungȱüberȱdieȱMajorität,ȱkeineȱÜbereinstimmungȱzuȱ erreichenȱist,ȱfallsȱeinȱbyzantinischȱfehlerhafterȱProzessȱdarunterȱist.ȱȱ Nachfolgendeȱ Abbildungȱ 5Ȭ5ȱ zeigtȱ dieȱ Arbeitsweiseȱ desȱ ÜbereinstimȬ mungsalgorithmusȱfürȱvierȱProzesseȱP1,ȱP2,ȱP3,ȱP4,ȱwobeiȱProzessȱP4ȱeinȱ Prozessȱ mitȱ byzantinischemȱ Verhaltenȱ ist.ȱ Derȱ privateȱ Wertȱ 1ȱ kannȱ dabeiȱdieȱEntscheidungȱAngriffȱrepräsentierenȱundȱderȱWertȱ0ȱdieȱEntȬ scheidungȱkeinȱAngriff.ȱȱ ȱ ȱ

350ȱ

5.4ȱȱÜbereinstimmungsalgorithmenȱ ȱ ȱ ȱ

Abb.ȱ5Ȭ5:ȱ Arbeitsweiseȱ desȱÜbereinȬ stimmungsȬ algorithmusȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

351ȱ

6 Rechenlastverteilung DurchȱdenȱkonkurrierendenȱZugriffȱvonȱmehrerenȱAnwendernȱaufȱdieȱ Ressourcenȱ einesȱ verteiltenȱ Systemsȱ entstehtȱ derȱ Bedarf,ȱ dieȱ ZuordȬ nungȱ dieserȱ Ressourcenȱ zuȱ regeln.ȱ Dieȱ Rechenleistungȱ derȱ einzelnenȱ Prozessorenȱ desȱ Systemsȱ istȱ dabeiȱ dieȱ wichtigsteȱ Ressource,ȱ dieȱ vonȱ allenȱ Anwendungenȱ zurȱ Bewältigungȱ derȱ anfallendenȱ Rechenlastȱ beȬ nötigtȱ wird.ȱ Seitȱ denȱ Anfängenȱ derȱ parallelenȱ undȱ verteiltenȱ Systemeȱ istȱdeshalbȱeineȱVielzahlȱvonȱMethodenȱentstanden,ȱumȱdieȱLastverteiȬ lungȱ denȱ unterschiedlichstenȱ Bedürfnissenȱ entsprechendȱ durchzufühȬ ren.ȱ

Taskȱ=ȱ Auftrag(Job)ȱ=ȱ ȱȱȱȱȱ Prozessȱ

DieȱzuȱverteilendenȱObjekteȱsindȱdieȱProzesseȱderȱAnwendungen.ȱDerȱ Begriffȱ Taskȱ istȱ mitunterȱ auchȱ anzutreffen.ȱ Derȱ Begriffȱ Jobȱ findetȱ hierȱ imȱSinneȱ einesȱArbeitsauftragsȱ desȱAnwendersȱanȱdasȱ Rechnersystemȱ Verwendung.ȱErȱistȱinȱTasksȱunterteilt,ȱdieȱimȱAllgemeinenȱzueinanderȱ inȱBeziehungȱstehen.ȱDieȱBegriffeȱTaskȱundȱProzessȱwerdenȱsynonymȱ verwendet,ȱ wennȱ esȱ sichȱ beiȱ denȱ betrachtetenȱ Anwendungenȱ umȱ zuȬ sammengesetzteȱJobsȱhandelt.ȱ

Prozess,ȱJob,ȱ Taskȱ

EinȱlokalerȱProzessȱwirdȱaufȱdemȱRechnerȱausgeführt,ȱaufȱdemȱerȱgeȬ startetȱwurde,ȱwährendȱalleȱProzesse,ȱdieȱvonȱderȱLastverteilungȱausȬ gelagertȱwerden,ȱauchȱdieȱBezeichnungȱRemoteȬProzesseȱtragenȱ[Sȱ96].ȱ UnterȱUmständenȱeigenenȱsichȱnichtȱalleȱProzesseȱfürȱdieȱAuslagerung.ȱ ReguläreȱProzesseȱkönnenȱnurȱlokalȱausgeführtȱwerden.ȱProzesse,ȱdieȱ verteiltȱ ausgeführtȱ werdenȱ können,ȱ heißenȱ auchȱ generischeȱ Prozesseȱ [Wȱ99].ȱ InȱderȱRegelȱwirdȱfürȱdieȱRechenressourcenȱderȱBegriffȱProzessorȱverȬ wendet.ȱSynonymȱkönnenȱhierȱauchȱdieȱBegriffeȱRechnerȱoderȱKnotenȱ vorkommen.ȱ

Prozessor,ȱ Rechner,ȱ Knotenȱ

Jeȱ nachȱ Artȱ desȱ Systemsȱ verfolgtȱ dieȱ Verteilungȱ derȱ Prozesseȱ aufȱ dieȱ ProzessorenȱunterschiedlicheȱZiele:ȱ

Zieleȱ ProzessverȬ teilungȱ

x

MinimierungȱderȱKostenȱderȱInterprozesskommunikation.ȱȱ

x

Erreichungȱ einesȱ hohenȱ Parallelisierungsgradesȱ undȱ damitȱ einenȱ hohenȱSpeedup.ȱ

x

EffizienteȱAuslastungȱallerȱProzessoren.ȱ

x

MinimaleȱBearbeitungszeitenȱfürȱProzesse.ȱ

353ȱ

6ȱȱRechenlastverteilungȱ Highȱ Performanceȱ Computing,ȱ Highȱ Throughputȱ Computingȱ Eigenschaftenȱ Lastverteilung sȬverfahrenȱ

Taxonomieȱ Lastverteilungȱ

354ȱ

x

MinimierungȱderȱtotalenȱAusführungskosten.ȱ

ImȱHighȱPerformanceȱComputingȱ(HPC)ȱinteressiertȱinȱersterȱLinieȱausȱ derȱ Anwendersichtȱ dieȱ Zeit,ȱ dieȱ zurȱ Erledigungȱ einerȱ bestimmtenȱ MengeȱanȱArbeitȱ(Berechnungen)ȱerforderlichȱist.ȱUmgekehrtȱstehtȱimȱ Highȱ Throughputȱ Computingȱ (HTC)ȱ dieȱ Systemsichtȱ imȱ Vordergrund,ȱ inȱeinerȱbestimmtenȱZeitȱmöglichstȱvielȱArbeitȱzuȱerledigen.ȱ Besondersȱ geeigneteȱ Verfahrenȱ derȱ Lastverteilungȱ solltenȱ dieȱ folgenȬ denȱEigenschaftenȱaufweisenȱ[Sȱ94][Sȱ96]:ȱ x

Keineȱ Verwendungȱ vonȱ Vorwissenȱ überȱ dieȱ zuȱ verteilendenȱ ProȬ zesse.ȱ

x

DynamischeȱArbeitsweiseȱmitȱEntscheidungen,ȱdieȱaufȱdemȱaktuȬ ellenȱSystemzustandȱbasieren.ȱ

x

SchnelleȱAlgorithmen.ȱ

x

Geringerȱ Overheadȱ durchȱ dieȱ Beschaffungȱ vonȱ Informationenȱ überȱdenȱSystemzustand.ȱ

x

Stabilität:ȱDasȱSystemȱdarfȱnichtȱinȱeinenȱZustandȱgeraten,ȱinȱdemȱ esȱ nurȱ nochȱ mitȱ Lastausgleichȱ beschäftigtȱ istȱ anstattȱ dieȱ AnwenȬ dungsprozesseȱauszuführen.ȱ

x

SkalierbarkeitȱbeiȱHinzunahmenȱneuerȱKnotenȱinȱdasȱSystem.ȱ

x

Ortstransparenz:ȱ Derȱ Anwenderȱ mussȱnichtȱ wissen,ȱ aufȱ welchemȱ RechnerȱseinȱProzessȱausgeführtȱwird.ȱ

x

HoheȱAusfallsicherheit.ȱ

x

Fairnessȱ gegenüberȱ denȱ Nutzern.ȱ Zuȱ diesemȱ Punktȱ gehörtȱ auch,ȱ dassȱderȱBesitzerȱeinesȱRechnersȱjederzeitȱdieȱRessourcenȱfürȱsichȱ beanspruchenȱ kannȱ undȱ laufendeȱ fremdeȱ Prozesseȱ unterbrochenȱ werden.ȱ

Dieȱ inȱ diesemȱ Kapitelȱ vorgestelltenȱ Artenȱ derȱ Lastverteilungȱ erfüllenȱ dieseȱ Kriterienȱ inȱ unterschiedlichemȱ Maße.ȱ Aufȱ derȱ oberstenȱ Ebeneȱ kannȱ dieȱ Verteilungȱ derȱ Prozesseȱ entwederȱ statischȱ oderȱ dynamischȱ erfolgen.ȱStatischeȱVerfahrenȱverteilenȱdieȱProzesseȱvorȱderȱLaufzeitȱanȱ dieȱ Prozessoren.ȱ Dabeiȱ wirdȱ inȱ derȱ Regelȱ auchȱ Vorwissenȱ überȱ dieȱ Prozesseȱ genutzt.ȱ Somitȱ sindȱ dieȱ erstenȱ beidenȱ Kriterienȱ nichtȱ erfüllt.ȱ DynamischeȱVerfahrenȱweisenȱProzessenȱerstȱbeimȱStartȱeinenȱProzesȬ sorȱzuȱundȱsorgenȱgegebenenfallsȱauchȱdanachȱfürȱeinenȱLastausgleich.ȱ Sieȱ benutzenȱ dazuȱ Informationenȱ überȱ denȱ Systemzustand.ȱ Dieȱ LastȬ verteilungȱ beiȱ dynamischenȱ Verfahrenȱ kannȱ entwederȱ mitȱ zentralerȱ

6.1ȱStatischeȱLastverteilungȱ Kontrolleȱ vonȱ einemȱ Rechnerȱ desȱ Systemsȱ ausȱ oderȱ dezentral,ȱ undȱ somitȱverteiltȱaufȱmehrereȱRechner,ȱvorgenommenȱwerden.ȱDenȱhöchsȬ tenȱGradȱdesȱLastausgleichsȱerreichtȱdieȱdezentraleȱKontrolleȱmitȱmigȬ rierendenȱ Prozessen.ȱ Migrationȱ bedeutetȱ eineȱ Unterbrechungȱ laufenȬ derȱProzesse,ȱdenȱTransferȱaufȱeinenȱanderenȱRechnerȱundȱdieȱWiederȬ aufnahmeȱ derȱ Berechnungenȱ aufȱ diesemȱ neuenȱ Rechner.ȱ Migrierendeȱ Verfahrenȱ heißenȱ auchȱ unterbrechendȱ (preemptive),ȱ imȱ Gegensatzȱ zuȱ nichtȱ unterbrechendenȱ Verfahrenȱ (nonȬpreemptive),ȱ dieȱ nurȱ neuȱ zuȱ startendeȱ Prozesseȱ verteilenȱ [Wȱ 99].ȱ Dieseȱ grobeȱ Einteilungȱ istȱ inȱ AbȬ bildungȱ6Ȭ1ȱwiedergegeben.ȱSieȱbestimmtȱauchȱdieȱweitereȱGliederungȱ desȱKapitels.ȱ ȱ ȱ

Abb.ȱ6Ȭ1:ȱ Taxonomieȱ Lastverteilungȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ Sowohlȱ dieȱ statischeȱ alsȱ auchȱ dieȱ dynamischeȱ Lastverteilungȱ gehörenȱ zuȱdenȱglobalenȱLastverteilungsverfahren.ȱProzesseȱwerdenȱaufȱRechȬ nerȱ inȱ einemȱ Netzwerkȱ verteilt,ȱ sofernȱ dieseȱ geeignetȱ sind.ȱ Lokaleȱ LastverteilungȱarbeitetȱnurȱaufȱeinemȱRechnerȱundȱteiltȱZeitscheibenȱanȱ Prozesseȱzuȱ[Wȱ99].ȱSieȱwirdȱhierȱnichtȱweiterȱbehandelt.ȱ

Lokaleȱundȱ globaleȱ Lastverteilungȱ

Außerȱ derȱ statischenȱ (6.1)ȱ undȱ derȱ dynamischenȱ Lastverteilungȱ (6.2)ȱ handeltȱ derȱ Abschnittȱ 6.3ȱ vomȱ Schedulingȱ imȱ Gridȱ Computing,ȱ dasȱ gegenüberȱ herkömmlichemȱ Verteiltemȱ Rechnenȱ bezüglichȱ derȱ LastȬ verwaltungȱeinigeȱBesonderheitenȱaufweist.ȱ

355ȱ

6ȱȱRechenlastverteilungȱ

6.1 Statische Lastverteilung JobȬ Anforderungs Ȭprofilȱ

DieȱstatischenȱVerfahrenȱteilenȱdenȱProzessenȱvorȱdemȱLaufȱProzessoȬ renȱ zuȱ undȱ nutzenȱ dazuȱ auchȱ aȱ prioriȱ bekannteȱ Parameterȱ derȱ Jobs.ȱ Dieseȱ Parameterȱ beschreibenȱ dasȱ Anforderungsprofilȱ derȱ Prozesse,ȱ etwaȱ anȱ dieȱ CPU,ȱ dieȱ Laufzeitumgebungȱ oderȱ auchȱ SpeicheranfordeȬ rungen.ȱ Auchȱ zeitlicheȱ Abhängigkeitenȱ undȱ Kommunikationskostenȱ gehörenȱdazu.ȱ

Vorwissenȱ überȱJobsȱ

Eineȱ ausreichendȱ genaueȱ Kenntnisȱ desȱ Anforderungsprofilsȱ zuȱ erlanȬ gen,ȱistȱjedochȱproblematischȱ[Wȱ98].ȱBesondersȱwichtigȱistȱdieȱKenntȬ nisȱ derȱ Ausführungszeitenȱ vonȱ Jobsȱ aufȱ geeignetenȱ Rechnernȱ sowieȱ derȱ SpeedupȬCharakteristik.ȱ Verschiedeneȱ Stufenȱ vonȱ Vorwissenȱ sindȱ zuȱunterscheidenȱ[FRSȱ97]:ȱ x

KeinȱVorwissen.ȱ

x

DieȱVerteilungȱderȱAusführungszeitenȱimȱgesamtenȱWorkloadȱistȱ bekannt,ȱaberȱesȱliegenȱkeineȱInformationenȱüberȱeinzelneȱJobsȱvor.ȱ

x

DieȱJobsȱsindȱKlassenȱmitȱspezifischenȱEigenschaftenȱzugeordnet.ȱ

x

Ausführungszeitenȱ fürȱ Jobsȱ fürȱ jedeȱ beliebigeȱ RechnerkombinatiȬ onȱliegenȱvor.ȱ

Anwenderangabenȱ sindȱ nichtȱ immerȱ zuverlässig.ȱ Oftȱ sindȱ genauereȱ Werteȱ erstȱ nachȱ wiederholtenȱ Durchläufenȱ zuȱ bestimmen.ȱ Außerdemȱ könnenȱsieȱvonȱdenȱzuȱbearbeitendenȱDatenȱabhängigȱsein.ȱ Schedulesȱ

Dieȱ statischeȱ Lastverteilungȱ wirdȱ auchȱ SchedulingȬProblemȱ genannt.ȱ SieȱerstelltȱeinenȱAblaufplanȱ(Schedule)ȱumȱeineȱMengeȱvonȱProzessenȱ nachȱ denȱ gegebenenȱ Anforderungenȱ aufȱ Prozessorenȱ ablaufenȱ zuȱlasȬ sen.ȱ Eineȱ Unterscheidungsmöglichkeitȱ istȱ dieȱ zwischenȱ einfacherenȱ QueuingȬSystemenȱ undȱ Planendenȱ Systemenȱ [HKSȱ 03].ȱ Erstereȱ verteiȬ lenȱ dieȱ Prozesseȱ inȱ Queues,ȱ ohneȱ Startzeitenȱ festzulegen.ȱ Planendeȱ Systemeȱ erstellenȱ vollständigeȱ Ablaufpläneȱ mitȱ Startzeitenȱ undȱ derȱ ZuweisungȱvonȱZeitintervallenȱaufȱRechnernȱanȱJobs.ȱSieȱplanenȱsomitȱ inȱ dieȱ Zukunft.ȱ Reservierungsmöglichkeitenȱ fürȱ Ressourcenȱ könnenȱ dannȱ genutztȱ werden,ȱ undȱ esȱ sindȱ umfassendeȱ Optimierungenȱ mögȬ lich.ȱ

GanttȬ Diagrammȱ

Derȱ Ablaufplanȱ mitȱ Startzeitenȱ lässtȱ sichȱ mitȱ einemȱ GanttȬDiagrammȱ beschreiben.ȱEinȱGanttȬDiagrammȱ(Abbildungȱ6Ȭ2)ȱlistetȱdieȱProzessoȬ renȱ vertikalȱ undȱ dieȱ Zeitȱ horizontal.ȱ Dieȱ Zeitachseȱ hatȱ keineȱ kontinuȬ ierlichenȱWerte,ȱsondernȱistȱinȱeinzelneȱdiskreteȱZeitscheibenȱunterteilt.ȱ Dieȱ Blöckeȱ innerhalbȱ desȱ Diagrammsȱ repräsentierenȱ dieȱ Laufzeitȱ derȱ

356ȱ

6.1ȱStatischeȱLastverteilungȱ Prozesseȱ(TȱfürȱTask).ȱGrauȱhinterlegteȱBlöckeȱstehenȱfürȱZeitscheiben,ȱ fürȱdieȱeinȱProzessorȱnichtȱbelegtȱwird.ȱGründeȱdafürȱkönnenȱsein:ȱ x

BerücksichtigungȱvonȱAbhängigkeitenȱzwischenȱdenȱTasks.ȱ

x

BerücksichtigungȱvonȱKommunikationszeiten.ȱ

x ȱ

Prozessorȱistȱnichtȱverfügbar.ȱ Abb.ȱ6Ȭ2:ȱ GanttȬ Diagrammȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ Dieȱ Ausführbarkeitȱ einesȱ Schedulesȱ (feasibility)ȱ [Bȱ 07]ȱ istȱ gegeben,ȱ wennȱesȱzuȱkeinenȱÜberlappungenȱderȱZeitintervalleȱfürȱdenselbenȱJobȱ oderȱaufȱdemselbenȱRechnerȱkommt.ȱErȱistȱoptimal,ȱwennȱerȱeinesȱoderȱ mehrereȱKriterienȱerfüllt.ȱ

Umplanungen

DieȱstatischeȱLastverteilungȱgibtȱeinenȱAblaufplanȱzunächstȱfestȱvor.ȱEsȱ bestehtȱ allerdingsȱ dieȱ Möglichkeitȱ fürȱ alleȱ nochȱ nichtȱ gestartetenȱ ProȬ zesse,ȱ eineȱ Umplanungȱ vorzunehmen.ȱ Auslöserȱ fürȱ dieseȱ UmplanunȬ genȱkönnenȱsein:ȱ x

VerzugȱbeimȱbisherigenȱPlan,ȱderȱnichtȱmehrȱakzeptabelȱist.ȱ

x

AnforderungenȱvonȱneuenȱTasks.ȱ

x

Rechnerausfälle.ȱ

Dieȱ Strategie,ȱ einmalȱ eingeplanteȱ Prozesseȱ nichtȱ mehrȱ umzuplanen,ȱ heißtȱauchȱatȬmostȬonceȬschedule.ȱBestehtȱdieȱMöglichkeitȱderȱUmplaȬ nung,ȱheißtȱdieȱStrategieȱmultipleȬscheduleȱ[Wȱ99].ȱ

Komplexitätȱ SchedulingȬ Problemȱ

Dieȱ Komplexitätȱ desȱ SchedulingȬProblemsȱ istȱ direktȱ einsichtig,ȱ wennȱ manȱbedenkt,ȱdassȱesȱfürȱdieȱZuweisungȱvonȱmȱProzessenȱanȱqȱProzesȬ soren,ȱ wennȱ keineȱ Einschränkungenȱ ausȱ denȱ RessourcenanforderunȬ genȱvorliegen,ȱqmȱMöglichkeitenȱgibt.ȱ DasȱProblem,ȱeineȱoptimaleȱZuordnungȱvonȱProzessenȱanȱdieȱProzesȬ sorenȱ zuȱ finden,ȱ wirdȱ inȱ derȱ Literaturȱ häufigȱ alsȱ NPȬvollständigȱ beȬ zeichnetȱ [Jȱ 03],ȱ daȱ esȱ bisȱ aufȱ einfacheȱ Fälleȱ nichtȱ inȱ polynomialerȱ Zeitȱ

357ȱ

6ȱȱRechenlastverteilungȱ gelöstȱwerdenȱkannȱ[KAȱ99].ȱFürȱOptimierungsproblemeȱistȱdieȱrichtiȬ geȱ Bezeichnungȱ allerdingsȱ NPȬschwerȱ [Sȱ 96],ȱ dasȱ istȱ äquivalentȱ zumȱ BegriffȱNPȬvollständig,ȱ derȱ eigentlichȱ nurȱ fürȱ Entscheidungsproblemeȱ mitȱderȱErgebnismengeȱ{ja,ȱnein}ȱdefiniertȱist.ȱOptimierungsproblemenȱ lassenȱ sichȱ aberȱ Entscheidungsproblemeȱ zuordnen,ȱ indemȱ ermitteltȱ wird,ȱ obȱ derȱ Zielfunktionswertȱ einerȱ zulässigenȱ Lösungȱ einenȱ beȬ stimmtenȱWertȱerreichtȱ(ja)ȱoderȱnichtȱ(nein)ȱ[Bȱ07].ȱ DieȱbisherigenȱAusführungenȱzurȱstatischenȱLastverteilungȱhabenȱzweiȱ Bereicheȱangesprochen,ȱdieȱinȱdenȱweiterenȱAbschnittenȱausführlicherȱ dargestelltȱsind.ȱVonȱbesondererȱWichtigkeitȱistȱdieȱModellierungȱvonȱ Jobs,ȱ ausȱ denenȱ dieȱ zuȱ verteilendenȱ Prozesseȱ resultieren.ȱ Imȱ letztenȱ Abschnittȱ schließlichȱ folgtȱ eineȱ genauereȱ Betrachtungȱ vonȱ Verfahrenȱ fürȱdieȱstatischeȱLastverteilung.ȱ

6.1.1 Jobmodelle Jobmodelleȱ ȱ ȱ ȱ Directedȱ AcyclicȱGraphȱ

Sofernȱ esȱ sichȱ beiȱ einemȱ Jobȱ nichtȱ umȱ einenȱ einzelnenȱ Taskȱ ȱ handelt,ȱ existierenȱ inȱ derȱ Regelȱ Beziehungenȱ zwischenȱ denȱ Tasks,ȱ dieȱ beiȱ derȱ Lastverteilungȱzuȱberücksichtigenȱsind.ȱDieserȱAbschnittȱerläutertȱdreiȱ Modelle.ȱ 1.ȱ TaskȬPräzedenzȬGraphen:ȱ Dieȱ Tasksȱ bildenȱ dieȱ Knotenȱ inȱ einemȱ gerichtetenȱ azyklischenȱ Graphenȱ (Directedȱ Acyclicȱ Graph:ȱ DAG).ȱ Dieȱ gerichtetenȱ Kantenȱ stellenȱ dieȱ zeitlicheȱ Reihenfolgeȱ oderȱ dieȱ PräzedenzȱderȱTasksȱdar.ȱ 2.ȱ TaskȬInteraktionsgraphen:ȱ Beiȱ einemȱ TaskȬInteraktionsgraphȱ reprȬ äsentierenȱdieȱTasksȱebenfallsȱdieȱKnoten.ȱDieȱKantenȱstellenȱdieȱInȬ teraktionȱoderȱKommunikationȱzwischenȱzweiȱTasksȱdar.ȱ 3.ȱȱ Workflows:ȱDenȱAblaufȱderȱTasksȱlegtȱeineȱWorkflowbeschreibungȱ fürȱ dieȱ Jobsȱ fest.ȱ Workflowsȱ gewinnenȱ vorȱ allemȱ imȱ Gridȱ CompuȬ tingȱzunehmendȱanȱBedeutung.ȱȱ InȱallenȱdreiȱVariantenȱistȱderȱeinfachsteȱFallȱenthalten,ȱdasȱistȱȱeinȱJobȱ mitȱ einemȱ Task,ȱ derȱ alsȱ einzelner,ȱ unteilbarerȱ Prozessȱ aufȱ einemȱ beȬ stimmtenȱRechnerȱzuȱplatzierenȱist.ȱ

PartitionieȬ rungȱ

358ȱ

Einenȱ wichtigenȱ Teilȱ imȱ Rahmenȱ derȱ Schedulingaufgabeȱ bildetȱ dieȱ Partitionierungȱ derȱ Graphenȱ [Wȱ 99].ȱ Dabeiȱ handeltȱ esȱ sichȱ umȱ eineȱ ZerlegungȱinȱGruppenȱvonȱTasksȱ(Partitionen),ȱdieȱdannȱeinemȱProzesȬ sorȱ zugeordnetȱ werden.ȱ Hauptzielȱ dabeiȱ istȱ dieȱ Minimierungȱ desȱ Overheadsȱ derȱ Interprozesskommunikation.ȱ Aberȱ auchȱ dasȱ ParalleliȬ sierungspotentialȱsollȱsoȱgutȱwieȱmöglichȱausgeschöpftȱwerden.ȱBeideȱ Zieleȱ widersprechenȱ sich.ȱ Beiȱ feingranularerȱ Partitionierungȱ wirdȱ derȱ

6.1ȱStatischeȱLastverteilungȱ Overheadȱ erhöht;ȱ jeȱ groberȱ partitioniertȱ wird,ȱ umsoȱ mehrȱ paralleleȱ TasksȱwerdenȱzusammenȱaufȱdemselbenȱProzessorȱeingeplant.ȱ

6.1.1.1 Task-Präzedenz-Graphen Dieȱ Implementierungȱ vonȱ DSMȱ kannȱ aufȱ folgendenȱ verschiedenenȱ TaskȬ Ebenenȱangesiedeltȱsein:ȱGegebenȱseiȱeineȱMengeȱvonȱProzessenȱPȱ=ȱ{P1,ȱ PräzedenzȬ P2,ȱ…,ȱPn},ȱderenȱAusführungȱaufȱeinerȱMengeȱvonȱidentischenȱProzesȬ Graphenȱ sorenȱ stattfindet.ȱ Eineȱ partielleȱ Ordnungsrelationȱ aufȱ Pȱ seiȱ ebenfallsȱ gegeben.ȱSieȱentsprichtȱderȱzeitlichenȱReihenfolgeȱoderȱPräzedenzordȬ nungȱ zwischenȱ denȱ Prozessen.ȱ Dieȱ partiellȱ geordneteȱ Mengeȱ (P,ȱ <)ȱ wirdȱ beschriebenȱ durchȱ einenȱ TaskȬPräzedenzȬGraphenȱ Gȱ =ȱ (V,ȱ A).ȱ Dieȱ Knotenȱ Vȱ repräsentierenȱ dieȱ Prozesse.ȱ A,ȱ dieȱ gerichtetenȱ Kanten,ȱ stelȬ lenȱ dieȱ Präzedenzȱ zwischenȱ denȱ Prozessenȱ dar.ȱ Denȱ Knotenȱ desȱ GraȬ phenȱuȱ ȱVȱistȱdieȱAusführungszeitȱderȱTasksȱalsȱKostenfunktionȱw(u)ȱ zugeordnet.ȱDenȱgerichtetenȱKantenȱ(u,v)ȱȱAȱistȱebenfallsȱeineȱKostenȬ funktionȱ w(u,v)ȱ =ȱ (l,l’)ȱ zugeordnet.ȱ l’ȱ sindȱ dieȱ Kommunikationskostenȱ innerhalbȱ desȱ Prozesses,ȱ fallsȱ uȱ undȱ vȱ demȱ gleichenȱ Prozessorȱ zugeȬ wiesenȱ werden.ȱ lȱ sindȱ dieȱ Kommunikationskosten,ȱ fallsȱ dieȱ Knotenȱ uȱ undȱ vȱ zweiȱ unterschiedlichenȱ Prozessorenȱ zugewiesenȱ werden.ȱ NorȬ malerweiseȱ sindȱ dieȱ IntraprozessorȬKostenȱ l’ȱ (Kommunikationȱ innerȬ halbȱeinesȱProzessors)ȱkleinȱimȱVergleichȱzuȱdenȱInterprozessorȬKostenȱ lȱundȱkönnenȱvernachlässigtȱwerden.ȱEsȱgiltȱw(u,v)ȱ=ȱl.ȱ Nachfolgendeȱ Abbildungȱ 6Ȭ3ȱ zeigtȱ eineȱ Applikation,ȱ bestehendȱ ausȱ fünfȱ Tasks,ȱ dargestelltȱ alsȱ PräzedenzȬGraphȱ (a).ȱ Dieȱ Zahlenȱ inȱ denȱ KnotenȱdesȱPräzedenzgraphenȱsindȱdieȱAusführungszeitenȱderȱTasks.ȱ DieȱZahlenȱanȱdenȱKantenȱsindȱdieȱZeitenȱfürȱdieȱInterprozesskommuȬ nikation.ȱDasȱBeispielȱistȱ[Wȱ99]ȱentnommen.ȱ Imȱ dazugehörigenȱ Ablaufplanȱ (b)ȱ fürȱ zweiȱ Prozessorenȱ istȱ dasȱ dazuȬ gehörigeȱ GanttȬDiagrammȱ umȱ 90° gedreht,ȱ umȱ eineȱ bessereȱ ÜbereinȬ stimmungȱ mitȱ demȱ PräzedenzȬGraphenȱ herzustellen.ȱ Dieȱ Ursacheȱ fürȱ dieȱ nichtȱ belegtenȱ Zeitscheibenȱ inȱ Prozessorȱ P2ȱ vorȱ Ausführungȱ desȱ TasksȱT4ȱundȱinȱP1ȱvorȱAusführungȱvonȱT5ȱistȱderȱKommunikationsoȬ verhead.ȱ Wegenȱ derȱ Kommunikationskostenȱ inȱ Höheȱ vonȱ einerȱ ZeitȬ einheitȱ kannȱ T4ȱ nachȱ Beendigungȱ vonȱ T2ȱ aufȱ Prozessorȱ P1ȱ erstȱ nachȱ einerȱ Zeiteinheitȱ eingeplantȱ werden.ȱ Inȱ gleicherȱ Weiseȱ mussȱ mitȱ derȱ EinplanungȱvonȱT5ȱaufȱP1ȱzweiȱZeiteinheitenȱgewartetȱwerden.ȱȱ ȱ ȱ ȱ

359ȱ

6ȱȱRechenlastverteilungȱ Abb.ȱ6Ȭ3:ȱ BeispielȱTaskȬ PräzedenzȬ Graphȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ Grundlageȱ derȱ vertikalenȱ Partitionierungȱ einesȱ PräzedenzȬGraphenȱ {LHFȱ 91]ȱ istȱ derȱ kritischeȱ (längste)ȱ Pfad.ȱ Dieȱ horizontaleȱ PartitionieȬ rungȱ teiltȱ einenȱ gegebenenȱ TaskȬPräzedenzȬGraphenȱ inȱ horizontaleȱ Schichten.ȱDenȱTasksȱwirdȱschichtweiseȱeineȱPrioritätȱzugewiesen.ȱ

6.1.1.2 Task-Interaktionsgraphen TaskȬ InteraktionsȬ graphenȱ

BeimȱTaskȬInteraktionsgraphenȱhandeltȱesȱsichȱumȱeinȱstatischesȱMoȬ dell.ȱDerȱzeitlicheȱAblaufȱeinesȱJobsȱundȱdieȱzeitlichenȱAbhängigkeitenȱ zwischenȱ denȱ Tasksȱ bleibenȱ unberücksichtigt.ȱ Dieȱ Kantenȱ stellenȱ eineȱ Interaktionȱ zwischenȱ zweiȱ kommunizierendenȱ Prozessenȱ dar.ȱ Jedeȱ Kanteȱ(u,v)ȱȱAȱbesitztȱeinȱKantengewichtȱw(u,v),ȱdasȱdieȱKommunikaȬ tionskostenȱ zwischenȱ denȱ Knotenȱ uȱ undȱ vȱ repräsentiert.ȱ w(u,v)ȱ ȱ beȬ zeichnetȱ dieȱ Kommunikationskosten,ȱ dieȱ anfallen,ȱ fallsȱ dieȱ Knotenȱ uȱ undȱ vȱ zweiȱ unterschiedlichenȱ Prozessorenȱ zugewiesenȱ werden.ȱ Dasȱ Knotengewichtȱ w(u)ȱ fürȱ einenȱ Knotenȱ uȱ ȱ Vȱ repräsentiertȱ dieȱ TaskȬȱ AusführungszeitȱalsȱKostenfunktion.ȱ Ausgehendȱ vomȱ TaskȬInteraktionsgraphenȱ gibtȱ esȱ mehrereȱ AlgorithȬ menȱzurȱstatischenȱVerteilungȱ[Wȱ99],ȱ[Tȱ95]ȱundȱ[Gȱ91].ȱVorgestelltȱseiȱ hierȱnurȱeineȱeinfacheȱgraphenbasierteȱMethodeȱ[Wȱ98],ȱdieȱeineȱAufȬ teilungȱdesȱTaskȬInteraktionsgraphenȱbezüglichȱminimalerȱKommuniȬ kationskostenȱvornimmt.ȱAufgabeȱistȱes,ȱeineȱmöglichstȱgünstigeȱPartiȬ tionierungȱdesȱGraphenȱzuȱfinden,ȱbeiȱderȱdieȱKommunikationskostenȱ

360ȱ

6.1ȱStatischeȱLastverteilungȱ anȱdenȱSchnittenȱminimalȱundȱdieȱProzessorenȱtrotzdemȱnichtȱüberlasȬ tetetȱsind.ȱȱ Nachfolgendeȱ Abbildungȱ6Ȭ4ȱ[Tȱ95]ȱzeigtȱ zweiȱ möglicheȱVerteilungenȱ vonȱ Tasksȱ aufȱ dreiȱ Prozessoren.ȱ Inȱ derȱ oberenȱ Partitionierungȱ sindȱ allenȱProzessorenȱjeweilsȱdreiȱTasksȱzugeordnet.ȱInȱderȱunterenȱPartitiȬ onierungȱ bearbeitetȱ Prozessorȱ1ȱ dreiȱ Tasks,ȱ Prozessorȱ2ȱ vierȱ Tasksȱ undȱ Prozessorȱ 3ȱ nurȱ zweiȱ Tasks.ȱ Obwohlȱ dieȱ obereȱ Partitionierungȱ gleichȬ verteiltȱaussieht,ȱtretenȱhöhereȱKommunikationskostenȱ(13ȱundȱ18)ȱauf,ȱ alsȱinȱderȱunterenȱ(13ȱundȱ14).ȱ ȱ

Abb.ȱ6Ȭ4:ȱ BeispielȱTaskȬ InteraktionsȬ graphȱ

ȱ ȱ ȱ ȱ

361ȱ

6ȱȱRechenlastverteilungȱ Workflowsȱ

6.1.1.3 Workflows Workflowsȱ sindȱ inȱ mehrfacherȱ Hinsichtȱ eineȱ Erweiterungȱ derȱ JobmoȬ delle.ȱSieȱsindȱinsbesondereȱfürȱdenȱEinsatzȱimȱGridȱComputingȱgeeigȬ net.ȱKennzeichnendȱfürȱGridsȱsindȱheterogene,ȱdomänenübergreifendeȱ Netzwerkeȱ aufȱ derȱ einenȱ Seiteȱ undȱ vielfältigeȱ Artenȱ vonȱ AnwendunȬ genȱmitȱhohemȱRechenzeitbedarf,ȱhohemȱSpeicherbedarfȱoderȱbeidemȱ (s.ȱ 6.3).ȱ Dieȱ Workflowsȱ werdenȱ häufigȱ ausschließlichȱ alsȱ gerichteteȱ azyklischeȱ Graphenȱ (DAG)ȱ beschrieben.ȱ Sieȱ entsprechenȱ insofernȱ denȱ TaskȬPräzedenzȬGraphen.ȱDieȱKnotenȱsymbolisierenȱalsoȱdieȱTasks,ȱdieȱ gerichtetenȱKantenȱdieȱReihenfolgeȱundȱgleichzeitigȱdenȱDatentransfer.ȱ

Dynamischeȱ Workflowsȱ

InȱvielenȱWorkflowdarstellungenȱgibtȱesȱWorkflowelemente,ȱmitȱdenenȱ sichȱkomplexereȱKonstrukteȱbeschreibenȱlassen,ȱwieȱSchleifenȱ(Loops)ȱ undȱ bedingteȱ Verzweigungen,ȱ dieȱ ifȬȱ oderȱ switchȬAnweisungenȱ entsprechenȱ [Wȱ 07}.ȱ Beiȱ DAGsȱ handeltȱ esȱ sichȱ umȱ statischeȱ BeschreiȬ bungen,ȱdieȱvorȱdemȱStartȱeinerȱApplikationȱderenȱAblaufȱvollständigȱ wiedergeben.ȱ Dieȱ volleȱ Bandbreiteȱ derȱ Workflowsȱ ermöglichtȱ dieȱ BeȬ schreibungȱdynamischerȱAbläufe.ȱTeileȱdesȱWorkflowsȱentwickelnȱsichȱ erstȱ beimȱ Ablaufȱ derȱ Prozesseȱ inȱ Abhängigkeitȱ derȱ vorangehendenȱ Berechnungen.ȱ Dynamischeȱ Workflowsȱ könnenȱ systematischȱ zurȱ LaufzeitȱstückweiseȱinȱDAGsȱüberführtȱwerden.ȱ EsȱexistierenȱverschiedeneȱWorkflowbeschreibungen,ȱdieȱfürȱApplikaȬ tionenȱ inȱ heterogenenȱ Systemenȱ eingesetztȱ werden.ȱ Eineȱ Auswahlȱ wirdȱimȱFolgendenȱvorgestellt.ȱ

DAGManȱ

Einȱ Beispiel,ȱ beiȱ demȱ nurȱ DAGsȱ bearbeitetȱ werden,ȱ istȱ dasȱ Werkzeugȱ DAGManȱ(DirectedȱAcyclicȱGraphȱManager)ȱfürȱdasȱLastverwaltungsȬ systemȱCondorȱ[TTLȱ04].ȱEsȱoperiertȱaufȱeinemȱhöherenȱLevelȱalsȱMetaȬ Scheduler.ȱCondorȱselbstȱberücksichtigtȱkeineȱzeitlichenȱAbhängigkeiȬ tenȱderȱJobsȱuntereinander.ȱDasȱWerkzeugȱDAGManȱübernimmtȱdieseȱ Aufgabe.ȱ Esȱ erhältȱ eineȱ Eingabedateiȱ mitȱ derȱ deklarativenȱ BeschreiȬ bungȱ derȱ Jobsȱ undȱ ihrerȱ Abhängigkeitenȱ imȱ DAG.ȱ Spezielleȱ ParentȬ ChildȬAnweisungenȱ beinhaltenȱ dieȱ Informationenȱ überȱ dieȱ JobreihenȬ folge.ȱDAGManȱübergibtȱdieȱJobsȱinȱeinzelnenȱDateienȱinȱderȱrichtigenȱ Reihenfolgeȱ anȱ Condorȱ undȱ stelltȱ überdiesȱ dieȱ Einhaltungȱ dieserȱ ReiȬ henfolgeȱdurchȱCondorȱsicher.ȱ

BPEL4WSȱ

Dieȱ Businessȱ Processȱ Executionȱ Languageȱ (BPEL,ȱ oderȱ BPEL4WSȱ fürȱ BPELȱ forȱ Webȱ Services)ȱ istȱ eineȱ Sprache,ȱ dieȱ derȱ Beschreibungȱ vonȱ Geschäftsprozessenȱ dientȱ [ACDȱ 03].ȱ Sieȱ basiertȱ aufȱ XMLȱ undȱ istȱ ausȱ denȱfrüherenȱSprachenȱXLANGȱvonȱMicrosoftȱ[MSȱ01]ȱundȱWebȱServiȬ ceȱFlowȱLanguageȱ(WSFL)ȱvonȱIBMȱ[IBMȱ01]ȱhervorgegangen.ȱMittelsȱ

362ȱ

6.1ȱStatischeȱLastverteilungȱ BPELȱkönnenȱWebȱServicesȱzuȱkomplexen,ȱstrukturiertenȱAnwendunȬ genȱzusammengefasstȱwerdenȱ(WebȬServiceȬOrchestrierung).ȱ BPELȱ enthältȱ soȱ genannteȱ Structuredȱ Activities,ȱ dieȱ einenȱ Workflowȱ aufbauen.ȱsequenceȱundȱflowȱermöglichenȱsequentielleȱundȱparalleȬ leȱ Abläufe.ȱ Verzweigungenȱ werdenȱ durchȱ switchȱ undȱ pickȱ ausgeȬ drückt,ȱ wobeiȱ switchȱ bedingteȱ Verzweigungenȱ darstelltȱ undȱ pickȱ eineȱ Wahlȱ durchȱ äußereȱ Ereignisse.ȱ Schleifenȱ lassenȱ sichȱ durchȱ dieȱ Aktivitätȱ whileȱ modellieren.ȱ Basicȱ Activitiesȱ sindȱ inȱ denȱ Structuredȱ Activitiesȱenthalten.ȱDieȱwichtigsteȱdieserȱAktivitätenȱistȱwohlȱinvoke,ȱ zumȱ Ausführenȱ vonȱ Webȱ Services,ȱ andereȱ dienenȱ unterȱ anderemȱ derȱ Fehlerbehandlungȱ oderȱ versetzenȱ dieȱ Applikationȱ inȱ einenȱ WartezuȬ stand.ȱ Esȱ bestehtȱ dieȱ Möglichkeit,ȱ durchȱ Scopesȱ Aktivitätenȱ zuȱ einerȱ Einheitȱzusammenzufassen.ȱ

Activitiesȱ BPELȱ

Dieȱ Ausführungȱ vonȱ BPELȬProzessinstanzenȱ wirdȱ vonȱ denȱ BPELȱ EnȬ ginesȱübernommen.ȱDazuȱistȱdasȱsoȱgenannteȱDeployment,ȱdasȱTransȬ ferierenȱ derȱ BPELȬProzesseȱ inȱ dieȱ Engine,ȱ erforderlich.ȱ Esȱ gibtȱ eineȱ ganzeȱReiheȱvonȱBPELȱEngines,ȱsowohlȱalsȱOpenȱSourceȱalsȱauchȱpropȬ rietäreȱEngines.ȱ

BPELȱEngine

Erweiterungenȱ vonȱ BPELȱ [DFHȱ 07]ȱ erlaubenȱ dieȱ Verwendungȱ zuȬ standsbehafteterȱ Webȱ Servicesȱ imȱ Webȱ Serviceȱ Resourceȱ Frameworkȱ (WSRF),ȱ dasȱ einenȱ Standardȱ fürȱ Gridanwendungenȱ bildet.ȱ Dieseȱ Webȱ Servicesȱ habenȱ eineȱ Identitätȱ undȱ persistenteȱ Attribute,ȱ dieȱ ihrenȱ ZuȬ standȱfesthalten.ȱ

ZustandbeȬ hafteteȱWebȱ Servicesȱ

EinenȱweiterenȱZugangȱzuȱkomplexenȱWorkflowsȱspeziellȱfürȱdasȱGridȱ ComputingȱbietetȱdieȱAbstractȱGridȱWorkflowȱLanguageȱ(AGWL)ȱ[FQȱ 05].ȱ Damitȱ lassenȱ sichȱ Anwendungenȱ durchȱ Spezifikationȱ vonȱ KonȬ trollȬȱ undȱ Datenflussȱ zuȱ Workflowsȱ zusammenstellen.ȱ Esȱ gibtȱ auchȱ hierȱ Aktivitäten.ȱ Sieȱ tauschenȱ Datenpaketeȱ überȱ EinȬȱ undȱ AusgabeȬ portsȱ aus.ȱ Dieȱ Kontrollflusskonstrukteȱ beinhaltenȱ Schleifenȱ undȱ beȬ dingteȱ Verzweigungenȱ sowieȱ auchȱ Konstrukte,ȱ dieȱ anzeigen,ȱ welcheȱ Aktivitätenȱ parallelȱ ausgeführtȱ werdenȱ können.ȱ Außerdemȱ könnenȱ EigenschaftenȱundȱRandbedingungenȱangegebenȱwerden.ȱSoȱlässtȱsichȱ beispielsweiseȱ dieȱ Artȱ derȱ Ausführungȱ einerȱ Aktivitätȱ spezifizieren.ȱ SchließlichȱkenntȱAGWLȱuntergeordneteȱWorkflows,ȱdieȱvonȱanderenȱ Workflowsȱausȱgestartetȱwerdenȱkönnen.ȱ

AGWLȱ

EineȱvielȱversprechendeȱFormȱvonȱgraphenbasierterȱWorkflowspracheȱ verwendetȱPetriȬNetzeȱ[Sȱ90].ȱEineȱGridlösungȱderȱFraunhoferȱGesellȬ schaftȱnutztȱdazuȱHighȬLevelȬPetriȬNetzeȱ(HLPN)ȱ[AHPȱ06].ȱDieȱzugeȬ hörigeȱ Spracheȱ heißtȱ GworkflowDLȱ (Gridȱ Workflowȱ Definitionȱ LanȬ guage).ȱ PetriȬNetzeȱ sindȱ gerichteteȱ Graphenȱ mitȱ zweiȱ Knotentypen:ȱ

PetriȬNetze

363ȱ

6ȱȱRechenlastverteilungȱ Transitionenȱ undȱ Stellen.ȱ Beideȱ sindȱ abwechselndȱ durchȱ gerichteteȱ Kantenȱverbunden.ȱDieȱStellenȱbeinhaltenȱsoȱgenannteȱToken,ȱdasȱsindȱ Datenelemente.ȱDieȱTransitionenȱrepräsentierenȱinȱderȱhierȱvorgestellȬ tenȱVerwendungȱServices.ȱDieȱTransitionenȱkönnenȱfeuern,ȱwennȱihreȱ vorgelagerterȱStelleȱ(Eingabestelle)ȱTokenȱenthält.ȱSieȱverarbeitenȱdannȱ dasȱTokenȱundȱerzeugenȱaufȱderȱnachgelagertenȱStelleȱ(Ausgabestelle)ȱ einȱneuesȱToken.ȱHierȱliegtȱsomitȱeinȱeinheitlichesȱModellȱfürȱKontrollȬȱ undȱ Datenflussȱ vor,ȱ undȱ dasȱ Feuernȱ derȱ Transitionenȱ modelliertȱ dieȱ tatsächlichȱstattfindendeȱProgrammausführung.ȱ GridAntȱ

GridAntȱ[LAAȱ02]ȱistȱeinȱBeispielȱfürȱeineȱWorkflowbeschreibung,ȱdieȱ vollständigȱ aufȱ einerȱ Scriptspracheȱ aufgebautȱ istȱ undȱ nichtȱ mitȱ demȱ Modellȱ einesȱ Graphenȱ arbeitet.ȱ Derȱ Nachteilȱ solcherȱ Beschreibungenȱ liegtȱdarin,ȱdassȱsieȱwenigerȱintuitivȱsindȱundȱdaherȱdenȱNutzerȱstärkerȱ inȱAnspruchȱnehmen.ȱ

6.1.2 Lösungsverfahren Maxȱ Flow/MinȱCutȱ

Wieȱ inȱ derȱ Einleitungȱ zuȱ diesemȱ Kapitelȱ bereitsȱ dargestellt,ȱ existierenȱ außerȱinȱwenigenȱspeziellenȱFällenȱkeineȱoptimalenȱLösungsverfahren.ȱ Inȱ denȱ optimalȱ lösbarenȱ Fällenȱ existierenȱ spezielleȱ Randbedingungen,ȱ dieȱdenȱSuchraumȱentsprechendȱeinengen.ȱEinȱBeispielȱsindȱDAGsȱzurȱ Verteilungȱ inȱ einemȱ ZweiȬProzessorȬSystemȱ unterȱ Verwendungȱ desȱ MaxȱFlow/MinȱCutȱȬȱAlgorithmus.ȱ[STȱ85].ȱ

Suboptimaleȱ LösungsverȬ fahrenȱ

Somitȱ bleibenȱ oftȱ nurȱ suboptimaleȱ Lösungsverfahrenȱ übrig,ȱ dieȱ nachȱ verschiedenenȱMethodenȱversuchen,ȱdemȱSchedulingȬProblemȱzuȱLeiȬ beȱzuȱrückenȱ[Bȱ07].ȱ Dasȱ SchedulingȬProblemȱ hatȱ allerdingsȱ eineȱ extremȱ großeȱ Zahlȱ vonȱ Varianten:ȱ

ZielfunkȬ tionenȱ

x

Sieȱ sindȱ abhängigȱ vonȱ denȱ Jobs,ȱ dieȱ zuȱ verteilenȱ sind,ȱ undȱ vonȱ derenȱAnforderungenȱanȱdieȱRessourcen.ȱ

x

WeiterȱsindȱsieȱvonȱderȱRechnerumgebungȱabhängig;ȱetwa,ȱobȱesȱ sichȱumȱeineȱhomogeneȱoderȱeineȱheterogeneȱUmgebungȱhandelt.ȱ

x

Schließlichȱ existiertȱ eineȱ Vielzahlȱ vonȱ Optimalitätskriterienȱ (ZielȬ funktionen).ȱ

Zielfunktionenȱ könnenȱ ausȱ Anwendersichtȱ undȱ ausȱ Ressourcensichtȱ gegebenȱsein.ȱ[FRSȱ97]ȱnennenȱalsȱBeispieleȱfürȱgebräuchlicheȱZielfunkȬ tionenȱausȱAnwendersicht:ȱ x

364ȱ

Gesamtbearbeitungszeitȱ(Makespan).ȱDasȱistȱdieȱFertigstellungszeitȱ desȱletztenȱTasks.ȱ

6.1ȱStatischeȱLastverteilungȱ x

AnzahlȱderȱÜberschreitungenȱeinerȱDeadline.ȱ

x

SummeȱderȱgewichtetenȱFertigstellungszeiten.ȱ

x

Summeȱ derȱ gewichtetenȱ Antwortzeiten.ȱ Dasȱ sindȱ dieȱ FertigstelȬ lungszeiten,ȱgerechnetȱabȱeinerȱfrühestmöglichenȱStartzeit.ȱ

x

SummeȱderȱgewichtetenȱVerzugszeiten.ȱ

FürȱdieȱRessourcensichtȱistȱinsbesondereȱdieȱAuslastungȱwichtig.ȱAuchȱ derȱ Gradȱ derȱ Parallelisierungȱ spieltȱ eineȱ Rolleȱ undȱ gehtȱ inȱ Formȱ vonȱ SpeedupȬFaktorenȱ inȱ eineȱ Zielfunktionȱ ein.ȱ Ausȱ ökonomischerȱ Sichtȱ spielenȱeventuelleȱKostenȱfürȱBerechnungenȱeineȱRolle.ȱDerȱAnwenderȱ möchteȱ dieseȱ minimieren.ȱ Derȱ Ressourcenproviderȱ möchteȱ denȱ GeȬ winnȱ maximieren.ȱ Zurȱ Konstruktionȱ vonȱ Zielfunktionenȱ lassenȱ sichȱ einzelneȱ Funktionenȱ durchȱ Aufsummierenȱ kombinierenȱ [Bȱ 07]ȱ undȱ gewichten.ȱNachfolgendeȱAbbildungȱ6Ȭ5ȱzeigtȱeineȱgrobeȱÜbersichtȱderȱ ZielfunktionenȱmitȱEinzelkriterien:ȱ ȱ ȱ ȱ

Abb.ȱ6Ȭ5:ȱ Taxonomieȱ ZielfunkȬ tionenȱ

ȱ ȱ ȱ ȱ ȱ ȱ Dieȱ Lösungsverfahrenȱ sindȱ aufgrundȱ detailliertenȱ Vorwissensȱ inȱ derȱ Regelȱdeterministischȱ[Wȱ98].ȱDanebenȱkommenȱauchȱprobabilistischeȱ Verfahrenȱ vor,ȱ dieȱ aufȱ statischenȱ Systemeigenschaftenȱ beruhenȱ undȱ einfacheȱ Regelnȱ fürȱ dieȱ Prozessverteilungȱ beinhaltenȱ [Sȱ 96].ȱ Imȱ FolȬ gendenȱ sindȱ einigeȱ wichtigeȱ Verfahrenȱ genauerȱ dargestellt.ȱ Ihreȱ AnȬ wendbarkeitȱhängtȱvonȱderȱspeziellenȱCharakteristikȱeinesȱSchedulingȬ Problemsȱab:ȱ

DeterminisȬ tischeȱundȱ probabilisȬ tischeȱ Verfahrenȱ

FürȱProbleme,ȱdieȱnichtȱzuȱgroßȱsind,ȱkommenȱMethodenȱderȱdynamiȬ schenȱ Programmierungȱ zumȱ Einsatz.ȱ Sieȱ setzenȱ voraus,ȱ dassȱ sichȱ dasȱ Problemȱ inȱ Teilproblemeȱ zerlegenȱ lässtȱ undȱ dassȱ sichȱ dieȱ optimalenȱ Lösungenȱ dieserȱ Teilproblemeȱ zumȱ Optimumȱ desȱ Gesamtproblemsȱ zusammensetzenȱ lassenȱ [Bȱ 07][BKȱ 06].ȱ Auchȱ Verfahrenȱ derȱ linearenȱ

Dynamischeȱ undȱlineareȱ ProgrammieȬ rungȱ

365ȱ

6ȱȱRechenlastverteilungȱ Programmierungȱ kommenȱ vor.ȱ Eineȱ lineareȱ Zielfunktionȱ istȱ inȱ einemȱ durchȱ lineareȱ Gleichungenȱ undȱ Ungleichungenȱ begrenztenȱ Teilgebietȱ desȱ Lösungsraumsȱ zuȱ optimieren.ȱ Beiȱ derȱ ganzzahligenȱ linearenȱ ProȬ grammierungȱ kommenȱ Variablenȱ desȱ Lösungsraumsȱ vor,ȱ dieȱ nurȱ ganzzahligeȱWerteȱannehmenȱkönnenȱ[Bȱ07][BKȱ06].ȱ BranchȬandȬ Boundȱ

EineȱverwandteȱMethodeȱistȱderȱBranchȬandȬBoundȬAlgorithmusȱ[LMȱ 92][B07].ȱ Derȱ Suchraumȱ istȱ soȱ aufgebaut,ȱ dassȱ jederȱ Punktȱ darinȱ mitȱ einemȱmöglichenȱScheduleȱkorrespondiertȱ[GLȱ87].ȱDasȱProblemȱwirdȱ inȱ Teilproblemeȱ zerlegtȱ entsprechendȱ einerȱ Zerlegungȱ desȱ Suchraumsȱ inȱ Teilräumeȱ (Branchingȱ Tree).ȱ Fürȱ denȱ Zielfunktionswertȱ inȱ denȱ UnȬ terräumenȱmussȱdieȱBerechnungȱvonȱunterenȱSchrankenȱmöglichȱsein.ȱ Fürȱ dasȱ gesamteȱ Problemȱ istȱ eineȱ möglichstȱ kleineȱ obereȱ Schrankeȱ zuȱ finden.ȱ Unterräumeȱ werdenȱ entwederȱ nichtȱ durchsucht,ȱ wennȱ derenȱ untereȱSchrankeȱgrößerȱalsȱdieȱobereȱSchrankeȱfürȱdasȱGesamtproblemȱ istȱ (dasȱ heißtȱ alleȱ Lösungenȱ sindȱ schlechterȱ alsȱ dieȱ bereitsȱ bekannte),ȱ oderȱ inȱ zuȱ durchsuchendenȱ Unterräumenȱ wirdȱ eineȱ bessereȱ obereȱ SchrankeȱfürȱdasȱGesamtproblemȱermittelt.ȱDerȱAlgorithmusȱfindetȱdieȱ optimaleȱ Lösung,ȱ wasȱ aberȱ jeȱ nachȱ Problemgrößeȱ entsprechendȱ langeȱ dauernȱkann.ȱ

Lokaleȱ SuchverȬ fahrenȱ

Lokaleȱ Suchverfahrenȱ kommenȱ häufigȱ zurȱ Lösungȱ vonȱ diskretenȱ OpȬ timierungsproblemenȱzumȱEinsatz,ȱbeiȱdenenȱinȱeinerȱendlichenȱMenȬ ge,ȱdemȱSuchraum,ȱnachȱeinerȱLösungȱgesuchtȱwird,ȱdieȱeineȱZielfunkȬ tionȱminimiert.ȱAusgehendȱvonȱeinerȱStartlösungȱwirdȱeineȱbestimmteȱ Nachbarschaftȱdurchsucht,ȱbisȱeinȱAbbruchkriteriumȱerfülltȱist,ȱinȱderȱ RegelȱbisȱkeineȱkleinereȱLösungȱinȱderȱNachbarschaftȱderȱjeweilsȱaktuȬ ellenȱ Lösungȱ mehrȱ gefundenȱ wird.ȱ Dieȱ einfachenȱ Algorithmenȱ konȬ vergierenȱ schnellȱ gegenȱ einȱ lokalesȱ Minimum,ȱ dessenȱ Wertȱ beliebigȱ weitȱvomȱWertȱdesȱglobalenȱMinimumsȱentferntȱseinȱkann.ȱ

Simulatedȱ Annealingȱ

SimulatedȱAnnealingȱ[LEEȱ92][Bȱ07]ȱistȱeinȱVerfahren,ȱumȱdieseȱschnelȬ leȱKonvergenzȱzuȱumgehen.ȱAuchȱhierȱwirdȱeineȱLösungȱausȱderȱjeweiȬ ligenȱNachbarschaftȱakzeptiert,ȱfallsȱsieȱbesserȱist.ȱAberȱauchȱschlechteȬ reȱLösungenȱwerdenȱmitȱeinerȱWahrscheinlichkeitȱakzeptiert,ȱdieȱvomȱ AbstandȱvonȱderȱbesserenȱLösungȱȱundȱvonȱderȱbisherigenȱAnzahlȱderȱ Schritteȱ desȱ Algorithmusȱ abhängt.ȱ Damitȱ kannȱ Simulatedȱ Annealingȱ einȱ lokalesȱ Minimumȱ auchȱ wiederȱ verlassen,ȱ allerdingsȱ istȱ esȱ auchȱ möglich,ȱ dassȱ derȱ Wertȱ umȱ einȱ solchesȱ schwingt.ȱ Dieȱ Laufzeitȱ istȱ einȱ häufigesȱAbbruchkriteriumȱfürȱdiesenȱAlgorithmus.ȱ

TabuȱSearchȱ

DerȱAlgorithmusȱTabuȱSearchȱ[Bȱ07]ȱsollȱdiesesȱSchwingenȱvermeiden.ȱ Inȱ einerȱ TabuȬListeȱ sindȱ bereitsȱ betrachteteȱ Lösungenȱ enthalten,ȱ dieȱ nachfolgendȱnichtȱmehrȱakzeptiertȱwerden.ȱDerȱAlgorithmusȱschränktȱ

366ȱ

6.1ȱStatischeȱLastverteilungȱ dieseȱListeȱaberȱein,ȱumȱeineȱzuȱlangeȱSucheȱdarinȱzuȱvermeiden.ȱDaȬ mitȱ istȱ dieȱ Größeȱ derȱ vermeidbarenȱ Zyklenȱ vomȱ Gradȱ dieserȱ EinȬ schränkungȱabhängig.ȱ EineȱweitereȱKlasseȱvonȱAlgorithmenȱwerdenȱzurȱLösungȱvonȱScheduȬ lingȬProblemenȱherangezogen:ȱdieȱEvolutionärenȱAlgorithmenȱmitȱdenȱ beidenȱGrundformenȱGenetischeȱAlgorithmenȱundȱEvolutionsstrategieȱ [Hȱ 75][Mȱ 94][Rȱ 94][KAȱ 97][GGMȱ 94].ȱ Fürȱ dieseȱ Algorithmenȱ werdenȱ PopulationenȱvonȱLösungenȱ(Individuen)ȱeinerȱderȱnatürlichenȱEvoluȬ tionȱ nachempfundenenȱ Prozedurȱ derȱ Erzeugung,ȱ Selektion,ȱ Mutationȱ undȱVererbungȱunterworfen.ȱDieȱSelektionȱbasiertȱaufȱderȱFitnessȱderȱ Individuen,ȱ dieȱ derȱ Zielfunktionȱ entspricht.ȱ Derȱ Erfolgȱ derȱ Verfahrenȱ hängtȱ abȱ vonȱ denȱ Methodenȱ derȱ Erzeugung,ȱ derȱ Populationsgrößen,ȱ denȱ Mutationsartenȱ undȱ Ȭraten.ȱ Sieȱ findenȱ rechtȱ schnellȱ vielȱ verspreȬ chendeȱRegionenȱ imȱSuchraum,ȱkönnenȱ aberȱlangeȱ fürȱdasȱ Auffindenȱ desȱexaktenȱOptimumsȱbenötigen.ȱEsȱgibtȱkeineȱKonvergenzgarantieȱinȱ endlicherȱZeit.ȱ

Evolutionäreȱ Algorithmenȱ

Memetischeȱ Algorithmenȱ[Jȱ06]ȱ versuchen,ȱ Vorteileȱvonȱ evolutionärenȱ Verfahren,ȱlokalenȱ Suchverfahrenȱ undȱHeuristikenȱunterȱ Vermeidungȱ derȱ Nachteileȱ zuȱ kombinieren.ȱ Dazuȱ werdenȱ alleȱ oderȱ einȱ Teilȱ derȱ Nachkommenȱ inȱ einemȱ Evolutionszyklusȱ einerȱ lokalenȱ Verbesserungȱ unterzogen.ȱSieȱkonvergierenȱschnellerȱundȱsichererȱalsȱreineȱEvolutioȬ näreȱAlgorithmen,ȱallerdingsȱauchȱhierȱohneȱKonvergenzgarantie.ȱ

Memetischeȱ Algorithmenȱ

DieȱgenanntenȱVerfahrenȱhabenȱalleȱdenȱNachteil,ȱextremȱrechenintenȬ sivȱ undȱ damitȱ zeitaufwändigȱ zuȱ sein.ȱ Deshalbȱ wirdȱ häufigȱ mitȱ einfaȬ cherenȱHeuristikenȱgearbeitet.ȱSieȱarbeitenȱnichtȱaufȱdemȱtatsächlichenȱ Suchraum,ȱ sondernȱ benutzenȱ Parameter,ȱ dieȱ dasȱ realeȱ Systemȱ näheȬ rungsweiseȱmodellieren,ȱundȱsieȱbenutzenȱeinfacheȱRegeln.ȱ EineȱVarianteȱistȱdasȱListȱSchedulingȱ[Wȱ99].ȱEsȱberuhtȱaufȱzweiȱSchritȬ ten:ȱ x

Sequenzierungȱ derȱ Prozesseȱ durchȱ Zuweisungȱ einerȱ Priorität,ȱ geȬ gebenenfallsȱ unterȱ Beachtungȱ vonȱ Randbedingungen,ȱ etwaȱ vonȱ zeitlichenȱAbhängigkeiten.ȱ

x

DerȱProzessȱamȱAnfangȱderȱListeȱwirdȱjeweilsȱanȱeinenȱpassendenȱ Prozessorȱverteilt.ȱ

Listȱ Schedulingȱ

Fürȱ beideȱ Schritteȱ kommenȱ verschiedeneȱ Strategienȱ inȱ Betracht,ȱ dieȱ vonȱderȱjeweiligenȱProblemstellungȱabhängenȱkönnen.ȱDieȱSequenzieȬ rungȱ verwendetȱ verschiedeneȱ Parameterȱ derȱ Tasks,ȱ zumȱ Beispielȱ dieȱ geschätzteȱ Ausführungszeitȱ oderȱ geforderteȱ Fertigstellungszeit.ȱ Auchȱ Kombinationenȱ vonȱ Parameternȱ könnenȱ betrachtetȱ werden.ȱ Eineȱ häuȬ

367ȱ

6ȱȱRechenlastverteilungȱ figȱ angewandteȱ Strategieȱ istȱ dieȱ Sucheȱ nachȱ derȱ kritischenȱ Pfadlängeȱ beimȱ Vorliegenȱ vonȱ zeitlichenȱ Abhängigkeiten.ȱ Sieȱ bestimmtȱ dieȱ kürȬ zestmöglicheȱGesamtbearbeitungszeit,ȱjedeȱVerzögerungȱvonȱTasksȱimȱ kritischenȱPfadȱwirktȱsichȱalsoȱdirektȱdaraufȱaus.ȱDeshalbȱwerdenȱdieseȱ Tasksȱ beiȱ derȱ Verteilungȱ bevorzugt.ȱ Dieȱ Strategieȱ gehtȱ alsoȱ vonȱ derȱ vertikalenȱ Partitionierungȱ aus.ȱ Ebensoȱ istȱ esȱ auchȱ möglichȱ vonȱ TaskȬ gruppenȱausȱeinerȱhorizontalenȱPartitionierungȱauszugehen.ȱ Beiȱ heterogenenȱ Rechnersystemenȱ oderȱ beiȱ homogenen,ȱauchȱ beiȱ speȬ ziellenȱAnforderungenȱvonȱTasks,ȱkönnenȱStrategienȱzurȱAuswahlȱderȱ ProzessorenȱzumȱZugȱkommen.ȱBeispielsweiseȱkönnenȱ(unabhängige)ȱ Tasksȱ nachȱ ihrenȱ Anforderungenȱ gruppiertȱ undȱ zusammenȱ einemȱ passendenȱRechnerȱzugewiesenȱwerden.ȱ EineȱganzeȱReiheȱvonȱHeuristikenȱistȱinȱ[DAȱ06]ȱausführlichȱdargestellt.ȱ GeradeȱbeiȱHeuristikenȱistȱdieȱZuordnungȱzuȱstatischenȱoderȱdynamiȬ schenȱVerfahrenȱnichtȱeindeutig.ȱ

6.2 Dynamische Lastverteilung Dynamischeȱ Lastverteilungȱ

Eineȱ dynamischeȱ Lastverteilungȱ garantiertȱ dieȱ Leistungstransparenzȱ einesȱ verteiltenȱ Systems.ȱ Nachȱ dieserȱ sollȱ einȱ Benutzerȱ keineȱ LeisȬ tungsunterschiedeȱimȱSystemȱbemerken.ȱDarausȱergibtȱsichȱdieȱFordeȬ rungȱ nachȱ einerȱ automatischenȱ undȱ dynamischenȱ Rekonfigurierungȱ beziehungsweiseȱVerteilungȱvonȱLast.ȱ Verfahrenȱ derȱ dynamischenȱ Lastverteilungȱ arbeitenȱ zurȱ Laufzeitȱ derȱ ProzesseȱundȱbenutzenȱinȱderȱRegelȱ–ȱzumindestȱüberȱProzesseȱ–ȱkeinȱ Vorwissen.ȱ Stattdessenȱ istȱ derȱ aktuelleȱ Zustandȱ desȱ Rechnersystemsȱ ausschlaggebend,ȱumȱdieȱdynamischenȱAnforderungenȱanȱRessourcenȱ zuȱ befriedigen.ȱ Derȱ Fokusȱ derȱ Lastverteilungȱ wandertȱ vomȱ AnfordeȬ rungsprofilȱ hinȱ zurȱ Lastȱ imȱ Rechnersystemȱ undȱ damitȱ zurȱ VerbesseȬ rungȱderȱSystemleistung.ȱ Zweiȱ Beispieleȱ vonȱ Umgebungenȱ verdeutlichenȱ denȱ Bedarfȱ anȱ dynaȬ mischerȱLastverteilung:ȱ

WorkstationȬ Modellȱ

368ȱ

x

Inȱ einemȱ WorkstationȬModellȱ [Sȱ96][Wȱ 98]ȱ sindȱ dieȱWorkstationsȱ mehrererȱ Benutzerȱ miteinanderȱ vernetzt.ȱ Dabeiȱ kannȱ eineȱ WorkȬ stationȱentwederȱgeradeȱbenutztȱsein,ȱdasȱheißtȱesȱlaufenȱProzesse,ȱ oderȱ sieȱ istȱ unbenutztȱ (idle)ȱ undȱ könnteȱ Berechnungenȱ übernehȬ men.ȱ Dieȱ Aufgabeȱ derȱ Lastverteilungȱ bestehtȱ darin,ȱ Prozesseȱ aufȱ unbenutzteȱWorkstationsȱauszulagernȱundȱdamitȱLastȱvonȱdenȱurȬ sprünglichenȱ Rechnernȱ zuȱ nehmen.ȱ Wesentlichȱ ist,ȱ dassȱ einȱ zuȬ

6.2ȱDynamischeȱLastverteilungȱ rückkehrenderȱBenutzer,ȱderȱneueȱJobsȱstartet,ȱVorrangȱaufȱseinerȱ Workstationȱhabenȱmuss.ȱȱ x

Inȱ einemȱ Prozessorpoolȱ [Sȱ 96][Wȱ 98]ȱ nimmtȱ einȱ zentralerȱ Serverȱ ProzesseȱvonȱNutzern,ȱdieȱüberȱTerminalsȱverbundenȱsind,ȱentgeȬ gen,ȱ undȱ verteiltȱ sieȱ dynamischȱ aufȱ dieȱ Rechnerȱ imȱ Pool.ȱ Jederȱ NutzerȱerhältȱdabeiȱeineȱpassendeȱAnzahlȱvonȱProzessorenȱjeȱnachȱ ParallelisierungsgradȱderȱAnwendung.ȱ

DieȱAufgaben,ȱdieȱimȱRahmenȱderȱLastverteilungȱdurchzuführenȱsind,ȱ entsprechenȱ denȱ Aufgabenȱ einesȱ Regelkreisesȱ [Lȱ 92].ȱ Dabeiȱ sindȱ folȬ gendeȱKomponentenȱzuȱunterscheiden:ȱ x

Eineȱ Komponenteȱ zurȱ Lasterfassungȱ oderȱ Lastmessungȱ(MessfühȬ ler).ȱ

x

EineȱLastbewertungskomponenteȱ(Regler).ȱ

x

EineȱLastverschiebekomponenteȱ(Stellglied).ȱ

Prozessorpool

Regelkreisȱ

Derȱ Sachverhaltȱ istȱ auchȱ inȱ derȱ folgendenȱ Abbildungȱ 6Ȭ6ȱ ausȱ [Lȱ 92]ȱ dargestellt:ȱ ȱ ȱ ȱ

Abb.ȱ6Ȭ6:ȱ Regelkreisȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ Jeȱnachdem,ȱwoȱdieȱLastbewertungȱerfolgt,ȱistȱzwischenȱanwendungsȬ integrierterȱLastverwaltungȱundȱsystemintegrierterȱLastverwaltungȱzuȱ unterscheiden.ȱBeiȱerstererȱistȱdieseȱKomponenteȱinȱdasȱProgrammsysȬ temȱ integriertȱ undȱ dasȱ Anwendungsprogrammȱ hatȱ dieȱ Kontrolleȱ darȬ über.ȱBeiȱletztererȱbefindenȱsichȱalleȱKomponentenȱderȱLastverwaltungȱ imȱRechnersystem,ȱundȱdamitȱauchȱdieȱKontrolleȱ[Lȱ92].ȱ

AnwendungsȬ undȱsysteminȬ tegrierteȱLastȬ verwaltungȱ

369ȱ

6ȱȱRechenlastverteilungȱ LoadȱSharingȱ –ȱLoadȱ Balancingȱ

Eineȱ wichtigeȱ Klassifizierungȱ vonȱ Lastverteilungsverfahrenȱ unterȬ scheidetȱ zwischenȱ Loadȱ Sharingȱ undȱ Loadȱ Balancingȱ oderȱ auchȱLastȬ verteilungȱ undȱ Lastausgleichȱ [Lȱ 92].ȱ Loadȱ Sharingȱ hatȱ zumȱ Ziel,ȱ ProȬ zesseȱsoȱzuȱverteilen,ȱdassȱkeinȱRechnerȱungenutztȱbleibt,ȱsolangeȱnochȱ passendeȱProzesseȱaufȱanderenȱRechnernȱwarten.ȱLoadȱBalancingȱgehtȱ weiterȱalsȱLoadȱSharing.ȱZielȱistȱes,ȱdieȱVerteilungȱderȱLastȱimȱgesamȬ tenȱSystemȱmöglichstȱausgeglichenȱzuȱhalten.ȱDasȱführtȱzuȱeinerȱgrößeȬ renȱHäufigkeitȱvonȱTasktransfersȱ[Sȱ94].ȱFürȱLoadȬBalancingȬVerfahrenȱ inȱ einerȱ gegebenenȱ Umgebungȱ mussȱabgeschätztȱ werden,ȱ obȱ derȱ gröȬ ßereȱAufwandȱauchȱdurchȱdenȱGewinnȱderȱLastverteilungȱwiederȱausȬ geglichenȱ wird.ȱ Dieȱ folgendenȱ Ausführungenȱ beziehenȱ sichȱ aufȱ Loadȱ Balancing,ȱfallsȱLoadȱSharingȱnichtȱexplizitȱerwähntȱwird.ȱ

Zentraleȱundȱ dezentraleȱ Verfahrenȱ

Dieȱ Verfahrenȱ lassenȱ sichȱ fernerȱ nachȱ zentralenȱ Verfahrenȱ mitȱ einemȱ Loadȱ Balancerȱ aufȱ einemȱ Prozessorȱ undȱ nachȱ dezentralenȱ Verfahren,ȱ beiȱ denenȱ dieȱ Aufgabenȱ aufȱ dieȱ Rechnerȱ desȱ Systemsȱ verteiltȱ sind,ȱ unterscheiden.ȱ Nähereȱ Informationenȱ dazuȱ enthaltenȱ dieȱ UnterabȬ schnitteȱ6.2.1ȱundȱ6.2.2.ȱ

WirkungsbeȬ reichȱ

BeiȱderȱBetrachtungȱdesȱWirkungsbereichesȱ[Lȱ92]ȱderȱLastverwaltungȱ kannȱzwischenȱdreiȱVariantenȱunterschiedenȱwerden:ȱ

Platzierungȱ undȱ Migration;ȱ preemptiveȱ undȱnonȬ preemptiveȱ

370ȱ

x

MinimalerȱWirkungsbereichȱ(gewöhnlichȱdieȱdirektenȱNachbarn).ȱ

x

MaximalerȱWirkungsbereich,ȱdasȱheißtȱdasȱgesamteȱSystem.ȱȱ

x

Begrenzterȱ Wirkungsbereichȱ dazwischen.ȱ Dieȱ Wirkungsbereicheȱ müssenȱsoȱgewähltȱwerden,ȱdassȱdasȱgesamteȱSystemȱüberdecktȱist.ȱ

Eineȱ weitereȱ Unterscheidungsmöglichkeitȱ betrifftȱ dieȱ Verfahrenȱ mitȱ undȱ ohneȱ Migration.ȱ Migrationȱ bedeutetȱ einȱ Unterbrechenȱ undȱ VerȬ schiebenȱvonȱbereitsȱlaufendenȱProzessenȱ(preemptive).ȱSieȱistȱungleichȱ komplexerȱalsȱdieȱVariante,ȱbeiȱderȱnurȱneuȱhinzukommendeȱProzesseȱ imȱ Systemȱ zuȱ verteilenȱ –ȱ zuȱ platzierenȱ –ȱ sindȱ (nonȬpreemptive).ȱ Dieȱ Bezeichnungȱ preemptiveȱ ausȱ demȱ Englischenȱ bedeutetȱ bevorrechtigtȱ undȱ stehtȱ hierȱ fürȱ denȱ Vorrangȱ vonȱ Prozessen,ȱ dieȱ andere,ȱ laufendeȱ Prozesseȱunterbrechenȱkönnen.ȱImȱDeutschenȱwerdenȱdieseȱVorgängeȱ daherȱ auchȱ unterbrechendȱ undȱ nichtȱ unterbrechendȱ genannt.ȱ Eineȱ ProzessplatzierungȱoderȱInitialȱPlacement,ȱdasȱistȱdieȱVerteilungȱneuerȱ TasksȱoderȱProzesse,ȱistȱtrivialerweiseȱimmerȱerforderlich.ȱProzessmigȬ rationȱkommtȱauchȱzentralȱvor,ȱistȱjedochȱeherȱbeiȱdezentralenȱVerfahȬ renȱsinnvoll.ȱDeshalbȱistȱderȱUnterabschnittȱfürȱdieseȱVerfahrenȱweiterȱ inȱ6.2.2.1ȱ(OhneȱMigration)ȱundȱ6.2.2.2ȱ(MitȱMigration)ȱunterteilt.ȱ

6.2ȱDynamischeȱLastverteilungȱ EinȱSpezialfallȱderȱdynamischenȱLastverteilungȱsindȱadaptiveȱȱVerfahȬ ren,ȱ dieȱ ihreȱ Parameterȱ dynamischȱ anȱ denȱ aktuellenȱ Systemzustandȱ anpassen.ȱ Soȱ kannȱ etwaȱ dieȱ Ermittlungȱ vonȱ Lastinformationenȱ eingeȬ stelltȱ werden,ȱ wennȱ dasȱ gesamteȱ Systemȱ starkȱ ausgelastetȱ istȱ undȱ kaumȱ Möglichkeitenȱ einerȱ Verbesserungȱ bestehenȱ [Sȱ 94].ȱ Damitȱ fälltȱ derȱ Overheadȱ dieserȱ Systemkomponenteȱ weg.ȱ Auchȱ Anpassungenȱ aufgrundȱderȱVorgeschichteȱsindȱdenkbarȱ[Lȱ92].ȱ

Adaptiveȱ Verfahrenȱ

Währendȱ Abbildungȱ 6Ȭ6ȱ obenȱ dieȱ gesamteȱ Lastverwaltungȱ alsȱ RegelȬ kreisȱ darstellt,ȱ zeigtȱ dieȱ folgendeȱ Abbildungȱ 6Ȭ7ȱ dieȱ Architekturȱ einerȱ automatischenȱ dynamischenȱ Lastverteilung.ȱ Dieȱ LastbewertungskomȬ ponenteȱmitȱdemȱLastverteilungsalgorithmusȱ(hierȱalsȱLastverteilungsȬ strategieȱ bezeichnet)ȱ erhältȱ Informationenȱ aufgrundȱ derȱ Lastmessungȱ undȱ gibtȱ gegebenenfallsȱ denȱ Anstoßȱ zurȱ Prozessplatzierungȱ oderȱ zurȱ Prozessmigration.ȱȱ ȱ ȱ ȱ ȱ

Abb.ȱ6Ȭ7:ȱȱ Architekturȱ Dynamischeȱ Lastverteilungȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

371ȱ

6ȱȱRechenlastverteilungȱ Strategienȱ Lastverteilungȱ

Einȱ Lastverteilungsalgorithmusȱ hatȱinȱderȱ Regelȱ vierȱ Teilbereiche,ȱ deȬ nenȱStrategienȱ(Policies)ȱfürȱdieȱBewältigungȱunterschiedlicherȱAufgaȬ benȱ entsprechen.ȱ Zurȱ gesamtenȱ Lastverteilungsstrategieȱ gehörtȱ nochȱ eineȱInitiierungsstrategie.ȱ DieseȱfünfȱStrategienȱinȱKurzfassungȱsind:ȱ x

Initiierungsstrategieȱ (Initiationȱ Policy),ȱ dieȱ festlegt,ȱ vonȱ welchenȱ KnotenȱdieȱInitiativeȱzurȱLastverteilungsaktivitätȱausgeht.ȱ

x

Informationsstrategieȱ (Informationȱ Policy),ȱ dieȱ bestimmt,ȱ wannȱ Informationȱ ausgetauschtȱ wird,ȱ vonȱ welchenȱ Knotenȱ Informationȱ angefordertȱbeziehungsweiseȱverbreitetȱwirdȱundȱwelcheȱInformaȬ tionenȱwichtigȱsind.ȱ

x

Transferstrategieȱ (Transferȱ Policy)ȱ zurȱ Entscheidung,ȱ obȱ einȱ LastȬ ausgleichȱerforderlichȱist.ȱ

x

Selektionsstrategieȱ (Selectionȱ Policy),ȱ durchȱ dieȱ einȱ zuȱ transferieȬ renderȱProzessȱausgewähltȱwird.ȱ

x

Lokationsstrategieȱ (Locationȱ Policy)ȱ mitȱ derȱ bestimmtȱ wird,ȱ welȬ cherȱKnotenȱanȱeinemȱalsȱerforderlichȱerkanntenȱLastausgleichȱbeȬ teiligtȱseinȱsoll.ȱ

Auchȱ dieȱ nachfolgendeȱ detaillierteȱ Betrachtungȱ gehtȱ vomȱ dezentralenȱ FallȱmitȱMigrationȱaus.ȱWesentlicheȱEinschränkungenȱoderȱErgänzunȬ genȱwerdenȱinȱdenȱjeweiligenȱAbschnittenȱbehandelt.ȱ InitiierungsȬ strategienȱ

Initiierungsstrategienȱ [Wȱ 99]:ȱ Beiȱ senderinitiierterȱ Strategieȱ gehtȱ dieȱ AktivitätȱvonȱdenȱüberlastetenȱoderȱstarkȱausgelastetenȱRechnernȱaus,ȱ dieȱ ihreȱ Lastȱ abstoßenȱ wollen;ȱ beiȱ empfängerinitiierterȱ Strategieȱ sindȱ esȱdieȱschwachȱausgelastetenȱRechner,ȱdieȱLastȱanziehenȱwollen.ȱAuchȱ eineȱ Kombinationȱ beiderȱ Vorgehensweisenȱ istȱ möglich,ȱ eineȱ symmetȬ rischȱinitiierteȱStrategie.ȱȱ

InformationsȬ strategienȱ

Informationsstrategienȱ [Wȱ 99,ȱ Sȱ 94]:ȱ Dieseȱ Strategienȱ bestimmen,ȱ wannȱundȱvonȱwelchenȱKnotenȱInformationenȱgesammeltȱwerdenȱundȱ welcheȱDatenȱzuȱermittelnȱsind.ȱDerȱZeitpunktȱkannȱzumȱBeispielȱapeȬ riodischȱ nachȱ Bedarfȱ festgelegtȱ sein,ȱ oderȱ dieȱ Rechnerȱ könnenȱ ihreȱ Lastinformationenȱperiodischȱaustauschen,ȱwobeiȱdieȱPeriodeȱvariabelȱ seinȱ kannȱ undȱ sichȱ nachȱ derȱ jeweiligenȱ Systemleistungȱ richtet.ȱ Beiȱ eiȬ nerȱweiterenȱStrategieȱwirdȱeineȱaktiveȱVerbreitungȱvonȱInformationenȱ einesȱ Knotensȱ durchȱ eineȱ Zustandsänderungȱ angestoßen.ȱ MöglicherȬ weiseȱ istȱ derȱ Aufwandȱ fürȱ eineȱ globaleȱ Informationssucheȱ zuȱ groß,ȱ undȱ esȱ istȱ festgelegt,ȱ dassȱ dieȱ Sucheȱ nurȱ lokalȱ inȱ einerȱ bestimmtenȱ

372ȱ

6.2ȱDynamischeȱLastverteilungȱ Nachbarschaftȱ stattfindet.ȱ Umgekehrtȱ kannȱ dieȱ Lastverteilungȱ umsoȱ genauerȱerfolgen,ȱjeȱmehrȱInformationȱzurȱVerfügungȱsteht.ȱ Dieȱ Verteilungȱ vonȱ Informationenȱ überȱdieȱ Lastȱ aufȱdenȱ Rechnernȱ eiȬ nesȱ Systemsȱ benötigtȱ inȱ jedemȱ Fallȱ Zeit,ȱ umsoȱ mehr,ȱ jeȱ weiträumigerȱ Informationȱ ermitteltȱ wird.ȱ Derȱ Informationsstandȱ istȱ dadurchȱ prakȬ tischȱimmerȱetwasȱveraltetȱundȱkannȱsoȱeineȱfalscheȱBewertungȱverurȬ sachenȱ[Wȱ98]ȱ[Lȱ92].ȱSoȱbestehtȱetwaȱbeiȱeinerȱsenderinitiiertenȱStrateȬ gieȱ derȱ Bedarfȱ nachȱ weitergehendenȱ Festlegungenȱ fürȱ denȱ Fall,ȱ dassȱ einȱ potentiellerȱ Empfängerȱ beiȱ Eintreffenȱ einesȱ zuȱ übernehmendenȱ Prozessesȱbereitsȱwiederȱhöherȱausgelastetȱist.ȱ Transferstrategienȱ[Wȱ99,ȱSȱ96,ȱSȱ94]ȱentscheidenȱdarüber,ȱobȱeinȱRechȬ nerȱ alsȱ Empfängerȱ oderȱ alsȱ Senderȱ anȱ einerȱ Lastübertragungȱ beteiligtȱ seinȱ kann.ȱ Üblichȱ ist,ȱ mitȱ Schwellenwertenȱ (Thresholds)ȱ fürȱ dieȱ Lastȱ aufȱdenȱbetrachtetenȱProzessorenȱzuȱarbeiten.ȱInȱeinerȱVarianteȱgibtȱesȱ genauȱeinenȱSchwellenwertȱalsȱÜbergangȱzwischenȱȈSenderȈȱ(überlasȬ tet)ȱ undȱ ȈEmpfängerȈȱ (geringȱ ausgelastet).ȱ Dieserȱ kannȱ statischȱ seinȱ oderȱdynamischȱderȱmittlerenȱLastȱaufȱdemȱSystemȱangepasstȱwerdenȱ [Sȱ96].ȱEinȱNachteilȱist,ȱdassȱderȱZustandȱeventuellȱständigȱhinȱundȱherȱ pendeltȱ undȱ zuȱ Instabilitätenȱ durchȱ unsinnigeȱ Transfersȱ führt.ȱ Mitȱ einerȱ ZweiȬSchwellenȬStrategieȱ (DoubleȬThresholdȱ Policy),ȱ dieȱ eineȱ Übergangszoneȱ schafft,ȱ könnenȱ dieȱ Instabilitätenȱ derȱ EinȬSchwellenȬ Strategieȱreduziertȱwerdenȱ(s.ȱnachfolgendeȱAbbildungȱ6Ȭ8ȱmitȱbeidenȱ Strategienȱzumȱvergleich)ȱ[Sȱ96].ȱAlsȱHighȬLowȬPolicyȱ(fürȱoberenȱundȱ unterenȱSchwellwert:ȱHighȱMark,ȱLowȱMark)ȱistȱdieseȱStrategieȱinȱ[ACȱ 88]ȱenthalten.ȱ

TransferȬ strategienȱ

ȱ

Abb.ȱ6Ȭ8:ȱ SchwellwertȬ strategienȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

373ȱ

6ȱȱRechenlastverteilungȱ SelektionsȬ strategienȱ

Selektionsstrategienȱ [Sȱ 94]:ȱ Dieseȱ Strategienȱ beziehenȱ sichȱ aufȱ dieȱ AuswahlȱvonȱProzessenȱfürȱeineȱVerteilung.ȱSieȱkommtȱzumȱZug,ȱsoȬ baldȱ einȱ Knotenȱ überlastetȱ istȱ undȱ zumȱ potentiellenȱ Senderȱ wird.ȱ Einȱ wichtigerȱPunktȱistȱderȱAusgleichȱdesȱOverheadsȱdesȱProzesstransfersȱ durchȱdieȱEinsparungȱanȱRechenzeit.ȱUmȱdiesȱzuȱbestimmenȱexistierenȱ teilweiseȱbesondereȱStrategienȱ(ProfitabilityȱPolicies)ȱ[Wȱ99].ȱAlsȱweiȬ teresȱ Kriteriumȱ istȱ zuȱ beachten,ȱ dassȱ eventuellȱ verbleibendeȱ SystemȬ aufrufeȱüberȱdasȱNetzwerkȱzusätzlicheȱLastȱverursachen.ȱ

LokationsȬ strategienȱ

Lokationsstrategien:ȱHierȱwirdȱermittelt,ȱwelcheȱRechnerȱalsȱEmpfänȬ gerȱ undȱ welcheȱ alsȱ Senderȱ vonȱ Lastȱ infrageȱ kommen.ȱ Dazuȱ werdenȱ entwederȱRechnerȱeinzelnȱabgefragtȱ(Polling)ȱoderȱdieȱAbfrageȱerfolgtȱ durchȱ Sammelaufrufȱ (Broadcast).ȱ Einzelabfragenȱ könnenȱ seriellȱ oderȱ parallelȱ erfolgen,ȱ Knotenȱ könnenȱ zufälligȱ dafürȱ ausgewähltȱ seinȱ oderȱ dieȱ Strategieȱ stütztȱ sichȱ aufȱ Informationenȱ ausȱ vorangegangenenȱ AbȬ fragenȱ[Sȱ94].ȱEineȱAbfrageȱkannȱsichȱnurȱanȱdieȱNachbarschaftȱrichtenȱ oderȱ globalȱ erfolgenȱ [Wȱ 99].ȱ Fürȱ dieȱ Abgabeȱ vonȱ Prozessenȱ kannȱ beiȱ einerȱSchwellenwertȬStrategieȱeineȱOrientierungȱanȱdenȱThresholdsȱ(s.ȱ Transferstrategien)ȱ derȱ potentiellenȱ Empfängerknotenȱ erfolgen.ȱ Derȱ EmpfängerȱdarfȱnichtȱüberlastetȱwerdenȱdurchȱdieȱAnnahmeȱdesȱProȬ zesses.ȱ Weiterhinȱ gibtȱ esȱ dieȱ Strategie,ȱ denȱ Empfängerȱ ausȱ einerȱ beȬ stimmtenȱ Anzahlȱ zufälligȱ gewählterȱ Knotenȱ auszuwählen.ȱ Derjenigeȱ Knotenȱ innerhalbȱ derȱ Gruppeȱ mitȱ derȱ geringstenȱ Lastȱ (fallsȱ nichtȱ beȬ reitsȱ überlastet)ȱ wirdȱ Empfänger.ȱ Schließlichȱ sindȱ nochȱ AuktionsstraȬ tegienȱ zuȱ nennenȱ sowieȱ Strategienȱ mitȱ festenȱ Paarungenȱ zwischenȱ starkȱbelastetenȱundȱwenigȱbelastetenȱKnotenȱ[Sȱ96].ȱ

Performanceȱ vonȱsenderȬȱ undȱempȬ fängerȬ initiiertenȱ Strategienȱ

Zumȱ Abschlussȱ derȱ Beschreibungȱ derȱ verschiedenenȱ Strategienȱ zeigtȱ eineȱDiskussionȱausȱ[Sȱ94]ȱAuswirkungenȱsenderȬȱundȱempfängerinitiȬ ierterȱ Strategienȱ aufȱ dieȱ Performanceȱ derȱ Lastverteilungȱ auf.ȱ Inȱ derȱ RegelȱhatȱeinȱsenderinitiierterȱAlgorithmusȱVorteileȱinȱgeringȱausgelasȬ tetenȱ Systemen;ȱ empfängerinitiierterȱ Lastausgleichȱ kommtȱ hierȱ meisȬ tensȱzuȱspätȱfürȱdieȱwenigenȱneuȱankommendenȱProzesse.ȱDagegenȱistȱ beiȱ hochȱ ausgelastetenȱ Systemenȱ eineȱ empfängerinitiierteȱ Strategieȱ geeigneter.ȱ Hierȱ belastenȱ dieȱ vielenȱ Senderȱ dasȱ Systemȱ unnötigȱ mitȱ Anfragen.ȱEineȱdynamischeȱAnpassungȱvonȱThresholdsȱistȱfürȱsenderȬ initiierteȱMethodenȱbeiȱhoherȱLastȱzuȱempfehlen.ȱSymmetrischȱinitiierȬ teȱSystemeȱschaffenȱeinenȱgewissenȱAusgleich,ȱkönnenȱaberȱvorȱallemȱ dieȱ Problemeȱ derȱ senderinitiiertenȱ Komponenteȱ beiȱ hoherȱ Lastȱ oftȱ nichtȱ beseitigen.ȱ Einȱ stabilerȱ symmetrischȱ initiierterȱ Algorithmusȱ ausȱ [SKȱ90]ȱarbeitetȱmitȱzweiȱThresholdsȱundȱrealisiertȱeinenȱallmählichenȱ ÜbergangȱzwischenȱdenȱInitiierungsstrategienȱdurchȱdynamischȱangeȬ passteȱ EmpfängerȬ,ȱ SenderȬ,ȱ undȱ OKȬListenȱ beiȱ jedemȱ Knoten.ȱ Einȱ

374ȱ

6.2ȱDynamischeȱLastverteilungȱ stabilerȱ senderinitiierterȱ Algorithmusȱ alsȱ Modifikationȱ davonȱ wirdȱ inȱ [Sȱ94]ȱbeschrieben.ȱGenerellȱverursachenȱempfängerinitiierteȱVerfahrenȱ beiȱ geringerȱ Lastȱ nichtȱ dieselbenȱ Problemeȱ mitȱ unnötigenȱ Anfragenȱ wieȱ umgekehrtȱ dieȱ senderinitiiertenȱ beiȱhoherȱ Last,ȱwasȱanȱ derȱ freienȱ Systemkapazitätȱliegt,ȱdieȱdieseȱZusatzlastȱaufnehmenȱkann.ȱ FürȱdieȱdynamischeȱLastverteilungȱistȱdieȱLastmessungȱdieȱwichtigsteȱ Komponenteȱ (vgl.ȱ Abbildungȱ 6Ȭ7).ȱ Dabeiȱ handeltȱ esȱ sichȱ häufigȱ mehrȱ umȱ eineȱ Abschätzungȱ derȱ aktuellenȱ Lastȱ aufȱ einemȱ Knoten,ȱ fürȱ dieȱ verschiedeneȱ Parameterȱ undȱ Kriterienȱ herangezogenȱ werdenȱ können.ȱ WieȱdieseȱKnoteninformationenȱdannȱzuȱverteilenȱsind,ȱistȱGegenstandȱ derȱ obenȱ beschriebenenȱ Informationsstrategien.ȱ Eineȱ Lastmessungȱ mussȱinȱkürzerenȱZeitintervallenȱerfolgen,ȱdamitȱdieȱInformationenȱfürȱ denȱ Lastbewertungsalgorithmusȱ denȱ aktuellenȱ Zustandȱ wiedergeben.ȱ Sieȱmussȱdaherȱeffizientȱseinȱundȱbeschränktȱsichȱoftȱaufȱeinenȱeinzigenȱ Parameter.ȱ Esȱ kommenȱ verschiedeneȱ Strategienȱ zurȱ Lastabschätzungȱ inȱBetracht:ȱ

Lastmessung

Eineȱ einfacheȱ Methodeȱ istȱ dieȱ Zählungȱ derȱ Gesamtzahlȱ derȱ Prozesseȱ aufȱ demȱ betreffendenȱ Knotenȱ [Sȱ 96].ȱ Dieȱ momentaneȱ Auslastungȱ istȱ dadurchȱzwarȱwiedergegeben,ȱaberȱihreȱEntwicklungȱistȱstarkȱvonȱdenȱ RestlaufzeitenȱderȱProzesseȱabhängig.ȱ Umȱdemȱzuȱbegegnen,ȱerfolgtȱeineȱAufsummierungȱderȱRestlaufzeitenȱ allerȱ Prozesse,ȱ mitȱ demȱ Problem,ȱ dieseȱ geeignetȱ abzuschätzenȱ [Sȱ 96].ȱ Derȱ Wertȱ selbstȱ kannȱ eineȱ prozessunabhängigeȱ Schätzungȱ seinȱ oderȱ dieȱ Gesamtlaufzeitȱ desȱ Prozessesȱ wirdȱ geeignetȱ abgeschätztȱ undȱ dieȱ verstricheneȱLaufzeitȱabgezogen.ȱ HäufigȱistȱauchȱdieȱBestimmungȱderȱAuslastungȱanhandȱderȱLängeȱderȱ CPUȬWarteschlangeȱanzutreffen.ȱObwohlȱinȱvielenȱFällenȱeineȱbrauchȬ bareȱGröße,ȱkannȱesȱjedochȱvorkommen,ȱdassȱdieȱAnnahmeȱvielerȱProȬ zesseȱ stattfindet,ȱ bevorȱ dieȱ erstenȱ tatsächlichȱ eintreffen,ȱ undȱ esȱ soȱ zuȱ Überlastungȱ kommt.ȱ Abhilfeȱ schafftȱ einȱ Inkrementierenȱ einerȱ HilfsȬ warteschlangeȱ beiȱ Akzeptanzȱ einesȱ Prozessesȱ mitȱ einemȱ Timeoutȱ fürȱ dasȱDekrementierenȱbeiȱausbleibendemȱProzessȱ[Sȱ94].ȱAuchȱFaktorenȱ wieȱetwaȱdieȱTaktfrequenzȱeinesȱProzessorsȱgehenȱinȱdieȱAbschätzunȬ genȱ mitȱ ein.ȱ Fernerȱ sindȱ Informationenȱ ausȱ vorangegangenenȱ Läufenȱ einesȱ Prozessesȱ beiȱ wiederholterȱ Ausführungȱ hilfreich,ȱ umȱ dieȱ durchȱ diesenȱProzessȱverursachteȱLastȱzuȱbestimmenȱ[Wȱ99].ȱ

CPUȬ Auslastungȱ

Daȱ dieȱ zuvorȱ genanntenȱ Methodenȱ beiȱ modernenȱ Rechnernȱ mitȱ einerȱ größerenȱZahlȱpermanentȱexistierenderȱProzesseȱkeinȱaussagekräftigesȱ ErgebnisȱliefernȱundȱdieȱLängeȱderȱCPUȬWarteschlangeȱoftȱnichtȱallzuȱ gutȱ mitȱ derȱ tatsächlichenȱ Lastȱ korreliert,ȱ wirdȱ hauptsächlichȱ aufȱ dieȱ

375ȱ

6ȱȱRechenlastverteilungȱ CPUȬAuslastungȱ zurückgegriffen.ȱ Sieȱ istȱ definiertȱ alsȱ dieȱ Anzahlȱ derȱ CPUȬZyklenȱdieȱproȱZeiteinheitȱtatsächlichȱProzesseȱausgeführtȱhabenȱ [Tȱ 95].ȱ Dieselbeȱ Informationȱ kannȱauchȱalternativȱ dieȱ Leerlaufzeitȱdesȱ Prozessorsȱliefernȱ[BKȱ88].ȱ SpeicherverȬ fügbarkeit,ȱ KommunikaȬ tionslastȱ

WeitereȱMessgrößenȱkönnenȱdieȱfreienȱSeitenȱimȱSpeichersystemȱsein,ȱ daȱ Speicherverfügbarkeitȱ durchausȱ eineȱ Rolleȱ beiȱ derȱ Prozessvergabeȱ spielt.ȱGrößenȱwieȱdieȱAnzahlȱgesendeterȱoderȱempfangenerȱNachrichȬ tenȱ oderȱ dieȱ Mengeȱ anȱ gesendetenȱ oderȱ empfangenenȱ Datenȱ bestimȬ menȱdieȱKommunikationslastȱimȱverteiltenȱSystemȱ[Wȱ98].ȱ

MonitoringȬ Prozessȱ

Dieȱ Ermittlungȱ derȱ Messgrößenȱ zurȱ Lastbestimmungȱ benötigtȱ einenȱ MonitoringȬProzess,ȱ derȱ seinerseitsȱ Lastȱ aufȱ dieȱ Knotenȱ bringtȱ [Sȱ 94].ȱ Dieseȱ zusätzlicheȱ Lastȱ sollteȱ dieȱ Messungȱ nichtȱ zuȱ starkȱ beeinträchtiȬ genȱ[Wȱ98].ȱ Ähnlichȱ wieȱ imȱ statischenȱ Fall,ȱ könnenȱ Prozesseȱ verschiedenenȱ KlasȬ senȱ zugeordnetȱ sein,ȱ dieȱ Formulierungȱ undȱ Lösungȱ desȱ LoadȬ BalancingȬProblemsȱ beeinflussenȱ [LKȱ 98].ȱ Außerdemȱ wirdȱ derȱ LoadȬ BalancingȬProzessȱ vereinfacht,ȱ wennȱ einȱ Systemȱ dedizierteȱ DatenserȬ verȱ hat.ȱ Wennȱ Datenȱ zusätzlichȱ bewegtȱ werdenȱ müssen,ȱ ergibtȱ sichȱ dadurchȱnochȱeinmalȱzusätzlicherȱOverheadȱ[Wȱ99].ȱ

Zentraleȱ Lastverteilungȱ

6.2.1 Zentrale Lastverteilungssysteme BeiȱderȱzentralenȱLastverteilungȱgibtȱesȱeineȱzentraleȱLastbewertungsȬ komponenteȱ mitȱ vierȱ derȱ inȱ Abbildungȱ 6Ȭ7ȱ dargestelltenȱ Strategien.ȱ Eineȱ besondereȱ Initiierungsstrategieȱ istȱ hierȱ nichtȱ gegeben.ȱ Dieȱ LastȬ messungȱ mussȱ natürlichȱ auchȱ hierȱ lokalȱ aufȱ jedemȱ einzelnenȱ Knotenȱ einesȱSystemsȱerfolgen,ȱundȱauchȱeineȱeventuellȱvorgeseheneȱMigratiȬ onȱ istȱ selbstverständlichȱ einȱ verteilterȱ Vorgang,ȱ derȱ dieȱ beteiligtenȱ Rechnerȱ umfasst.ȱ Derȱ zentraleȱ Serverknotenȱ mitȱ derȱ Lastbewertungȱ kannȱ auchȱ einȱ dedizierterȱ Lastausgleichsserverȱ sein.ȱ Eineȱ zentraleȱ Lastbewertungȱ mussȱ entwederȱ maximalenȱ Wirkungsbereichȱ habenȱ oderȱeineȱMengeȱvonȱbegrenztenȱWirkungsbereichen,ȱdieȱdasȱgesamteȱ Systemȱabdecken.ȱ

Prozessorfarmȱ

376ȱ

Einȱ einfachesȱ Beispielȱ ausȱ demȱ Parallelenȱ Rechnenȱ istȱ dieȱ ProzessorȬ farmȱ [OAȱ 02],ȱ dieȱ auchȱ inȱ 4.2.2.2.1ȱ alsȱ MasterȬWorkerȬSchemaȱ beȬ schriebenȱ ist.ȱ Derȱ Masterȱ führtȱ dieȱ sequentiellenȱ Anteileȱ einesȱ ProȬ grammsȱausȱundȱverteiltȱparalleleȱTeileȱanȱdieȱWorker.ȱInformationenȱ derȱ Workerȱ hältȱ derȱ Masterȱ zentral.ȱ Sieȱ sindȱ dessenȱ EntscheidungsȬ grundlage.ȱDieȱInitiierungȱerfolgtȱdurchȱdieȱWorker,ȱdieȱnachȱBearbeiȬ tungȱ einerȱ zugewiesenenȱ Rechenlastȱ neueȱ Tasksȱ beimȱ Masterȱ anforȬ dernȱ(ereignisgesteuert).ȱ

6.2ȱDynamischeȱLastverteilungȱ Durchȱ dieȱ Zentralisierung,ȱ insbesondereȱ denȱ Zusammenflussȱ allerȱ SystemȬȱ undȱ Lastinformationenȱ sowieȱ derȱ Informationenȱ überȱ alleȱ zuȱ verteilendenȱ Prozesseȱ beiȱ einerȱ Instanz,ȱ kannȱ dieseȱ sehrȱ effizientȱ EntȬ scheidungenȱ insbesondereȱ zurȱ Platzierungȱ vonȱ Prozessenȱ treffen.ȱ Inȱ derȱRegelȱerfolgtȱeineȱStatusauffrischungȱseitensȱderȱKnoten,ȱhäufigȱistȱ dieseȱ periodisch.ȱ Dadurchȱ lässtȱ sichȱ dasȱ Alternȱ vonȱ Informationȱ eherȱ vermindernȱalsȱdurchȱAnfrageȱseitensȱdesȱServersȱ[Sȱ96].ȱ Dieȱ Zuverlässigkeitȱ einerȱ zentralenȱ Lastverteilungȱ stelltȱ einȱ Problemȱ dar.ȱDerȱzentraleȱServerknotenȱistȱderȱFlaschenhalsȱfürȱdenȱInformatiȬ onsfluss.ȱ Seinȱ Ausfallȱ bedeutetȱ denȱ Zusammenbruchȱ derȱ LastverteiȬ lungȱfürȱ dasȱgesamteȱ System.ȱ DurchȱdasȱAnlegenȱ vonȱ Replikatenȱ desȱ ServersȱlässtȱsichȱdieȱAusfallwahrscheinlichkeitȱstarkȱherabsetzen.ȱDerȱ Aufwand,ȱ dieseȱ ständigȱ konsistentȱ zuȱ halten,ȱ istȱ sehrȱ hoch.ȱ Strengeȱ Konsistenzȱwirdȱallerdingsȱalsȱverzichtbarȱangesehen,ȱsoȱdassȱeinȱeinȬ fachererȱMechanismusȱzurȱAktualisierungȱderȱSeverkopienȱausreichtȱ[Sȱ 96].ȱ Wennȱ kurzzeitigeȱ Verzögerungenȱ vonȱ wenigenȱ Sekundenȱ akzepȬ tabelȱ sind,ȱ sindȱ Serverkopienȱ verzichtbar.ȱ Stattdessenȱ kannȱ eineȱ beȬ stimmteȱAnzahlȱvonȱKnotenȱdenȱServerȱüberwachen.ȱBeiȱServerausfallȱ kannȱeinȱneuerȱServerprozessȱaufȱdemȱregistrierendenȱKnotenȱgestartetȱ werden,ȱderȱsichȱdieȱbenötigtenȱInformationenȱneuȱbeschafftȱundȱseineȱ Arbeitȱaufnimmtȱ[TLȱ89].ȱ

ZuverlässigȬ keitȱZentraleȱ Lastverteilungȱ

EinȱweitererȱMinuspunktȱfürȱdieȱzentralenȱVerfahrenȱistȱihreȱschlechteȱ Skalierbarkeitȱ[ZLPȱ96].ȱ TeilweiseȱwirdȱInformationȱüberȱdasȱSystemȱvomȱzentralenȱServerknoȬ tenȱ ausȱ wiederȱ verteiltȱ anȱ dieȱ Knotenȱ desȱ Systems,ȱ damitȱ diese,ȱ etwaȱ beiȱ einerȱ Migrationȱ oderȱ zurȱ Einschätzungȱ derȱ eigenenȱ Auslastungȱ daraufȱzugreifenȱkönnen.ȱEinȱBeispielȱdafürȱistȱeinȱzentralerȱAlgorithȬ musȱausȱ[FMDȱ98]:ȱErȱverteiltȱdenȱWertȱderȱmittlerenȱSystemlastȱanȱalleȱ Prozessoren,ȱ dieȱ dannȱ inȱ dreiȱ Klassenȱ (ungenutzt,ȱ ȱ überlastetȱ undȱ dieȱ anderen)ȱ eingeteiltȱ werden.ȱ Derȱ Algorithmusȱ bringtȱ ungenutzteȱ undȱ überlasteteȱ Knotenȱ zusammen.ȱ Denȱ Gradȱ derȱ ÜberȬȱ undȱ Unterlastȱ berücksichtigtȱderȱRendezvousȬAlgorithmusȱ[DFMȱ95].ȱImȱallgemeinenȱ Fallȱ erfolgtȱ eineȱ Einteilungȱ inȱ dieȱ Klassenȱ Überlast,ȱ Unterlast,ȱ DurchȬ schnittlicheȱLast.ȱ

Zentralerȱ Algorithmus,ȱ RendezvousȬȱ Algorithmusȱ

Dasȱ vonȱ [HLAȱ 95]ȱ vorgestellteȱ Verfahrenȱ SASHȱ (SelfȬAdjustingȱ ScheȬ dulingȱforȱ Heterogeneousȱ Systems)ȱistȱeinȱ Beispielȱfürȱ zentralenȱLastȬ ausgleichȱ mitȱ einemȱ dediziertenȱ zentralenȱ Serverknoten.ȱ Esȱ arbeitetȱ mitȱeinerȱVarianteȱdesȱBranchȬandȬBoundȬVerfahrensȱundȱistȱinsofernȱ interessant,ȱ alsȱ esȱ Schedulesȱ untersuchtȱ undȱ dabeiȱ wiederholtȱ Phasenȱ

SASHȱ

377ȱ

6ȱȱRechenlastverteilungȱ durchläuft,ȱanȱderenȱEndeȱdieȱverplantenȱTasksȱbeiȱdenȱzugewiesenenȱ ProzessorenȱinȱdieȱWarteschlangeȱeingereihtȱwerden.ȱ Condorȱ

Dasȱ Lastverwaltungssystemȱ Condorȱ derȱ Universityȱ ofȱ WisconsinȬ Madison,ȱ[Cȱ07]ȱistȱeinȱvielfachȱgenutztes,ȱausgereiftesȱSystem,ȱdasȱmitȱ einemȱ zentralenȱ Managerȱ fürȱ dieȱ Lastverteilungȱ arbeitet.ȱ Esȱ wirdȱ inȱ WorkstationȬNetzwerkenȱeingesetzt,ȱumȱungenutzteȱ(idle)ȱRechnerȱfürȱ dieȱ Bearbeitungȱ rechenintensiverȱ Prozesseȱ zuȱ nutzen.ȱ Condor,ȱ dasȱ auchȱ inȱ Gridumgebungenȱ alsȱ Lastverteilerȱ zumȱ Einsatzȱ kommt,ȱ hatȱ einigeȱbemerkenswerteȱEigenschaften.ȱ

Matchmaking,ȱ ClassAds,ȱ Claimingȱ

WorkstationȬUmgebungenȱsindȱseltenȱreinȱhomogeneȱUmgebungen,ȱsoȱ dassȱimȱAllgemeinenȱnichtȱalleȱKnotenȱdesȱSystemsȱdieȱAnforderungenȱ vonȱ Prozessenȱ erfüllen.ȱ Darumȱ istȱ dasȱ MatchmakingȬKonzeptȱ einȱ KernstückȱvonȱCondor.ȱDieȱAnforderungenȱderȱClientsȱundȱdasȱAngeȬ botȱderȱRechnerȱsindȱinȱsoȱgenanntenȱClassifiedȱAdvertismentsȱ(ClassȬ Ads)ȱspezifiziert.ȱDieȱClassAdsȱwerdenȱvonȱAgentenȱfürȱdieȱBenutzerȱ undȱ fürȱ dieȱ Rechenknotenȱ anȱ einenȱ Matchmakerȱ übergeben.ȱ Dieseȱ zentraleȱ Komponenteȱ stelltȱ dieȱ passendenȱ ClassAdsȱ zusammenȱ undȱ übergibtȱ sieȱ denȱ beteiligtenȱ Agenten,ȱ denenȱ dieȱ Umsetzungȱ durchȱ soȱ genanntesȱ Claimingȱ obliegt.ȱ Derȱ Vorgangȱ desȱ Matchmakingsȱ nachȱ [NSWȱ04,ȱKap.ȱ9]ȱistȱinȱAbbildungȱ6Ȭ9ȱdargestellt.ȱ

Abb.ȱ6Ȭ9:ȱ CondorȬ Matchmakingȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

Condorȱ–ȱ CheckpointȬ ingȱ

378ȱ

Beiȱ Workstationsȱ handeltȱ esȱ sichȱ umȱ Rechner,ȱ dieȱ beiȱ Bedarfȱ einemȱ Besitzerȱ zurȱ Verfügungȱ stehenȱ müssen.ȱ Sieȱ sollenȱ dannȱ nichtȱ durchȱ fremdeȱ Prozesseȱ belastetȱ werden.ȱ Ausȱ diesemȱ Grundȱ mussȱ Condorȱ präemptivȱarbeiten.ȱFernerȱkannȱCondorȱauchȱperiodischȱtesten,ȱobȱesȱ fürȱ laufendeȱ Prozesseȱ nichtȱ einenȱ besserenȱ Rechnerȱ findet.ȱ Condorȱ führtȱdamitȱnachȱderȱobenȱdargelegtenȱEinteilungȱzwarȱkeinȱvollstänȬ digesȱLoadȱBalancing,ȱaberȱdochȱeinȱLoadȱSharingȱdurch.ȱDieȱMigratiȬ

6.2ȱDynamischeȱLastverteilungȱ onȱ derȱ Prozesseȱ wirdȱ durchȱ dieȱ CheckpointingȬFunktionalitätȱ vonȱ Condorȱ unterstützt,ȱ dieȱ denȱ Zustandȱ derȱ Prozesseȱ sichertȱ undȱ damitȱ dieȱWiederaufnahmeȱdesȱProzesslaufsȱnachȱderȱMigrationȱermöglicht.ȱ (Fürȱ eineȱ ausführlicheȱ Beschreibungȱ derȱ Vorgängeȱ beiȱ einerȱ ProzessȬ migrationȱs.ȱAbschnittȱ6.2.2.2.)ȱ LoadLeveler®ȱ[LLȱ01]ȱistȱeineȱkommerzielleȱClusterȱManagementȱSoftȬ wareȱ (CMS)ȱ vonȱ IBM.ȱ Einȱ Lastausgleichȱ erfolgtȱ überȱ einenȱ zentralenȱ Manager,ȱderȱneueȱJobsȱanȱeinenȱgeeignetenȱKnotenȱzuweist.ȱLoadLeȬ velerȱ unterstütztȱ Checkpointingȱ undȱ Migration.ȱ Dasȱ Systemȱ istȱ gutȱ skalierbarȱundȱfehlertolerant.ȱ

LoadLeveler®

6.2.2 Dezentrale Lastverteilungssysteme BeiȱdezentralerȱLastverteilungȱverfügenȱmehrereȱoderȱsogarȱalleȱRechȬ nerȱ einesȱ Systemsȱ überȱ eineȱ Lastbewertung,ȱ dieȱ dieȱ LastverteilungsȬ strategienȱ (s.ȱ Abbildungȱ 6Ȭ7)ȱ implementiert.ȱ Esȱ sindȱ auchȱ gemischteȱ Verfahrenȱdenkbar;ȱzumȱBeispielȱkannȱdieȱInformationshaltungȱzentralȱ erfolgen,ȱwährendȱdieȱeigentlicheȱBewertungȱmitȱdenȱEntscheidungenȱ zumȱ eventuellenȱ Lastausgleichȱ dezentralȱ erfolgt.ȱ Selektionsstrategienȱ müssenȱ jeȱ nachdem,ȱ werȱ denȱ Lastausgleichȱ initiiert,ȱ nurȱ nochȱ denȱ jeȬ weilsȱ anderenȱ Partnerȱ festlegen.ȱ Dieȱ Wirkungsbereicheȱ allerȱ LastbeȬ wertungskomponentenȱ imȱ Systemȱ müssenȱsichȱüberlappen,ȱ umȱ einenȱ LastflussȱdurchȱdasȱgesamteȱSystemȱzuȱgewährleistenȱundȱsieȱmüssenȱ auchȱdasȱgesamteȱSystemȱabdecken.ȱ

Dezentraleȱ Lastverteilungȱ

DieȱdezentralenȱLastverteilungsalgorithmenȱlassenȱsichȱinȱkooperativeȱ undȱnichtȬkooperativeȱVerfahrenȱunterteilenȱ[Sȱ96][Lȱ92].ȱKooperativeȱ VerfahrenȱsindȱkomplexerȱalsȱnichtȬkooperative,ȱdaȱhierȱdieȱeinzelnenȱ Lastverteilungseinheitenȱ miteinanderȱ kommunizierenȱ –ȱ etwaȱ LastinȬ formationenȱ austauschenȱ ȱ umȱ einenȱ gemeinsamenȱ Algorithmusȱ ausȬ zuführen.ȱ Mithinȱ wirdȱ mehrȱ Overheadȱ produziert.ȱ Dagegenȱ agierenȱ dieȱ nichtȬkooperativenȱ Einheitenȱ völligȱ autonom.ȱ Kooperationȱ kannȱ auchȱsoȱvonstattenȱgehen,ȱdassȱverschiedeneȱLastbewertungseinheitenȱ verschiedeneȱ Teileȱ einesȱ Algorithmusȇȱ ausführen.ȱ Schließlichȱ gibtȱ esȱ nochȱ eineȱ indirekteȱ Kooperation,ȱ dieȱ aufȱ derȱ Wechselwirkungȱ durchȱ überlappendeȱ Wirkungsbereicheȱ beruht.ȱ Kooperativeȱ Algorithmenȱ geltenȱalsȱstabilerȱalsȱnichtȬkooperative.ȱ

Kooperativeȱ undȱnichtȬ kooperativeȱ Verfahrenȱ

Imȱ dezentralenȱ Fallȱ istȱ nochȱ eineȱ Strategieȱ derȱ Prioritätszuweisungȱ (Priorityȱ Assignmentȱ Policy)ȱ erwähnenswertȱ [LTȱ 86].ȱ Dieȱ Zuweisungȱ kannȱ entwederȱ egoistischȱ mitȱ Bevorzugungȱ lokalerȱ Prozesse,ȱ altruisȬ tischȱmitȱBevorzugungȱfremderȱProzesseȱoderȱausgeglichenȱinȱAbhänȬ gigkeitȱvonȱderȱAnzahlȱanȱlokalenȱbeziehungsweiseȱfremdenȱProzessenȱ erfolgen.ȱDieȱbesteȱLeistungssteigerungȱerbringtȱdieȱaltruistischeȱVariȬ

Strategieȱderȱ Prioritätszuw eisungȱ

379ȱ

6ȱȱRechenlastverteilungȱ ante,ȱ wenngleichȱ sieȱ ausȱ derȱ Sichtȱ einesȱ Rechnerbesitzersȱ sicherȱ nichtȱ ganzȱeinsichtigȱist.ȱ Verhaltenȱ dezentralerȱ LastverteiȬ lungssystemeȱ

Mitȱ einemȱ dezentralenȱ Systemȱ wirdȱ derȱ Flaschenhalsȱ bezüglichȱ desȱ InformationsflussesȱzentralerȱSystemeȱvermieden.ȱEsȱistȱdeshalbȱflexibȬ lerȱ undȱ kannȱ rascherȱ aufȱ dynamischeȱ Veränderungenȱ reagieren.ȱ Jedeȱ Komponenteȱ läuftȱ parallelȱ undȱ imȱ Allgemeinenȱ unabhängigȱ vonȱ denȱ anderen.ȱSieȱtrifftȱEntscheidungenȱfürȱdieȱKnotenȱinȱihremȱWirkungsȬ bereich,ȱinȱderȱRegelȱnachȱeinerȱsystemweitenȱZielfunktion.ȱImȱExtremȬ fallȱ einerȱ vollständigenȱ Dezentralisierungȱ geltenȱ dieȱ Entscheidungenȱ einerȱ Komponenteȱ ȱ ausschließlichȱ fürȱ dieȱ (ankommendenȱ undȱ abgeȬ henden)ȱProzesseȱdesȱeigenenȱKnotensȱ[Sȱ96].ȱ DezentraleȱAlgorithmenȱsindȱdeutlichȱausfalltoleranterȱalsȱdieȱzentraȬ lenȱVerfahren.ȱAufȱderȱNegativseiteȱerhöhenȱsieȱdieȱSystemlast,ȱindemȱ derȱ Informationsaustauschȱ aufȱ mehrereȱ beziehungsweiseȱ alleȱ ProzesȬ sorenȱdesȱSystemsȱübergeht.ȱMassivȱparalleleȱSystemeȱbenötigenȱschonȱ ausȱGründenȱderȱSkalierbarkeitȱeinȱdezentralesȱLastverteilungsverfahȬ renȱ[Wȱ99][CLZȱ99].ȱ Obwohlȱ derȱ Informationsaustauschȱ beiȱ reinȱ dezentralenȱ Verfahrenȱ zwischenȱ denȱ einzelnenȱ Knotenȱ stattfindet,ȱ erfolgtȱ nichtȱ immerȱ einȱ Sammelaufrufȱ(Broadcast)ȱanȱalleȱoderȱeineȱAnfrageȱbeiȱallen.ȱErȱistȱ–ȱ nichtȱzuletztȱausȱGründenȱderȱSystembelastungȱ–ȱoftȱaufȱeineȱgewisseȱ Nachbarschaftȱ beschränkt.ȱ Durchȱ dieȱ Überlappungȱ vonȱ WirkungsbeȬ reichenȱ kommtȱ esȱ allerdingsȱ nachȱ einerȱ ausreichendenȱ Anzahlȱ vonȱ LastverteilungsdurchläufenȱzuȱeinerȱglobalenȱVerteilungȱvonȱInformaȬ tionȱ[Wȱ99][CLZȱ99].ȱ

TilingȬȱundȱ AverageȬ NeighborȬ Algorithmus,ȱ Diffusiveȱ Algorithmenȱ

380ȱ

Beimȱ TilingȬAlgorithmusȱ [DFMȱ 95]ȱ istȱ dasȱ gesamteȱ Rechnernetzȱ inȱ nichtȱ überlappendeȱ Bereicheȱ eingeteilt.ȱ Innerhalbȱ dieserȱ Bereicheȱ erȬ folgtȱ inȱ jedemȱ Lastausgleichsschrittȱ einȱ vollständigesȱ präemptivesȱ LoȬ adȱ Balancing.ȱ Fürȱ denȱ Folgeschrittȱ werdenȱ dieȱ Bereicheȱ jeweilsȱ leichtȱ verschoben,ȱsoȱdassȱsieȱdieȱaltenȱKnotenȱnurȱzumȱTeilȱbeinhaltenȱundȱ Lastȱ langsamȱ durchȱ dasȱ Systemȱ wandernȱ kann.ȱ Beimȱ AverageȬ NeighborȬAlgorithmusȱ[WRȱ93]ȱistȱdasȱNetzȱebenfallsȱinȱBereicheȱaufȬ geteilt,ȱdieȱsichȱhierȱjedochȱüberlappen.ȱVonȱeinemȱzentralenȱProzessorȱ inȱ einemȱ Bereichȱ (Insel)ȱ ausȱ wirdȱ dieȱ Lastȱ innerhalbȱ derȱ Inselȱ verteiltȱ undȱ kannȱ durchȱ dieȱ Überlappungenȱ gleichmäßigȱ durchȱ dasȱ Systemȱ wandern.ȱWegenȱderȱallmählichenȱBewegungȱvonȱLastȱdurchȱdasȱSysȬ temȱundȱdemȱdamitȱüberȱvieleȱSchritteȱhinwegȱverbundenenȱglobalenȱ LastausgleichȱsprichtȱmanȱinȱAnalogieȱzuȱphysikalischenȱPhänomenenȱ vonȱDiffusionȱ(DiffusiveȱAlgorithmenȱ[CLZȱ99]).ȱ

6.2ȱDynamischeȱLastverteilungȱ Wennȱ jeweilsȱ nurȱ zweiȱ direkteȱ Nachbarnȱ Lastȱ austauschenȱ (Nearestȱ Neighborȱ[Wȱ99])ȱwirdȱdieȱLastȱsolangeȱvomȱstärkerȱausgelastetenȱzumȱ geringerȱausgelastetenȱKnotenȱweitergegeben,ȱsolangeȱeinȱsolchesȱGeȬ fälleȱexistiert.ȱEinȱDiffusionsparameterȱimȱIntervallȱ[0,ȱ1]ȱbestimmtȱdenȱ Anteilȱ derȱ Lastdifferenzȱ zwischenȱ denȱ beidenȱ beteiligtenȱ Knoten,ȱ derȱ verschobenȱwird.ȱEsȱgibt,ȱabhängigȱvonȱderȱArchitekturȱdesȱNetzwerȬ kes,ȱweitereȱMöglichkeitenȱdesȱzweiseitigenȱLastaustausches.ȱInȱeinemȱ GitterȱoderȱHypercubeȱlässtȱsichȱeinȱGradientenmaßȱdefinieren,ȱsoȱdassȱ LastȱimmerȱinȱRichtungȱdesȱgrößtenȱGradientenȱfließenȱkann.ȱInȱeinemȱ Hypercubeȱ könnenȱ jeweilsȱ zweiȱ benachbarteȱ Knotenȱ entlangȱ einerȱ festenȱ Dimensionȱ Lastȱ austauschen,ȱ wobeiȱ dieȱ Dimensionȱ beiȱ jedemȱ Lastausgleichsschrittȱwechselt.ȱNachȱeinemȱUmlaufȱistȱdieȱLastȱfürȱalleȱ Knotenȱ ausgeglichen.ȱ Mitȱ diesemȱ Prinzipȱ istȱ esȱauchȱ möglich,ȱ imȱ HyȬ percubeȱderȱDimensionȱnȱmitȱbisȱzuȱ2nȱ–ȱ3ȱunterbrochenenȱVerbindunȬ genȱdennochȱeinenȱLastausgleichȱdurchzuführenȱ[Wȱ97].ȱ

Nearestȱ Neighborȱ

Dieȱ NearestȬNeighborȬVerfahrenȱ sindȱ auchȱ einȱ gutesȱ Beispielȱ fürȱ diȬ rekteȱ kooperativeȱ Verfahren,ȱ beiȱ denenȱ aufgrundȱ vonȱ LastinformatioȬ nenȱ beiderȱ Knotenȱ eineȱ Zusammenarbeitȱ beimȱ Lastausgleichȱ stattfinȬ det.ȱ Dieȱ steigendeȱ Komplexitätȱ verteilterȱ Systeme,ȱ dieȱ ausȱ derȱ Größeȱ derȱ Ökonomischeȱ Systemeȱ(Nutzer,ȱProzesse,ȱProzessoren)ȱundȱausȱderȱsteigendenȱHeteȬ Verfahrenȱ rogenitätȱ (Anwendungenȱ undȱ Ressourcen)ȱ resultiert,ȱ hatȱ selbstverȬ ständlichȱauchȱ Einflussȱaufȱ dieȱ Anforderungenȱanȱ LastverteilungsmeȬ thoden.ȱDieseȱEntwicklungȱwirdȱseitȱlängeremȱschonȱerkanntȱundȱeineȱ neueȱ Klasseȱ vonȱ Algorithmenȱ sollȱ ihrȱ begegnenȱ [Fȱ 96][Sȱ 96].ȱ Dabeiȱ handeltȱesȱsichȱumȱVerfahren,ȱdieȱaufȱdemȱökonomischenȱPrinzipȱdesȱ Wettbewerbsȱ beruhenȱ undȱ dieȱ eineȱ besondereȱ Lokationsstrategieȱ bieȬ ten.ȱSieȱarbeitenȱmitȱAgenten,ȱdieȱeigennützigeȱZieleȱverfolgenȱundȱinȱ dieȱ beidenȱ Klassenȱ Kundenȱ (Clients)ȱ undȱ Lieferantenȱ (Suppliers)ȱ einȬ geteiltȱsind.ȱDieseȱAgentenȱrepräsentierenȱdannȱdieȱAnwendungenȱmitȱ ihremȱ primärenȱ Zielȱ derȱ Optimierungȱ derȱ eigenenȱ Performanceȱ undȱ dieȱComputersystemeȱmitȱdemȱprimärenȱZielȱderȱGewinnmaximierung,ȱ demȱZieleȱwieȱErhöhungȱdesȱDurchsatzesȱundȱSteigerungȱderȱSystemȬ performanceȱ untergeordnetȱ sind.ȱ Auchȱ Modelleȱ mitȱ kooperierendenȱ Agentenȱ sindȱ vertreten.ȱ Nebenȱ denȱ Agentenȱ werdenȱ auchȱ Geldȱ undȱ eineȱ Preisbildungȱ modelliert.ȱ Fürȱ letztereȱ sindȱ nebenȱ Warenbörsenȱ (Commodityȱ Markets)ȱ auchȱ verschiedeneȱ Auktionsmodelleȱ (Auctionȱ Markets)ȱ gebräuchlich.ȱ Danebenȱ kommenȱ auchȱ spieltheoretischeȱ MoȬ delleȱ vorȱ [Fȱ 96].ȱ Einȱ Problemȱ derȱ Verfahrenȱ sindȱ starkeȱ NachfrageȬ schwankungen.ȱ Sieȱ führenȱ zuȱ starkenȱ Preisschwankungenȱ undȱ inȱ derȱ FolgeȱzuȱübermäßigerȱMigration.ȱ

381ȱ

6ȱȱRechenlastverteilungȱ

6.2.2.1 Lastausgleich ohne Migration Lastausgleichȱ ohneȱ Migrationȱ

WennȱeinȱLastverteilungsverfahrenȱohneȱProzessmigrationȱarbeitet,ȱistȱ derȱAufwandȱsehrȱvielȱgeringerȱalsȱbeiȱderȱEinbeziehungȱderȱMigration.ȱ EinȱvollständigesȱLoadȱBalancingȱistȱjedochȱnichtȱzuȱerreichen,ȱdaȱdieȱ AuswahlȱanȱProzessenȱmitȱentsprechendenȱLastenȱgeringerȱistȱundȱzuȱ jedemȱZeitpunktȱnurȱdieȱgeradeȱankommendenȱProzesseȱzumȱLastausȬ gleichȱ beitragen.ȱ Derȱ Untergrundȱ anȱ längerȱ imȱ Systemȱ befindlichen,ȱ laufendenȱProzessen,ȱausȱdenenȱderȱAusgleichsmechanismusȱschöpfenȱ kann,ȱfehlt.ȱEsȱliegtȱeherȱeinȱLoadȱSharingȱvor.ȱ

Strategienȱ ohneȱ Migrationȱ

BezüglichȱderȱStrategienȱfürȱLastausgleichsverfahrenȱändertȱsichȱnichtȱ viel.ȱInȱderȱGesamtsichtȱ(Abbildungȱ6Ȭ7)ȱfehltȱnatürlichȱdieȱMigration.ȱ Alsȱ Initiierungsstrategieȱ eignetȱ sichȱ praktischȱ nurȱ dieȱ senderbasierteȱ Strategie,ȱ ausȱ demselbenȱ Grundȱ wieȱ einȱ vollständigerȱ Lastausgleichȱ kaumȱzuȱerreichenȱist.ȱEinȱpotentiellerȱEmpfängerȱwirdȱsichȱvergeblichȱ bemühen,ȱ wennȱ esȱ zumȱ Zeitpunktȱ seinerȱ Anfrageȱ keineȱ neuȱ ankomȬ mendenȱ Prozesseȱ gibt.ȱ Beiȱ denȱ Transferstrategienȱ fallenȱ beiȱ denȱ EntȬ scheidungsprozessenȱ jeweilsȱ dieȱ Teileȱ weg,ȱ dieȱ präemptiveȱ Transfersȱ inȱBetrachtȱziehenȱmüssen,ȱundȱderȱVorgangȱwirdȱdadurchȱeinfacher.ȱ Einfacherȱ wirdȱ auchȱ dieȱ Abschätzungȱ desȱ Transferaufwandsȱ beiȱ derȱ Selektion,ȱ daȱ dieserȱ fürȱ Prozessplatzierungȱ vielȱ geringerȱ istȱ alsȱ fürȱ Prozessmigration.ȱ

ZufallsalgoȬ rithmusȱ

EinȱBeispielȱfürȱeinenȱeinfachenȱdezentralenȱAlgorithmusȱohneȱMigraȬ tionȱ istȱ derȱ Zufallsalgorithmusȱ [SSȱ 94].ȱ Dasȱ Verfahrenȱ schicktȱ vonȱ jeȬ demȱ Prozessorȱ ausȱ dieȱ dortȱ ankommendenȱ neuenȱ Tasksȱ anȱ zufälligȱ ausgewählteȱKnotenȱimȱgesamtenȱNetz.ȱDieȱWahrscheinlichkeit,ȱeinenȱ Prozessȱzuȱerhalten,ȱistȱfürȱjedenȱKnotenȱgleich.ȱ

6.2.2.2 Lastausgleich mit Migration Migrationȱ

Dasȱ Zielȱ desȱ Loadȱ Balancing,ȱ dieȱ Lastverhältnisseȱ inȱ einemȱ verteiltenȱ Systemȱ stetsȱ ausgeglichenȱ zuȱ halten,ȱ erfordertȱ außerȱ einerȱ optimalenȱ PlatzierungȱneuerȱTasksȱauch,ȱLastȱdurchȱlaufendeȱProzesseȱvonȱeinemȱ überlastetenȱ Knotenȱ imȱ Netzȱ abzubauenȱ undȱ sieȱ zuȱ geringȱ belastetenȱ oderȱ unbelastetenȱ Knotenȱ zuȱ transferieren.ȱ Dasȱ bedeutet,ȱ laufendeȱ Prozesseȱ auszulagernȱ beziehungsweiseȱ zuȱ migrieren.ȱ Migrationȱ inȱ dezentralenȱSystemenȱermöglichtȱdenȱhöchstenȱGradȱanȱLastausgleich.ȱ Dieserȱ Abschnittȱ beschreibtȱ ausführlichȱ dieseȱ Prozessmigrationȱ undȱ gehtȱ amȱ Endeȱ nochȱ kurzȱ aufȱ andereȱ Migrationsformenȱ (CodeȬȱ undȱ Jobmigration)ȱein.ȱ ȱ

382ȱ

6.2ȱDynamischeȱLastverteilungȱ SystemeȱmitȱderȱMöglichkeitȱzurȱMigrationȱbietenȱfolgendeȱVorteileȱ[Sȱ 96][Sȱ94]:ȱ x

Verringernȱ vonȱ Laufzeitenȱ durchȱ paralleleȱ Prozessausführungȱ oderȱ Transferierenȱ aufȱ schnellereȱ CPUs.ȱ Voraussetzungȱ ist,ȱ dassȱ derȱGewinnȱdieȱKostenȱderȱMigrationȱüberwiegt.ȱ

x

ErhöhenȱdesȱDurchsatzesȱdurchȱNutzungȱfreierȱKapazitäten.ȱ

x

ReduktionȱderȱNetzwerkbelastungȱdurchȱkürzereȱWegeȱzuȱzusätzȬ lichȱbenötigtenȱRessourcen,ȱauchȱhierȱunterȱBeachtungȱderȱMigraȬ tionskosten.ȱ

x

Verlässlichkeitȱerhöhen,ȱindemȱzumȱBeispielȱkritischeȱProzesseȱaufȱ verlässlicheȱ Rechnerȱ transferiertȱ oderȱ Kopienȱ derȱ Prozesseȱ angeȬ legtȱundȱtransferiertȱwerden.ȱ

x

ZurȱBewältigungȱvonȱLastspitzenȱoderȱheterogenerȱLastverteilung.ȱ

x

Transferierenȱ vonȱ Prozessenȱ beiȱ Shutdownsȱ oderȱ wennȱ Besitzerȱ vonȱRechnernȱeigeneȱJobsȱstarten.ȱ

x

TransferȱaufȱRechnerȱmitȱhöherenȱSicherheitsanforderungen.ȱ

x

Ständigeȱ Umverteilungȱ kannȱ auchȱ dasȱ Verhungernȱ (starvation)ȱ vonȱProzessenȱvermeiden.ȱ

AnȱdieserȱStelleȱinteressierenȱdieȱVorteile,ȱdieȱLastȱverringernȱundȱzurȱ Leistungssteigerungȱbeitragen.ȱ AnȱeinenȱMigrationsmechanismusȱsindȱunterȱanderenȱfolgendeȱAnforȬ derungenȱzuȱstellenȱ[Sȱ96]:ȱ x

Transparenzȱ bezüglichȱ Objektnamenȱ undȱ Ȭorten,ȱ Systemaufrufenȱ sowieȱInterprozesskommunikation.ȱ

x

Transparenzȱgegenüberȱ demȱ Nutzer,ȱ derȱ eineȱ Migrationȱ nichtȱ beȬ merkenȱsoll.ȱȱ

x

Möglichstȱ geringeȱ Kostenȱ fürȱ denȱ Transferȱ undȱ dieȱ spätereȱ AusȬ führungȱaufȱdemȱneuenȱKnoten.ȱ

x

KeineȱRestabhängigkeitȱzumȱaltenȱKnoten,ȱdaȱZugriffeȱmitȱzusätzȬ licherȱLastȱverbundenȱwärenȱundȱdieȱFehlertoleranzȱabnimmt.ȱ

ImȱMigrationsfallȱkommenȱzuȱdenȱbisherigenȱLastverteilungsstrategienȱ (s.ȱAbbildungȱ6Ȭ7)ȱnochȱMigrationsstrategienȱhinzu.ȱSieȱsindȱeigentlichȱ Selektionsstrategien,ȱ dennȱ sieȱ legenȱ auchȱ fest,ȱ welcheȱ Prozesseȱ ausgeȬ wähltȱwerdenȱkönnen.ȱEinmalȱgehtȱesȱdabeiȱumȱdieȱAnzahlȱvonȱMigraȬ tionen,ȱ dieȱ fürȱ einenȱ bestimmtenȱ Prozessȱ erlaubtȱ sindȱ [Sȱ 96].ȱ Völligeȱ

Vorteileȱ Migrationȱ

AnforderunȬ genȱanȱ MigrationsȬ mechanismusȱ

MigrationsȬ strategien,ȱ MigrationsȬ begrenzungȱ

383ȱ

6ȱȱRechenlastverteilungȱ FreiheitȱhatȱdenȱNachteil,ȱdassȱInstabilitätenȱbegünstigtȱwerden.ȱDaherȱ kannȱ eineȱ bestimmteȱ Anzahlȱ festgelegtȱ sein,ȱ dieȱ nichtȱ überschrittenȱ werdenȱ darfȱ (Migrationsbegrenzung).ȱ Dieseȱ kannȱ zumȱ Beispielȱ auchȱ vonȱ derȱ Prozessgrößeȱ abhängen.ȱ Beiȱ derȱ Auswahlȱ kannȱ esȱ auchȱ eineȱ Rolleȱspielen,ȱwieȱlangeȱeinȱProzessȱschonȱohneȱUnterbrechungȱläuft.ȱ Ablaufȱ Migrationȱ

DurchȬ führungȱ Migrationȱ

Einfrierenȱ

DerȱAblaufȱeinerȱMigrationȱkannȱfolgendermaßenȱunterteiltȱwerden:ȱ x

DieȱInitiierungȱerfolgtȱentwederȱsenderȬȱoderȱempfängerseitig.ȱ

x

DieȱTransferentscheidungȱwirdȱnachȱeinerȱderȱobenȱbeschriebenenȱ Transferstrategienȱvorgenommen.ȱ

x

Einȱ zuȱ migrierenderȱ Prozessȱ aufȱ demȱ Quellknotenȱ wirdȱ gewähltȱ nachȱeinerȱSelektionsstrategie.ȱ

x

Eineȱderȱ Lokationsstrategienȱentscheidetȱ überȱ denȱZielknoten,ȱzuȱ demȱderȱProzessȱauszulagernȱist.ȱ

x

Derȱ Transferȱ wirdȱ durchgeführt.ȱ Dieȱ Ortstransparenzȱ wirdȱ amȱ ehestenȱ gewährleistet,ȱ wennȱ derȱ kompletteȱ Prozesszustandȱ transȬ feriertȱwirdȱ[Sȱ94].ȱ

DieȱDurchführungȱderȱMigrationȱbestehtȱausȱfolgendenȱEinzelaktivitäȬ tenȱ[Sȱ96]:ȱ x

EinfrierenȱdesȱProzesses.ȱ

x

TransferȱdesȱAdressraumsȱ undȱ desȱ Prozesszustandsȱ aufȱ denȱ ZielȬ knoten.ȱ

x

WeiterleitungȱvonȱNachrichtenȱfürȱdenȱmigrierendenȱProzess.ȱ

x

Ermöglichenȱ derȱ Fortführungȱ derȱ Kommunikationȱ mitȱ KoȬ prozessen.ȱ

x

AktivierenȱdesȱProzessesȱaufȱdemȱZielknoten.ȱ

Zumȱ Einfrierenȱ mussȱ derȱ Prozessȱ entwederȱ sofortȱ oderȱ nachȱ einemȱ nichtȬunterbrechbarenȱ Systemaufrufȱ blockiertȱ werden.ȱ Schnelleȱ E/AȬ Operationenȱ werdenȱ zuȱ Endeȱ geführt,ȱ beiȱ langsamenȱ mussȱ fürȱ eineȱ korrekteȱ Weiterführungȱ nachȱ demȱ Neustartȱ gesorgtȱ sein.ȱ InformatioȬ nenȱzuȱgeöffnetenȱDateienȱsindȱfestzuhalten.ȱ ȱ ȱ

384ȱ

6.2ȱDynamischeȱLastverteilungȱ ȱ ȱ

Abb.ȱ6Ȭ10:ȱ Vollständigesȱ Einfrierenȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

Abb.ȱ6Ȭ11:ȱ VortransfeȬ rierungȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

385ȱ

6ȱȱRechenlastverteilungȱ Abb.ȱ6Ȭ12:ȱ Transferȱbeiȱ ReferenzieȬ rungȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

Transferȱ Adressraumȱ

Derȱ Transferȱ desȱ Adressraumsȱ undȱ derȱ Zustandsinformationenȱ kannȱ nachȱdreiȱMethodenȱdurchgeführtȱwerdenȱ(Abbildungenȱ6Ȭ10ȱ–ȱ6Ȭ12)ȱ[Sȱ 96]:ȱ

Vollständigesȱ Einfrierenȱ

x

VollständigesȱEinfrieren:ȱDerȱProzessȱbleibtȱwährendȱderȱgesamtenȱ Prozedurȱ gestoppt.ȱ Dasȱ Vorgehenȱ istȱ langsam,ȱ esȱ kannȱ zuȱ TimeȬ outsȱ kommenȱ undȱ derȱ Nutzerȱ kann,ȱ besondersȱ beiȱ interaktivenȱ Prozessen,ȱbeeinträchtigtȱsein.ȱ

VortransferieȬ rungȱ

x

BeiȱVortransferierungȱ(auchȱPreȬCopying)ȱtransferiertȱdenȱAdressȬ raumȱ desȱ nochȱ laufendenȱ Prozesses.ȱ Seiten,ȱ dieȱ derȱ Prozessȱ wähȬ renddessenȱ modifiziert,ȱ werdenȱ sukzessiveȱ inȱ abnehmenderȱ Zahlȱȱ nachgeladen,ȱbisȱnurȱnochȱwenigeȱrestlicheȱSeitenȱnachȱdemȱStopȬ penȱ desȱ Prozessesȱ zuȱ transferierenȱ sind.ȱ Dieȱ Einfrierzeitȱ desȱ ProȬ zessesȱ istȱ reduziert,ȱ dieȱ Gesamtzeitȱ kannȱ sichȱ aberȱ wegenȱ desȱ reȬ dundantenȱNachladensȱerhöhen.ȱ

Transferȱbeiȱ ReferenzieȬ rungȱ

x

Transferȱ beiȱ Referenzierung:ȱ (auchȱ CopyȬonȬReference):ȱ Beiȱ dieserȱ MethodeȱwirdȱderȱAdressraumȱaufȱdemȱQuellknotenȱzurückgelasȬ senȱundȱderȱProzessȱzunächstȱaufȱdemȱZielknotenȱgestartet.ȱSeitenȱ werdenȱ sukzessiveȱ beiȱ Bedarfȱ nachgeladen.ȱ Fürȱ dieȱ Migrationȱ istȱ dieȱZeitersparnisȱzwarȱhoch,ȱaufȱderȱanderenȱSeiteȱsindȱdieȱKostenȱ fürȱdieȱweitereȱAusführungȱhoch,ȱundȱdurchȱdieȱandauerndeȱAbȬ hängigkeitȱ vomȱ Quellknotenȱ vermindertȱ sichȱ dieȱ Fehlertoleranz.ȱ Dieȱ durchȱ solcheȱ Restabhängigkeitenȱ hervorgerufenenȱ Problemeȱ werdenȱdurchȱmehrfacheȱMigrationȱnochȱverstärkt.ȱ

386ȱ

6.2ȱDynamischeȱLastverteilungȱ BeiȱNachrichtenweiterleitungȱwerdenȱdreiȱTypenȱunterschiedenȱ[Sȱ96]:ȱ x

Nachrichten,ȱ die,ȱ währendȱ derȱ Prozessȱ eingefrorenȱ ist,ȱ amȱ QuellȬ knotenȱeintreffen.ȱ

x

Nachrichten,ȱdieȱnachȱderȱWeiterführungȱaufȱdemȱZielknotenȱbeimȱ Quellknotenȱeintreffen.ȱ

x

Nachrichten,ȱdieȱnachȱderȱWeiterführungȱerstȱanȱdenȱProzessȱverȬ sendetȱwerden.ȱ

NachrichtenȬ weiterleitungȱ

EsȱgibtȱvierȱMethoden,ȱmitȱdenȱNachrichtenȱzuȱverfahrenȱ[Sȱ96]:ȱ x

RücksendungȱmitȱderȱMaßgabe,ȱesȱerneutȱzuȱprobieren,ȱwobeiȱderȱ SenderȱdenȱEmpfängerȱselbstständigȱausfindigȱmachenȱmuss.ȱDerȱ Vorteilȱist,ȱdassȱkeineȱZustandsinformationȱdesȱmigriertenȱProzesȬ sesȱaufȱdemȱQuellknotenȱzurückbleibt,ȱjedochȱistȱdieȱOrtstranspaȬ renzȱgegenüberȱdemȱSenderȱverletzt.ȱ

x

Weiterleitungȱ vomȱ Ursprungsknotenȱ aus:ȱ Derȱ Quellknotenȱ leitetȱ eintreffendeȱNachrichtenȱweiter,ȱwodurchȱderȱProzessȱvonȱdiesemȱ Knotenȱ abhängigȱ bleibt.ȱ Dasȱ Weiterleitenȱ verursachtȱ zusätzlicheȱ Last.ȱAußerdemȱsindȱspätereȱProzessorenȱverpflichtet,ȱdenȱOrtȱdesȱ ProzessesȱjeweilsȱdemȱUrsprungsknotenȱbekanntȱzuȱmachen.ȱȱ

x

Wiederholteȱ Weiterleitung:ȱ Nachrichtenȱ desȱ Typsȱ 1ȱ werdenȱ zumȱ Abschlussȱ desȱ Migrationsvorgangsȱ nochȱ hinterherȱ gesendet.ȱ SpäȬ tereȱ Nachrichtenȱ werdenȱ überȱ alleȱ eventuellȱ vomȱ Prozessȱ durchȬ laufenenȱ Knotenȱ weitergeleitet.ȱ Dadurchȱ hängtȱ derȱ Prozessȱ nachȱ mehrfacherȱMigrationȱsogarȱvonȱmehrerenȱKnotenȱabȱundȱauchȱdieȱ Lastȱwirdȱentsprechendȱerhöht.ȱ

x

Aktualisierungȱ vonȱ potentiellenȱ Sendern:ȱ Nachrichtenȱ desȱ Typsȱ 1ȱ undȱ2ȱwerdenȱhinterherȱgesendet.ȱWährendȱdesȱTransfersȱwerdenȱ alleȱ mitȱ demȱ zuȱ migrierendenȱ Prozessȱ inȱ Verbindungȱ stehendenȱ potentiellenȱSenderȱvonȱNachrichtenȱüberȱdenȱneuenȱOrtȱdesȱProȬ zessesȱ informiert.ȱ Damitȱ werdenȱ dieȱ Nachteileȱ derȱ anderenȱ MeȬ thodenȱweitgehendȱvermieden.ȱ

DieȱBehandlungȱvonȱKoprozessenȱkenntȱzweiȱgrundsätzlicheȱMöglichȬ keitenȱ[Sȱ96]:ȱ x

VerbotȱderȱTrennung:ȱAufȱdieȱBeendigungȱvonȱKindprozessenȱwirdȱ gewartet;ȱ Elternprozessȱ undȱ Kindprozesseȱ müssenȱ gemeinsamȱ migriertȱ werden.ȱ Dadurchȱ kannȱ Parallelisierungspotentialȱ nichtȱ genutztȱwerden.ȱ

Behandlungȱ vonȱ Koprozessenȱ

387ȱ

6ȱȱRechenlastverteilungȱ x

Kommunikationȱ überȱ denȱ Ursprungsknotenȱ erlaubtȱ dieȱ unabhänȬ gigeȱ Migration.ȱ Diesȱ hatȱ wiederȱ dieȱ bekanntenȱ Nachteileȱ derȱ erȬ höhtenȱLastȱundȱderȱgeringerenȱFehlertoleranz.ȱ

Aktivierungȱ

NachȱderȱkomplettenȱÜbertragungȱdesȱGesamtzustandsȱdesȱzuȱmigrieȬ rendenȱ Prozessesȱ aufȱ denȱ Zielknotenȱ erfolgtȱ dessenȱ Aktivierung,ȱ undȱ derȱalteȱProzessȱaufȱdemȱQuellknotenȱkannȱgelöschtȱwerden.ȱ

Migrationȱinȱ heterogenenȱ Systemenȱ

DieȱbeschriebenenȱProzedurenȱfunktionierenȱinȱhomogenenȱSystemen.ȱ Inȱ heterogenenȱ Systemenȱ mitȱ verschiedenenȱ Architekturen,ȱ LaufzeitȬ umgebungen,ȱBibliothekenȱundȱUtilitiesȱgestaltetȱsichȱeineȱProzessmigȬ rationȱ schwieriger.ȱ Datenformateȱ sindȱ inȱ derȱ Regelȱ anzupassen.ȱ Eineȱ ausführlicheȱDiskussionȱdiesesȱSachverhaltsȱsprengtȱdenȱRahmenȱdieȬ sesȱ Buches.ȱ [Sȱ 96]ȱ undȱ [TSȱ 06]ȱ bietenȱ beiȱ tiefergehendemȱ Interesseȱ eiȬ nenȱEinstiegȱinȱdieȱThematik.ȱ

CodeȬ migrationȱ

NachȱeinemȱModellȱvonȱFuggettaȱetȱal.ȱ[FPVȱ98]ȱwirdȱderȱAdressraumȱ einschließlichȱProzesszustandȱinȱdreiȱSegmenteȱunterteilt:ȱ x

Codesegment.ȱ

x

Ressourcensegmentȱ(Daten,ȱDrucker,ȱandereȱProzesse,ȱetc.).ȱ

x

Ausführungssegmentȱ(Zustand,ȱLaufzeitstapel,ȱetc.)ȱ

Dieȱ soȱ genannteȱ Codemigrationȱ wirdȱ unterschiedenȱ inȱ schwacheȱ undȱ starkeȱ Migrationȱ [TSȱ06].ȱBeiȱderȱ schwachenȱ Codemigrationȱ wirdȱ nurȱ dasȱCodesegmentȱtransferiert;ȱeinȱBeispielȱsindȱJavaȱApplets.ȱBeiȱstarȬ kerȱ Migrationȱ wirdȱ auchȱ dasȱ Ausführungssegmentȱ übertragen;ȱ sieȱ entsprichtȱderȱProzessmigration.ȱ Jobmigrationȱ

Gangȱ Schedulingȱ

388ȱ

Betrachtetȱ manȱ Jobsȱ inȱ einerȱ Form,ȱ inȱ derȱ sieȱ ausȱ einzelnenȱ Threadsȱ (oderȱ Prozessen)ȱ aufgebautȱ sind,ȱ dieȱ auchȱ parallelȱ laufenȱ undȱ miteinȬ anderȱ kommunizierenȱ können,ȱ dannȱ lassenȱ sichȱ verschiedeneȱ Stufenȱ derȱUnterbrechungȱunterscheidenȱ[FRSȱ97]:ȱ x

OhneȱMigration:ȱEinȱJobȱläuftȱvonȱAnfangȱbisȱEndeȱaufȱdenȱeinmalȱ zugewiesenenȱProzessoren.ȱ

x

LokaleȱUnterbrechung:ȱDieȱUnterbrechungȱvonȱThreadsȱwirdȱzwarȱ ermöglicht,ȱetwaȱausȱPrioritätsgründen,ȱsieȱwerdenȱaberȱaufȱdemȬ selbenȱProzessorȱspäterȱfortgeführt.ȱ

x

Migration:ȱ Einzelneȱ Threadsȱ könnenȱ vonȱ Prozessorȱ zuȱ Prozessorȱ migrierenȱ(entsprichtȱderȱobenȱbeschriebenenȱProzessmigration).ȱ

x

Gangȱ Scheduling:ȱ Beimȱ Gangȱ Schedulingȱ werdenȱ alleȱ Threadsȱ eiȬ nesȱ Jobsȱ simultanȱ behandelt.ȱ Sieȱ werdenȱ alsoȱ simultanȱ unterbroȬ

6.3ȱGridȱSchedulingȱ chenȱundȱwiederȱfortgeführt,ȱentwederȱohneȱMigrationȱaufȱdenselȬ benȱProzessorenȱoderȱmitȱMigrationȱvonȱProzessen.ȱZielȱistȱesȱbeimȱ Gangȱ Scheduling,ȱ parallelȱ laufende,ȱ kommunizierendeȱ Threadsȱ nichtȱ einzelnȱzuȱunterbrechen,ȱ damitȱ keineȱ Wartezeitenȱ entstehenȱ undȱjeȱnachȱProzessorȬȱoderȱSystemlastȱauchȱVerhungernȱ(starvatiȬ on)ȱauftretenȱkann.ȱ ZumȱAbschlussȱsollȱnunȱnochȱdieȱStabilitätȱvonȱdynamischenȱLastverȬ Stabilität,ȱ teilungsverfahrenȱ mitȱ Migrationȱ betrachtetȱ ȱ werden.ȱ Derȱ Begriffȱȱ Thrashingȱ Thrashingȱ[Wȱ99][Sȱ96]ȱkennzeichnetȱeinenȱSystemzustand,ȱbeiȱdemȱdieȱ Leistungȱsehrȱstarkȱabfällt,ȱweilȱderȱoderȱdieȱProzessorenȱnurȱmitȱunȬ sinnigenȱ Aufgabenȱ beschäftigtȱ sind,ȱ dieȱ sichȱ wechselseitigȱ bedingen.ȱ Esȱ trittȱ auf,ȱ wennȱ jederȱ Prozessorȱ unabhängigeȱ SchedulingȬ Entscheidungenȱ treffenȱ kann.ȱ Einȱ Beispielȱ istȱ eineȱ EinȬSchwellenȬ Transferstrategie,ȱ beiȱ derȱ einȱ überlasteterȱ Prozessorȱ einenȱ Prozessȱ anȱ einenȱ geringȱ belastetenȱ abgibt,ȱ sichȱ dadurchȱ dieȱ Lastverhältnisseȱ umȬ kehrenȱundȱderȱbetreffendeȱProzessȱpermanentȱhinȬȱundȱherȱgeschobenȱ wirdȱ[Wȱ99].ȱ Fernerȱ könnenȱ auchȱ einȱ oderȱ mehrereȱ Prozessorenȱ Lastȱ aufȱ einenȱ geȬ ringȱbelastetenȱKnotenȱauslagernȱundȱdamitȱeineȱKaskadeȱvonȱMigraȬ tionenȱ auslösen,ȱ dieȱ zwarȱ denȱ jeweilsȱ betroffenenȱ Knotenȱ entlasten,ȱ aberȱinsgesamtȱdasȱSystemȱnurȱnochȱmehrȱbelastenȱ[Sȱ96].ȱ GegenmaßnahmenȱsindȱzumȱBeispielȱdasȱSammelnȱvonȱInformationenȱ überȱ Migrationenȱ undȱ dasȱ Vermeidenȱ vonȱ Schleifenȱ aufgrundȱ dieserȱ Kenntnisseȱ überȱ dieȱ Vorgeschichteȱ [Sȱ 96].ȱ Instabilitätenȱ resultierenȱ nichtȱzuletztȱauchȱausȱdemȱDeterminismusȱderȱVerfahren,ȱetwaȱimmerȱ denȱamȱgeringstenȱbelastetenȱProzessorȱzurȱMigrationȱheranzuziehen.ȱ EinȱgewissesȱMaßȱvonȱZufallȱkannȱhierȱzumȱBeispielȱverhindern,ȱdassȱ mehrereȱProzessorenȱnahezuȱgleichzeitigȱdenselbenȱEmpfängerȱfürȱdasȱ AuslagernȱihrerȱLastȱwählen.ȱ MehrȱInformationenȱzuȱalgorithmischȱinduziertenȱInstabilitätenȱsindȱinȱ [CKȱ88]ȱzuȱfinden.ȱ

6.3 Grid Scheduling Derȱ wesentlicheȱ Unterschiedȱ einesȱ Gridsȱ zuȱ anderenȱ verteiltenȱ SysteȬ menȱliegtȱdarin,ȱdassȱdieȱGridressourcenȱüberȱbeliebigȱvieleȱadministȬ rativeȱ Domänenȱ verteiltȱ sind.ȱ Inȱ derȱ Bewältigungȱ dieserȱ zusätzlichenȱ SchwierigkeitȱliegtȱauchȱdieȱBesonderheitȱdesȱGridȱScheduling.ȱEinȱJobȱ imȱ Gridȱ Schedulingȱ istȱ jederȱ Vorgang,ȱderȱ Ressourcenȱ benötigt.ȱ Auchȱ derȱBegriffȱRessourceȱistȱimȱGridȱsehrȱweitȱgefasst.ȱEsȱkannȱsichȱdabeiȱ

Job,ȱ Ressourcenȱȱ Gridȱ Schedulingȱ

389ȱ

6ȱȱRechenlastverteilungȱ umȱallesȱhandeln,ȱwasȱeinȱJobȱfürȱseineȱAufgabeȱbenötigtȱundȱdasȱihmȱ überȱ einenȱ SchedulingȬProzessȱ zugeführtȱ werdenȱ kann.ȱ Natürlichȱ istȱ auchȱ hierȱ dieȱ Rechenleistungȱ derȱ Rechnerȱ imȱ Gridȱ derȱ amȱ meistenȱ interessierendeȱRessourcentypȱ[NSWȱ04,ȱKap.ȱ2].ȱ Dynamikȱinȱ Gridsystemenȱ

Einȱ weiteresȱ Merkmalȱ imȱ Gridȱ Computingȱ istȱ dieȱ hoheȱ Dynamikȱ inȱ Gridsystemen.ȱ Dieseȱ trittȱ zumȱ einenȱ beiȱ denȱ Anwendungenȱ auf,ȱ dieȱ unvorhersehbarȱ völligȱ unterschiedlicheȱ Charakteristikenȱ aufweisenȱ können.ȱ Zumȱ anderenȱ betrifftȱ esȱ dieȱ Ressourcen.ȱ Derȱ zurȱ Verfügungȱ stehendeȱ Poolȱ ändertȱ sichȱ häufigȱ inȱ seinerȱ Zusammensetzungȱ undȱ bezüglichȱderȱNutzungsbedingungen.ȱ

Koallokationȱ

KoallokationȱhatȱimȱGridȱComputingȱeineȱsehrȱgroßeȱBedeutung.ȱDaȬ beiȱ sindȱ fürȱ eineȱ Anwendungȱ mehrereȱ Ressourcenȱ verschiedenerȱ TyȬ penȱgleichzeitigȱerforderlichȱundȱsomitȱvomȱSchedulerȱauchȱzurȱselbenȱ Zeitȱeinzuplanenȱ[CFKȱ99].ȱ

Gridȱ InformationsȬ systemȱ

InȱderȱRegelȱwirdȱesȱinȱeinemȱGridȱsoȱsein,ȱdassȱinnerhalbȱeinerȱDomäȬ neȱlokaleȱSchedulerȱfürȱdieȱdortigenȱRechnerȱzuständigȱsind.ȱEinȱGridȱ Schedulerȱ besitztȱ dieȱ Ressourcenȱ nicht,ȱ erȱ hatȱ oftȱ auchȱ nichtȱ dieȱ KonȬ trolleȱ überȱ alleȱ Jobs.ȱ Erȱ agiertȱ imȱ Auftragȱ einesȱ bestimmtenȱ GridnutȬ zers.ȱSeineȱInformationenȱbeziehtȱeinȱGridȱSchedulerȱausȱeinemȱGridȬȱ Informationssystemȱ (GIS),ȱ zumȱ Beispielȱ dasȱ Globusȱ Monitoringȱ andȱ Discoveryȱ Systemȱ (MDS4)ȱ inȱ derȱ Gridȱ Middlewareȱ GlobusȬToolkitȱ 4ȱ [GTȱ07].ȱ Derȱ gesamteȱ Prozessȱ desȱ Gridȱ Schedulingȱ kannȱ inȱ dreiȱ Phasenȱ mitȱ jeweilsȱmehrerenȱEinzelschrittenȱunterteiltȱseinȱ[NSWȱ04,ȱKap.ȱ2]:ȱ

PhasenȱGridȱ Schedulingȱ

x

Phaseȱ1:ȱRessourcensuche.ȱ

x

Phaseȱ2:ȱSystemauswahl.ȱ

x

Phaseȱ3:ȱJobausführung.ȱ

RessourcenȬ sucheȱ

DieȱRessourcensucheȱermitteltȱeineȱMengeȱvonȱRessourcen,ȱdieȱinȱPhaȬ seȱ 2ȱ inȱ dieȱ engereȱ Wahlȱ kommen.ȱ Sieȱ müssenȱ bestimmteȱ minimaleȱ Anforderungenȱerfüllen.ȱPhaseȱ1ȱlässtȱsichȱinȱdreiȱEinzelschritteȱunterȬ teilen:ȱ

AutorisieȬ rungsfilterȱ

x

390ȱ

Autorisierungsfilter:ȱ Hierȱ werdenȱ dieselbenȱ Anforderungenȱ geȬ stelltȱwieȱinȱnormalenȱverteiltenȱSystemen.ȱDerȱNutzerȱmussȱautoȬ risiertȱsein,ȱaufȱdieȱRessourceȱzuzugreifen.ȱImȱGridȱistȱlediglichȱdieȱ AnzahlȱanȱRessourcenȱsehrȱvielȱgrößer,ȱsoȱdassȱesȱsinnvollȱist,ȱdieȱ RessourcenȱohneȱZugriffsrechtȱgleichȱzuȱBeginnȱherauszufiltern.ȱ

6.3ȱGridȱSchedulingȱ x

DefinitionȱderȱAnwendungsanforderungen:ȱDerȱNutzerȱspezifiziertȱ minimaleȱ Anforderungen,ȱ dieȱ derȱ Jobȱ anȱ dieȱ gewünschtenȱ ResȬ sourcenȱ stellt.ȱ Dieserȱ Schrittȱ deutetȱ aufȱ eineȱ interaktiveȱ VorgeȬ hensweiseȱ inȱ dieserȱ Phaseȱ desȱ Gridȱ Schedulingȱ hin,ȱ wieȱ sieȱ heuteȱ häufigȱ anzutreffenȱ ist.ȱ Eineȱ automatischeȱ Vorgehensweiseȱ würdeȱ diesenȱ Schrittȱ vorȱ dasȱ Schedulingȱ verlegen.ȱ Soȱ könnenȱ AnfordeȬ rungenȱ etwaȱinȱ einerȱWorkflowdefinitionȱ desȱ Jobsȱ hinterlegtȱ sein,ȱ dieȱdemȱGridȱSchedulerȱeingangsȱzuȱübergebenȱistȱ[HDȱ03][SQJȱ06].ȱ

Definitionȱ Anwendungs anforderunȬ genȱ

x

Filternȱ bezüglichȱ Anwendungsanforderungen:ȱ Dieȱ imȱ zweitenȱ SchrittȱangegebenenȱoderȱdenȱJobsȱbereitsȱmitgegebenenȱAnfordeȬ rungenȱ schränkenȱ dieȱ Mengeȱ derȱ bislangȱ inȱ Frageȱ kommendenȱ Ressourcenȱweiterȱein.ȱ

Filternȱ Anwendungs anforderunȬ genȱ

Anforderungenȱ derȱ Anwendungȱ kannȱ sichȱ aufȱ bestimmteȱ BetriebssysȬ temeȱ undȱ CPUs,ȱ Speicherplatz,ȱ Laufzeitumgebungen,ȱ dasȱ Netzwerkȱ undȱ Datenzugriffsmöglichkeitenȱ beziehen.ȱSieȱ könnenȱ auchȱVorgabenȱ bezüglichȱAntwortzeitenȱoderȱKostenȱmachen.ȱ Bisȱ zuȱ diesemȱ Punktȱ wirdȱ Vorwissenȱ ausȱ demȱ Jobȱ benutzt,ȱ umȱ eineȱ Ressourcenvorauswahlȱ zuȱ treffen.ȱ Dieȱ nächsteȱ Phaseȱ istȱ derȱ SystemȬ auswahl,ȱ derȱ endgültigenȱ Auswahlȱ einesȱ Rechnersystemsȱ (oderȱ auchȱ vonȱ Einzelrechnern)ȱ gewidmet.ȱ Ohneȱ Zugriffȱ aufȱ einzelneȱ Knotenȱ mussȱnachȱderȱAuswahlȱdesȱSystemsȱeinȱlokalerȱSchedulerȱdieȱweitereȱ Verteilungȱ übernehmen.ȱ Hierȱ sindȱ zweiȱ Einzelschritteȱ zuȱ unterscheiȬ den:ȱ x

DynamischeȱInformationsbeschaffungȱüberȱeinȱGISȱoderȱauchȱüberȱ lokaleȱScheduler.ȱBestimmteȱNutzungsbedingungenȱsindȱzuȱbeachȬ ten.ȱ

Dynamischeȱ InformationsȬ beschaffungȱ

x

Systemauswahl:ȱ Anȱ diesemȱ Punktȱ erfolgtȱ dannȱ dieȱ dynamischeȱ Lastverteilungȱ imȱ Grid,ȱ jedenfallsȱ soweitȱ derȱ Gridȱ Schedulerȱ aufȬ grundȱseinerȱBerechtigungenȱdazuȱinȱderȱLageȱist.ȱHierȱistȱauchȱdieȱ Gelegenheit,ȱ insbesondereȱ beiȱ derȱ Verteilungȱ vonȱ mehrerenȱ Jobsȱ gleichzeitig,ȱ dieȱ Lastverteilungȱ zuȱ optimieren.ȱ Inȱ Gridsȱ istȱ eineȱ multikriterielleȱOptimierungȱangebracht,ȱdaȱverschiedeneȱBeteiligȬ teȱverschiedeneȱSchwerpunkteȱsetzen.ȱEinȱBeispielȱfürȱeinȱLastverȬ teilungssystemȱistȱCondorȱ(s.ȱa.ȱ6.2.1),ȱdasȱsichȱinzwischenȱauchȱalsȱ GridsystemȱetabliertȱhatȱundȱdessenȱMatchmakingȬTechnikȱanȱdieȬ serȱStelleȱzumȱEinsatzȱkommt.ȱ

SystemȬ auswahlȱ

FürȱdieȱPhaseȱ3,ȱdieȱJobausführung,ȱsollȱhierȱnurȱeinȱkurzerȱÜberblickȱ gegebenȱwerden,ȱdaȱsieȱmitȱderȱLastverteilungȱnurȱinsofernȱzuȱtunȱhat,ȱ alsȱ dieȱ Ergebnisseȱ desȱ Gridȱ Schedulingȱ inȱ dieserȱ Phaseȱ umzusetzenȱ

JobausfühȬ rungȱ

391ȱ

6ȱȱRechenlastverteilungȱ sind.ȱSieȱistȱunterteiltȱinȱeinenȱoptionalenȱSchrittȱderȱReservierungȱvonȱ Ressourcen.ȱ Dieȱ nächstenȱ Schritteȱ sindȱ dieȱ Jobübergabe,ȱ einȱ VorbereiȬ tungsschritt,ȱ zumȱ Beispielȱ zumȱ Transferȱ benötigterȱ Daten,ȱ dieȱ JobȬ überwachungȱ zurȱ Laufzeit,ȱ umȱ Fortschritteȱ meldenȱ zuȱ können,ȱ dieȱ BeendigungȱderȱJobsȱundȱAufräumarbeiten.ȱ Performanceȱ GridȬ anwendungȱ

Dieȱ Qualitätȱ derȱ Ressourcenzuteilungȱ kannȱ verbessertȱ werden,ȱ wennȱ Voraussagenȱ überȱ dieȱ zuȱ erwartendeȱ Performanceȱ einerȱ GridanwenȬ dungȱ gemachtȱ werdenȱ könnenȱ [NWSȱ 04,ȱ Kap.ȱ 3].ȱ Esȱ sindȱ dreiȱ MethoȬ denȱverfügbar:ȱ x

Dieȱ Theoretischeȱ Vorhersageȱ hängtȱ vonȱ derȱ Kenntnisȱ derȱ AnwenȬ dungȱundȱihrerȱBerechnungsmodelleȱab.ȱ

x

Vorhersagenȱ ausȱ derȱ Vorgeschichteȱ hängenȱ davonȱ ab,ȱ wieȱ oftȱ dieȱ AnwendungȱunterȱdenselbenȱVoraussetzungenȱausgeführtȱwird.ȱ

x

AlsȱweitereȱMöglichkeitȱbleibenȱdieȱVorhersagenȱausȱTestläufen.ȱ

Performanceȱ GridȬ ressourcenȱ

Dieȱ Bereitstellungȱ vonȱ dynamischenȱ Informationenȱ zurȱ Performanceȱ vonȱ Gridressourcen,ȱ wieȱ CPUȬAuslastungenȱ undȱ Datendurchsatzȱ imȱ Netzwerk,ȱ istȱ fürȱ dasȱ Gridȱ Schedulingȱ ebensoȱ notwendigȱ wieȱ dieȱ KenntnisȱvonȱstatischenȱInformationen,ȱdieȱsichȱwährendȱeinerȱnormaȬ lenȱ Programmlaufzeitȱ nichtȱ ändern,ȱ wieȱ zumȱ Beispielȱ CPUȬ Taktfrequenzen.ȱȱ

PerformanceȬ vorhersageȱ

Systeme,ȱdieȱPerformanceȬDatenȱliefern,ȱstellenȱdreiȱBasisfunktionalitäȬ tenȱzurȱVerfügungȱ[NWSȱ04,ȱKap.ȱ14]:ȱ

Networkȱ Weatherȱ Serviceȱ

x

Monitoring:ȱSammlungȱundȱVerwaltungȱvonȱPerformanceȬDaten.ȱ

x

Vorhersage:ȱ Berechnungȱ vonȱ Vorhersagewertenȱ derȱ zukünftigenȱ Performance.ȱ

x

Bereitstellungȱ derȱ Datenȱ inȱ verschiedenenȱ Formatenȱ fürȱ verschieȬ deneȱScheduler.ȱ

DerȱNetworkȱWeatherȱServiceȱ(NWS)ȱ[WSHȱ99]ȱistȱeinȱsolchesȱPerforȬ manceȬVorhersagesystem,ȱdasȱmitȱverschiedenenȱGridȬInfrastrukturenȱ kompatibelȱ ist.ȱ Dieȱ MonitoringȬDatenȱ undȱ damitȱ dieȱ Vorgeschichteȱ sindȱdieȱGrundlageȱfürȱdieȱVorhersagen.ȱ Nebenȱ demȱ erwähntenȱ CondorȬSystemȱ sindȱ weitereȱ SchedulingsysteȬ meȱimȱEinsatz:ȱ

LSF®ȱ

392ȱ

x

LSF®ȱ [LSFȱ 07]:ȱ Dasȱ kommerzielleȱ Produktȱ Platformȱ LSF®ȱ (Loadȱ SharingȱFacility)ȱkommtȱalsȱlokalesȱSchedulingsystemȱzumȱEinsatzȱ

6.3ȱGridȱSchedulingȱ (lowerȬlevel)ȱ undȱ wirdȱ vonȱ globalenȱ Gridȱ Schedulernȱ angesproȬ chenȱ(higherȬlevel)ȱ[NWSȱ04,ȱKap.ȱ12].ȱ x

PBSȱ[Pȱ07]:ȱDasȱPortableȱBatchȱSystem,ȱdasȱalsȱOpenPBSȱverfügbarȱ istȱ undȱ inȱ einerȱ kommerziellenȱ Versionȱ PBSȱ Professional®,ȱ gehörtȱ alsȱQueuingȬSystemȱebenfallsȱzuȱdenȱlowerȬlevelȱSchedulern.ȱ

PBSȱ

x

Mauiȱ [CRMȱ 07]ȱ istȱ einȱ OpenȬSourceȬScheduler,ȱ derȱ mitȱ verschieȬ denenȱ Ressourcenverwaltungssystemenȱ zusammenarbeitenȱ kann;ȱ erȱ erweitertȱ dabeiȱ derenȱ Möglichkeiten,ȱ etwaȱ imȱ PrioritätsmanaȬ gementȱoderȱzurȱOptimierungȱderȱSchedules.ȱ

Mauiȱ

x

Silverȱ[CRSȱ07]ȱ(kommerziellerȱProduktname:ȱMoabȱGridȱScheduȬ ler®)ȱ istȱ einȱ Gridȱ Scheduler,ȱ derȱ aufȱ Mauiȱ aufbaut.ȱ Alsȱ MetaȬ Schedulerȱ erlaubtȱ erȱ dieȱ Zusammenarbeitȱ mitȱ mehrerenȱ verteiltenȱ RessourcenverwaltungenȱinȱGrids.ȱȱ

Silverȱ

Dieȱ genanntenȱ Systemeȱ sindȱ Jobȱ Scheduler,ȱ dasȱ sindȱ Scheduler,ȱ dieȱ überȱ Domänengrenzenȱ hinwegȱ dieȱ ankommendenȱ Anwendungenȱ bedienen.ȱSieȱfindenȱauchȱinȱherkömmlichenȱverteiltenȱSystemenȱVerȬ wendung.ȱ Demgegenüberȱ gehörenȱ ApplicationȬLevelȱ Schedulerȱ zuȱ denȱ jeweiligenȱ Anwendungen,ȱ dieȱ ihreȱ eigenenȱ SchedulingȬ Entscheidungenȱtreffenȱ[NWSȱ04,ȱKap.ȱ18].ȱEinȱBeispielȱistȱ

JobȱSchedulerȱ undȱ ApplicationȬ Levelȱ Schedulerȱ

x

AppLeSȱ

AppLeS:ȱDerȱApplicationȱLevelȱSchedulerȱermöglichtȱsoȱgenanntesȱ adaptivesȱSchedulingȱfürȱGridanwendungen.ȱJederȱAnwendungȱistȱ einȱ Agentȱ zugeordnet,ȱ derȱ dieȱ SchedulingȬAufgabeȱ übernimmt.ȱ [BWCȱ03].ȱ

Nachfolgendeȱ Abbildungȱ 6Ȭ13ȱ zeigtȱ schematischȱ dieȱ Arbeitsweiseȱ derȱ beidenȱTypenȱ(analogȱzuȱ[NWSȱ04,ȱKap.ȱ18]).ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

393ȱ

6ȱȱRechenlastverteilungȱ Abb.ȱ6Ȭ13:ȱȱ JobȱSchedulerȱ undȱ ApplicationȬ Levelȱ Schedulerȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

Gridȱ ȱ SchedulingȬȱ Algorithmenȱ

394ȱ

Dieȱ Einteilungȱ vonȱ Gridȱ SchedulingȬAlgorithmenȱ inȱ verschiedeneȱ KaȬ tegorienȱunterscheidetȱsichȱpraktischȱnichtȱvonȱderȱEinteilungȱinȱandeȬ renȱ verteiltenȱ Systemen.ȱ Eineȱ Taxonomieȱ inȱ [DAȱ 06]ȱ gibtȱ einenȱ gutenȱ ÜberblickȱüberȱverschiedeneȱKategorienȱundȱauchȱInformationenȱundȱ Referenzenȱ zuȱ einerȱ Vielzahlȱ vonȱ Algorithmenȱ undȱ Verfahren.ȱ TaxoȬ nomien,ȱdieȱverschiedeneȱAspekteȱdesȱGridȱSchedulingȱbetreffen,ȱundȱ Beschreibungenȱ vonȱ Algorithmenȱ findenȱ sichȱ auchȱ inȱ [NSWȱ 04]ȱ undȱ [Wȱ07].ȱBesondereȱBedeutungȱgewinnenȱimȱGridȱSchedulingȱauchȱökoȬ nomischeȱ Modelleȱ (s.a.ȱ 6.2.1).ȱ Eineȱ weitergehendeȱ Darstellungȱ dieserȱ AnsätzeȱistȱimȱRahmenȱdiesesȱWerkesȱnichtȱmöglich.ȱZumȱEinstiegȱinȱ dieȱThematikȱseiȱaufȱ[Bȱ02]ȱundȱ[FSYȱ06]ȱverwiesen.ȱ

7 Virtualisierungstechniken Virtualisierungȱ istȱ eineȱ Herangehensweiseȱ inȱ derȱ InformationstechnoȬ logie,ȱ dieȱ Ressourcenȱ soȱ inȱ einerȱ logischenȱ Sichtȱ zusammenfasst,ȱ dassȱ ihreȱ Auslastungȱ optimiertȱ wirdȱ undȱ sieȱ Anforderungenȱ automatischȱ zurȱVerfügungȱstehen.ȱDerȱLösungsansatzȱbestehtȱinȱderȱVerknüpfungȱ vonȱServern,ȱSpeichernȱundȱNetzenȱzuȱeinemȱvirtuellenȱGesamtsystem,ȱ ausȱ welchemȱ dieȱ Anwendungenȱ direktȱ undȱ bedarfsgerechtȱ ihreȱ ResȬ sourcenȱbeziehen.ȱ Manȱmussȱunterscheidenȱzwischenȱderȱ x

Virtualisierungȱ vonȱ Hardware,ȱ dieȱ sichȱ mitȱ derȱ Verwaltungȱ vonȱ HardwareȬRessourcen,ȱbeschäftigt,ȱundȱdieȱȱ

x

Virtualisierungȱ vonȱ Software,ȱ dieȱ sichȱ mitȱ derȱ Verwaltungȱ vonȱ SoftwareȬRessourcen,ȱ wieȱ z.B.ȱ Anwendungenȱ undȱ BetriebssysteȬ menȱbeschäftigt.ȱȱ

EineȱVirtualisierungȱbietetȱvielfältigeȱVorteile:ȱ x

x

x

x

Serverkonsolidierungȱ bedeutetȱ Zusammenlegenȱ vielerȱ virtuellerȱ Serverȱ aufȱ möglichstȱ wenigenȱ physikalischenȱ Servern.ȱ Zurȱ optiȬ malenȱ Ausnutzungȱ derȱ vorhandenenȱ HardwareȬRessourcenȱ könȬ nenȱaufȱdenȱphysikalischenȱHostsȱvirtuelleȱServerȱmitȱaufeinanderȱ abgestimmtenȱ Leistungsmerkmalenȱ sowieȱ zueinanderȱ passendenȱ Lastprofilenȱ zusammengelegtȱ werden.ȱ Darausȱ ergibtȱ sichȱ nichtȱ nurȱ eineȱ Kostensenkungȱ beiȱ derȱ Hardware,ȱ sondernȱ dieȱ KonsoliȬ dierungȱ führtȱ auchȱ imȱ laufendenȱ Betriebȱ zuȱ einemȱ niedrigerenȱ StromverbrauchȱundȱwenigerȱKlimatisierungaufwand.ȱȱ VereinfachteȱAdministration,ȱdieȱZahlȱderȱphysischenȱServerȱverȬ ringertȱ sich.ȱ Beiȱ denȱ virtuellenȱ Servernȱ könnenȱ sehrȱ ausgereifteȱ Managementwerkzeugeȱ eingesetztȱ werden:ȱ Dieȱ Erstellungȱ undȱ Anpassungȱ derȱ einzelnenȱ virtuellenȱ Serverȱ istȱ durchȱ Templatesȱ oderȱInstallationsvorlagenȱleichtȱautomatisierbar.ȱȱ VereinfachteȱBereitstellung:ȱVerringernȱderȱZeitȱfürȱdieȱBereitstelȬ lungȱ einerȱ neuenȱ Infrastrukturȱ wieȱ z.B.ȱ einesȱ Serversȱ innerhalbȱ vonȱMinutenȱmitȱhervorragendenȱAutomatisierungsfunktionen.ȱ Hoheȱ Verfügbarkeitȱ derȱ Systemeȱ undȱ Servicesȱ istȱ gewährleistetȱ durchȱ Migrationsfähigkeitȱ derȱ Systemeȱ undȱ Servicesȱ undȱ durchȱ

Vorteileȱderȱ VirtualisieȬ rungȱ

395ȱ

7ȱȱVirtualisierungstechnikenȱ

x

x

x

x

einfachesȱ Duplizierenȱ oderȱ Klonenȱ derȱ virtuellenȱ Maschinen.ȱ DurchȱReplikationȱderȱphysikalischenȱRessourcenȱistȱeinȱpraktischȱ unterbrechungsfreierȱ Betriebȱ beiȱ Datensicherung,ȱ HardwareȬ UpgradesȱundȱAusfällenȱmöglich.ȱ ServiceȬLevels:ȱVirtualisierungȱbietetȱneueȱMöglichkeitenȱzurȱVerȬ einbarungȱvonȱgarantiertenȱRessourceȬZuwendungenȱanȱApplikaȬ tionen.ȱDasȱLastverhaltenȱvonȱAnwendungenȱkannȱdamitȱsehrȱgeȬ nauȱüberwachtȱundȱeingestelltȱwerden.ȱ OptimierungȱvonȱSoftwareȬTestsȱundȱSoftwareȬEntwicklung:ȱUnȬ terschiedlicheȱ Testumgebungen,ȱ unterschiedlicheȱ Betriebssystemeȱ undȱ Versionenȱ oderȱ unterschiedlicheȱ Setupsȱ undȱ Umgebungenȱ sindȱohneȱzusätzlicheȱHardwareȱschnellȱaufzusetzen.ȱ UnterstützungȱvonȱaltenȱAnwendungen:ȱMigrierenȱvonȱsog.ȱLegaȬ cyȬBetriebssystemenȱundȱLegacyȬAnwendungen,ȱdieȱaufȱneuerȱakȬ tuellerȱHardwareȱnichtȱmehrȱlaufenȱwürdenȱ(z.B.ȱWindowsȱNT4).ȱ Höhereȱ Sicherheit:ȱ Einrichtungȱ einerȱ eigensȱ hochȱ abgesichertenȱ undȱ isoliertenȱ virtuellenȱ Installationȱ fürȱ InternetȬDiensteȱ oderȱ WebȬBrowser.ȱ Auchȱ unternehmenskritischeȱ Anwendungenȱ könȬ nenȱinȱeinerȱvirtuellenȱMaschineȱgekapseltȱwerdenȱundȱinȱeinerȱsiȬ cherenȱUmgebungȱablaufen.ȱȱ

DieȱverschiedenenȱTechnikenȱderȱVirtualisierungȱsind:ȱȱ 1.ȱ Betriebssystemvirtualisierung,ȱ welcheȱ dieȱ Ausführungȱ mehrererȱ BetriebssystemeȱaufȱeinemȱRechnerȱerlaubt.ȱȱ 2.ȱ Javaȱ Virtuelleȱ Maschineȱ (JVM),ȱ welcheȱ dieȱ Ausführungȱ vonȱ ProȬ grammenȱaufȱjedemȱBetriebssystemȱermöglicht.ȱ 3.ȱ Softwarevirtualisierung,ȱ welcheȱ dieȱ lokaleȱ Ausführungȱ vonȱ ProȬ grammenȱohneȱvorherigeȱInstallationȱerlaubt.ȱ 4.ȱ Hardwarevirtualisierung,ȱ welcheȱ dieȱ Verwaltungȱ vonȱ heterogenenȱ HardwareȬRessourcenȱinȱsog.ȱRessourceȬPoolsȱermöglicht.ȱ

7.1 Betriebssystemvirtualisierung DerȱVMMȱ oderȱ Hypervisorȱ steuertȱ Virtuelleȱ Maschinenȱ

396ȱ

Dieȱ Virtualisierungȱ vonȱ Betriebssystemenȱ erlaubtȱ dieȱ Ausführungȱ mehrererȱ Betriebssysteminstanzenȱ aufȱ einemȱ Rechner.ȱ Dasȱ GastȬ Systemȱ istȱ hierbeiȱ stetsȱ fürȱ dieȱ gleicheȱ CPUȬArchitekturȱ ausgelegtȱ (sonstȱ sprichtȱ manȱ vonȱ Emulation).ȱ Dasȱ Konzeptȱ derȱ BetriebssystemȬ virtualisierungȱistȱnichtȱneu:ȱEsȱreichtȱzurückȱinȱdieȱ60erȱJahreȱdesȱverȬ gangenenȱJahrhundertsȱundȱstammtȱausȱdemȱUmfeldȱderȱGroßrechner.ȱ Dortȱstelltȱderȱsog.ȱVirtuelleȱMaschinenȬMonitorȱ(VMM)ȱoderȱHyperviȬ

7.1ȱBetriebssystemvirtualisierungȱ sorȱjedemȱBenutzerȱeinenȱspezifischenȱAnteilȱanȱRessourcenȱalsȱKopieȱ derȱ unterliegendenȱ Hardwareȱ inȱ Formȱ einerȱ virtuellenȱ Maschineȱ zurȱ Verfügungȱ(Abb.ȱ7Ȭ1).ȱ

ȱ ȱ

Abb.ȱ7Ȭ1:ȱ BetriebsȬ systemvirtuaȬ lisierungȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ EsȱentstehtȱsoȱdieȱIllusion,ȱjederȱBenutzerȱbesitzeȱeinenȱeigenenȱpersönȬ lichenȱ Rechnerȱ mitȱ allenȱ Ein/AusgabeȬOperationen,ȱ Interruptsȱ undȱ Betriebsmodiȱ desȱ realenȱ Rechners.ȱ Durchȱ dieseȱ Technikȱ könnenȱ verȬ schiedeneȱ Gastbetriebssystemeȱ konkurrentȱ aufȱ einemȱ einzigenȱ physiȬ schenȱGroßrechnerȱlaufen.ȱ Dasȱ ersteȱ undȱ bekanntesteȱ kommerziellȱ eingesetzteȱ Betriebssystemȱ inȱ diesemȱ Umfeldȱ warȱ VM/370ȱ vonȱ IBM,ȱ dasȱ aufȱ Großrechnernȱ alsȱ TräȬ gersystemȱfürȱeineȱVielzahlȱvonȱBetriebssystemenȱdienenȱkannȱwieȱz.B.ȱ MVSȱoderȱAIX.ȱAuchȱderȱBetriebȱvonȱDialogsystemenȱwieȱConversatiȬ onalȱ Monitorȱ Systemȱ (CMS)ȱ istȱ möglich.ȱ Dieȱ aktuelleȱ Versionȱ z/VMȱ unterstütztȱauchȱLinuxȬInstanzen.ȱ DasȱControlȱProgramȱ(CP)ȱȱsorgtȱfürȱdieȱPartitionierungȱundȱZuteilungȱ vonȱ HardwareȬRessourcenȱ wieȱ Prozessorleistungȱ undȱ Datenspeicherȱ entsprechendȱ derȱ Anforderungenȱ derȱ Anwendungenȱ [IBMȱ 72].Alsȱ Folgeȱ derȱ enormenȱ Leistungssteigerungȱ derȱ Mikroprozessorenȱ gibtȱ esȱ dieȱ Virtualisierungȱ inzwischenȱ nichtȱ nurȱ aufȱ leistungsstarkenȱ GroßȬ rechnern,ȱsondernȱauchȱimȱMikroprozessorȬBereichȱ[Iȱ06,ȱAMDȱ06].ȱ ȱ

397ȱ

7 Virtualisierungstechniken Mögliche Virtualisierungskonzepte bei Betriebssystemen sind: x

Vollvirtualisierung bildet einen kompletten Rechner inklusive BIOS nach und unterstützt mehrere unterschiedliche unmodifizierte Betriebssysteme nebeneinander.

x

Containervirtualisierung erlaubt die mehrfache Ausführung desselben Betriebssystems auf einem Rechner.

x

Paravirtualisierung virtualisiert Teilaspekte und kann entsprechend angepasste Betriebssysteme sehr performant unterstützen.

7.1.1 Vollvirtualisierung Bereitstellung eines kompletten virtuellen Computers

Abb. 7-2: Vollvirtualisierung

Bei der Vollvirtualisierung stellt das Gastbetriebssystem der virtuellen Maschine im Idealfall alle Bereiche der physischen Hardware in Form von virtueller Hardware über spezielle Gerätetreiber zur Verfügung. Dadurch kann ein unverändertes Gastbetriebssystem in einer isolierten Umgebung ausgeführt werden. Wie Abbildung 7-2 zeigt, sorgt der Hypervisor dabei für eine bedarfsgerechte Zuteilung der Ressourcen:

Anwendungen

Anwendungen

GastBetriebsystem 1

GastBetriebsystem n

...

Virtuelle Treiber Hypervisor

CPU

Disk

Netze

Als Beispiele für die Vollvirtualisierung sollen die Produkte der Firma VMware dienen [L 07]. VMware Workstation ist für den Einsatz unter einem DesktopBestriebssystem konzipiert. Es kann damit unter den Wirtsbetriebssys-

398

7.1 Betriebssystemvirtualisierung temen Linux und Windows ein kompletter x86-PC bzw. x86-64-PC virtualisiert werden. Auf diesen virtuellen Systemen können die meisten x86 Betriebssysteme installiert und betrieben werden, wobei den virtuellen Maschinen Ressourcen des Hostsystems zur Verfügung stehen [VMP 07]. Für den Einsatz im Serverbereich wird VMware Server kostenfrei angeboten. Das Produkt unterscheidet sich von der Workstation-Version durch zusätzliche Leistungsmerkmale und bessere Managementfähigkeiten [VMS 07]. Der VMware ESX Server basiert auf einem VMware-eigenen Betriebssystemkernel und benötigt daher kein Wirtsbetriebssystem. Dadurch ist prinzipiell eine höhere Performanz, Skalierbarkeit und Sicherheit möglich, da das Produkt speziell auf den Einsatzzweck als Virtualisierungsserver optimiert ist.

Hochverfügbarkeit und Lastausgleich Die darauf aufbauende VMware Infrastructure erweitert den ESX Server um eine Hochverfügbarkeitslösung für Cluster und um automatischen dynamischen Lastausgleich (Load-Balancing). Das Verschieben von virtuellen Maschinen im laufenden Betrieb ermöglicht das zusätzliche Paket VMotion. Dies führt zu einer ausfallsicheren Plattform, die in ihren Managementfähigkeiten nahezu den Möglichkeiten eines Großrechners entspricht. So ist es möglich, Wartungsarbeiten wie z.B. Firmware-Upgrades oder Speichererweiterungen der Hosts ohne Betriebsunterbrechung durchzuführen [VMV 07]. Die neueste Entwicklung zielt darauf ab, den 32 MB großen Kernel des ESX-Servers direkt in das BIOS der physischen Server zu integrieren, so dass die Virtualisierungsplattform ohne weitere Softwareinstallation direkt nach dem Einschalten des Servers zur Verfügung steht.

Managementfähigkeiten Die Verwaltungssoftware VirtualCenter ermöglicht die zentrale Administration mehrerer VMware-Server und ESX-Server und deren virtueller Maschinen, inklusive zentraler Leistungsüberwachung und Steuerung. VirtualCenter besteht aus einer Serverkomponente mit Datenbank, den Software-Agenten auf jedem zu überwachenden Host, sowie einer oder mehreren Konsolen. Die Agenten überwachen den Zustand der Systeme und steuern die Ressourcenzuteilung. Die Kommunikation zwischen Konsole, Server und Agenten erfolgt über Web Services, das Informationsmodell orientiert sich dabei am weit verbreiteten Industriestandard Common Information Model [DMTF 07].

399

7 Virtualisierungstechniken

7.1.2 Containervirtualisierung Abb. 7-3: Containervirtualisierung

Anwendungen Container 1

Anwendungen

...

Container n

Basisbetriebssystem Hypervisor

CPU Container virtualisieren Teile eines Basisbetriebssystems

Disk

Netze

Virtualisierung durch Container stellt Anwendungen virtuell eine komplette Laufzeitumgebung innerhalb eines geschlossenen isolierten Bereichs zur Verfügung. Dadurch ist die mehrfache Nutzung eines einzelnen Betriebssystems möglich. Der Hypervisor startet auf dem Rechner kein zusätzliches, komplettes Betriebssystem, sondern die Container bilden lediglich aktuell in der Anwendung benötigte Teilfunktionalitäten des Wirtbetriebssystems ab, wie Bild 7-3 veranschaulicht: Der Vorteil dieses Vorgehens liegt in der guten Integration der Container an das Gastbetriebssystem. Der Nachteil dieses Konzepts besteht darin, dass die Containervirtualisierug ausschließlich die Plattform des Wirts unterstützt und man aus den Containern heraus keine Treiber laden kann. Beispiele für die Containervirtualisierung sind Produkte wie OpenSolaris [S 07], FreeBSD Jails [KW 07], Linux Vserver [Li 07] und Virtuozzo [P 08].

7.1.3 Paravirtualisierung Einrichten einer abstrakten Verwaltungsschicht

400

Die Paravirtualisierung startet auf einem Basisbetriebssystem zusätzliche Betriebssysteme virtuell neu, ohne jedoch Hardware zu virtualisieren oder zu emulieren. Die virtuell gestarteten Betriebssysteme verwenden eine abstrakte Verwaltungsschicht, um auf gemeinsame Ressourcen wie Netzanbindung, Festplattenspeicher, Benutzerein/ausgaben zuzugreifen, ohne dass spezielle Treiber zum Einsatz kommen (Abb. 7-4). In der Regel ist dazu aber eine Anpassung des Gastsys-

7.2 Virtuelle Maschine tems nötig. Ein Beispiel für die Paravirtualisierung ist der Xen Hypervisor [RM 06]. Der Vorteil der Paravirtualisierung ist die sehr effiziente Ressourcennutzung: Die virtuellen Systeme laufen nahezu ebenso performant wie die physischen Systeme.

Anwendungen Container 1

Anwendungen

...

Abb. 7-4: Paravirtualisierung

Container n

Modifiziertes Betriebssystem Hypervisor

CPU

Disk

Netze

7.2 Virtuelle Maschine Virtuelle Maschinen zur Interpretation des von einem Compiler erzeugten Zwischencodes gibt es in zwei Ausprägungen oder Ansätzen: 1. Java Virtuelle Maschine (JVM) und 2. das .NET-Framework mit der Laufzeitumgebung der Common Language Runtime (CLR).

7.2.1 Java Virtuelle Maschine (JVM) Die Philosophie von Sun und Java ist, dass damit geschriebene Programme sofort auf allen Plattformen lauffähig sein sollen und auch immer dieselben Ergebnisse liefern. Die Java Virtuelle Maschine (JVM) emuliert zu diesem Zweck einen idealisierten Rechner, der auf jeder Plattform gleich funktioniert. Ein Java-Compiler übersetzt die JavaProgramme zunächst in einen Bytecode, den die JVM anschließend auf den Zielplattformen interpretiert [C 06]. Die Bestandteile der JVM sind x

Klassenlader (classloader),

x

Konsistenzprüfer (verifier),

Java ermöglicht die Programmierung plattformunabhängiger Anwendungen

401

7ȱȱVirtualisierungstechnikenȱ x

Ausführungseinheitȱ(executionȱengine)ȱzurȱInterpretationȱdesȱByteȬ codes,ȱ

x

Speicherverwaltungȱ undȱ automatischeȱ Speicherbereinigungȱ (garȬ bageȱcollection).ȱ

DerȱKlassenladerȱkannȱBytecodeȱlokalȱoderȱüberȱeineȱNetzverbindungȱ laden,ȱwobeiȱerȱnachȱeinerȱKonsistenzprüfungȱdasȱauszuführendeȱProȬ grammȱ anȱ dieȱ Ausführungseinheitȱ übergibt.ȱ Dieȱ JavaȬLaufzeitumgebȬ ungȱstütztȱsichȱdabeiȱaufȱumfangreicheȱJavaȬKlassenbibliotheken.ȱ JavaȱbietetȱdieȱMöglichkeit,ȱAnwendungenȱzuȱentwickeln,ȱdieȱinȱunterȬ schiedlichenȱ verteiltenȱ Ausführungsumgebungenȱ ablaufenȱ können.ȱ Nebenȱ herkömmlichenȱ Applikationenȱ gibtȱ esȱ auchȱ dieȱ Möglichkeit,ȱ überȱeinenȱWebȬServerȱaufȱeinerȱfernenȱMaschineȱsog.ȱAppletsȱinȱWebȬ Browsernȱ auszuführen,ȱ wieȱ esȱ dasȱ Bildȱ 7Ȭ5ȱ veranschaulicht.ȱ Dasȱ SiȬ cherheitskonzeptȱvonȱJavaȱgewährleistetȱdabei,ȱdassȱunbekannteȱKomȬ ponentenȱkeinenȱSchadenȱanrichtenȱkönnen:ȱEineȱsog.ȱSandboxȱkapseltȱ alleȱOperationen.ȱ ȱ Abb.ȱ7Ȭ5:ȱ Ausführungȱ einesȱJavaȬ Appletȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

402ȱ

7.3ȱSoftwarevirtualisierungȱ

7.2.2 Common Language Runtime (CLR) DieȱPhilosophieȱvonȱMicrosoftȱmitȱdemȱ.NETȱFrameworkȱist,ȱdassȱProȬ gramme,ȱ dieȱ inȱ unterschiedlichenȱ Programmiersprachenȱ geschriebenȱ sind,ȱ aufȱ allenȱ Rechnernȱ mitȱ derȱ .NETȬPlattformȱ durchȱ dieȱ Commonȱ LanguageȱRuntimeȱ(CLR)ȱlauffähigȱsindȱ(sieheȱauchȱAbschnittȱ3.4.5.8.2)ȱ DieȱCLRȱrealisiertȱeineȱvirtuelleȱMaschine,ȱdieȱeineȱausreichendeȱAbsȬ traktionȱ vonȱ derȱ konkretenȱ Basismaschineȱ garantiert.ȱ Dieȱ virtuelleȱ MaschineȱbasiertȱwieȱdieȱJVMȱaufȱeinerȱabstraktenȱStackmaschine,ȱdieȱ nurȱ Anweisungenȱ einerȱ Zwischenspracheȱ derȱ Commonȱ Intermediateȱ Languageȱ (CIL)ȱ ausführt.ȱ Dieȱ Compilerȱ fürȱ dieȱ verschiedenenȱ SpraȬ chenȱ(C++,ȱC#,ȱJava,ȱProlog,ȱHaskell,ȱ…)ȱerzeugenȱdieȱnotwendigeȱZwiȬ schenspracheȱundȱunterstützenȱdasȱvonȱderȱ.NETȬPlattformȱdefinierteȱ Typsystem.ȱ Dieseȱ Zwischenspracheȱ wirdȱ erstȱ zurȱ Laufzeitȱ desȱ ProȬ grammesȱ kompiliertȱ undȱ fürȱ dieȱ konkreteȱ Basismaschineȱ angepasstȱ undȱ optimiert.ȱ Weiterhinȱ stelltȱ sieȱ Mechanismenȱ zurȱ SpeicherȬȱ undȱ TypverwaltungȱsowieȱeineȱAusnahmebehandlungȱbereit.ȱȱ

7.3 Softwarevirtualisierung Dieȱ Softwarevirtualisierungȱ erlaubtȱ dieȱ virtuelleȱ Installationȱ vonȱ SoftȬ wareproduktenȱ oderȱ Betriebssystemenȱ aufȱ einemȱ Rechner.ȱ VoraussetȬ zungȱdafürȱist,ȱdassȱüberȱeinȱNetzwerkȱZugangȱzuȱeinemȱInstallationsȬ serverȱ besteht,ȱ vonȱ demȱ nachȱ Bedarfȱ Softwarekomponentenȱ geladenȱ werdenȱ können.ȱ Dieȱ Vorteileȱ sind:ȱ Bessereȱ Wartbarkeitȱ undȱ größereȱ Flexibilitätȱ derȱ Softwareinfrastruktur.ȱ Prinzipiellȱ ermöglichtȱ SoftwareȬ virtualisierungȱ inȱ sog.ȱ verwaltetenȱ Systemenȱ auchȱ dieȱ komponentenȬ weiseȱundȱzeitabhängigeȱVerrechnungȱvonȱSoftwarelizenzen.ȱ

7.3.1 Services DieȱVirtualisierungȱvonȱServicesȱmachtȱServeranwendungenȱfürȱeinenȱ KlientenȱtransparentȱüberȱeinȱNetzwerk,ȱalsȱobȱsieȱlokalȱlaufenȱwürden.ȱ Hierbeiȱ kommenȱ aufȱ derȱ Seiteȱ derȱ Klientenȱ sehrȱ oftȱ sog.ȱ „Thinȱ Clients“ȱzumȱEinsatz,ȱdieȱnurȱeinȱminimalesȱBetriebssystemȱzurȱKomȬ munikationȱundȱzurȱAusführungȱderȱAnwendungȱbesitzenȱundȱdamitȱ sehrȱpreiswertȱinȱBeschaffungȱundȱBetriebȱsind.ȱEineȱStudieȱderȱFraunȬ hofergesellschaftȱ zeigt,ȱ dassȱ imȱ Vergleichȱ zuȱ individuellȱ betriebenenȱ PCȬSystemenȱ derȱ Einsatzȱ vonȱ Thinȱ Clientsȱ dieȱ Unterhaltungskostenȱ umȱeinenȱFaktorȱ3ȱsenkenȱkannȱ[Kȱ07].ȱDieȱKlientenȱkönnenȱdabeiȱsoȬ wohlȱinȱeinemȱIntranetȱalsȱauchȱimȱInternetȱbetriebenȱwerdenȱ(Abb.ȱ7Ȭ 6).ȱ Dasȱ Systemȱ bietetȱ insbesondereȱ Firmenȱ Vorteileȱ beiȱ derȱ sicherenȱ

Virtuelleȱ Servicesȱ erlaubenȱ transparentenȱ Zugriffȱaufȱ ServeranwenȬ dungenȱüberȱ ICAȱoderȱRDPȱ

403ȱ

7ȱȱVirtualisierungstechnikenȱ Anbindungȱ vonȱ externenȱ Arbeitsplätzen,ȱ daȱ einȱ Befallȱ mitȱ SchadsoftȬ wareȱquasiȱausgeschlossenȱist.ȱ Abb.ȱ7Ȭ6:ȱ Ausführungȱ vonȱServicesȱ aufȱThinȱ Clientsȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ Anȱ ersterȱ Stelleȱ sindȱ inȱ diesemȱ Zusammenhangȱ TerminalȬServicesȱ zuȱ nennen.ȱEinȱprominentesȱBeispielȱsindȱdieȱDiensteȱderȱFirmaȱCitrix,ȱdieȱ dasȱAusführenȱvonȱWindowsȬAnwendungenȱaufȱUnixȬKlientenȱerlauȬ benȱ[Lȱ05].ȱDieȱwichtigsteȱAnwendungȱvonȱCitrixȱheißtȱCitrixȱPresenȬ tationȱServer.ȱSieȱbietetȱdieȱMöglichkeit,ȱvonȱeinemȱbeliebigenȱCompuȬ ter/Deviceȱ mitȱ einemȱ beliebigenȱ Betriebssystemȱ überȱ dasȱ Internetȱ aufȱ eineȱ Firmenanwendungȱ zuzugreifen,ȱ ohneȱ dassȱ dieȱ eigentlicheȱ FirȬ mensoftwareȱaufȱdemȱverwendetenȱRechnerȱinstalliertȱseinȱmuss;ȱdortȱ istȱ nurȱ einȱ Citrixȱ IndependentȱComputingȱArchitectureȱ(ICA)ȬClientȱ oderȱ RemoteȱDesktopȱProtocolȱ(RDP)ȬClientȱinstalliert.ȱȱDieȱAnwendungȱläuftȱ dabeiȱaufȱdemȱServer,ȱundȱesȱwerdenȱnurȱdieȱGrafikdatenȱübertragen.ȱ Daȱ nurȱ dieȱ Datenȱ übertragenȱ werden,ȱ dieȱ sichȱ auchȱ tatsächlichȱ geänȬ dertȱ haben,ȱ könnenȱ dieȱ Terminaldiensteȱ auchȱ aufȱ langsamenȱ NetzȬ werkverbindungenȱgenutztȱwerden.ȱ

404ȱ

7.4ȱHardwareȬVirtualisierungȱ

7.3.2 Anwendungen EinenȱSchrittȱweiterȱgehtȱdieȱVirtualisierungȱvonȱAnwendungen.ȱHierȱ werdenȱ DesktopȬȱ oderȱ Serveranwendungenȱ lokalȱ ausgeführt,ȱ ohneȱ dassȱ dieseȱ zuvorȱ lokalȱ installiertȱ werdenȱ müssen.ȱFürȱ dieȱ virtualisierteȱ AnwendungȱwirdȱdazuȱeineȱvirtuelleȱUmgebungȱgeneriert,ȱdieȱalleȱDaȬ teienȱ undȱ Komponentenȱ enthält,ȱ dieȱ dasȱ Programmȱ zurȱ Ausführungȱ benötigt.ȱDieȱvirtuelleȱUmgebungȱwirktȱdabeiȱwieȱeinȱPufferȱzwischenȱ AnwendungȱundȱBetriebssystem,ȱwodurchȱKonflikteȱmitȱanderenȱAnȬ wendungenȱ oderȱ Betriebssystemkomponentenȱ vermiedenȱ werden.ȱ Soȱ wirdȱ z.B.ȱ beiȱ demȱ Produktȱ SoftGridȱ derȱ Firmaȱ MicroSoftȱ vonȱ einemȱ Softwareserverȱ beiȱ Bedarfȱ dieȱ Softwareȱ (z.B.ȱ Office)ȱ zumȱ Rechnerȱ desȱ Anwendersȱ übertragen,ȱ sobaldȱ dieserȱ eineȱ Anwendungȱ aufruft,ȱ inȱ ähnlicherȱ Weiseȱ wieȱ diesȱ beiȱ einemȱ OnlineȬVideoȱ derȱ Fallȱ ist.ȱ Kurzȱ nachȱ Beginnȱ derȱ Übertragungȱ kannȱ dasȱ Programmȱ gestartetȱ werden,ȱ wobeiȱimȱHintergrundȱweitereȱKomponentenȱübertragenȱwerden.ȱDaȬ mitȱdiesȱfunktioniert,ȱmussȱzuvorȱaufȱdemȱPCȱdesȱAnwendersȱlediglichȱ derȱSoftGridȬKlientȱinstalliertȱwerden.ȱDerȱVorteilȱdiesesȱVorgehensȱist,ȱ dassȱ beiȱ einerȱ größerenȱ verteiltenȱ Installationȱ vonȱ PCsȱ jederȱ Rechnerȱ mitȱ derselbenȱ identischenȱ Softwareausstattungȱ ausgeliefertȱ werdenȱ kann.ȱ Dieȱ verschiedenenȱ Anwendungenȱ stehenȱ dannȱ überȱ denȱ SoftȬ wareserverȱ nachȱ Bedarfȱ ohneȱ weitereȱ Installationȱ wahlfreiȱ zurȱ VerfüȬ gung.ȱ Derȱ Administrationsaufwandȱ fürȱ großeȱ Installationenȱ vonȱ PCsȱ kannȱdamitȱstarkȱreduziertȱwerden.ȱ

Virtuelleȱ AnwenȬ dungenȱ werdenȱ virtuellȱ installiertȱ

7.4 Hardware-Virtualisierung Dieȱ HardwareȬVirtualisierungȱ verwaltetȱ Ressourcenȱ wieȱ Prozessor,ȱ Hauptspeicherȱ undȱ Datenspeicherȱ überȱ dieȱ Firmwareȱ desȱ Rechnersȱ undȱteiltȱdieseȱeinerȱvirtuellenȱMaschineȱzu.ȱȱ Dieȱsog.ȱPartitionierungȱunterteiltȱdabeiȱeinȱGesamtsystemȱdynamischȱ inȱTeilsysteme.ȱEinȱbekanntesȱBeispielȱistȱdieȱPlattenpartitionierungȱbeiȱ derȱInstallationȱvonȱBetriebssystemen.ȱȱ DieȱPartitionierungstechnikȱkommtȱz.B.ȱbeiȱIBMȱzumȱEinsatzȱinȱGroßȬ rechnernȱderȱzSerieȱ[IBMȱ07]ȱoderȱMidrangeȬSystemenȱderȱpSerieȱ[IBMȱ 08].ȱOhneȱNeustartȱistȱesȱmöglich,ȱimȱlaufendenȱBetriebȱeineȱRessourȬ cenzuteilungȱ nahezuȱ beliebigȱ zuȱ verändern.ȱ Aufȱ einemȱ Großrechnerȱ aktuellerȱBauartȱkönnenȱaufȱdieseȱWeiseȱproblemlosȱmehrereȱhundertȱ bisȱtausendȱLinuxȬInstanzenȱgleichzeitigȱlaufen.ȱ

Großrechner:ȱ PartitionieȬ rung,ȱd.h.ȱ Unterteilungȱ inȱTeilȬ systemeȱ

Beiȱ Mikroprozessorenȱ gibtȱ esȱ dieseȱ Formȱ derȱ Partitionierungȱ desȱ GeȬ samtsystemsȱ nicht,ȱ sondernȱ esȱ wirdȱ lediglichȱ dieȱ Partitionierungȱ derȱ CPUȱ unterstützt,ȱ wieȱ beiȱ Intelȱ Vanderpoolȱ oderȱ AMDȱ Pacifica.ȱ Zurȱ

405ȱ

7ȱȱVirtualisierungstechnikenȱ Betriebssystemvirtualisierungȱ stehenȱ Publicȱ DomainȬSoftwareprodukȬ teȱ wieȱ Xenȱ [RMȱ 06]ȱ oderȱ kommerzielleȱ Produkteȱ wieȱ VMwareȱ [Lȱ 07]ȱ zurȱVerfügung.ȱ

7.4.1 Prozessor BeiȱPC:ȱIntelȱ Vanderpoolȱ undȱAMDȱ Pacificaȱ

Beiȱ aktuellenȱ Prozessorenȱ werdenȱ Virtualisierungsfunktionenȱ direktȱ aufȱ demȱ Chipȱ unterstützt.ȱ Dabeiȱ gehenȱ dieȱ Firmenȱ Intelȱ undȱ AMDȱ unterschiedlicheȱWege:ȱ 1.ȱDieȱSecureȱVirtualȱMachineȱArchitectureȱ PacificaȱvonȱAMDȱerweiȬ tertȱdieȱAMD64ȬCPUsȱumȱdenȱsoȱgenanntenȱSecureȱVirtualȱMachiȬ neȱ (SVM)ȬBefehlssatz.ȱ Dieȱ neuenȱ Befehleȱ bietenȱ virtuellenȱ MaschiȬ nenȱ ProzessorȬLevelȬSupport,ȱ indemȱ sieȱ vierȱ verschiedeneȱ PrivileȬ gienȱanbieten.ȱNormalerweiseȱlaufenȱwieȱinȱAbb.ȱ7Ȭ7ȱgezeigtȱdasȱBeȬ triebssystemȱundȱdieȱTreiberȱimȱsoȱgenanntenȱRingȱ0ȱ(KernelȱMode)ȱ undȱ Applikationenȱ imȱ Ringȱ 3ȱ (Userȱ Mode).ȱ Dieȱ neuenȱ Befehleȱ erȬ laubenȱes,ȱausȱeinemȱBetriebssystemȱherausȱVirtuelleȱMaschinenȱinȱ Ringȱ1,ȱ2,ȱoderȱ3ȱzuȱplatzieren.ȱPrivilegierteȱInstruktionenȱinȱvirtuelȬ lenȱMaschinenȱerzeugenȱInterrupts,ȱsoȱdassȱdasȱBasissystemȱdieȱvolȬ leȱKontrolleȱüberȱdieȱRessourcenȱbehält.ȱ 2.ȱIntelsȱkonkurrierendeȱVanderpoolȬLösungȱmitȱderȱBezeichnungȱVTȬ xȱ fürȱ IA32ȬCPUsȱ undȱ VTȬiȱ fürȱ Itaniumsȱ implementierenȱ dagegenȱ denȱ soȱ genanntenȱ Virtualȱ Machineȱ Extensionsȱ (VMX)ȬBefehlssatz.ȱ Dabeiȱ gibtȱ esȱ mitȱ ȈRootȈȱ undȱ ȈNonȬRootȈȱ zweiȱ Betriebsmodi.ȱ Derȱ Virtuelleȱ MaschinenȬMonitorȱ (VMM)ȱ läuftȱ imȱ VMXȱ RootȬModusȱ undȱbesitztȱjederzeitȱdieȱvolleȱKontrolleȱüberȱdenȱProzessorȱundȱdieȱ Ressourcen,ȱ daȱ damitȱ prinzipiellȱ einȱ höheresȱ Privilegȱ alsȱ Ringȱ 0ȱ implementiertȱist.ȱDieȱvirtuellenȱMaschinenȱarbeitenȱimȱNonȬRootȬȱ Modus,ȱ wobeiȱ auchȱ privilegierteȱ Befehleȱ erlaubtȱ sind.ȱ Esȱ istȱ dabeiȱ fürȱeineȱvirtuelleȱMaschineȱnichtȱerkennbar,ȱdassȱsieȱunterȱderȱKonȬ trolleȱeinesȱVMMȱläuft.ȱ AMDsȱ Virtualisierungstechnologieȱ Pacificaȱ istȱ mitȱ Vanderpoolȱ vonȱ Intelȱ nichtȱ kompatibel:ȱ AMD64ȬProzessorenȱ unterscheidenȱ sichȱ durchȱ ihrenȱ integriertenȱ MemoryȬControllerȱ vonȱ Intelsȱ x86ȬCPUs.ȱ Hierȱ hebtȱ sichȱ Pacificaȱ wesentlichȱ vonȱ Vanderpoolȱ ab,ȱ indemȱ derȱ SpeicherȬ Controllerȱ ebenfallsȱ virtualisiertȱ wird.ȱ Eineȱ weitereȱ Eigenschaftȱ vonȱ PacificaȱstelltȱderȱDeviceȱExclusionȱVectorȱ(DEV)ȱdar,ȱderȱinȱvirtuellenȱ MaschinenȱGeräteȱbehandelt,ȱdieȱohneȱHilfeȱdesȱProzessorsȱdirektȱaufȱ denȱSpeicherȱdesȱSystemsȱzugreifenȱkönnen.ȱ

406ȱ

7.4ȱHardwareȬVirtualisierungȱ Abb.ȱ7Ȭ7:ȱ PrivilegienȬ stufenȱ(PL)ȱinȱ denȱRingenȱ derȱCPUȱ

ȱ ȱ ȱ ȱ ȱ

7.4.2 Hauptspeicher BeiȱderȱHauptspeichervirtualisierungȱhandeltȱesȱsichȱumȱeineȱerweiterȬ teȱ Artȱ derȱ Speicherverwaltung,ȱ dieȱ inaktiveȱ Hauptspeicherbereicheȱ automatischȱ aufȱ Festplattenspeicherȱ auslagert,ȱ umȱ Platzȱ fürȱ weitereȱ Anwendungenȱ zuȱ schaffen.ȱ Hierbeiȱ entstehtȱ einȱ großerȱ linearerȱ AdȬ ressraum,ȱ derȱ denȱ realȱ eingebautenȱ Hauptspeicherȱ weitȱ übertreffenȱ kann.ȱ Einȱ explizitesȱ „Swapȱ out“ȱ undȱ „Swapȱ in“ȱ vonȱ komplettenȱ ProȬ zessenȱ wirdȱ dadurchȱ prinzipiellȱ überflüssig,ȱ daȱ jedemȱ Prozessȱ genüȬ gendȱSpeicherȱzurȱVerfügungȱsteht.ȱ Derȱ virtuelleȱ Speicherȱ bezeichnetȱ denȱ vomȱ tatsächlichȱ vorhandenenȱ Arbeitsspeicherȱ unabhängigenȱ Adressraum,ȱ derȱ einemȱ Prozessȱ fürȱ DatenȱundȱdasȱProgrammȱvomȱBetriebssystemȱzurȱVerfügungȱgestelltȱ wird.ȱ Eineȱ virtuelleȱ Adresseȱ beschreibtȱ einenȱ Ortȱ imȱ Speicherȱ einesȱ Computersystems,ȱ dessenȱ Betriebssystemȱ eineȱ virtuelleȱ SpeicherverȬ

Erweiterungȱ desȱ Adressraumsȱ

407ȱ

7ȱȱVirtualisierungstechnikenȱ waltungȱ zurȱ Adressierungȱ verwendet.ȱ Dieȱ Gesamtheitȱ allerȱ virtuellenȱ AdressenȱwirdȱauchȱalsȱvirtuellerȱAdressraumȱbezeichnet.ȱ Vorteileȱderȱ virtuellenȱ SpeicherverȬ waltungȱ

DieȱvirtuelleȱSpeicherverwaltungȱsorgtȱfürȱdieȱeffizienteȱNutzungȱvorȬ handenenȱ Speichers,ȱ stelltȱ große,ȱ linearȱ zusammenhängendeȱ logischeȱ SpeicherbereicheȱzurȱVerfügungȱundȱermöglichtȱdieȱImplementierungȱ vonȱ Speicherschutzmechanismen.ȱ Nurȱ dieȱ Betriebssysteme,ȱ dieȱ eineȱ virtuelleȱSpeicherverwaltungȱverwenden,ȱkönnenȱeinenȱvirtuellenȱAdȬ ressraumȱ generierenȱ undȱ dadurchȱ Speicherseiten,ȱ dieȱ physikalischȱ nichtȱ zusammenhängendȱ sind,ȱ fürȱ denȱ Programmiererȱ bzw.ȱ dasȱ ProȬ grammȱalsȱlogischȱzusammenhängendenȱSpeicherbereichȱabbilden.ȱSoȱ stellenȱbeispielsweiseȱ32ȬBitȱBetriebssystemeȱbisȱzuȱ4ȱGigabyteȱfürȱProȬ grammeȱundȱDatenȱzurȱVerfügung,ȱauchȱwennȱwenigerȱphysikalischerȱ Arbeitsspeicher,ȱz.ȱB.ȱnurȱ1ȱGigabyte,ȱeingebautȱist.ȱȱ Aktuelleȱ 64ȬBitȬProzessorenȱ erweiternȱ denȱ virtuellenȱ Adressraumȱ aufȱ 48ȱBit,ȱsoȱdassȱProzesseȱbisȱzuȱ128ȱTeraByteȱansprechenȱkönnen.ȱNebenȱ derȱgößerenȱLeistungsfähigkeitȱderȱ64ȬBitȬProzessorenȱistȱvorȱallemȱderȱ größereȱ Adressraumȱ einȱ Grundȱ fürȱ dieȱ Verwendungȱ derȱ neuenȱ ProȬ zessorgeneration.ȱ

7.4.3 Datenspeicher DatenmaȬ nagementȱ

BeiȱderȱDatenspeichervirtualisierungȱsollȱdieȱRechenkapazitätȱvonȱderȱ Speicherkapazitätȱ entkoppeltȱ werdenȱ [Cȱ 05].ȱ Manȱ trenntȱ dieȱ DatenȬ speicherȱ vonȱ denȱ Servernȱ undȱ fasstȱ dieȱ vorhandeneȱ SpeicherȬ HardwareȱaufȱeinerȱneuenȱlogischenȱEbeneȱzusammen.ȱAufȱdieseȱWeiȬ seȱ entstehtȱ einȱ virtuellerȱ Gesamtspeicher.ȱ Derȱ Aufbauȱ einerȱ logischenȱ SichtȱaufȱdieȱphysischenȱSpeicherȱschafftȱdieȱVoraussetzung,ȱProdukteȱ verschiedenerȱHerstellerȱzentralȱundȱflexibelȱzuȱverwalten.ȱManȱbildetȱ sog.ȱSpeicherpoolsȱausȱverschiedenenȱSpeichernȱmitȱunterschiedlichenȱ Speichertechniken,ȱaufȱwelcheȱdieȱServerȱüberȱeinȱNetzwerkȱzugreifenȱ können.ȱInȱdieseȱPoolsȱintegriertȱmanȱz.B.ȱFestplattensysteme,ȱoptischeȱ Speicherȱ undȱ Bandarchive.ȱ Entsprechendeȱ Managementwerkzeugeȱ unterstützenȱOperationenȱwieȱKategorisieren,ȱKopierenȱoderȱVerschieȬ benȱ überȱ dieȱ verschiedenenȱ Speichertypenȱ hinweg.ȱ Dadurchȱ ergebenȱ sichȱdieȱfolgendenȱVorteile:ȱ

Vorteileȱderȱ Datenspeicher virtualisieȬ rungȱ

x

408ȱ

Datenspeicherkonsolidierung:ȱ Dieȱ HardwareȬübergreifendeȱ ZuȬ sammenfassungȱverschiedenerȱphysischerȱSpeicherȱermöglichtȱdieȱ bedarfsgerechteȱSkalierungȱundȱZuweisung.ȱDieȱKlientenȱdesȱSysȬ temsȱ könnenȱ denȱ virtuellenȱ Speicherplatzȱ aufȱ dieȱ bekannteȱ Artȱ undȱWeiseȱnutzen.ȱDerȱalsȱeinȱGesamtbereichȱdargestellteȱSpeicherȱ kannȱdabeiȱphysikalischȱauchȱgeräteübergreifendȱverteiltȱsein.ȱ

7.4ȱHardwareȬVirtualisierungȱ x

Vereinfachteȱ Administration:ȱ Esȱ wirdȱ einȱ flexibelȱ skalierbarerȱ Speicherpoolȱ geschaffen,ȱ derȱ unabhängigȱ vonȱ denȱ verwendetenȱ TechnologienȱundȱProduktenȱzentralȱverwaltetȱwerdenȱkann.ȱ

x

LifecycleȬManagementȱ ermöglichtȱ dieȱ Migrationȱ vonȱ Datenȱ zwiȬ schenȱteurenȱDirektzugriffspeichernȱundȱpreiswertenȱMassenspeiȬ chern.ȱ Entsprechendȱ ihrerȱ Nachfrageȱ wandernȱ Datensätzeȱ autoȬ matischȱzwischenȱdenȱSpeicherortenȱhinȱundȱher.ȱEineȱBeeinträchȬ tigungȱdesȱServerbetriebsȱfindetȱdabeiȱnichtȱstatt.ȱ

x

ÜberbuchenȱvonȱSpeicher:ȱBeimȱȱsog.ȱOverȬCommitmentȱbekommtȱ einȱServerȱeineȱvirtuelleȱSpeicherreservierungȱerstȱbeimȱSchreibenȱ vonȱ Datenȱ physischȱ zugeteilt.ȱ Diesȱ verringertȱ denȱ Platzverschnittȱ beiȱFilesystemen.ȱ

Speichernetze als Basis für Virtualisierung DieȱbeiȱderȱUmsetzungȱderȱSpeicherȬVirtualisierungȱmeistȱeingesetzteȱ TechnikȱistȱeinȱspeziellesȱSpeichernetzwerk,ȱdasȱStorageȱAreaȱNetworkȱ (SAN).ȱDasȱSANȱbildetȱeinȱNetzwerkȱzwischenȱServernȱundȱSpeicherȬ ressourcen,ȱwobeiȱesȱblockbasierteȱDatenȱüberträgtȱ(Abb.ȱ7Ȭ8): Abb.ȱ7Ȭ8:ȱ StorageȱAreaȱ Networkȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

409ȱ

7ȱȱVirtualisierungstechnikenȱ DieȱSANȬUmgebung,ȱdieȱsog.ȱFabric,ȱbeinhaltetȱSwitchesȱoderȱDirektoȬ ren,ȱ welcheȱ Kanäleȱ fürȱ denȱ Datentransferȱ aufbauen.ȱ Dieȱ Serverȱ sindȱ durchȱ spezielleȱ Hostȱ Busȱ Adapterȱ (HBA)ȱ angebunden.ȱ Oftȱ sindȱ inȱ eiȬ nemȱ SANȱ dieȱVerbindungenȱ redundantȱ überȱ unabhängigeȱ PfadeȱausȬ gelegt,ȱumȱAusfallsicherheitȱoderȱgrößerenȱDurchsatzȱzuȱerreichen.ȱDaȱ alleȱ möglichenȱ Datenpfadeȱ gleichzeitigȱ sichtbarȱ sind,ȱ aberȱ immerȱ nurȱ einerȱ aktivȱ seinȱ kann,ȱ mußȱ aufȱ denȱ Servernȱ eineȱ sog.ȱ MultiȬPathingȱ SoftwareȱzumȱEinsatzȱkommen,ȱwelcheȱdasȱSystemȱüberwachtȱundȱimȱ FallȱeinesȱFehlersȱautomatischȱaufȱeinenȱalternativenȱPfadȱumschaltet.ȱ VomȱSpeicherherstellerȱmitgelieferteȱManagementwerkzeugeȱerlaubenȱ dieȱ Partitionierungȱ desȱ Gesamtspeichersȱ inȱ sog.ȱ Logicalȱ Unitsȱ (LUN).ȱ DieȱZuordnungȱvonȱLUNsȱzuȱServernȱistȱüberȱManagementwerkzeugeȱ wahlfreiȱ undȱ dynamischȱ möglich.ȱ Dasȱ verwendeteȱ Protokollȱ istȱ meistȱ SCSI,ȱsoȱdassȱdieȱzugeordnetenȱLUNsȱalsȱSCSIȬPlattenȱinȱdenȱServernȱ sichtbarȱsind.ȱ Dieȱ SANȬTechnikȱ ermöglichtȱ auchȱ dieȱ Verlagerungȱ vonȱ speziellenȱ Funktionenȱ derȱ Serverȱ undȱ derȱ Speichersystemeȱ inȱ dasȱ Netzwerk.ȱ Esȱ sindȱdiesȱFunktionenȱwieȱ x

Speichermanagement:ȱ Hinzufügenȱ undȱ Löschenȱ vonȱ Volumenȱ oderȱDateisystemen.ȱ

x

InstantȱCopy:ȱDirekteȱKopieȱzwischenȱPlatteȱundȱBand.ȱ

x

Snapshot:ȱ Einfrierenȱ undȱ Abspeichernȱ einerȱ Konfigurationȱ oderȱ ȱ einesȱSpeicherzustandsȱzurȱspäterenȱWiederherstellung.ȱ

x

Mirroring:ȱ Spiegelungȱ vonȱ Plattensystemenȱ zurȱ Erhöhungȱ derȱ ȱ AusfallsicherheitȱundȱdesȱDurchsatzes.ȱ

Beiȱ derȱ praktischenȱ Umsetzungȱ derȱ SpeicherȬVirtualisierungȱ gibtȱ esȱ zweiȱMöglichkeiten:ȱȱ Integrationȱ verschiedenerȱ Herstellerȱ durchȱSMIȬSȱ

410ȱ

1.

Dieȱ kostengünstigsteȱ Lösungȱ ist,ȱ dieȱ Virtualisierungsfunktionenȱ direktȱinȱdieȱSpeichergeräteȱ oderȱ dieȱ Switchesȱzuȱ integrieren.ȱ Derȱ Herstellerȱ liefertȱ dabeiȱ inȱ derȱ Regelȱ spezifischeȱ Werkzeugeȱ zumȱ Managementȱ derȱ Ressourcenȱ mit.ȱ Standardisierteȱ Schnittstellen,ȱ dieȱ derȱ Storageȱ Managementȱ Initiativeȱ Ȭȱ Specificationȱ (SMIȬS)ȱ entsprechen,ȱ erlaubenȱ auchȱ dieȱ Integrationȱ vonȱ Gerätenȱ verschieȬ denerȱ Herstellerȱ zuȱ einemȱ System.ȱ Esȱ istȱ dannȱ möglich,ȱ dasȱ GeȬ samtsystemȱvonȱeinerȱzentralenȱKonsoleȱzuȱadministrieren.ȱȱ

2.

BeiȱsehrȱhohenȱAnforderungenȱanȱdieȱVerfügbarkeitȱundȱdieȱFlexiȬ bilitätȱ derȱ Systemeȱ kommenȱ vorȱ allemȱ sog.ȱ „VirtualisierungsȬ

7.4ȱHardwareȬVirtualisierungȱ Appliances“ȱzumȱ Einsatz.ȱ Esȱ handeltȱ sichȱ dabeiȱ umȱ spezielleȱ SerȬ ver,ȱwelcheȱdieȱVirtualisierungsfunktionenȱrealisieren.ȱManȱunterȬ scheidetȱ zwischenȱ „InȬBandȬVirtualisierung“ȱ undȱ „OutȬofȬBandȬ Virtualisierung“ȱ[Cȱ05].ȱ

7.4.3.1 In-Band-Virtualisierung Beiȱ derȱ InȬBandȬVirtualisierungȱ liegtȱ dasȱ Virtualisierungssystemȱ zwiȬ schenȱServerȬFabricȱundȱSpeicherȬFabricȱ(Abb.ȱ7Ȭ9).ȱȱ ȱ ȱ ȱ ȱ

Abb.ȱ7Ȭ9:ȱȱȱȱȱ InȬBandȱ VirtualisieȬ rungȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ DerȱVorteilȱ diesesȱAnsatzesȱ bestehtȱ inȱ derȱ direktenȱ Beeinflussungȱdesȱ Datenstroms,ȱohneȱdassȱmitȱdenȱdaranȱangeschlossenenȱServernȱkomȬ muniziertȱ werdenȱ muss.ȱ Esȱ lassenȱ sichȱ soȱ auchȱ sehrȱ einfachȱ weitereȱ Übertragungsprotokolleȱ undȱ Filesystemeȱ wieȱ z.B.ȱ ȱ InternetȬProtokollȱ (IP),ȱ Serverȱ Messageȱ Blockȱ (SMB)ȱ oderȱ Networkȱ Filesystemȱ (NFS)ȱ inȬ tegrieren,ȱundȱdasȱGesamtsystemȱwirdȱflexibler.ȱEinȱNachteilȱistȱjedoch,ȱ dassȱ manȱ einenȱ Flaschenhalsȱ generiert,ȱ durchȱ denȱ alleȱ Datenȱ fließenȱ müssen.ȱ Darüberȱ hinausȱ führtȱ einȱ Ausfallȱ derȱ Applianceȱ zuȱ einemȱ Totalausfallȱ desȱ Systems.ȱ Dieseȱ Schwierigkeitenȱ lassenȱ sichȱ jedochȱ durchȱdenȱAufbauȱvonȱredundantenȱPfadenȱbzw.ȱSpiegelungȱdesȱVirȬ tualisierungsserversȱgutȱinȱdenȱGriffȱbekommen.ȱ

Direkteȱ Beeinflussungȱ desȱ Datenstromsȱ

ȱ ȱ

411ȱ

7ȱȱVirtualisierungstechnikenȱ Indirekteȱ Beeinflussungȱ desȱ Datenstromsȱ

7.4.3.2 Out-of-Band-Virtualisierung Beiȱ derȱ OutȬofȬBandȬVirtualisierungȱ wirdȱ dieȱ VirtualisierungsȬ ApplianceȱnebenȱdemȱDatenpfadȱplatziertȱ(Abb.ȱ7Ȭ1o).ȱȱ ȱ

Abb.ȱ7Ȭ10:ȱ OutȬofȬBandȬȱ VirtualisieȬ rungȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ DieȱDatenströmeȱfließenȱdadurchȱohneȱUmwegȱdirektȱzwischenȱServerȱ undȱ Speicher,ȱ esȱ entstehtȱ aberȱ dieȱ Notwendigkeit,ȱ aufȱ denȱ Servernȱ modifizierteȱ SANȬTreiberȱ einzuspielen,ȱ welcheȱ mitȱ demȱ VirtualisieȬ rungsserverȱ kommunizieren.ȱ Dadurchȱ kannȱ esȱ vorȱ allemȱ inȱ größerenȱ SystemenȱzuȱLatenzenȱkommen.ȱEinȱAusfallȱderȱApplianceȱlässtȱjedochȱ dieȱ Grundfunktionalitätȱ desȱ SANȱ unberührt.ȱ Esȱ lassenȱ sichȱ aberȱ inȱ diesemȱ Fallȱ dieȱ virtualisiertenȱ Datenblöckeȱ nichtȱ mehrȱ korrektȱ zuordȬ nen,ȱundȱalsȱdirekteȱFolgeȱsindȱdannȱauchȱdieȱdaraufȱbasierendenȱFileȬ systemeȱnichtȱmehrȱverfügbar.ȱ

7.4.4 Netzwerke Durchȱ dieȱ Virtualisierungȱ vonȱ Netzwerkenȱ istȱ esȱ möglich,ȱ aufȱ verȬ schiedenenȱ physikalischenȱ Netzsegmentenȱ logischeȱ Bereicheȱ zuȱ defiȬ nieren.ȱ Dieȱ Abbildungȱ einesȱ Subnetzesȱ mitȱ einemȱ gemeinsamenȱ IPȬ Adressbereichȱ überȱ mehrereȱ unterschiedlicheȱ physikalischeȱ Netzeȱ istȱ dadurchȱmöglich.ȱ

412ȱ

7.4ȱHardwareȬVirtualisierungȱ

7.4.4.1 Virtual Local Area Network EinȱVirtualȱLocalȱAreaȱNetworkȱ(VLAN)ȱistȱeinȱvirtuellesȱlokalesȱNetzȱ innerhalbȱ einesȱ physischenȱ Netzes.ȱ Dieȱ technischeȱ Realisierungȱ vonȱ VLANsȱ istȱ imȱ Standardȱ IEEEȱ 802.1Qȱ definiert,ȱ welcherȱ denȱ EthernetȬ Frameȱumȱ4ȱByteȱerweitert.ȱȱ

IEEEȱ802.1Qȱ definiertȱ virtuelleȱ Netzeȱ

ȱ

Abb.ȱ7Ȭ11:ȱ EthernetȬ Frameȱfürȱ VLANȱ

ȱ ȱ ȱ ȱ ȱ ȱ 12ȱBitȱdavonȱsindȱfürȱdieȱsog.ȱVLANȬIDȱvorgesehen,ȱwelcheȱeinȱVLANȱ eindeutigȱkennzeichnet.ȱEinȱGerät,ȱdasȱzumȱVLANȱmitȱderȱID=1ȱgehört,ȱ kannȱ mitȱ jedemȱ anderenȱ Gerätȱ imȱ gleichenȱ VLANȱ kommunizieren,ȱ nichtȱjedochȱmitȱeinemȱGerätȱmitȱeinerȱanderenȱVLANȬIDȱ[Kȱ99].ȱ VorteileȱderȱVLANȬTechnikȱsindȱ x

Transparenz:ȱ Verteiltȱ aufgestellteȱ Geräteȱ könnenȱ inȱ einemȱ einziȬ genȱ logischenȱ Netzȱ zusammengefasstȱ werden.ȱ VLANsȱ sindȱ sehrȱ nützlichȱ beiȱ derȱ Konzeptionȱ derȱ ITȬInfrastrukturȱ verteilterȱ StandȬ orte.ȱȱ

x

Sicherheit:ȱ Bestimmte,ȱ besondersȱ zuȱ schützendeȱ Systemeȱ könnenȱ inȱeinemȱeigenenȱNetzȱverborgenȱwerden.ȱ

Vorteileȱderȱ virtuellenȱ Netzeȱ

ȱ Aufȱ derȱ anderenȱ Seiteȱ entstehtȱ durchȱ VLANsȱ einȱ erhöhterȱ Aufwandȱ beiȱ derȱ Netzkonfigurationȱ undȱ beiȱ derȱ Programmierungȱ derȱ aktivenȱ Netzkomponentenȱ(Switchesȱu.ä.).ȱ

7.4.4.2 Virtual Private Network MitȱeinemȱVirtualȱPrivateȱNetworkȱ(VPN)ȱlassenȱsichȱüberȱeinȱöffentliȬ chesȱDatennetz,ȱwieȱetwaȱdemȱInternet,ȱsichereȱprivateȱVerbindungenȱ aufbauen.ȱDieȱVerbindungȱderȱNetzeȱwirdȱdabeiȱüberȱeinenȱsog.ȱTunȬ nelȱ zwischenȱ VPNȬClientȱ undȱ VPNȬServerȱ (Concentrator)ȱ realisiert,ȱ wobeiȱdieȱDatenȱmeistȱverschlüsseltȱübertragenȱwerden.ȱAlsȱProtokollȱ

Virtuelleȱ privateȱNetzeȱ ermöglichenȱ sichereȱ VerbindunȬ genȱ

413ȱ

7ȱȱVirtualisierungstechnikenȱ fürȱdieȱsicherenȱVerbindungenȱwirdȱinȱderȱRegelȱSecureȱSocketȱLayerȱ (SSL)ȱ eingesetzt.ȱ Dieȱ Teilnehmerȱ müssenȱ sichȱ zunächstȱ authentisierenȱ undȱkönnenȱsichȱdannȱz.B.ȱausȱdemȱInternetȱinȱeinȱdurchȱeineȱFirewallȱ gesichertesȱ Firmennetzȱ einklinken,ȱ wobeiȱ alleȱ Ressourcenȱ wieȱ beiȬ spielsweiseȱFileserverȱoderȱDruckerȱtransparentȱverfügbarȱsindȱ[Bȱ02].ȱ

414ȱ

8 Cluster Dasȱ Konzeptȱ derȱ Clusterȱ entstandȱ ausȱ demȱ Wunschȱ heraus,ȱ dieȱ LeisȬ tungsfähigkeitȱ hinsichtlichȱ Rechenleistung,ȱ Speicherkapazitätȱ undȱ DatendurchsatzȱvonȱmiteinanderȱvernetztenȱRechnernȱzuȱbündelnȱundȱ fürȱrechenintensiveȱAufgabenȱzuȱnutzen.ȱDieseȱIdeeȱresultierteȱausȱderȱ Überlegung,ȱwieȱesȱmöglichȱist,ȱdieȱBerechnungȱundȱAbarbeitungȱvonȱ Problemenȱ zuȱ beschleunigen.ȱ Nachȱ Pfisterȱ existierenȱ dafürȱ dreiȱ MögȬ lichkeitenȱ[Pfiȱ98]:ȱ 1. 2.

dieȱSteigerungȱderȱRechenleistungȱdurchȱschnellereȱProzessoren,ȱ derȱEinsatzȱbessererȱAlgorithmenȱundȱOptimierungȱderȱeingesetzȬ tenȱAlgorithmenȱundȱ 3. dieȱ Nutzungȱ vonȱ mehrȱ alsȱ einemȱ Rechnersystemȱ zurȱ LeistungsȬ steigerung.ȱ Daȱ dieȱ Rechenleistungȱ nichtȱ beliebigȱ zuȱ steigernȱ istȱ undȱ Algorithmenȱ nurȱ mitȱ großemȱ Aufwandȱ undȱ auchȱ nichtȱ beliebigȱ optimierbarȱ sind,ȱ bietetȱsichȱdieȱdritteȱMöglichkeit,ȱderȱZusammenschlussȱvonȱmehrerenȱ RechnersystemenȱzuȱClusternȱan.ȱȱ Dieȱ Steigerungȱ derȱ Leistungsfähigkeitȱ einesȱ Systems,ȱ dasȱ aufȱ einemȱ Clusterȱbasiert,ȱistȱpraktischȱunbegrenztȱundȱnurȱvonȱfolgendenȱFaktoȬ renȱbeschränkt:ȱ x

dieȱLeistungsfähigkeitȱderȱeinzelnenȱKnoten,ȱ

x

derȱ maximalenȱ Datenübertragungsrateȱ derȱ verwendetenȱ NetzȬ werktechnologieȱundȱ

x

desȱ zuȱ bewältigendenȱ WartungsȬȱ undȱ Administrationsaufwandsȱ derȱSysteme,ȱdieȱdenȱClusterȱbilden.ȱ

Bereitsȱ 1983ȱ botȱ dieȱ Firmaȱ Digitalȱ Equipmentȱ Corporationȱ (DEC)ȱ fürȱ ihreȱVAXȬ11ȬRechnerȱeineȱClusterlösungȱan,ȱumȱmehrereȱRechnerȱmitȱ einemȱ seriellenȱ HochgeschwindigkeitsȬInterface,ȱ demȱ soȱ genanntenȱ Clusterȱ Interconnectȱ (CI),ȱ zusammenzuschließenȱ [Haȱ 01].ȱ Durchȱ denȱ Zusammenschlussȱ mehrererȱ VAXenȱ warȱ esȱ möglich,ȱ aufȱ dieȱ RechenȬ leistungȱundȱdenȱSpeicherplatzȱderȱRechnerȱzuzugreifen,ȱalsȱwürdeȱesȱ sichȱdabeiȱumȱeinenȱeinzelnenȱRechnerȱhandeln.ȱImȱJahrȱ1986ȱverkaufȬ teȱDigitalȱEquipmentȱauchȱmitȱderȱVAXȱ8978ȱundȱderȱ8974ȱkompletteȱ ClusterȬSysteme,ȱ dieȱ ausȱ 4ȱ oderȱ 8ȱ Knotenȱ undȱ einerȱ MicroVAXȱ IIȱ alsȱ Steuerkonsoleȱbestanden.ȱ

Zieleȱeinesȱ Clusters:ȱ LeistungsȬ steigerungȱ

Historischeȱ Entwicklungȱ derȱClusterȱ

415ȱ

8ȱȱClusterȱ SeitȱAnfangȱderȱ90erȱJahreȱundȱdemȱimmerȱgrößerenȱDurchsetzenȱderȱ ClientȬServerȬArchitekturȱ haltenȱ immerȱ mehrȱ UNIXȬWorkstationsȱ inȱ Unternehmenȱ undȱ Hochschulenȱ Einzug.ȱ Manȱ erkannteȱ schnell,ȱ dassȱ eineȱ typischeȱ Workstationȱ imȱ Arbeitsalltagȱ nurȱ zuȱ 5Ȭ10ȱ %ȱ ausgelastetȱ istȱ undȱ daherȱ derȱ größteȱ Teilȱ ihrerȱ potentiellenȱ Rechenleistungȱ ungeȬ nutztȱ ist.ȱ Daȱ zuȱ diesemȱ Zeitpunktȱ auchȱ dieȱ Vernetzungȱ immerȱ mehrȱ Einzugȱ hielt,ȱ lagȱ esȱ nahe,ȱ eineȱ Middlewareȱ zuȱ entwickeln,ȱ dieȱ eineȱ Nutzungȱ derȱ freienȱ Rechenleistungȱ zurȱ Bewältigungȱ komplexerȱ AufȬ gabenȱermöglicht.ȱMitȱHilfeȱvonȱPVMȱundȱMPI,ȱdieȱbeideȱeineȱMessaȬ geȱ PassingȬSchichtȱ (Layer)ȱ fürȱ denȱ Nachrichtenaustauschȱ unabhängigȱ vonȱ derȱ Architekturȱ derȱ Knotenȱ anbieten,ȱ istȱ esȱ möglich,ȱ ClusterȬ ApplikationenȱmitȱparallelenȱProzessenȱzuȱentwickeln.ȱ Steigendesȱ DatenaufȬ kommenȱinȱ Wissenschaftȱ undȱIndustrieȱ

SeitȱMitteȱderȱ90erȱJahreȱwerdenȱzunehmendȱClusterȱausȱStandardȬPCsȱ populär,ȱdaȱsieȱnebenȱeinerȱsehrȱhohenȱRechenleistungȱund/oderȱVerȬ fügbarkeitȱzuȱgeringenȱPreisenȱangeschafftȱwerdenȱkönnen.ȱZusätzlichȱ bietenȱdieseȱSystemeȱeineȱbislangȱunerreichteȱFlexibilität,ȱwasȱEinsatzȬ zweckȱundȱSystemerweiterungenȱangeht.ȱ Inȱ vielenȱ Fachbereichenȱ vonȱ Wissenschaftȱ undȱ Industrieȱ steigenȱ UmȬ fangȱundȱKomplexitätȱderȱbenötigtenȱDatenȱrasantȱan.ȱDieseȱEntwickȬ lungȱ istȱ vorȱ allemȱ inȱ denȱ Naturwissenschaftenȱ zuȱ beobachten,ȱ insbeȬ sondereȱHochenergieȬȱundȱAstrophysikȱundȱIngenieurwissenschaften,ȱ aberȱ auchȱ Klimaforschungȱ undȱ Medizin.ȱ Dieserȱ Trendȱ hältȱ anȱ undȱ machtȱ Clusterȱ zuȱ einemȱ unverzichtbarenȱ Werkzeugȱ inȱ weitenȱ Teilenȱ derȱForschungslandschaftȱundȱvielenȱBereichenȱderȱIndustrie.ȱ

8.1 Definition Cluster NachȱPfister[Pfiȱ98]ȱlässtȱsichȱeinȱClusterȱwieȱfolgtȱdefinieren:ȱȱ “Aȱ clusterȱ isȱ aȱ typeȱ ofȱ parallelȱ systemȱ thatȱ consistsȱ ofȱ interconnectedȱ wholeȱ computersȱandȱisȱusedȱasȱaȱsingle,ȱunifiedȱcomputingȱresource.”ȱ Ganzȱallgemeinȱgilt,ȱdassȱeinȱClusterȱausȱeinerȱGruppeȱvonȱmiteinanȬ derȱ vernetztenȱ eigenständigenȱ Computernȱ (wholeȱ computers),ȱ denȱ sogenanntenȱKnotenȱ(englisch:ȱNodes) ȱbesteht,ȱ dieȱ sichȱ wieȱ einȱ einheitlicherȱ Uniprozessorȱ verhalten.ȱ Vonȱ ClusternȱimȱengerenȱSinnȱwirdȱgesprochen,ȱwennȱdieȱKnoten,ȱdieȱsichȱ inȱ derȱ Regelȱ unterȱ derȱ Kontrolleȱ einesȱ Mastersȱ befinden,ȱ exklusivȱ fürȱ denȱClusterȱverwendetȱwerdenȱundȱaufȱeinemȱgemeinsamenȱDatenbeȬ standȱ arbeitenȱ [Diȱ 00].ȱ Beiȱ denȱ Knotenȱ kannȱ esȱ sichȱ umȱ gewöhnlicheȱ PCsȱ ausȱ Standardkomponentenȱ oderȱ Workstationsȱ handeln.ȱ Dieseȱ Workstationsȱ enthaltenȱ einenȱ oderȱ mehrereȱ Prozessorenȱ (CPUs),ȱ ArȬ

416ȱ

8.1ȱDefinitionȱClusterȱ beitsspeicher,ȱ Speichermedien,ȱ mindestensȱ eineȱ Netzwerkverbindungȱ undȱ einȱ eigenesȱ Betriebssystem.ȱ Alternativȱ sindȱ auchȱ Serverȱ oderȱ SuȬ percomputerȱalsȱKnotenȱeinsetzbar.ȱȱ Istȱ dieȱ HardȬȱ undȱ Softwareȱ aufȱ allenȱ Knotenȱ einesȱ Clustersȱ identisch,ȱ handeltȱ esȱ sichȱ umȱ einenȱ homogenenȱ Cluster.ȱ Unterscheidenȱ sichȱ dieȱ KnotenȱinȱihrerȱRechnerarchitektur,ȱHardwareȱoderȱSoftware,ȱhandeltȱ esȱsichȱumȱeinenȱheterogenenȱCluster.ȱ

Homogenȱundȱ heterogenȱ aufgebauteȱ Clusterȱ

8.1.1 Vor- und Nachteile von Clustern VorteileȱvonȱClustern,ȱderenȱKnotenȱausȱStandardkomponentenȱbesteȬ hen,ȱsind,ȱdassȱbeimȱAusfallȱvonȱKomponentenȱdieseȱschnellȱundȱkosȬ tengünstigȱ wiederbeschaffbarȱ sind.ȱ Solcheȱ Systemeȱ sindȱ inȱ derȱ AnȬ schaffungȱ finanziellȱ günstigerȱ alsȱ Großrechner.ȱ Reparaturenȱ oderȱ derȱ AustauschȱvonȱKomponentenȱbeiȱSupercomputernȱoderȱGroßrechnernȱ verlangenȱinȱderȱRegelȱnachȱspeziellerȱHardware,ȱdieȱnichtȱeinfachȱundȱ kostengünstigȱ zuȱ beschaffenȱ ist.ȱ Einȱ weitererȱ Vorteilȱ vonȱ Clusternȱ istȱ dieȱ Flexibilitätȱ undȱ Erweiterbarkeit,ȱ daȱ dieseȱ dynamischȱ demȱ Bedarfȱ entsprechendȱvergrößertȱoderȱverkleinertȱwerdenȱkönnen.ȱ

Vorteileȱvonȱ Clusternȱ

Einȱ Nachteilȱ vonȱ Clusternȱ ist,ȱ dassȱ dieȱ großeȱ Anzahlȱ vonȱ einzelnenȱ Rechnersystemenȱ denȱ Administrationsaufwandȱ vergrößertȱ undȱ soȱ mehrȱ Personalaufwandȱ notwendigȱ ist,ȱ alsȱ esȱ derȱ Einsatzȱ vonȱ einemȱ oderȱeinigenȱwenigenȱSupercomputernȱerfordert.ȱEinȱweitererȱNachteilȱ vonȱ Clusternȱ istȱ derȱ hoheȱ Aufwandȱ zumȱ Verteilenȱ undȱ Kontrollierenȱ vonȱAnwendungen.ȱDieserȱAufwandȱnimmtȱeinenȱmitȱderȱAnzahlȱderȱ Knotenȱ wachsendenȱ Anteilȱ derȱ Gesamtleistungsfähigkeitȱ einesȱ ClusȬ tersȱinȱAnspruch.ȱ

Nachteileȱvonȱ Clusternȱ

8.1.2 Single System Image Clusterȱ bestehenȱ ausȱ mindestensȱ zweiȱ Knoten,ȱ beiȱ denenȱ esȱ sichȱ umȱ eigenständigeȱ Rechnersystemeȱ handelt.ȱ Demȱ Anwenderȱ präsentiertȱ sichȱeinȱClusterȱaberȱwieȱeinȱeinzelnesȱSystem.ȱIdealerweiseȱwissenȱdieȱ Anwenderȱgarȱnicht,ȱdassȱesȱsichȱbeiȱdemȱSystem,ȱaufȱdemȱsieȱarbeiten,ȱ umȱeinenȱClusterȱhandelt.ȱDiesesȱKonzeptȱderȱparallelenȱTransparenzȱ bezeichnetȱ manȱalsȱ SingleȱSystemȱImageȱ (SSI)ȱ .ȱ Esȱ beschreibtȱ einȱSysȬ tem,ȱ dasȱ dieȱ Knotenȱ einesȱ Clustersȱ zuȱ einemȱ großenȱ Systemȱ zusamȬ menfasstȱundȱdieȱAufträgeȱderȱBenutzerȱundȱlaufendenȱApplikationenȱ aufȱdieȱeinzelnenȱRessourcenȱdesȱClustersȱverteilt.ȱȱ

Konzeptȱdesȱ SingleȱSystemȱ Imageȱ

DasȱKonzeptȱdesȱSingleȱSystemȱImageȱexistiertȱaufȱverschiedenenȱEbeȬ nenȱnichtȱnurȱbeiȱClustern.ȱDerȱSpeicherȱeinesȱRechnersȱmitȱmehrerenȱ Prozessorenȱ(SMP)ȱȱstelltȱeinȱSingleȱSystemȱImageȱfürȱdieȱAnwendunȬ genȱ darȱ (Abbildungȱ 8Ȭ1).ȱ Dieȱ laufendenȱ Anwendungenȱ adressierenȱ

SingleȱSystemȱ Imageȱaufȱ Hardwareȱ ebeneȱ

417ȱ

8ȱȱClusterȱ keinenȱ bestimmtenȱ Prozessorȱ derȱ Multiprozessormaschine,ȱ wennȱ sieȱ ihreȱ Datenȱ inȱ denȱ Speicherȱ ablegen.ȱ Dieȱ Anwendungenȱ wissenȱ nicht,ȱ welcherȱProzessorȱihreȱDatenȱbearbeitenȱwird.ȱHierȱwirdȱdasȱKonzeptȱ desȱSingleȱSystemȱImageȱaufȱHardwareebeneȱrealisiert.ȱ Abb.ȱ8Ȭ1:ȱ Konzeptȱdesȱ SingleȱSystemȱ Imageȱbeiȱ SMPȬ Rechnern.ȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ Dasȱ Konzeptȱ desȱ Singleȱ Systemȱ Imageȱ kannȱ auchȱ aufȱ Softwareebeneȱ realisiertȱwerden.ȱEinȱDatenbanksystem,ȱdasȱeinenȱClusterȱnutzt,ȱoderȱ einȱ verteiltesȱ Dateisystemȱ verwendetȱ auchȱ dasȱ Konzeptȱ desȱ Singleȱ Systemȱ Image.ȱ Auchȱ hierȱ weißȱ derȱ Benutzerȱ oderȱ eineȱ Applikationȱ nicht,ȱwoȱgenauȱDatenȱalsȱnächstesȱabgelegtȱwerden.ȱExistiertȱfürȱeinenȱ Clusterȱ eineȱ Steuerkonsole,ȱ überȱ dieȱ derȱ Anwenderȱ Aufträgeȱ anȱ denȱ ClusterȱübergebenȱundȱApplikationenȱstartenȱkann,ȱwerdenȱdieseȱmitȱ HilfeȱdesȱSingleȱSystemȱImageȱanȱdieȱamȱClusterȱangeschlossenenȱResȬ sourcenȱ verteilt.ȱ Derȱ Anwenderȱ undȱ auchȱ dieȱ Applikationenȱ wissenȱ nicht,ȱwelcheȱRessourcenȱsieȱalsȱnächstesȱbelegen.ȱ EineȱweitereȱRealisierungȱdesȱSingleȱSystemȱImageȱaufȱSoftwareebeneȱ imȱ Clusterȱ stellenȱ verteilteȱ Dateisystemeȱ dar.ȱ Hierȱ wissenȱ Anwenderȱ undȱApplikationenȱnicht,ȱwoȱdieȱDatenȱphysikalischȱabgelegtȱsind.ȱȱ

Vernetzungȱ derȱKnotenȱimȱ Clusterȱ

Dieȱ Knotenȱ einesȱ Clustersȱ sindȱ durchȱ einȱ Netzwerkȱ miteinanderȱ verȬ bunden.ȱBeiȱClustern,ȱdieȱnurȱausȱwenigenȱKnotenȱbestehen,ȱkommenȱ ausȱ Kostengründenȱ StandardȬNetzwerktechnologienȱ wieȱ FastȬȱ oderȱ GigaȬEthernetȱ zumȱ Einsatz.ȱ Beiȱ größerenȱ Clustern,ȱ dieȱ ausȱ mehrerenȱ hundertȱ Knotenȱ bestehenȱ können,ȱ sindȱ HochgeschwindigkeitsnetzȬ werkeȱwieȱbeispielsweiseȱMyrinet,ȱInfinibandȱoderȱdasȱScalableȱCoheȬ rentȱInterconnectȱ(SCI)ȱnotwendig.ȱȱ ȱ

418ȱ

8.1ȱDefinitionȱClusterȱ

8.1.3 Aufstellungskonzepte von Clustern FürȱClusterȱexistierenȱzweiȱAufstellungskonzepte:ȱ 1.

GlassȬHouseȱ

2.

CampusȬWideȱ

EinȱClusterȱmitȱdemȱAufstellungskonzeptȱGlassȬHouseȱbefindetȱsichȱinȱ einemȱspeziellȱdafürȱreserviertenȱRaumȱoderȱServerȬSchrankȱ(englisch:ȱ Rack).ȱVorteileȱsind,ȱdassȱdieȱschnelleȱErreichbarkeitȱallerȱKomponenȬ tenȱdieȱWartungȱundȱBehebungȱvonȱFehlernȱerleichtertȱundȱeinȱeinzelȬ nerȱ Raumȱ oderȱ Schrankȱ leichterȱ gegenȱ Sabotageȱ undȱ Datenspionageȱ abgesichertȱwerdenȱkann.ȱDurchȱdieȱräumlicheȱNäheȱderȱKnotenȱkönȬ nenȱ dieseȱ einfacherȱ mitȱ Hochgeschwindigkeitsnetzwerkenȱ verbundenȱ werden.ȱDieseȱVorteileȱsindȱderȱGrundȱdafür,ȱdassȱdieȱmeistenȱClusterȱ nachȱdemȱAufstellungskonzeptȱGlassȬHouseȱaufgebautȱsind.ȱEinȱNachȬ teilȱ ist,ȱ dassȱ beiȱ einemȱ Stromausfallȱ oderȱ Brandȱ inȱ demȱ Gebäude,ȱ inȱ demȱ sichȱ derȱ Clusterȱ befindet,ȱ derȱ Betriebȱ desȱ gesamtenȱ Clustersȱ geȬ fährdetȱist.ȱ BeiȱClustern,ȱdieȱnachȱdemȱAufstellungskonzeptȱCampusȬWideȱaufgeȬ bautȱsind,ȱbefindenȱsichȱdieȱKontenȱinȱmehrerenȱGebäuden,ȱverteiltȱaufȱ dasȱ Geländeȱ desȱ Institutsȱ oderȱ Unternehmens.ȱ Derȱ häufigsteȱ Grundȱ dafürȱist,ȱ dassȱ sichȱ dieȱ Anzahlȱ derȱ Knotenȱ undȱ derenȱ Positionȱ oftȱ änȬ dern.ȱTypischerweiseȱhandeltȱesȱsichȱbeiȱsolchenȱClusternȱumȱeinȱNetȬ workȱofȱWorkstationsȱ(NOWȬCluster)ȱoderȱFeierabendcluster,ȱdieȱnurȱ inȱderȱarbeitsfreienȱZeitȱdieȱRolleȱderȱClusterȬKnotenȱübernehmen.ȱDerȱ dezentraleȱ Aufbauȱ einesȱ solchenȱ Clustersȱ hatȱ denȱ Vorteil,ȱ dassȱ einȱ solchesȱSystemȱkaumȱzuȱzerstörenȱist.ȱEsȱüberwiegenȱbeiȱdiesemȱKonȬ zeptȱaberȱdieȱfolgendenȱNachteile:ȱȱ x

DieȱLeistungȱvonȱsolchenȱClusternȱistȱinȱderȱRegelȱdeutlichȱgerinȬ ger,ȱdaȱkeineȱHochgeschwindigkeitsnetzwerkeȱverwendetȱwerdenȱ könnenȱ undȱ dieȱ Knotenȱ ausȱ verschiedenenȱ HardwareȬ Architekturenȱbestehen.ȱ

x

WegenȱderȱEntfernungȱzwischenȱdenȱKnotenȱistȱdieȱWartungȱeinesȱ solchenȱSystemsȱschwierig.ȱ

AufstellungsȬ konzept:ȱ GlassȬHouseȱ

AufstellungsȬ konzept:ȱ CampusȬWideȱ ȱ FeierabendȬ clusterȱ

Abgesehenȱ vonȱ Speziallösungenȱ wieȱ derȱ DECȬClusterlösungȱ erlebteȱ dasȱClusterȬKonzeptȱseinenȱgroßenȱDurchbruchȱerstȱinȱdenȱ90erȱJahren.ȱ Werȱ damalsȱ einenȱ Clusterȱ ausȱ StandardȬPCsȱ betreibenȱ wollte,ȱ warȱ gezwungen,ȱdiesenȱselbstȱaufzubauen.ȱSpäterȱwurdeȱesȱmöglich,ȱsolcheȱ Systemeȱfertig,ȱquasiȱ„vonȱderȱStange“ȱzuȱkaufen.ȱSeitȱBeginnȱdesȱneuȬ enȱ Jahrtausendȱ istȱ einȱ Trendȱ zurȱ Konsolidierungȱ derȱ Hardwareȱ erȬ kennbar.ȱ Einȱ bekannterȱ Herstellerȱ vonȱ fertigȱ aufgebautenȱ ClusterȬ

419ȱ

8ȱȱClusterȱ SystemenȱistȱMEGWAREȱ[MEȱ07]ȱausȱChemnitz.ȱDieȱClusterȬSystemeȱ werdenȱ immerȱ kompakterȱ undȱ bestehenȱ ausȱ Pizzaboxenȱ oderȱ Blades.ȱ Aktuellȱist,ȱwieȱinȱallenȱBereichenȱderȱElektronik,ȱeineȱimmerȱgrößereȱ IntegrationȱderȱKomponentenȱzuȱbeobachten.ȱSpezialarchitekturenȱwieȱ BlueGeneȱ [BGȱ 07]ȱ vonȱ IBMȱ undȱ seineȱ Nachfolger.ȱ BlueGeneȱ istȱ einȱ massivȱparallelesȱSystemȱmitȱsehrȱgutenȱSkalierungseigenschaften.ȱBeiȱ diesenȱ Spezialarchitekturenȱ handeltȱ esȱ sichȱ zwarȱ auchȱ umȱ Cluster,ȱ allerdingsȱbestehenȱdieseȱnichtȱmehrȱausȱgewöhnlichenȱStandardkomȬ ponenten,ȱ wasȱ dieȱ bekanntenȱ VorȬȱ undȱ Nachteileȱ hinsichtlichȱ GeȬ schwindigkeit,ȱVerfügbarkeit,ȱStabilität,ȱundȱPreisȱmitȱsichȱbringt.ȱ

8.2 Klassifikationen von Clustern Multipleȱ Instructionȱ MultipleȱDataȱ

SMPȬSystemeȱundȱMehrrechnersystemeȱfolgenȱdemȱKonzeptȱMultipleȱ Instructionȱ Multipleȱ Dataȱ (MIMD),ȱ dasȱ mehrereȱ unabhängigeȱ ProzesȬ sorenȱvorsieht,ȱdieȱunterschiedlicheȱBefehleȱaufȱunterschiedlichenȱDaȬ tenȱausführen.ȱ Andrewȱ S.ȱ Tanenbaumȱ entwickelteȱ eineȱ tiefergehendeȱ Unterteilungȱ derȱ Rechnersysteme,ȱ dieȱ demȱ MIMDȬKonzeptȱ entsprechen.ȱ TanenȬ baumȱunterscheidetȱdieȱMIMDȬSystemeȱinȱ x

Systeme,ȱ dieȱ mehrereȱ Prozessorenȱ (SMPȬSysteme)ȱ undȱ einenȱ engȱ gekoppeltenȱSpeicherȱ(SharedȱMemory)ȱenthaltenȱundȱinȱ

x

Systeme,ȱ dieȱ ausȱ mehrerenȱ Rechnernȱ mitȱ verteiltemȱ Speicherȱ (DistributedȱMemory)ȱbestehen.ȱ

AusȱderȱSichtȱvonȱTanenbaumsȱTaxonomieȱistȱderȱeinzigeȱUnterschiedȱ zwischenȱ SMPȬȱ undȱ Mehrrechnersystemenȱ derȱ Gradȱ derȱ Kopplung.ȱ Problemeȱ wieȱ Synchronisierungȱ undȱ Deadlocksȱ müssenȱ beiȱ derȱ EntȬ wicklungȱ vonȱ solchenȱ Systemenȱ beachtetȱ werden.ȱ Beimȱ SymmetriȬ schenȱMultiprozessingȱ(SMP)ȱȱhandeltȱesȱsichȱumȱRechnerȱmitȱmehreȬ renȱ Prozessoren,ȱ dieȱ gleichberechtigtȱ nebeneinanderȱ stehenȱ undȱ aufȱ einenȱ gemeinsamenȱ Speicherȱ (Sharedȱ Memory)ȱ zugreifen.ȱ Währendȱ beiȱ SMPȬSystemenȱ dieȱ Kommunikationȱ zwischenȱ denȱ Prozessorenȱ überȱ sehrȱ schnelleȱ Bussystemeȱ verläuft,ȱ müssenȱ dieȱ Ressourcenȱ einesȱ Mehrrechnersystemsȱ überȱ einȱ Netzwerkinterfaceȱ miteinanderȱ komȬ munzieren.ȱDiesesȱverfügtȱimmerȱüberȱeineȱgeringereȱGeschwindigkeitȱ undȱBandbreiteȱ[Tanȱ01].ȱȱ Dieȱ engȱ gekoppeltenȱ Multiprozessorsystemeȱ undȱ loseȱ gekoppeltenȱ Mehrrechnersystemeȱ unterteiltȱ Tanenbaumȱ anhandȱ ihrerȱ SpeicherarȬ chitekturenȱundȱȬverwaltungȱ(Abbildungȱ8Ȭ2).ȱ

420ȱ

8.2ȱKlassifikationenȱvonȱClusternȱ ȱ

Abb.ȱ8Ȭ2:ȱ TanenbaumȬ scheȱ UnterscheiȬ dungȱvonȱ MIMDȬ Systemenȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ DieȱGruppeȱderȱengȱgekoppeltenȱMultiprozessorsystemeȱenthältȱunterȱ anderemȱ dieȱ SMPȬRechnersysteme.ȱ Dieȱ Gruppeȱ derȱ loseȱ gekoppeltenȱ MehrrechnersystemeȱunterteiltȱTanenbaumȱ[Tanȱ01]ȱinȱzweiȱGruppen:ȱ x

MassivelyȱParallelȱProcessorsȱ(MMP)ȱ.ȱZuȱdieserȱKategorieȱgehöȬ renȱ Supercomputerȱ mitȱ vielenȱ Prozessoren.ȱ Dieȱ Prozessorenȱ sindȱ überȱ herstellerspezifischeȱ Hochgeschwindigkeitsnetzwerkeȱ mitȬ einanderȱverbunden.ȱEinȱBeispielȱfürȱdieȱSystemeȱdieserȱKategorieȱ istȱdieȱCrayȱT3EȱvonȱCrayȱInc,ȱeinȱmassivȬparallelesȱProzessorsysȬ temȱ mitȱ bisȱ zuȱ 2048ȱ Prozessoren.ȱ Entsprechendȱ derȱ Anordnungȱ derȱ Prozessorenȱ undȱ ihrenȱ Verbindungenȱ unterscheidetȱ manȱ MMPȬSystemeȱinȱGitterȱundȱHyperwürfel.ȱ

x

Clusterȱ ofȱ Workstationsȱ (COW),ȱ auchȱ Networkȱ ofȱ Workstationsȱ (NOW)ȱoderȱFeierabendclusterȱgenannt.ȱ

engȱundȱloseȱ gekoppelteȱ MultiprozesȬ sorsystemeȱ

Dieȱ häufigsteȱ Artȱ derȱ Klassifikationȱ vonȱ Clusternȱ unterscheidetȱ dieseȱ nachȱ ihrenȱ Einsatzgebietenȱ undȱ Anforderungen.ȱ Wieȱ Abbildungȱ 8Ȭ3ȱ zeigt,ȱexistierenȱvierȱunterschiedlicheȱEinsatzgebieteȱvonȱClustern.ȱȱ ȱ ȱ

421ȱ

8ȱȱClusterȱ Abb.ȱ8Ȭ3:ȱ Klassifikationȱ vonȱClusternȱ

8.2.1 Hochverfügbarkeits-Cluster HochverfügȬ barkeitsȬ Clusterȱ

HochverfügbarkeitsȬCluster,ȱ soȱ genannteȱ Highȱ Availabilityȱ Clusterȱ (HA),ȱ besitzenȱ eineȱ großeȱAusfallsicherheitȱ undȱ damitȱ eineȱ hoheȱ VerȬ fügbarkeit.ȱDieȱVerfügbarkeitȱwirdȱdurchȱRedundanzȱderȱeingesetztenȱ Komponentenȱ undȱ dasȱ Ausschließenȱ einesȱ Singleȱ Pointȱ ofȱ Failureȱ (SPOF)ȱȱerreicht.ȱȱ

Redundanzȱ alsȱSchlüsselȱ zurȱ Verfügbarkeitȱ

DasȱWortȱRedundanzȱkommtȱvonȱdemȱlateinischenȱBegriffȱredundareȱ undȱ bedeutetȱ wörtlichȱ übersetzt,ȱ dassȱ etwasȱ imȱ Überflussȱ vorhandenȱ ist.ȱImmerȱwennȱeinȱSystemȱKomponentenȱenthält,ȱdieȱzurȱArbeitȱdesȱ Systemsȱnichtȱnotwendigȱsind,ȱaberȱdieȱArbeitȱvonȱbaugleichenȱKomȬ ponentenȱ imȱ Fehlerfallȱ übernehmen,ȱ bedeutetȱ diesȱ Redundanz.ȱ Dasȱ Clusteringȱ forȱ Availabilityȱ bietetȱ durchȱ denȱ redundantenȱ Einsatzȱ derȱ Knotenȱ dieȱ Möglichkeit,ȱ dieȱ Technikȱ undȱ Vorteileȱ derȱ Mainframesȱ zuȱ einemȱsehrȱgünstigenȱPreisȱnachzubildenȱundȱdennochȱeineȱhoheȱFleȬ xibilitätȱzuȱerhaltenȱ[Solȱ02].ȱ Dieȱ Verfügbarkeitȱ Vȱ einesȱ Systemsȱ berechnetȱ sichȱ ausȱ derȱ mittlerenȱ Betriebszeit,ȱ derȱ Meanȱ Timeȱ Betweenȱ Failuresȱ (MTBF),ȱ geteiltȱ durchȱ dieȱ Summeȱ ausȱ MTBFȱ undȱ mittlererȱ Ausfallzeit,ȱ derȱ Meanȱ Timeȱ Toȱ Repairȱ(MTTR).ȱ ȱ

422ȱ

8.2ȱKlassifikationenȱvonȱClusternȱ Systeme,ȱdieȱ24ȱStundenȱproȱTagȱundȱ7ȱTageȱinȱderȱWocheȱbeiȱ365ȱJahȬ restagenȱarbeiten,ȱsindȱbeiȱeinerȱVerfügbarkeitȱvonȱ100%ȱanȱ24ȱ*ȱ365ȱ=ȱ 8760ȱStundenȱvollȱeinsatzbereit.ȱEineȱVerfügbarkeitȱvonȱ99%ȱbedeutetȱ fürȱeinenȱClusterȱschonȱeineȱAusfallzeitȱvonȱüberȱ3ȱ1/2ȱTagen.ȱȱ ȱ Verfügbarkeitȱ

Minimaleȱerwarteteȱ Betriebszeitȱ

Maximaleȱerlaubteȱ Ausfallzeitȱ

100%ȱ

8760ȱStundenȱ

0ȱStundenȱ

99,95%ȱ

8755ȱStundenȱ

5ȱStundenȱ

99,9%ȱ

8751ȱStundenȱ

9ȱStundenȱ

99,5%ȱ

8716ȱStundenȱ

44ȱStundenȱ

99%ȱ

8672ȱStundenȱ

88ȱStundenȱ

95%ȱ

8322ȱStundenȱ

438ȱStundenȱ

Tabelleȱ8Ȭ1:ȱ UnterschiedȬ licheȱ VerfügbarȬ keitswerteȱ

ȱ Umȱ eineȱ hoheȱ Verfügbarkeitȱ einesȱ ClusterȬSystemsȱ zuȱ gewährleisten,ȱ genügtȱ esȱ nicht,ȱ dieȱ Knotenȱ undȱderenȱHardwareȱ redundantȱ auszuleȬ gen.ȱ Dieȱ Verfügbarkeitȱ kannȱ auchȱ durchȱ denȱ Einsatzȱ einerȱ unterbreȬ chungsfreienȱ Stromversorgungȱ (USV)ȱ erhöhtȱ werden.ȱ Beiȱ Systemen,ȱ dieȱ alsȱ ausfallsicherȱ deklariertȱ werden,ȱ mussȱ jederzeitȱ einȱ ErsatzrechȬ nerȱzurȱVerfügungȱstehen,ȱderȱimȱFehlerfallȱeinspringenȱundȱdieȱangeȬ botenenȱ Diensteȱ weiterȱ zurȱ Verfügungȱ stellenȱ kann.ȱ Beimȱ Clusteringȱ fürȱ Verfügbarkeitȱ hatȱ nichtȱ dieȱ Verfügbarkeitȱ derȱ Knotenȱ Priorität,ȱ sondernȱdieȱVerfügbarkeitȱderȱangebotenenȱDienste.ȱEsȱexistierenȱzweiȱ Gruppenȱ vonȱ HochverfügbarkeitsȬClustern,ȱ dieȱ sichȱ inȱ ihremȱ VerhalȬ tenȱbeiȱAusfällenȱvonȱKnotenȱunterscheiden:ȱ x

Active/PassiveȬCluster,ȱ auchȱ HotȬStandbyȬClusterȱ genannt.ȱ Beiȱ diesenȱHochverfügbarkeitsȬClustern,ȱistȱmindestensȱeinȱKnotenȱimȱ Normalbetriebȱ nichtȱ inȱ Verwendung.ȱ Dieseȱ Knotenȱ befindenȱ sichȱ imȱ Zustandȱ Passivȱ undȱ übernehmenȱ keineȱ Dienste,ȱ dennȱ ihreȱ Aufgabeȱ istȱ es,ȱ beimȱ Ausfallȱ einesȱ Knotensȱ dessenȱ Diensteȱ zuȱ übernehmen.ȱ DerȱVorteilȱbeiȱActive/PassiveȬClusternȱ ist,ȱdassȱ dieȱ ausgeführtenȱ Diensteȱ nichtȱ explizitȱ fürȱ denȱ Betriebȱ inȱ einemȱ Clusterȱ ausgelegtȱ seinȱ müssen.ȱ Dasȱ Übernehmenȱ einesȱ Dienstesȱ durchȱ einenȱ Knotenȱ vonȱ einemȱ ausgefallenenȱ ȱ Knotenȱ wirdȱ ȱ alsȱ FailȬoverȬFunktionȱbezeichnet.ȱ

Active/ȱ PassiveȬ Clusterȱ

423ȱ

8ȱȱClusterȱ Active/ActiveȬ Clusterȱ

x

Failoverȱundȱ Failbackȱ

Failoverȱ istȱ dieȱ Fähigkeit,ȱ beimȱ Ausfallȱ einesȱ Knotensȱ alleȱ Aufgabenȱ automatischȱeinemȱanderenȱKnotenȱzuȱübergebenȱundȱsoȱdieȱAusfallȬ zeitȱzuȱminimieren.ȱDieȱFailoverȬFunktionalitätȱwirdȱgewöhnlichȱvomȱ eingesetztenȱ Betriebssystemȱ zurȱ Verfügungȱ gestellt.ȱ Einȱ Beispielȱ istȱ Heartbeat[LHAȱ 07]ȱ fürȱ Linux.ȱ Mitȱ Hilfeȱ vonȱ Heartbeatȱ überwachenȱ sichȱdieȱKnotenȱeinesȱClustersȱgegenseitig.ȱDabeiȱwerdenȱkeineȱDiensteȱ aufȱihreȱFunktionalitätȱhinȱüberwacht,ȱsondernȱnurȱobȱdieȱKnotenȱlauȬ fen.ȱTunȱsieȱdas,ȱwirdȱdavonȱausgegangen,ȱdassȱauchȱdieȱDiensteȱlauȬ fen.ȱ Istȱ einȱ Knotenȱ ausgefallen,ȱ startenȱ dieȱ Diensteȱ aufȱ demȱ BackupȬ Knoten,ȱundȱdieserȱübernimmtȱdieȱIPȬAdresseȱdesȱausgefallenenȱKnoȬ tens.ȱ

Active/ActiveȬCluster.ȱ Beiȱ diesenȱ HochverfügbarkeitsȬClusternȱ sindȱ aufȱ allenȱ Knotenȱ dieȱ gleichenȱ Diensteȱ aktiv.ȱ Fallenȱ einȱ oderȱ mehrereȱKnotenȱaus,ȱerhaltenȱdieȱnochȱaktivenȱKnotenȱdieȱAnfraȬ genȱderȱausgefallenȱKnotenȱzusätzlich.ȱDerȱVorteilȱistȱeineȱbessereȱ Lastverteilungȱ zwischenȱ denȱ Knoten.ȱ Derȱ Nachteilȱ istȱ allerdings,ȱ dassȱ dieȱ Diensteȱ speziellȱ fürȱ denȱ Betriebȱ inȱ einemȱ Clusterȱ entwiȬ ckeltȱseinȱ müssen,ȱ daȱzeitgleichȱalleȱ Knotenȱ aufȱ dieȱgleichenȱResȬ sourcenȱzugreifen.ȱȱ

Sindȱ ausgefalleneȱ Knotenȱ wiederȱ einsatzbereit,ȱ meldenȱ sichȱ dieseȱ amȱ Clusterȱ zurückȱ undȱ erhaltenȱ vomȱ Lastverteilerȱ wiederȱ Aufgaben.ȱ Derȱ Clusterȱ verfügtȱ abȱ diesemȱ Zeitpunktȱ wiederȱ überȱ dieȱ gleicheȱ LeisȬ tungsfähigkeit,ȱdieȱerȱvorȱdemȱAusfallȱderȱKnotenȱhatte.ȱDiesesȱVerhalȬ tenȱwirdȱalsȱFailbackȱbezeichnet.ȱ Sharedȱ Nothingȱundȱ SharedȱDiskȱ

Esȱ existierenȱ zweiȱ unterschiedlicheȱ Architekturenȱ beimȱ Clusteringȱ forȱ Availability,ȱ Sharedȱ Nothingȱ undȱ Sharedȱ Disk.ȱ Beideȱ Architekturenȱ entstandenȱausȱderȱProblematik,ȱdassȱbeimȱClusteringȱforȱAvailabilityȱ dieȱgleichzeitigeȱNutzungȱvonȱRessourcenȱdurchȱmehrȱalsȱeinenȱKnoȬ tenȱnotwendigȱistȱ[Solȱ02].ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

424ȱ

8.2ȱKlassifikationenȱvonȱClusternȱ ȱ ȱ ȱ ȱ

Abb.ȱ8Ȭ4:ȱȱȱȱ DieȱSharedȱ Nothingȱundȱ SharedȱDiskȬ Architekturȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ Beiȱ derȱ Architekturȱ Sharedȱ Nothingȱ hatȱ jederȱ Knoten,ȱ inȱ diesemȱ Fallȱ auchȱPartitionȱgenanntȱ[Riȱ10],ȱeineȱeigeneȱSpeicherressourceȱmitȱfesterȱ Größe.ȱ Auchȱ wennȱ dieȱ Ressourceȱ physikalischȱ mitȱ mehrerenȱ Knotenȱ verbundenȱ ist,ȱ hatȱ dochȱ immerȱ nurȱ einȱ Knotenȱ Zugriffȱ darauf.ȱ Keinȱ Knotenȱ hatȱ Zugriffȱ aufȱ dieȱ Ressourcenȱ einesȱ anderenȱ Knotens.ȱ Beimȱ AuftretenȱeinesȱFehlersȱbeiȱeinemȱKnotenȱübernimmtȱeinȱandererȱKnoȬ tenȱdieȱSpeicherressourceȱ(Abbildungȱ8Ȭ4).ȱȱ Derȱ Vorteilȱ ist,ȱ dassȱkeinȱ Sperrmechanismusȱ(LockȬManagement)ȱnotȬ wendigȱist,ȱumȱeinenȱgleichzeitigenȱZugriffȱvonȱmehrȱalsȱeinemȱKnotenȱ aufȱ eineȱ Ressourceȱ zuȱ kontrollieren.ȱ Dasȱ istȱ beiȱ großenȱ ClustersysteȬ menȱvonȱVorteil,ȱdaȱhierȱkeinȱProtokolloverheadȱdieȱPerformanceȱverȬ ringernȱkann.ȱDerȱClusterȱkannȱtheoretischȱfastȱlinearȱskalieren.ȱNachȬ teiligȱ ist,ȱ dassȱ unterȱ Umständenȱ höhereȱ Investitionenȱ inȱ SpeicherresȬ

425ȱ

8ȱȱClusterȱ sourcenȱ notwendigȱ sind,ȱ daȱ dieȱ Datenȱ nichtȱ optimalȱ verteiltȱ werdenȱ können.ȱȱ Clusterȱ mitȱ einemȱ WindowsȬBetriebssystemȱ sindȱ immerȱ Sharedȱ NoȬ thingȬCluster.ȱBeiȱjedemȱKnotenȱhandeltȱesȱsichȱumȱeinȱeigenständigesȱ WindowsȬServersystem,ȱdasȱüberȱeineȱeigeneȱSystempartitionȱverfügt.ȱ Dasȱheißtȱaberȱnicht,ȱdassȱdieȱKnotenȱnichtȱaufȱgemeinsameȱSpeicherȬ ressourcenȱ zugreifenȱ können.ȱ Beiȱ diesenȱ handeltȱ esȱ sichȱ umȱ FestplatȬ tensysteme,ȱdieȱüberȱgeeigneteȱVerbindungenȱmitȱdenȱKnotenȱverbunȬ denȱsind.ȱUmȱdieȱKonsistenzȱderȱDatenȱsicherȱzuȱstellen,ȱistȱdieȱKomȬ munikationȱ derȱ Knotenȱ mitȱ derȱ gemeinsamenȱ Speicherressourceȱ nurȱ überȱdenȱClusterlinkȱundȱdieȱQuorumressourceȱmöglich.ȱBeimȱClusterȬ linkȱhandeltȱesȱsichȱumȱeineȱNetzwerkverbindung.ȱȱ QuorumȬ ressourceȱ

Dieȱ Quorumressourceȱ istȱ eineȱ Datenträgerressource,ȱ aufȱ derȱ sichȱ dieȱ Clusterdatenbankȱ befindet.ȱ Dieseȱ enthältȱ dieȱ ClusterkonfigurationsȬȱ undȱStatusdaten,ȱ dieȱfürȱdenȱ Betriebȱ desȱ Clustersȱ relevantȱ sind.ȱ Dazuȱ gehörenȱ x

dieȱAnzahlȱderȱKnoten,ȱdieȱamȱClusterȱangeschlossenȱsind,ȱ

x

dieȱZugehörigkeitȱderȱangeschlossenenȱRessourcenȱzuȱdenȱKnotenȱ undȱ

x

dieȱFailbackȬȱundȱFailoverȬEinstellungenȱderȱGruppenȱimȱCluster.ȱ

AllenȱKnotenȱdesȱClustersȱmussȱeinȱZugriffȱaufȱdieȱQuorumressourceȱ möglichȱsein.ȱDabeiȱistȱmitȱHilfeȱeinesȱLockȬMechanismusȱsicherzustelȬ len,ȱdassȱimmerȱnurȱeinȱKnotenȱZugriffȱdaraufȱhat,ȱumȱdieȱKonsistenzȱ derȱ Datenbankȱ zuȱ gewährleisten.ȱ Dieȱ Knotenȱ einesȱ Clustersȱ überwaȬ chenȱ sichȱ mitȱ Hilfeȱ einesȱ Abfragealgorithmusȱ permanentȱ gegenseitig,ȱ umȱ denȱ Ausfallȱ einesȱ oderȱ mehrererȱ Knotenȱ feststellenȱ zuȱ können.ȱ Dabeiȱ wirdȱ dieȱ Anzahlȱ derȱ aktivenȱ (antwortenden)ȱ Knotenȱ mitȱ derȱ Anzahlȱ derȱ Knotenȱ verglichen,ȱ dieȱ inȱ derȱ Clusterdatenbankȱ eingetraȬ genȱ sind.ȱDasȱ Quorumȱistȱ erfüllt,ȱ sobaldȱ alleȱ inȱderȱClusterdatenbankȱ eingetragenenȱKnotenȱaktivȱsind.ȱFallenȱeinȱoderȱmehrereȱKnotenȱaus,ȱ startetȱeineȱFehlerprozedur,ȱdieȱdenȱUmfangȱderȱvomȱAusfallȱbetroffeȬ nenȱ Ressourcenȱ ermittelt.ȱ Mitȱ Hilfeȱ derȱ Quorumressourceȱ wirdȱ dannȱ einȱ neuerȱ Clusterȱ gebildet.ȱ Derȱ ersteȱ Rechnerȱ imȱ Clusterȱ strebtȱ dabeiȱ denȱBesitzȱderȱQuorumressourceȱanȱundȱübernimmtȱdiese.ȱJederȱKnoȬ ten,ȱ derȱ währendȱ desȱStartprozessesȱ einesȱ Clustersȱkeinenȱ solchenȱ erȬ kennenȱkann,ȱversuchtȱaufȱdieȱQuorumressourceȱzuzugreifen,ȱdieseȱzuȱ übernehmenȱundȱeinenȱneuenȱClusterȱzuȱbilden.ȱ Gelingtȱ demȱ Knotenȱ derȱ Zugriffȱ aufȱ dieȱ Quorumressource,ȱ wirdȱ erȱ zumȱ erstenȱ Knotenȱ desȱ neuenȱ Clustersȱ undȱ verwaltetȱ dauerhaftȱ dieȱ

426ȱ

8.2ȱKlassifikationenȱvonȱClusternȱ Quorumressource.ȱ Schlägtȱ derȱ Zugriffȱ aufȱ dieȱ Quorumressourceȱ fehl,ȱ bedeutetȱdies,ȱdassȱbereitsȱeinȱandererȱKnotenȱdieseȱübernommenȱhatȱ undȱderȱKnotenȱdemȱClusterȱbeitretenȱkann.ȱDieȱQuorumressourceȱistȱ dieȱ gängigsteȱ Möglichkeit,ȱ umȱ Problemeȱ imȱ laufendenȱ Betriebȱ einesȱ Clustersȱ zuȱ erkennenȱ undȱ einenȱ neuenȱ Clusterȱ zuȱ bilden,ȱ ohneȱ dieȱ Gefahr,ȱdassȱTeilclusterȱgebildetȱwerden.ȱȱ BeiȱderȱArchitekturȱSharedȱDiskȱhatȱjederȱKnotenȱZugriffȱaufȱjedeȱamȱ Clusterȱ angeschlosseneȱ Speicherressourceȱ (Abbildungȱ 8Ȭ4).ȱ Umȱ dieȱ Konsistenzȱ derȱ Datenȱ sicherzustellen,ȱ istȱ einȱ LockȬManagementȱ notȬ wendig.ȱ Dabeiȱ handeltȱ esȱ sichȱ gewöhnlichȱ umȱ einȱ Protokoll,ȱ dasȱ denȱ Zugriffȱ aufȱ dieȱ Speicherressourcenȱ koordiniert.ȱ Möchteȱ Knotenȱ Aȱ aufȱ Datenȱ zugreifen,ȱ dieȱ geradeȱ durchȱ Knotenȱ Bȱ gesperrtȱ wurden,ȱ mussȱ Knotenȱ Aȱ soȱ langeȱ warten,ȱ bisȱ Knotenȱ Bȱ seineȱ Operationenȱ aufȱ dieȱ Datenȱ abgeschlossenȱ hatȱ [Riȱ 10].ȱ Vorteilhaftȱ beiȱ derȱ Sharedȱ DiskȬ Architekturȱ ist,ȱ dassȱ hierȱ dieȱ anfallendenȱ Datenmengenȱ gutȱ aufȱ dieȱ vorhandenenȱ Ressourcenȱ verteiltȱ werden.ȱ Nachteiligȱ ist,ȱ dassȱ mitȱ eiȬ nemȱ Anwachsenȱ derȱ Clustergrößeȱ derȱ Protokolloverheadȱ desȱ LockȬ MechanismusȱimmerȱmehrȱsteigtȱundȱsichȱdieȱGesamtperformanceȱdesȱ ClustersȱdurchȱdieȱimmerȱhäufigerȱvorkommendenȱWartezeitenȱwegenȱ gesperrterȱDatenȱverringert.ȱ

8.2.2 High Performance-Cluster Dasȱ Zielȱ beimȱ Einsatzȱ vonȱ Highȱ PerformanceȬClusternȱ (HPC)ȱ istȱ es,ȱ eineȱ möglichstȱ hoheȱ Rechenleistungȱ zuȱ erreichen.ȱ Dieseȱ Systemeȱ beȬ stehenȱinȱderȱRegelȱausȱgewöhnlichen,ȱhandelsüblichenȱPCsȱmitȱeinemȱ oderȱmehrerenȱProzessoren.ȱ Dieȱ Leistungȱ einesȱ Highȱ PerformanceȬClustersȱ lässtȱ sichȱ mitȱ deutlichȱ weniger,ȱ aberȱ dafürȱ sehrȱ vielȱ teurerenȱ Großrechnernȱ (Mainframes)ȱȱ erreichen.ȱ Vorteileȱ derȱ Highȱ PerformanceȬClusterȱ imȱ Gegensatzȱ zuȱ GroßrechnernȱsindȱderȱgeringeȱPreisȱundȱdieȱHerstellerunabhängigkeit.ȱ AusgefalleneȱHardwareȬKomponentenȱsindȱschnellȱundȱkostengünstigȱ zuȱbeschaffen.ȱDurchȱdenȱEinsatzȱweitererȱKnotenȱkannȱeinȱHighȱPerȬ formanceȬClusterȱ schnellȱ erweitertȱ undȱ seineȱ Leistungsfähigkeitȱ verȬ größertȱ werden.ȱ Derȱ großeȱ Nachteilȱ vonȱ Highȱ PerformanceȬClusternȱ istȱ derȱ imȱ Gegensatzȱ zuȱ Großrechnernȱ hoheȱ AdministrationsȬȱ undȱ Wartungsaufwand.ȱ Dieȱ gängigstenȱ Anwendungsbereicheȱ fürȱ Highȱ PerformanceȬClusterȱsind:ȱ x

VorȬȱundȱ Nachteileȱvonȱ Highȱ PerformanceȱȬ Clusternȱ

Pipelineberechnungen.ȱ Damitȱ sindȱ Anwendungenȱ gemeint,ȱ dieȱ eineȱSequenzȱalsȱErgebnisȱhaben.ȱHierȱwerdenȱvorwiegendȱÄndeȬ rungenȱanȱeinemȱZustandȱunterȱbestimmtenȱBedingungenȱberechȬ netȱundȱinȱvielenȱFällenȱauchȱvisualisiert.ȱ

427ȱ

8ȱȱClusterȱ

Anwendungs beispieleȱfürȱ Highȱ PerformanceȬȱ Clusterȱ

x

Anwendungen,ȱ dieȱ demȱ Prinzipȱ desȱ Divideȱ andȱ Conquerȱ folgen.ȱ Dieseȱ bildenȱ mehrereȱ Teilprobleme,ȱ wertenȱ dieseȱ ausȱ undȱ bildenȱ ausȱdenȱErgebnissenȱdasȱEndergebnis.ȱ

x

Anwendungen,ȱ dieȱ dazuȱ dienen,ȱ sehrȱ großeȱ Datenbeständeȱ ausȬ zuwerten.ȱ

Einigeȱ Anwendungsbeispieleȱ ausȱ demȱ breitenȱ Anwendungsgebietȱ sind:ȱ x

CrashȬTestȬSimulationȱ

x

Wettervorhersagenȱ

x

OptimierungȱvonȱBauteilenȱ

x

MonteȬCarloȬSimulationenȱ

x

Flugbahnberechnungenȱ

x

DataȱMiningȱ

x

Strömungsberechnungenȱ

x

Festigkeitsanalysenȱ

x

BerechnungȱvonȱFilmenȱoderȱFilmsequenzenȱ

x

SimulationenȱdesȱSternenhimmelsȱ

x

VariantenberechnungȱbeimȱSchachȱ

x

Primzahlberechnungenȱ

Hauptabnehmerȱ undȱ Nutznießerȱ solcherȱ Clusterȱ sindȱ inȱ derȱ Regelȱ Forschungseinrichtungenȱ imȱ naturwissenschaftlichenȱ Bereichȱ undȱ Unternehmenȱ inȱ denȱ Bereichenȱ Finanzdienstleistung,ȱ Automobilbau,ȱ RüstungȱundȱBiotechnologie.ȱWeitereȱtypischeȱEinsatzgebieteȱfürȱHighȱ PerformanceȬClusterȱsindȱApplikationsserver.ȱDatenhaltungȱundȱ–verȬ arbeitungȱ werdenȱ beiȱ diesemȱ Konzeptȱ getrennt.ȱ Mehrereȱ ApplikatiȬ onsserverȱ könnenȱ einenȱ Highȱ PerformanceȬClusterȱ bilden.ȱ Wennȱ fürȱ eineȱbestimmteȱApplikationȱ(oderȱBerechnung)ȱdieȱLeistungȱeinesȱoderȱ derȱ bereitsȱ reserviertenȱ Applikationsserverȱ nichtȱ ausreicht,ȱ könnenȱ automatischȱweitereȱzurȱVerfügungȱstehendeȱhinzugezogenȱwerden.ȱ

8.2.2.1 Beowulf BeowulfȬ Clusterȱ

428ȱ

Wirdȱ aufȱ einemȱ Highȱ PerformanceȬClusterȱ Linuxȱ oderȱ einȱ anderesȱ OpenSourceȬBetriebssystemȱ verwendet,ȱ inȱ denȱ allermeistenȱ Fällenȱ Linux,ȱ handeltȱ esȱ sichȱumȱ einenȱ BeowulfȬCluster.ȱDerȱ Nameȱ Beowulfȱ stammtȱvonȱdemȱgleichnamigenȱenglischenȱHeldeneposȱausȱdemȱelftenȱ

8.2ȱKlassifikationenȱvonȱClusternȱ Jahrhundert.ȱ Inȱ denȱ 3182ȱ Versenȱ desȱ Werkesȱ erfährtȱ derȱ Leserȱ vomȱ SchicksalȱdesȱjungenȱHeldenȱBeowulf,ȱderȱmitȱ14ȱGefährtenȱdieȱDänenȱ vorȱdemȱmenschenfressendenȱGrendel,ȱseinerȱMutterȱundȱeinemȱfeuerȬ speiendenȱDrachenȱbefreiteȱ[Toȱ01].ȱ ImȱJahrȱ1994ȱsuchtenȱdieȱbeidenȱWissenschaftlerȱThomasȱSterlingȱundȱ DonaldȱJ.ȱBeckerȱamȱGoddardȱSpaceȱFlightȱCenterȱ(GSFC)ȱimȱAuftragȱ derȱ Nationalȱ Aeronauticsȱ andȱ Spaceȱ Administrationȱ (NASA)ȱ nachȱ kostengünstigenȱ Alternativenȱ zumȱ herkömmlichenȱ Supercomputing.ȱ Dasȱ Teamȱ vernetzteȱ mehrereȱ handelsüblicheȱ LinuxȬPCsȱ mitȱ einemȱ 10MBitȱEthernetȬNetzwerkȱzuȱeinemȱClusterȱausȱ16ȱKnotenȱmitȱjeweilsȱ einemȱIntelȱ486ȱDX4ȬProzessorȱmitȱ100ȱMhz.ȱDieȱSoftwareȱdesȱClustersȱ bestandȱ ausschließlichȱ ausȱ freierȱ Software.ȱ Dazuȱ gehörtenȱ dasȱ BeȬ triebssystemȱ Linux,ȱ derȱ GNUȱ Compiler,ȱ dieȱ Parallelȱ Virtualȱ Machineȱ (PVM)ȱȱundȱdasȱMessageȱPassingȱInterfaceȱ(MPI).ȱDasȱSystemȱerreichteȱ aufȱeinemȱKnotenȱeineȱPerformanceȱvonȱ4,6ȱMFlopsȱundȱaufȱdenȱsechȬ zehnȱKnotenȱ60ȱMFlops.ȱSpäterȱerhieltȱdasȱProjektȱdenȱNamenȱBeowulfȱ [GLȱS02]ȱ[BaMeȱ06].ȱ

Entwicklungȱ desȱBeowulfȬ Clusteringȱ

BeowulfȬClusterȱsindȱkeineȱCOW/NOWȬSysteme.ȱZwarȱbestehenȱBeoȬ wulfȬClusterȱ auchȱ ausȱ gewöhnlichenȱ PCsȱ oderȱ Workstations,ȱ dochȱ dienenȱ dieȱ Knotenȱ einesȱ BeowulfȬClustersȱ ausschließlichȱ derȱ Arbeitȱ desȱClustersȱundȱwerdenȱnichtȱwährendȱderȱüblichenȱArbeitszeitenȱalsȱ ArbeitsplatzȬRechnerȱ verwendet.ȱ Dieȱ Bedienungȱ desȱ Clustersȱ erfolgtȱ überȱ einenȱ MasterȬKnoten.ȱ Dieserȱ übernimmtȱ auchȱ dieȱ AufgabenverȬ teilung.ȱ Dieȱ einzelnenȱ Knotenȱ verfügenȱ inȱ derȱ Regelȱ überȱ keinerleiȱ EingabeȬ/Ausgabemöglichkeitenȱ wieȱ Monitorȱ undȱ Tastatur,ȱ sondernȱ nurȱüberȱdieȱNetzwerkverbindung.ȱ Aufȱ BeowulfȬClusternȱ kommenȱ immerȱ OpenSourceȬBetriebssysteme,ȱ zumȱ Beispielȱ Linuxȱ oderȱ einȱ BSDȬUNIXȬDerivat,ȱ zumȱ Einsatz.ȱ Dasȱ sorgtȱfürȱSicherheitȱundȱVertrauen,ȱdaȱdieȱQuellenȱdesȱBetriebssystemsȱ offenȱliegenȱundȱeinsehbarȱsind,ȱundȱfürȱKostenminimierung,ȱdaȱkeineȱ Lizenzkostenȱanfallen.ȱ Einȱ Problemȱ beiȱ BeowulfȬClusternȱ ist,ȱ dassȱ dieȱ Knotenȱ ausȱ StandardȬ PCȬKomponentenȱ bestehenȱ undȱ dieseȱ nichtȱ redundant,ȱ alsoȱ aufȱ hoheȱ Verfügbarkeitȱ ausgelegtȱsind.ȱ Eineȱgroßeȱ Gefahrenquelleȱfürȱ dieȱKnoȬ tenȱeinesȱBeowulfȬClustersȱistȱdieȱKühlungȱderȱSystemȬKomponenten.ȱ Beiȱ StandardȬPCsȱ wirdȱ dieȱ CPUȱ durchȱ einenȱ Kühlkörperȱ undȱ einenȱ Lüfterȱ imȱ zulässigenȱ Temperaturbereichȱ gehalten.ȱ Dieȱ Kühlungȱ derȱ übrigenȱKomponentenȱübernehmenȱGehäuselüfterȱundȱderȱLüfterȱdesȱ Netzteils.ȱLüfterȱhabenȱwieȱalleȱmechanischenȱKomponentenȱnurȱeineȱ begrenzteȱLebensdauerȱundȱfallenȱoftȱohneȱVorwarnungȱaus.ȱAktuelleȱ

429ȱ

8ȱȱClusterȱ Prozessoren,ȱdieȱinȱPCsȱeingesetztȱwerden,ȱsindȱaberȱohneȱausreichenȬ deȱKühlungȱnichtȱfunktionsfähigȱ[GLSȱ02].ȱ Derȱ vonȱ Thomasȱ Sterlingȱ undȱ Donaldȱ J.ȱ Beckerȱ entwickelteȱ BeowulfȬ ClusterȱsollteȱspäterȱvieleȱNachahmerȱfinden.ȱEsȱwirdȱkaumȱeineȱForȬ schungseinrichtungȱ oderȱ Hochschuleȱ zuȱ findenȱ sein,ȱ inȱ derȱ nichtȱ weȬ nigstensȱ einȱ BeowulfȬClusterȱ existiert.ȱ Einȱ Grundȱ dafürȱ ist,ȱ dassȱ BeoȬ wulfȬClusterȱ heuteȱ nichtȱ mehrȱ zwangsläufigȱ selbstȬzusammengebauteȱ Systemeȱ darstellen,ȱ sondernȱ schlüsselfertigȱ gekauftȱ werdenȱ können.ȱ EinȱBlickȱinȱdieȱzweimalȱjährlichȱerscheinendeȱTOP500ȬListeȱ[Topȱ500]ȱ derȱ 500ȱ schnellstenȱ Computersystemeȱ zeigt,ȱ dassȱ BeowulfȬClusterȱ beȬ reitsȱ heuteȱ denȱ Marktȱ fürȱ Supercomputerȱ dominieren,ȱ undȱ dieserȱ TrendȱwirdȱsichȱaufgrundȱderȱfinanziellenȱVorteileȱundȱhohenȱFlexibiȬ litätȱderȱSystemeȱweiterȱfortsetzen.ȱ

8.2.2.2 Wolfpack WolfpackȬ Clusterȱ

Verwendetȱ dasȱ Systemȱ einȱ Betriebssystem,ȱ dasȱ nichtȱ OpenSourceȱ ist,ȱ z.B.ȱ Windows,ȱ bezeichnetȱ manȱ denȱ Clusterȱ alsȱ Wolfpackȱ oderȱ inȱ derȱ LiteraturȱoftȱalsȱWulfpack.ȱ WolfpackȱistȱderȱinterneȱCodenameȱfürȱMicrosoftsȱClusterȬLösung,ȱdieȱ 1997ȱalsȱBestandteilȱderȱWindowsȱNTȱ4.0ȱEnterpriseȱEditionȱveröffentȬ lichtȱwurde.ȱDerȱoffizielleȱNameȱwarȱMicrosoftȱClusterȱServerȱ(MSCS).ȱȱ

Windowsȱ Computeȱ ClusterȱServerȱ 2003ȱ

Steigerungȱ desȱ DatendurchȬ satzesȱmitȱ Highȱ Throughputȱ Clusternȱ

430ȱ

DasȱaktuelleȱProduktȱvonȱMicrosoftȱimȱBereichȱHochleistungsrechnenȱ istȱ derȱ Windowsȱ Computeȱ Clusterȱ Serverȱ 2003.ȱ Dabeiȱ handeltȱ esȱ sichȱ umȱeinȱPaket,ȱdasȱdenȱschnellenȱEinstiegȱinȱdasȱHochleistungsrechnenȱ mitȱ WindowsȬSystemenȱ ermöglichenȱ soll.ȱ Enthaltenȱ sindȱ u.a.ȱ einȱ Jobȱ Schedulerȱ undȱ eineȱ Implementierungȱ desȱ Messageȱ Passingȱ Interfaceȱ (MPI)ȱ.ȱZurȱBenutzerverwaltungȱwirdȱderȱDienstȱActiveȱDirectoryȱbeȬ nötigtȱ [ScStȱ 07].ȱ Derȱ Windowsȱ Computeȱ Clusterȱ Serverȱ 2003ȱ unterȬ stütztȱ nurȱ x64ȬArchitekturen.ȱ Einȱ Vorteilȱ desȱ Windowsȱ Computeȱ Clusterȱ Serverȱ 2003ȱ istȱ dieȱ vergleichsweiseȱ einfacheȱ Installationȱ undȱ dieȱ Integrationȱ allerȱ notwendigenȱ Komponentenȱ inȱ einemȱ Paket.ȱ NachteiligȱsindȱdieȱgeringereȱFlexibilitätȱundȱderȱhöhereȱPreis.ȱȱ

8.2.3 Cluster für hohen Datendurchsatz MitȱHighȱThroughputȬClusternȱ(HTC)ȱwirdȱversucht,ȱdenȱDatendurchȬ satzȱzuȱmaximieren.ȱDieseȱClusterȱbestehenȱinȱdenȱmeistenȱFällenȱausȱ WebȬȱ oderȱ MailȬServernȱ undȱ bildenȱ einenȱ Lastverbund.ȱ Dasȱ Highȱ Throughputȱ Clusteringȱ istȱ eineȱ Varianteȱ desȱ Highȱ Performanceȱ ClusȬ tering.ȱBeimȱklassischenȱHighȱPerformanceȱClusteringȱstelltȱsichȱimmerȱ dieȱFrage,ȱwieȱschnellȱeineȱumfangreicheȱBerechnungȱaufȱeinemȱClusȬ

8.2ȱKlassifikationenȱvonȱClusternȱ terȱ berechnetȱ werdenȱ kann.ȱ Beimȱ Highȱ Throughputȱ Clusteringȱ stelltȱ sichȱdieȱFrage,ȱwieȱvieleȱJobsȱeinȱClusterȱinȱeinerȱbestimmtenȱZeitȱbeȬ wältigenȱkann.ȱ FürȱeinzelneȱgroßeȱRechenaufträgeȱwerdenȱHighȱPerformanceȬClusterȱ eingesetzt.ȱWennȱesȱsichȱaberȱumȱsehrȱvieleȱkleinereȱAufträgeȱinȱeinerȱ kurzenȱ Zeitȱ handelt,ȱ dieȱ einzelnȱ theoretischȱ aufȱ einemȱ gewöhnlichenȱ PCȱ bewältigtȱ werdenȱ können,ȱ müssenȱ Highȱ ThroughputȬClusterȱ einȬ gesetztȱ werden.ȱ TypischeȱEinsatzgebieteȱ imȱ Highȱ Throughputȱ ClusteȬ ringȱ sindȱ WebȬServer.ȱ Suchmaschinenȱ wieȱ Google,ȱ AltaVistaȱ undȱ YaȬ hooȱbasierenȱaufȱsolchenȱClusternȱausȱ(WebȬ)Servern.ȱ DieȱArtȱundȱWeiseȱderȱVerteilungȱderȱAnfragenȱerfolgtȱimȱeinfachstenȱ Falleȱ nachȱ demȱ RoundȬRobinȬDNSȬSchedulingȬVerfahren.ȱ Dieȱ ersteȱ Anfrageȱ wirdȱ vomȱ Lastverteiler,ȱ derȱ inȱ diesemȱ Fallȱ hauptsächlichȱ alsȱ Nameserverȱ arbeitet,ȱ anȱ denȱ erstenȱ Knotenȱ imȱ Clusterȱ weitergeleitet.ȱ Dieȱ zweiteȱ Anfrageȱ leitetȱ derȱ Lastverteilerȱ anȱ denȱ zweitenȱ Knotenȱ imȱ Clusterȱ weiter,ȱ undȱ soȱ weiter.ȱ Daȱ alleȱ Knotenȱ dieȱ gleicheȱ HardȬȱ undȱ Softwareausstattungȱ haben,ȱ istȱ esȱ demȱ Benutzerȱ egal,ȱ welcherȱ Knotenȱ seineȱ Anfrageȱ bedient.ȱ Beiȱ gleichartigenȱ Anfragenȱ wirdȱ inȱ derȱ Regelȱ eineȱfastȱgleicheȱAuslastungȱallerȱbeteiligtenȱKnotenȱerreicht.ȱ

DasȱRoundȬ RobinȬDNSȬ SchedulingȬ Verfahrenȱ

8.2.4 Skalierbare-Cluster Skalierbareȱ Clusterȱ stellenȱ einenȱ Kompromissȱ zwischenȱ hoherȱ PerȬ formanceȱ undȱ Hochverfügbarkeitȱ dar.ȱ Beiȱ skalierbarenȱ Clusternȱ sindȱ einigeȱ oderȱ alleȱ Knotenȱ redundantȱ ausgelegt.ȱ Alleȱ Knotenȱ einesȱ solȬ chenȱ Clustersȱ erhaltenȱ vonȱ einemȱ Lastverteilerȱ Aufträgeȱ zugewiesen.ȱ Skalierbareȱ Clustersystemeȱ bestehenȱ üblicherweiseȱ ausȱ Servern,ȱ dieȱ Diensteȱanbieten.ȱInȱdenȱmeistenȱFällenȱhandeltȱesȱsichȱdabeiȱumȱWebȬȱ oderȱ MailȬServer.ȱ Dieȱ Knotenȱ desȱSystemsȱ überwachenȱ sichȱ gegenseiȬ tig.ȱAuchȱhierȱgeltenȱdieȱPrinzipienȱdesȱFailoverȱundȱFailback.ȱInȱAbȬ bildungȱ 8Ȭ5ȱ istȱ einȱ skalierbarerȱ Clusterȱ mitȱ 4ȱ Knotenȱ undȱ einemȱ LastȬ verteilerȱzuȱsehen.ȱKnotenȱ1ȱundȱ2ȱsowieȱKnotenȱ3ȱundȱ4ȱüberwachenȱ sichȱgegenseitig,ȱdamitȱbeiȱeinemȱAusfallȱimmerȱeinȱKnotenȱdieȱDiensȬ teȱdesȱausgefallenenȱübernehmenȱkann.ȱ

Skalierbareȱ Clusterȱ vereinenȱhoheȱ Performanceȱ undȱ HochverfügȬ barkeitȱ

ȱ ȱ ȱ ȱ ȱ ȱ

431ȱ

8ȱȱClusterȱ ȱ ȱ Abb.ȱ8Ȭ5:ȱȱȱȱȱ ȱ Einȱ skalierbarerȱ Clusterȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

8.3 Zugangs-Konzepte Esȱ existierenȱ zweiȱ unterschiedlicheȱ Konzepte,ȱ wieȱ dieȱ verbundenenȱ Ressourcenȱ einesȱ Clustersȱ untereinanderȱ undȱ mitȱ derȱ Außenweltȱ kommunizieren:ȱ DasȱExposedȬȱ undȱEnclosedȬ Konzeptȱ

1.

Exposedȱ

2.

Enclosedȱ

DasȱExposedȬKonzeptȱwirdȱauchȱalsȱoffeneȱKommunikationȱbezeichnet,ȱ daȱ dieȱ Kommunikationȱ derȱ Knotenȱ miteinanderȱ ungeschütztȱ ist.ȱ Beiȱ diesemȱ Konzeptȱ sindȱ alleȱ Knotenȱ fürȱ externeȱ Systemeȱ sichtbar.ȱ Dieȱ Knotenȱ einesȱ Clustersȱ mitȱ ExposedȬKommunikationȱ sindȱ überȱ einȱ loȬ kalesȱNetzwerk,ȱz.B.ȱEthernet,ȱmiteinanderȱverbunden.ȱȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

432ȱ

8.3ȱZugangsȬKonzepteȱ ȱ

Abb.ȱ8Ȭ6:ȱȱȱȱ DasȱExposedȬȱ undȱEnclosedȬ Konzeptȱderȱ KommunikaȬ tionȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ InȱAbbildungȱ8Ȭ6ȱistȱeinȱClusterȬSystemȱzuȱsehen,ȱdessenȱKnotenȱnachȱ demȱExposedȬKonzeptȱverbundenȱsind.ȱNachteileȱbeiȱdiesemȱKonzeptȱ sind:ȱ x

Dieȱ verwendetenȱ Standardprotokolleȱ erzeugenȱ oftȱ einenȱ hohenȱ Overheadȱundȱsindȱdadurchȱineffizient.ȱ

x

SicherheitsmechanismenȱmüssenȱaufȱjedemȱKnotenȱimplementiertȱ sein,ȱumȱDatenȱvorȱZugriffȱvonȱaußenȱzuȱschützen.ȱ

Nachteileȱdesȱ ExposedȬ Konzeptsȱ

433ȱ

8ȱȱClusterȱ x

Esȱ müssenȱ geschützte,ȱ verschlüsselteȱ Kommunikationskanäleȱ zwischenȱ denȱ Knotenȱ möglichȱ sein,ȱ daȱ dieȱ Kommunikationȱ zwiȬ schenȱ denȱ Knotenȱ unsicherȱ ist.ȱ Derȱ fürȱ dieȱ Sicherheitȱ derȱ Datenȱ notwendigeȱ Aufwandȱ vergrößertȱ denȱ NetzwerkȬOverheadȱ undȱ dieȱfürȱdieȱKommunikationȱbenötigteȱRechenleistung.ȱ

Vorteileȱdesȱ ExposedȬ Konzeptsȱ

Dasȱ ExposedȬKonzeptȱ bringtȱ aberȱ auchȱ Vorteileȱ mitȱ sich.ȱ Durchȱ dieȱ VerwendungȱeinesȱbestehendenȱlokalenȱNetzwerksȱergibtȱsichȱfürȱdieȱ Vernetzungȱ derȱ Knotenȱ einȱ sehrȱ günstigerȱ Preis,ȱ daȱ keinȱ neuesȱ NetzȬ werkȱ angeschafftȱ undȱ verlegtȱ werdenȱ muss.ȱ Rechner,ȱ dieȱ nichtȱ zumȱ Cluster,ȱ aberȱ amȱ gleichenȱ lokalenȱ Netzwerkȱ angeschlossenȱ sind,ȱ könȬ nenȱ beiȱ Leistungsengpässenȱ oderȱ knappenȱ Ressourcenȱ demȱ Clusterȱ schnellȱzugeordnetȱwerden.ȱ

Vorteileȱdesȱ EnclosedȬ Konzeptsȱ

Beiȱ demȱ EnclosedȬKonzeptȱ handeltȱ esȱ sichȱ umȱ eineȱ geschlosseneȱ Kommunikation.ȱ Dieȱ Kommunikationȱ derȱ Knotenȱ miteinanderȱ istȱ geȬ schützt.ȱUmȱdieȱinterneȱKommunikationȱdesȱClustersȱvonȱderȱAußenȬ weltȱabzuschirmenȱexistiertȱeinȱzweitesȱNetzwerkȱ(Abbildungȱ8Ȭ6),ȱdasȱ nurȱdieȱKnotenȱdesȱClustersȱmiteinanderȱverbindet.ȱDurchȱdieȱEinrichȬ tungȱ diesesȱ zweitenȱ Netzwerksȱ entfallenȱ dieȱ Probleme,ȱ dieȱ dasȱ ExpoȬ sedȬKonzeptȱmitȱsichȱbringt.ȱDerȱKommunikationsȬOverheadȱistȱgering,ȱ daȱ keineȱ vorgegebenenȱ Standardsȱ oderȱ sonstigeȱ Regelnȱ fürȱ dieȱ KomȬ munikationȱeinzuhaltenȱsind.ȱ Außerȱ fürȱ denȱ Masterknoten,ȱ derȱ mitȱ derȱ Außenweltȱ verbundenȱ ist,ȱ müssenȱ keineȱ Sicherheitsmechanismenȱ implementiertȱ sein.ȱ Wederȱ dieȱ Benutzer,ȱ nochȱ irgendwelcheȱ Rechnersystemeȱ außerhalbȱ desȱ Clustersȱ könnenȱ einzelneȱ Ressourcenȱ desȱ Clustersȱ direktȱ ansprechen.ȱ Nurȱ derȱ ClusterȱalsȱGesamtsystemȱistȱvonȱaußenȱsichtbar.ȱȱ

Nachteileȱdesȱ EnclosedȬ Konzeptsȱ

DerȱeinzigeȱNachteil,ȱderȱsichȱbeimȱEnclosedȬKonzeptȱergibt,ȱsindȱdieȱ Kostenȱ undȱderȱAufwand,ȱ derȱfürȱ dieȱAnschaffungȱundȱdasȱVerlegenȱ desȱzweitenȱNetzwerksȱanfällt.ȱ DerȱMasterknoten,ȱauchȱPrimaryȱClusterȱNodeȱgenannt,ȱistȱinȱderȱReȬ gelȱinȱ seinerȱLeistungsfähigkeitȱ großzügigerȱ dimensioniertȱalsȱ dieȱ übȬ rigenȱ Knoten,ȱ dieȱ SlaveȬ,ȱ bzw.ȱ SecondaryȬKnoten.ȱ Cluster,ȱ beiȱ denenȱ zwischenȱMasterȬȱundȱSlaveknotenȱunterschiedenȱwird,ȱsindȱüblicherȬ weiseȱhomogeneȱCluster.ȱBisȱaufȱdenȱMasterknotenȱverfügenȱdieȱKnoȬ tenȱ überȱ eineȱ identischeȱ HardȬȱ undȱ Softwareausstattung.ȱ Einȱ AnwenȬ dungsgebietȱ vonȱ MasterȬSlaveȬClusternȱ istȱ derȱ Domainȱ Nameȱ Serviceȱ (DNS).ȱ ȱ ȱ

434ȱ

9 Grid-Computing Inȱ vielenȱ Fachbereichenȱ derȱ Wissenschaftȱ undȱ Industrieȱ steigenȱ UmȬ fangȱundȱKomplexitätȱderȱbenötigtenȱDatenȱundȱderȱdamitȱverbundeȬ nenȱVerarbeitungsprozesseȱrasantȱan,ȱwasȱschonȱzurȱEntwicklungȱundȱ Etablierungȱ desȱ ClusterȬComputingsȱ geführtȱ hat.ȱ Besondersȱ großȱ istȱ derȱBedarfȱnachȱimmerȱmehrȱRechenleistungȱundȱSpeicherplatzȱinȱdenȱ Naturwissenschaftenȱ undȱ Ingenieurwissenschaften,ȱ aberȱ auchȱ inȱ derȱ KlimaforschungȱundȱderȱMedizin.ȱȱ

Steigenderȱ Bedarfȱnachȱ RechenȬ leistungȱundȱ Speicherplatzȱ

ZurȱgleichenȱZeitȱbewegtȱsichȱdieȱwissenschaftlicheȱArbeitsweltȱimmerȱ mehrȱ inȱ Richtungȱ standortübergreifender,ȱ internationalerȱ KooperatioȬ nen.ȱ Derȱ Einsatzȱ modernerȱ Informationsinfrastrukturenȱ undȱ –techȬ nologienȱ aufȱ Basisȱ desȱ GridȬComputingȱ schafftȱ dieȱ Voraussetzungenȱ fürȱ neueȱ kollaborativeȱ Arbeitsumgebungen.ȱ alsȱ eȬScienceȱ bezeichneteȱ Entwicklung.ȱ Dasȱ GridȬComputingȱ kannȱ somitȱ alsȱ eineȱ logische,ȱ ortȬ sungebundeneȱ Weiterentwicklungȱ desȱ ClusterȬComputingȱ angesehenȱ werden.ȱ

Vermehrtȱ standortüberȬ greifendeȱ KooperaȬ tionenȱ

9.1 Definition Grid Perȱ Definitionȱ istȱ dasȱ GridȬComputingȱ eineȱ Technikȱ zurȱ Integrationȱ undȱ gemeinsamen,ȱ institutionsübergreifenden,ȱ ortsunabhängigenȱ Nutzungȱ verteilterȱ Ressourcenȱ aufȱ Basisȱ bestehenderȱ KommunikatiȬ onsinfrastrukturenȱwieȱz.B.ȱdemȱInternet.ȱȱ DieseȱgemeinsameȱNutzungȱderȱRessourcenȱerfolgtȱinȱvirtuellenȱOrgaȬ nisationenȱ (VO),ȱ inȱ denenȱ Ressourcenȱ dynamischȱ Benutzernȱ imȱ Gridȱ zugewiesenȱ werden.ȱ Dieseȱ Funktionalitätȱ erfordertȱ eineȱ Infrastruktur,ȱ dieȱeinenȱstabilenȱBetrieb,ȱDatensicherheitȱundȱDatenschutzȱgarantiert.ȱ

Integrationȱ undȱ gemeinsame,ȱ ortsunabȬ hängigeȱ Nutzungȱ verteilterȱ Ressourcenȱ

Dasȱ Hauptunterscheidungsmerkmalȱ vonȱ GridȬComputingȱ gegenüberȱ ClusterȬComputingȱ ist,ȱ dassȱ dieȱ Ressourcenȱ inȱ einemȱ Gridȱ üblicherȬ weiseȱ verschiedenen,ȱ unabhängigenȱ Organisationenȱ (öffentlichenȱ undȱ wissenschaftlichenȱ Einrichtungen,ȱ Unternehmen,ȱ Privatpersonen)ȱ anȬ gehören,ȱ dieȱ sichȱ selbstȱ umȱ derenȱ Verwaltungȱ kümmern.ȱ Dieȱ BeȬ triebsmittelȱeinesȱClustersȱgehörenȱ inȱ derȱRegelȱ nurȱzuȱ einerȱ einzigenȱ administrativenȱEinheitȱundȱwerdenȱvonȱdieserȱbetriebenȱundȱverwalȬ tet.ȱȱ

435ȱ

9ȱȱGridȬComputingȱ heterogenerȱ Aufbau,ȱaberȱ homogenesȱ Auftretenȱ

Einȱ weitererȱ Unterschiedȱ bestehtȱ darin,ȱ dassȱ ClusterȬSystemeȱ oftȱ ausȱ homogenenȱ Ressourcenȱ aufgebautȱ sind,ȱ währendȱ Gridsȱ immerȱ ausȱ heterogenenȱRessourcenȱbestehen,ȱdieȱsichȱfürȱdenȱBenutzerȱaberȱmögȬ lichstȱhomogenȱdarstellenȱsollen.ȱ Beiȱ denȱ imȱ Gridȱ eingebundenenȱ Ressourcenȱ handeltȱ esȱ sichȱ inȱ ersterȱ Linieȱ umȱ Rechenleistungȱ undȱ Speicherkapazitätȱ sowieȱ spezielle,ȱ wisȬ senschaftlicheȱ Hardwareȱ (z.B.ȱ Teleskope),ȱ Dateienȱ undȱ Datenbanken.ȱ Denkbarȱ sindȱ aberȱ auchȱ spezielleȱ Softwareinstallationenȱ bzw.ȱ SoftȬ warelizenzen.ȱ Einigeȱ derȱ zentralenȱ Fragen,ȱ dieȱ sichȱ beimȱ GridȬComputingȱ stellen,ȱ sind:ȱ

Dreiȱ Kriterien,ȱ dieȱeinȱGridȱ erfüllenȱmussȱ

x

VerfügbarkeitȱundȱQualitätȱderȱRessourcenȱ(QualityȱofȱService),ȱ

x

AbrechnungȱderȱabgerufenenȱRessourcenȱ(AccountingȱundȱBilling),ȱȱ

x

ÜberwachungȱderȱverbundenenȱRessourcenȱ(Monitoring),ȱȱ

x

GewährleistungȱvonȱSicherheitȱundȱDatenschutzȱ(Security)ȱundȱ

x

GradȱderȱBenutzbarkeitȱ(z.B.ȱSingleȱSignȬOn).ȱ

IanȱFoster,ȱeinerȱderȱPioniereȱderȱGridȬForschung,ȱnenntȱinȱseinerȱAusȬ arbeitungȱ„Whatȱ isȱ theȱ Grid?ȱ Aȱ ThreeȱPointȱ Checklist“ȱ dreiȱKriterien,ȱ dieȱeinȱGridȱerfüllenȱmussȱ[Fos02]:ȱ 1.

2.

3.

436ȱ

Einȱ Gridȱ koordiniertȱ unterschiedlichsteȱ Artenȱ vonȱ dezentralenȱ Ressourcen.ȱ Dazuȱ gehörenȱ StandardȬPCs,ȱ Workstations,ȱ GroßȬ rechner,ȱCluster,ȱusw.ȱBenutzergruppenȱsindȱinȱsog.ȱVirtuellenȱOrȬ ganisationenȱzusammengefasst.ȱ Gridsȱ verwendenȱ offene,ȱ standardisierteȱ Protokolleȱ undȱ SchnittȬ stellen.ȱ Daȱ inȱ einemȱ Gridȱ wichtigeȱ Punkteȱ wieȱ Authentifikation,ȱ AutorisierungȱundȱdasȱAuffindenȱundȱAnfordernȱvonȱDienstenȱeiȬ neȱfundamentaleȱRolleȱspielen,ȱmüssenȱdieȱverwendetenȱProtokolȬ leȱundȱSchnittstellenȱoffenȱundȱstandardisiertȱsein.ȱAnsonstenȱhanȬ deltȱesȱsichȱumȱeinȱapplikationsspezifischesȱSystemȱundȱnichtȱumȱ einȱGrid.ȱ Gridsȱ bietenȱ unterschiedliche,ȱ nichtȬtrivialeȱ Dienstqualitätenȱ an.ȱ Dieȱ verschiedenenȱ Ressourcenȱ einesȱ Gridsȱ offerierenȱ zusammenȱ genommenȱeineȱVielzahlȱvonȱMöglichkeitenȱimȱBezugȱaufȱDurchȬ satz,ȱ Sicherheit,ȱ Verfügbarkeitȱ undȱ Rechenleistung.ȱ Derȱ Nutzenȱ derȱzuȱeinemȱGridȱzusammengeschlossenenȱSystemeȱistȱgrößerȱalsȱ dieȱSummeȱderȱeinzelnenȱTeile.ȱ

9.2ȱUnterscheidungȱvonȱGridsȱ DerȱBegriffȱGridȱ(deutsch:ȱGitter)ȱkommtȱursprünglichȱvonȱeinemȱVerȬ gleichȱ derȱ GridȬTechnologieȱ mitȱ demȱ Stromnetzȱ [FoKeȱ 99].ȱ Zielȱ desȱ GridȬComputingȱsollȱesȱsein,ȱgenauȱsoȱeinfachȱComputingȬRessourcenȱ überȱ dasȱ Gridȱ zuȱ beziehenȱ undȱ abzurechnen,ȱ wieȱ Stromȱ ausȱ einerȱ SteckdoseȱzuȱbeziehenȱundȱmonatlichȱüberȱdieȱStromrechnungȱzuȱbeȬ zahlen.ȱȱ

GridȬ Computingȱistȱ vergleichbarȱ mitȱdemȱ Stromnetzȱ

EinȱGridȱundȱdasȱStromnetzȱhabenȱgemein,ȱdassȱesȱdenȱmeistenȱBenutȬ zernȱeigentlichȱegalȱist,ȱwoȱdieȱRessourcenȱ(RechenzentrenȱoderȱKraftȬ werke)ȱ sichȱ befindenȱ bzw.ȱ wemȱ sieȱ gehören,ȱ solangeȱ dasȱ Systemȱ verȬ lässlichȱfunktioniert.ȱȱ

9.2 Unterscheidung von Grids FrüheȱGridȬProjekteȱinȱdenȱ90erȱJahrenȱwurdenȱausȱAnwendungssichtȱ inȱdieȱzweiȱGruppenȱunterschieden:ȱ x

ComputationalȱGridsȱ

x

DataȱGridsȱ

Beiȱ Computationalȱ Gridsȱ istȱ dieȱ Rechenleistungȱ dieȱ entscheidendeȱ Größe.ȱ Dieseȱ Gridsȱ bestehenȱ ausȱ heterogenenȱ Rechnersystemen.ȱ Dasȱ heißt,ȱdassȱdieȱmitȱdemȱGridȱverbundenenȱProzessorenȱunterschiedlichȱ sind,ȱ wasȱ ihreȱ Geschwindigkeit,ȱ Architekturȱ undȱ dasȱ verwendeteȱ BeȬ triebssystemȱangeht.ȱEntsprechendȱderȱverwendetenȱRechnerhardwareȱ unterscheidetȱ manȱ dreiȱ Gruppenȱ vonȱ Computationalȱ Gridsȱ [Ahm04].ȱ InternetbasierteȱDistributedȱComputingȬProjekteȱwieȱSETI@home,ȱFolȬ ding@homeȱundȱRC5Ȭ72ȱwerdenȱanȱmanchenȱStellenȱauchȱalsȱCompuȬ tationalȱ Gridsȱ bezeichnet,ȱ wasȱ irreführendȱ ist.ȱ Beiȱ genauererȱ BetrachȬ tungȱwirdȱaberȱersichtlich,ȱdassȱesȱsichȱbeiȱdiesenȱDistributedȱCompuȬ tingȬProjektenȱ umȱ PeerȬtoȬPeerȬApplikationenȱ handelt,ȱ dieȱ bestenfallsȱ Computationalȱ Gridsȱ derȱ erstenȱ Generationȱ [Fosȱ 02]ȱ sind.ȱ Derȱ Grundȱ ist,ȱdassȱdieseȱProjekteȱspezielleȱProtokolleȱeinsetzen,ȱdieȱinȱderȱRegelȱ nichtȱoffenȱundȱstandardisiertȱsind.ȱ BeiȱDataȱGridsȱistȱesȱdasȱZiel,ȱdenȱTeilnehmernȱdenȱZugangȱzuȱverteilȬ tenȱ Speicherressourcenȱ überȱ RechnerȬ,ȱ OrganisationsȬȱ undȱ eventuellȱ Landesgrenzenȱ hinwegȱ zuȱ ermöglichenȱ [Wieȱ 04].ȱ InternetȬ Tauschbörsenȱ wieȱ Napster,ȱ Kazaaȱ undȱ Gnutellaȱ werdenȱ anȱ manchenȱ StellenȱauchȱalsȱDataȱGridsȱbezeichnet,ȱundȱtatsächlichȱhatȱdasȱPeerȬtoȬ PeerȬComputingȱ zumȱ Datenaustauschȱ ähnlicheȱ Zieleȱ wieȱ dasȱ (DataȬ)ȱ GridȬComputing.ȱ Allerdingsȱ liegtȱ einȱ wesentlicherȱ Unterschiedȱ zwiȬ schenȱ GridȬComputingȱ undȱ PeerȬtoȬPeerȱ darin,ȱ dassȱ letzteresȱ keineȱ ProtokollȬArchitekturȱ besitzt.ȱ Einȱ weitererȱ Unterschiedȱ ist,ȱ dassȱ PeerȬ

MitȱComputaȬ tionalȱGridsȱ RechenleisȬ tungȱbereitȱ stellenȱ

MitȱDataȱ Gridsȱ SpeicherȬ ressourcenȱ bereitȱstellenȱ

437ȱ

9ȱȱGridȬComputingȱ toȬPeerȱ imȱ Gegensatzȱ zumȱ Gridȱ keineȱ zentralenȱ Diensteȱ anstrebt.ȱ Beiȱ InternetȬTauschbörsenȱ handeltȱ esȱ sichȱ umȱ PeerȬtoȬPeerȬApplikationenȱ undȱ nurȱ unterȱ wohlwollenderȱ Betrachtungȱ umȱ sehrȱ einfacheȱ Dataȱ Grids.ȱDieseȱProjekteȱsetzenȱgenauȱwieȱComputationalȱGridsȱderȱerstenȱ GenerationȱProtokolleȱein,ȱdieȱinȱderȱRegelȱwederȱoffenȱnochȱstandarȬ disiertȱsind.ȱ Gridsȱ verfolgenȱ heuteȱ universelleȱ Zieleȱ

AktuelleȱGridȬInfrastrukturenȱverfolgenȱuniverselleȱZieleȱundȱwerdenȱ nichtȱnurȱfürȱeineȱArtȱvonȱRessourcenȱkonzipiert,ȱsondernȱermöglichenȱ dieȱgemeinsameȱVerwendungȱallerȱdenkbarenȱITȬRessourcen.ȱDaherȱistȱ eineȱ Differenzierungȱ inȱ Dataȱ Gridsȱ undȱ Computationalȱ Gridsȱ nichtȱ mehrȱzeitgemäß.ȱ

GridȱAufbauȬ schemenȱ

Eineȱ weitereȱ Unterscheidungsmöglichkeitȱ vonȱ GridȬProjektenȱ istȱ dieȱ UnterscheidungȱinȱIntraȬ,ȱExtraȬȱundȱInterȬGrids:ȱ x

IntraȬGridsȱsindȱVerbündeȱvonȱClusternȱeinerȱeinzelnenȱOrganisaȬ tion.ȱ

x

ExtraȬGridsȱ sindȱ eineȱ Vernetzungȱ vonȱ mindestensȱ zweiȱ IntraȬ Gridsȱ einerȱ einzelnenȱ Organisationȱ überȱ geografischeȱ Distanzen.ȱ ExtraȬGridsȱ sindȱ genauȱ wieȱ IntraȬGridsȱ nurȱ einerȱ geschlossenenȱ Benutzergruppeȱzugänglich.ȱ

x

InterȬGridsȱsindȱoffenȱundȱerstreckenȱsichȱüberȱgroßeȱgeografischeȱ Distanzen.ȱ Mehrereȱ verschiedeneȱ Organisationenȱ sindȱ anȱ einemȱ InterȬGridȱbeteiligt.ȱ

Aktuellȱ handeltȱ esȱ sichȱ beiȱ denȱ meistenȱ GridȬInstallationenȱ umȱ IntraȬ Grids,,ȱundȱdiesesȱAufbauschemaȱistȱauchȱdasȱvonȱderȱIndustrieȱfavoȬ risierte,ȱ daȱ esȱ dieȱ wenigstenȱ potentiellenȱ Sicherheitsrisikenȱ mitȱ sichȱ bringt.ȱ Inȱ Wissenschaftȱ undȱ Forschungȱ sindȱ InterȬGridsȱ dieȱ Basisȱ derȱ meistenȱGridȬProjekte.ȱȱ

9.3 Grid Middleware-Systeme InteroperaȬ bilitätȱdurchȱ Gridȱ Middlewareȱ

438ȱ

Eineȱ derȱ größtenȱ Herausforderungenȱ beimȱ Aufbauȱ vonȱ Gridsȱ liegtȱ inȱ derȱ allgemeinverbindlichenȱ Definitionȱ vonȱ Protokollenȱ undȱ Diensten,ȱ dieȱ dieȱ Interoperabilitätȱ vonȱ Systemenȱ undȱ Anwenderprogrammenȱ überhauptȱ erstȱ garantieren.ȱ DerȱSammelbegriffȱfürȱdieȱ benötigteȱ stanȬ dardisierteȱ VermittlungsȬȱ undȱ Verwaltungssoftwareȱ istȱ Middleware.ȱ Dieȱ Middlewareȱ stelltȱ dieȱ Schichtȱ desȱ GridȬComputingȱ dar,ȱ aufȱ dieȱ verteilteȱ Anwendungenȱ aufbauenȱ können.ȱ Dasȱ StandardisierungsgreȬ miumȱ fürȱ GridȬComputingȱ istȱ dasȱ Openȱ Gridȱ Forumȱ (OGF),ȱ inȱ welȬ chemȱVertreterȱausȱWissenschaftȱundȱIndustrieȱzusammenarbeiten.ȱDieȱ Openȱ Gridȱ Servicesȱ Architectureȱ (OGSA)ȱ definiertȱ inȱ diesemȱ Bereichȱ

9.3ȱGridȱMiddlewareȬSystemeȱ einenȱ standardisiertenȱ Architekturplanȱ fürȱ dasȱ Zusammenspielȱ derȱ zugehörigenȱ GridȬServicesȱ [OGSA].ȱ Meistȱ kommenȱ beiȱ derȱ RealisieȬ rungȱvonȱOGSAȱWebȬServicesȱzumȱEinsatz.ȱDasȱWebȱServiceȱResourceȱ Frameworkȱ(WSRF)ȱlegtȱdabeiȱeinenȱstandardisiertenȱSatzȱvonȱSchnittȬ stellenȱundȱProtokollenȱfestȱ[WSRF].ȱȱȱ Inȱ diesemȱ Abschnittȱ werdenȱ dieȱ dreiȱ bekanntestenȱ Gridȱ MiddlewareȬ Systemeȱdiskutiert:ȱdasȱGlobusȱToolkit,ȱgLiteȱundȱUnicore.ȱ

9.3.1 Globus Toolkit Dasȱ vonȱ derȱ Globusȱ Allianceȱ entwickelteȱ Globusȱ Toolkitȱ realisiertȱ einȱ GridȬSystemȱaufȱderȱBasisȱvonȱOGSAȱundȱimplementiertȱentsprechenȬ deȱOpenȬSourceȬWerkzeugeȱundȱProtokolleȱ[Globus].ȱȱ

Middlewareȱ Globusȱ Toolkitȱ

Globusȱ4ȱnutztȱWebȱServices.ȱDieserȱBegriffȱbeschreibtȱimȱAllgemeinenȱ eineȱ Mengeȱ vonȱ Funktionenȱ zurȱ Kommunikationȱ inȱ heterogenenȱ verȬ teiltenȱSystemen.ȱWebȱServicesȱbasierenȱaufȱeinfachȱzuȱbeherrschenden,ȱ aberȱ weitȱ verbreitetenȱ Standardsȱ wieȱ XMLȱ undȱ bietenȱ PlattformȬȱ undȱ Sprachenunabhängigkeit.ȱ Dieȱ Openȱ Gridȱ Serviceȱ Infrastructureȱ beȬ schreibtȱMechanismenȱzumȱ x

Erschaffen,ȱ

x

Kontrollierenȱoderȱ

x

AustauschȱvonȱInformation.ȱ

zwischenȱ zweiȱ Webȱ ServiceȬInstanzen.ȱ Dieȱ Verwendungȱ desȱ OGSAȬ StandardsȱstelltȱeineȱuneingeschränkteȱInteroperabilitätȱsicher.ȱ VorteileȱdasȱGlobusȱToolkitȱ4ȱsind:ȱȱ x

Globusȱ Toolkitȱ 4ȱ setztȱ aufȱ denȱ Standardsȱ desȱ Webȱ Servicesȱ ReȬ sourceȱFrameworkȱ(WSRF)ȱauf.ȱ

x

DurchȱdieȱModularitätȱdesȱGlobusȱToolkitȱistȱesȱleichtȱerweiterbar,ȱ daȱeinzelneȱKomponentenȱausgetauschtȱwerdenȱkönnen.ȱȱ

NachteileȱdasȱGlobusȱToolkitȱ4ȱsind:ȱ x

Dasȱ Globusȱ Toolkitȱ istȱ keinȱ vertikalȱ integriertesȱ System,ȱ sondernȱ nurȱ einȱ Baukasten.ȱ Diesesȱ bringtȱ zwarȱ eineȱ hoheȱ Flexibilitätȱ mitȱ sich,ȱmachtȱdieȱInbetriebnahmeȱaberȱauchȱaufwändiger.ȱȱ

x

EsȱexistiertȱkeinȱGUI.ȱ

439ȱ

9ȱȱGridȬComputingȱ

9.3.2 gLite Middlewareȱ gLiteȱ

Dieȱ„LightweightȱMiddlewareȱforȱGridȱComputing“,ȱkurzȱgLite,ȱistȱausȱ demȱ LHCȱ Computingȱ Gridȱ (LCG)ȬProjektȱ desȱ CERNȱ hervorgegangenȱ undȱwirdȱimȱRahmenȱdesȱeuropäischenȱProjektsȱ„EnablingȱGridsȱforȱEȬ SciencEȱ(EGEE)“ȱgefördertȱundȱweiterȱentwickeltȱ[EGEE].ȱ VorteileȱvonȱgLiteȱsind:ȱ

Vorteileȱvonȱ gLiteȱ

x

gLiteȱ istȱ dieȱ weltweitȱ größte,ȱ reinȱ wissenschaftlichȱ genutzteȱ GridȬ MiddlewareȱimȱProduktionsstatus.ȱȱ

x

gLiteȱ istȱ eineȱ vollständigeȱ GridȬLösung,ȱ dieȱ nichtȱ nurȱ RechenresȬ sourcenȱ verwaltet,ȱ sondernȱ auchȱ Datenressourcenȱ undȱ FileȬ Kataloge.ȱ Zusätzlichȱ gibtȱ esȱ MonitoringȬ,ȱ LoggingȬȱ undȱ AccounȬ tingȬFunktionalitäten.ȱ

x

DasȱKonzeptȱderȱVirtuellenȱOrganisationenȱistȱinȱgLiteȱrealisiert.ȱ

x

Esȱ istȱ möglich,ȱ einzelneȱ Lokationenȱ gezieltȱ anzusprechen,ȱ aberȱ üblicherweiseȱ legtȱ einȱ Resourceȱ Brokerȱ selbstständigȱ nachȱ wahlȬ freienȱ Kriterienȱ fest,ȱ welcherȱ Ortȱ amȱ bestenȱ fürȱ einenȱ bestimmtenȱ Auftragȱgeeignetȱist.ȱȱ

NachteileȱvonȱgLiteȱsind:ȱ Nachteileȱvonȱ gLiteȱ

x

DieȱPortabilitätȱvonȱgLiteȱistȱsehrȱeingeschränkt.ȱgLiteȱwirdȱzurzeitȱ nurȱ fürȱ dasȱ Betriebssystemȱ Scientificȱ Linuxȱ 3ȱ (32ȱ Bit)ȱ ausgeliefert.ȱ Portierungenȱ aufȱ andereȱ LinuxȬDistributionenȱ sindȱ prinzipiellȱ möglich,ȱaberȱaufwändig.ȱSoȱsetztȱzumȱBeispielȱdieȱGesellschaftȱfürȱ Schwerionenphysikȱ (GSI)ȱ inȱ Darmstadtȱ gLiteȱ unterȱ GNU/Debianȱ ein.ȱ

x

Esȱ existiertȱ aktuellȱ nurȱ rudimentäreȱ Unterstützungȱ fürȱ 64ȱ BitȬ Architekturen.ȱ

9.3.3 Unicore Middlewareȱ Unicoreȱ

Dieȱ Middlewareȱ Unicoreȱ (Uniformesȱ Interfaceȱ fürȱ ComputerȬ Ressourcen)ȱ wirdȱ seitȱ 1997ȱ entwickeltȱ [Unicore].ȱ Dasȱ ursprünglicheȱ Zielȱ warȱ es,ȱ einenȱ sicherenȱ undȱ einfachenȱ Zugangȱ zuȱ verschiedenenȱ Hochleistungsrechnernȱzuȱermöglichen.ȱȱ SoftwareseitigȱdecktȱUnicoreȱnurȱdenȱBereichȱdesȱJobȱManagementsȱab.ȱ UnicoreȱunterscheidetȱzwischenȱClientȬSystemenȱundȱServerȬSystemen.ȱ DerȱUnicoreȱClientȱistȱeineȱJavaȬApplikation,ȱdieȱaufȱdemȱRechnerȱdesȱ Benutzersȱläuft.ȱMitȱdemȱClientȱkannȱeinȱBenutzer:ȱȱ x

440ȱ

Jobsȱerzeugen.ȱȱ

9.3ȱGridȱMiddlewareȬSystemeȱ x

JobsȱaufȱdieȱüberȱUnicoreȱerreichbarenȱRessourcenȱübertragenȱundȱ dortȱablaufenȱlassen.ȱȱ

x

DenȱZustandȱderȱeigenenȱJobsȱüberprüfenȱundȱdieȱErgebnisseȱeinȬ sehen.ȱ

DieȱArchitekturȱvonȱUnicoreȱVersionȱ5ȱistȱinȱAbb.ȱ9Ȭ1ȱgezeigt:ȱServerȬ seitigȱ bestehtȱ eineȱ Unicoreȱ Siteȱ (Usite)ȱ ausȱ demȱ Gatewayȱ undȱ einemȱ oderȱmehrerenȱNetworkȱJobȱSupervisorȱ(NJS)ȱundȱTargetȱSystemȱInterȬ faceȱ (TSI).ȱ Dasȱ Unicoreȱ Gatewayȱ authentifiziertȱ dieȱ Benutzerȱ anhandȱ desȱ X.509ȱ Zertifikats.ȱ Dieȱ Kommunikationȱ zwischenȱ Clientȱ undȱ GateȬ wayȱerfolgtȱviaȱHTTPSȱ(SSL).ȱDerȱNJSȱübersetztȱdieȱJobsȱderȱBenutzerȱ inȱ dasȱ lokaleȱ Formatȱ undȱ bildetȱ dasȱ Benutzerzertifikatȱ aufȱ dasȱ lokaleȱ Autorisationssystemȱ ab.ȱ Enthältȱ einȱ Jobȱ Unterjobs,ȱ dieȱ aufȱ anderenȱ Usitesȱ desȱ Unicoreȱ Gridsȱausgeführtȱ werdenȱ sollen,ȱwerdenȱ dieseȱ perȱ HTTPSȱ anȱ dasȱ Gatewayȱ dieserȱ Usitesȱ übertragen.ȱ Dieȱ eigentlicheȱ Kommunikationȱ mitȱ denȱ lokalenȱ BatchȬSystemenȱ istȱ dieȱ Aufgabeȱ desȱ TSIȱ[RiMa06].ȱ

Komponentenȱ vonȱUnicoreȱ

VorteileȱvonȱUnicoreȱsind:ȱ x

DerȱClientȱbesitztȱeineȱgrafischeȱOberfläche.ȱ

x

Derȱ Clientȱ istȱ inȱJAVAȱ entwickeltȱ undȱdaherȱ betriebssystemunabȬ hängig.ȱ

x

DieȱInstallationȱdesȱClientsȱistȱeinfachȱundȱdieȱBedienungȱleichtȱzuȱ erlernen.ȱ

x

Aufȱ denȱ Rechenknotenȱ (Workerȱ Nodes)ȱ istȱ keinerleiȱ SoftwareinȬ stallationȱfürȱeineȱNutzungȱmitȱUnicoreȱnotwendig,ȱdaȱdieȱlokalenȱ Remoteȱ ManagementȬSystemeȱ (BatchsystemȬServer)ȱ vomȱ Targetȱ SystemȱInterfaceȱ(TSI)ȱdieȱJobsȱerhalten.ȱ

x

HoheȱStabilitätȱdurchȱdieȱlangeȱEntwicklungsȬȱundȱEinsatzzeit.ȱ ȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ

441ȱ

9ȱȱGridȬComputingȱ Abb.9Ȭ1:ȱ Unicoreȱ5ȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ NachteileȱvonȱUnicoreȱsind:ȱ

VoraussetȬ zungȱvonȱ Unicoreȱ

x

DerȱClientȱistȱnichtȱSkriptingȬfähig.ȱ

x

Esȱ istȱ nurȱ eineȱ manuelleȱ Verteilungȱ derȱ Jobsȱ aufȱ dieȱ Ressourcenȱ möglich,ȱ daȱ keinȱ Resourceȱ Brokerȱ zwischenȱ denȱ Clientsȱ undȱ ResȬ sourcenȱexistiert.ȱ

x

UnicoreȱimplementiertȱnichtȱdasȱVOȬKonzept.ȱDasȱBenutzermanaȬ gementȱbasiertȱaufȱeinerȱDatenbank,ȱdieȱdieȱDistinguishedȱNamesȱ (DN)ȱenthält.ȱ

x

KomponentenȱzumȱDatenmanagementȱfehlen.ȱȱ

Dieȱ einzigeȱ Voraussetzung,ȱ dieȱ dieȱ Clientsȱ erfüllenȱ müssen,ȱ istȱ einȱ installiertesȱ SUNȱ Javaȱ Runtimeȱ Environmentȱ (JRE)ȱ Versionȱ 1.4.2ȱ oderȱ höher.ȱ Dieȱ Serverkomponentenȱ benötigenȱ einȱ UNIXȬBetriebssystemȱ wieȱLinux,ȱSUNȱSolaris,ȱAIX,ȱMacȱOSȱX,ȱusw.ȱundȱebenfallsȱeinȱinstalȬ liertesȱSUNȱJavaȱRuntimeȱEnvironmentȱ(JRE)ȱVersionȱ1.4.2ȱoderȱhöher,ȱ sowieȱPerlȱ5.4ȱoderȱhöher.ȱ Dieȱ aktuelleȱ Versionȱ 6ȱ vonȱ Unicoreȱ orientiertȱ sichȱ anȱ OGSAȱ undȱ istȱ WebserviceȬbasiert,ȱwobeiȱderȱWSRFȬStandardȱvollständigȱerfülltȱist.ȱȱ

442ȱ

9.3ȱGridȱMiddlewareȬSystemeȱ ȱ ȱ

Abb.9Ȭ2:ȱ Unicoreȱ6ȱ

ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ ȱ Dieȱ Interaktionȱ einesȱ WebserviceȬKlientenȱ mitȱ demȱ UnicoreȬServerȱ gehtȱ überȱ einȱ Gateway,ȱ wobeiȱ aufȱ demȱ Serverȱ dieȱ Unicoreȱ BasiskomȬ ponentenȱundȱKomponentenȱfürȱhöhereȱGridȬServicesȱinȱeinemȱServiȬ ceȬContainerȱ integriertȱ sind.ȱ Dieseȱ sindȱ entsprechendȱ derȱ Standards:ȱ OGSAȬSAMLȱ fürȱ Authentifizierung,ȱ OGSAȬBESȱ (Basicȱ Executionȱ SerȬ vices)ȱfürȱdieȱJobȱSubmission,ȱOGSAȬRUSȱ(ResourceȱUsageȱService)ȱfürȱ dasȱ Accountingȱ undȱ OGSAȬDAIȱ (Dataȱ Accessȱ Interface)ȱ fürȱ denȱ ZuȬ griffȱ aufȱ strukturierteȱ Datenȱ bzw.ȱ OGSAȬByteIOȱ fürȱ dieȱ Übertragungȱ unstrukturierterȱ Daten.ȱ Einȱ erweitertesȱ Networkȱ Jobȱ Submissionȱ SysȬ temȱ(XJNS)ȱüberträgtȱdenȱRechenauftragȱüberȱdasȱTargetȱSystemȱInterȬ faceȱ (TSI)ȱ anȱ dieȱ Zielplattformȱ undȱ überwachtȱ dessenȱ Ausführungȱ (sieheȱAbb.ȱ9Ȭ2).ȱ Alleȱ Komponentenȱ derȱ UNICOREȬTechnologieȱ sindȱ alsȱ Openȱ Sourceȱ Softwareȱ unterȱ derȱ Berkeleyȱ Softwareȱ Distributionȱ (BSD)ȬLizenzȱ beiȱ SourceForgeȱ verfügbar.ȱ Auchȱ neuereȱ Entwicklungenȱ stehenȱ dortȱ reȬ gelmäßigȱderȱAllgemeinheitȱzurȱVerfügung.ȱ

443ȱ

9ȱȱGridȬComputingȱ

9.4 Weitere Grid Software AußerȱdenȱGridȱMiddlewareȬSystemenȱexistiertȱnochȱeineȱVielzahlȱvonȱ Softwarepaketen,ȱdieȱdieȱVerwaltungȱeinesȱGridȱundȱdieȱArbeitȱdamitȱ vereinfachen.ȱ

9.4.1 GridSphere GridSphereȱ Portalȱ Frameworkȱ

DasȱGridSphereȱPortalȱFrameworkȱstelltȱeinȱWebportalȱzurȱVerfügung,ȱ dasȱ Entwicklerȱ darinȱ unterstützt,ȱ WebȬAnwendungenȱ zuȱ entwickelnȱ dieȱimȱsogenanntenȱGridSphereȱPortalȱContainerȱablaufen.ȱ MitȱHilfeȱexistierenderȱPortletsȱkönnenȱAdministratorenȱdieȱverfügbaȬ renȱRessourcenȱimȱGridȱverwaltenȱundȱzurȱVerfügungȱstellen.ȱAnwenȬ derȱ könnenȱ dieȱ Ressourcen,ȱ zuȱ denenȱ Sieȱ Zugriffȱ haben,ȱ beobachtenȱ undȱJobsȱimȱGridȱstarten.ȱEbensoȱkönnenȱdieȱBenutzerȱüberȱbestehendeȱ PortletsȱihreȱDateienȱimȱGridȱverwalten.ȱ DurchȱdieȱUnterstützungȱdesȱFrameworkȬStandardsȱJavaȱServerȱFacesȱ (JSF)ȱkönnenȱKomponentenȱfürȱBenutzerschnittstellenȱundȱdieȱNavigaȬ tionȱinȱeigeneȱWebȬAnwendungenȱkomfortabelȱeingebundenȱwerden.ȱ

9.4.2 Shibboleth AAIȱmitȱ Shibbolethȱ

ShibbolethȱdientȱderȱRealisierungȱeinerȱInfrastrukturȱfürȱAuthentifizieȬ rungȱ undȱ Autorisierungȱ (AAI)ȱ insbesondereȱ aufȱ nationalerȱ Ebene.ȱ Imȱ BereichȱderȱdigitalenȱBibliothekenȱundȱderȱKlimaforschungȱhatȱShibboȬ lethȱ einenȱ gutenȱ Standȱundȱ wirdȱinȱ großemȱStilȱ eingesetzt,ȱ umȱSingleȱ SignȱOnȱüberȱmehreȱEinrichtungenȱaufȱnationalerȱEbeneȱzuȱrealisieren.ȱ DieȱArchitekturȱvonȱShibbolethȱbestehtȱausȱdreiȱTeilen:ȱ x

IdentityȱProvider,ȱderȱsichȱinȱjederȱlokalenȱEinrichtungȱmitȱBenutȬ zernȱbefindet.ȱ

x

ServiceȱProvider,ȱderȱsichȱbeimȱAnbieterȱbefindet.ȱ

x

Lokalisierungsdienst,ȱ auchȱ WAYFȱ (Whereȱ Areȱ Youȱ From?)ȱ geȬ nannt.ȱ

EineȱFöderationȱistȱderȱZusammenschlussȱvonȱInstituten,ȱdieȱeinȱüberȬ greifendesȱ Singleȱ Signȱ Onȱ zwischenȱ ihrenȱ Standortenȱ realisierenȱ wolȬ len.ȱJedeȱFöderationȱinstalliertȱeinenȱWAYFȬDienst/Server.ȱDieȱAutoriȬ tätȱ verbleibtȱ beiȱ denȱ lokalenȱ Instituten.ȱ Alleȱ beteiligtenȱ Parteienȱ einerȱ Föderationȱ müssenȱ sichȱ aufȱ Standardsȱ fürȱ MetadatenȬSchemataȱ undȱ Sicherheitȱusw.ȱeinigen.ȱ Inȱ Globusȱ Versionȱ 4.2ȱ werdenȱ einigeȱ Komponentenȱ vonȱ Shibbolethȱ enthaltenȱseinȱundȱimȱZugeȱvonȱIVOMȱ(InteroperabilitätȱundȱIntegraȬ

444ȱ

9.4ȱWeitereȱGridȱSoftwareȱ tionȱderȱVOȬManagementȱTechnologienȱimȱDȬGrid)ȱsollȱunterȱanderemȱ eineȱShibbolisierungȱdesȱUnicoreȱKlientenȱvorgenommenȱwerden.ȱ

9.4.3 VOMS Derȱ Virtualȱ Organizationȱ Membershipȱ Serviceȱ (VOMS)ȱ kommtȱ ausȱ demȱgLiteȬUmfeldȱundȱdientȱdemȱManagementȱvirtuellerȱOrganisatioȬ nen.ȱ VOMSȱ wurdeȱ imȱ Rahmenȱ vonȱ LCGȱ zurȱ Benutzerverwaltungȱ inȱ VirtuellenȱOrganisationenȱentwickelt.ȱMehrȱEinstellungsmöglichkeitenȱ alsȱVOMSȱbietetȱdasȱVerwaltungstoolȱVOMRS.ȱ

9.4.4 SRB DerȱStorageȱResourceȱBrokerȱ[SRBweb]ȱ(SRB)ȱistȱeineȱMiddleware,ȱdieȱ esȱ ermöglicht,ȱ vonȱ jedemȱ Punktȱ ausȱ aufȱ Datenȱ zuzugreifen,ȱ dieȱ aufȱ verteilten,ȱ heterogenenȱ Speichersystemenȱ liegen.ȱ Dieȱ Dateienȱ (DatenȬ objekte)ȱ undȱ Verzeichnisseȱ (Kollektionen)ȱ lassenȱ sichȱ zusätzlichȱ mitȱ beliebigenȱMetadatenȱversehen.ȱAusȱBenutzersichtȱerzeugtȱderȱSRBȱeinȱ virtuellesȱ Dateisystemȱ mitȱ denȱ verteiltenȱ Daten.ȱ Einȱ Nachteilȱ ist,ȱ dassȱ derȱ SRBȱ nichtȱ unterȱ einerȱ OpenSourceȬLizenzȱ stehtȱ undȱ nurȱ vonȱ wisȬ senschaftlichenȱ undȱ nichtȱ gewinnȬorientiertenȱ Organisationenȱ kostenȬ losȱverwendetȱwerdenȱdarf.ȱ

virtuelleȱ Dateisystemeȱ mitȱdemȱSRBȱ

9.4.5 SRM/dCache Dasȱ Datenmanagementsystemȱ SRM/dCacheȱ kommtȱ ausȱ demȱ Umfeldȱ derȱ Hochenergiephysikȱ undȱ wirdȱ zurȱ Speicherungȱ vonȱ Datenȱ eingeȬ setzt.ȱ SRM/dCacheȱermöglichtȱdenȱZugriffȱaufȱDaten,ȱdieȱüberȱvieleȱverwalȬ teteȱSpeicherpoolsȱverteiltȱsind.ȱ

DatenmanȬ agementȬ systemȱ SRM/dCacheȱ

Bestandteileȱ sindȱ derȱ dCacheȬServer,ȱ derȱ denȱ Zugriffȱ aufȱ dieȱ Datenȱ regeltȱ undȱ einȱ oderȱ mehrereȱ PoolȬKnoten,ȱ dieȱ denȱ Speicherplatzȱ zurȱ Verfügungȱ stellen.ȱ SRM/dCacheȱ kannȱ nichtȱ nurȱ mitȱ FestplattenȬ Speicher,ȱsondernȱauchȱmitȱBandspeicherȱumgehen.ȱ Fallsȱ einȱ dCacheȬServerȱ nichtȱ Leistungsfähigȱ genugȱ ist,ȱ könnenȱ dieȱ anstehendenȱAufgabenȱauchȱaufȱmehrereȱServerȱverteiltȱwerden.ȱ AufȱdenȱverteiltenȱSpeichermedienȱbefindetȱsichȱdasȱParallelȱNetworkȱ FileȱSystemȱ (PNFS),ȱ einȱ verteiltesȱ Dateisystem,ȱdasȱvonȱ jedemȱ gespeiȬ chertenȱDatensatzȱMetadatenȱerzeugt.ȱDieȱMetadatenȱwerdenȱgetrenntȱ vonȱdenȱeigentlichenȱDatenȱgespeichert,ȱumȱeineȱhöhereȱGeschwindigȬ keitȱzuȱgarantieren,ȱindemȱZugriffslastenȱverteiltȱwerden.ȱDieȱBenutzerȱ greifenȱdabeiȱtransparentȱaufȱihreȱDateienȱzu,ȱohneȱüberȱdenȱgenauenȱ SpeicherortȱBescheidȱzuȱwissen.ȱ

445ȱ

9ȱȱGridȬComputingȱ Dieȱ gleichmäßigeȱ Auslastungȱ derȱ PoolȬKnotenȱ undȱ Festplattenȱ wirdȱ perȱLoadȬBalancingȱsichergestellt.ȱ

9.4.6 OGSA-DAI Zugriffȱaufȱ DatenresȬ sourcenȱmitȱ OGSAȬDAIȱ

DasȱMiddlewareȬWerkzeugȱOGSAȬDAIȱ(OpenȱGridȱServicesȱArchitecȬ tureȱ Ȭȱ Dataȱ Accessȱ andȱ Integrationȱ Projekt)ȱ bietetȱ denȱ transparentenȱ Zugriffȱ aufȱ strukturierteȱ Datenȱ inȱ Formȱ vonȱ relationalenȱ oderȱ XMLȬ basiertenȱDatenbankenȱinȱeinerȱGridȬInfrastrukturȱ[DAIweb].ȱ SprachȬȱundȱPlattformunabhängigkeitȱistȱsichergestellt,ȱdaȱZugriffeȱaufȱ dieȱ Datenressourcenȱ überȱ einenȱ WSRFȬkonformenȱ Webȱ Serviceȱ erfolȬ gen.ȱ Dadurchȱ istȱ einȱ transparenterȱ Zugriffȱ aufȱ dieȱ darunterliegendenȱ Datenressourcenȱmöglich,ȱdaȱsowohlȱdieȱLokation,ȱalsȱauchȱdieȱArtȱderȱ Datenressourcenȱabstrahiertȱwerden.ȱ OGSAȬDAIȱ hatȱ sichȱ inȱ denȱ letztenȱ Jahrenȱ zumȱ DeȬfactoȬStandardȱ fürȱ DatenbankzugriffeȱimȱGridȱentwickelt.ȱ

9.4.7 GAT Entwickelnȱ mitȱdemȱGridȱ Applicationȱ Toolkitȱ

DasȱGridȱApplicationȱToolkitȱ(GAT)ȱstelltȱeineȱeinfacheȱProgrammierȬ schnittstelleȱzuȱverschiedenenȱGridȬDienstenȱzurȱVerfügung.ȱBeispieleȱ fürȱ unterstützteȱ GridȬDiensteȱ sindȱ Resourcebroker,ȱ DatentransferȬ dienst,ȱDatenkommunikation,ȱremoteȱDateiȬȱundȱDatenzugriff.ȱ ȱ ȱ ȱ

446ȱ

Literatur 1. Einführung und Grundlagen [A 06]

Abbenhaus C.: Web 2.0. Informatik Spektrum, Band 29, Heft 6, Dezember 2006.

[A 07]

Alby T.: Web 2.0. Konzepte, Anwendungen, Technologien. 2., aktualisierte Auflage. Carl Hanser Verlag 2007.

[ACK 03]

Alonso G., Casati F., Kuno H.: Web Services. Springer Verlag Berlin 2003.

[AS 04]

Androutsellis-Theotokis S., Spinellis D.: A Survey of Peerto-Peer Content Distribution Technologies. ACM Computing Surveys. Vol. 36, No. 4, Dec. 2004.

[B 01]

Berners-Lee T., Hendler J., Lassila O.: The Semantic Web. A new form of Web content that is meaningful to computers will unleash a revolution of new possibilities. Scientific American, 284 (5), S. 34-43, May 2001. http://www.sciam.com/article.cfm?articleID=0004814410D2-1C70-84A9809EC588EF21, 2001.

[B 04]

Bengel G.: Grundkurs Verteilte Systeme. 3. verbesserte und erweiterte Auflage. Vieweg Verlag 2004.

[B 06]

Bächle M.: Social Software. Informatik Spektrum, Band 29, Heft 2, April 2006.

[B1 06]

Baun C.: Analyse vorhandener Grid-Technologien zur Evaluation eines Campus Grid an der Hochschule Mannheim. Master Thesis, Hochschule Mannheim 2006.

[B2 06]

Baun C.: Gemeinsam stark. Cluster-, Grid-, Peer-to-Peerund Distributed Computing. c’t Magazin für Computertechnik, No. 3, 2006.

[BCF 95]

Boden N.J., Chen D., Felderman R.E., Kulawik A.E., Seitz C. L., Seizovic J. N. and Su W.: Myrinet: a Gigabit-persecond local area network. IEEE Micro, Vol. 15, No. 1, 1995

447

Literatur

448

[BK 07]

Bächle M., Kirchberg P.: Frameworks für das Web 2.0. Informatik Spektrum, Band 30, Heft 2, April 2007.

[BM 06]

Bauke H., Mertens S.: Cluster Computing, Praktische Einführung in das Hochleistungsrechnen auf Linux-Clustern. Springer Verlag 2006.

[Br 06]

Brochard L.: High performane computing technology, applications and business. Informatik Spektrum, Band 29, Heft 3, Juni 2006.

[C 04]

Cayzer S.: Semantic Blogging and Decentralized Knowledge Management. Communications of the ACM, Vol. 47, No. 12, Dec. 2004.

[CDK 02]

Couloris G., Dollimore J., Kindberg T.: Verteilte Systeme. Konzepte und Design. 3., überarbeitete Auflage. Pearson Studium 2002.

[D 02]

Dreamtech: Peer-to-Peer-Aplikationen entwickeln. mitpVerlag /Bonn 2002.

[D 06]

Dolphin Interconnect Solutions: http://www.dolphinics. com, 2006.

[DFG 07]

DFG SPP 1183: Organic Computing. http://www.organic-computing.de/SPP, 2007

[DJM 05]

Dostal W., Jeckle M., Melzer I., Zengler B.: Serviceorientierte Architekturen mit Web Services. Spektrum Akademischer Verlag, 2005.

[EG 05]

Ebersbach A., Glaser M.: Wiki. Informatik Spektrum Band 28, Heft 2, April 2005.

[G 06]

Grütter R.: Software-Agenten im Semantic Web, Informatik Spektrum, Band 29, Heft 1, Febr. 2006.

[G 07]

Google Maps: http://google.maps.de/maps, 2007.

[H 02]

Hesse W.: Ontologie(n). Informatik Spektrum, Band 25, Heft 6, Dez. 2002.

[HH 98]

Hertwich R.G., Hommel G.: Nebenläufige Programme. 2. Auflage. Springer Verlag 1998.

[Ho 78]

Hoare C. A. R.: Communicating Sequential Processes. Communications of the ACM, Vol. 21, No. 8, 1978.

1. Einführung und Grundlagen [HP 06]

Hennessy J. L., Patterson D.A.: Computer Architecture, A Quantitative Approach, 4rd Edition, Morgan Kaufmann Publishing Co., Menlo Park, CA. 2006.

[J 04]

Jones M.T.: BSD Sockets Programming from a MultiLanguage Perspective. Charles River Media, Inc., 2004.

[I 06]

InfiniBand Trade Association: http://www.infinibandta. org, 2006.

{IBM 07]

IBM: Autonomic Computing. http://www-03.ibm.com/ autonomic/, 2007.

[K 05]

Kuhlen F.: E-World – Technologien für die Welt von morgen. Springer Verlag 2005.

[KC 03]

Kephardt J.O., Chess D.M.: The Vision of Autonomic Computing. IEEE Computer, Vol. 36, No. 1, Jan. 2003.

[KMU 06]

Kemper H.G., Mehanna W., Unger C.: Business Intelligence – Grundlagen und praktische Anwendungen. 2. Auflage, Vieweg Verlag 2006.

[KW 02]

Kuschke M., Wölfel L.: Web Services kompakt. Spektrum Akademischer Verlag, 2002.

[KNR 04]

Kumar R., Novak J. Raghavan P., Tomkins A.: Structure and Evolution of Blogspace. Communications of the ACM, Vol. 47, No. 12, Dec. 2004.

[L 01]

Leopold C.: Parallel and Distributed Computing, A Survey of Models, Paradigms, and Approaches. John Wiley & Sons Inc., 2001.

[M 03]

Mattern F. (Hrsg.): Total vernetzt. Szenarien einer informatisierten Welt. 7. Berliner Kolloquium der Gottlieb Daimler- und Karl Benz-Stiftung. Springer Verlag 2003.

[M 06]

Myricon: http://www.myri.com, 2006.

[M 07]

Maurer H.: Google – Freund oder Feind. Informatik Spektrum, Band 30, Heft 4, August 2007.

[MB 76]

Metcalfe R.M., Boggs D. R.: Ethernet: Distributed packet switching for local computer Networks. Communications of the ACM, Vol. 19, No. 5, 1976.

[MDM 07]

Merwe Van Der J., Dawoud D., McDonald S.: A Survey on Peer-to-Peer Key Management for Mobile Ad Hoc Net-

449

Literatur works. ACM Computing Surveys. Vol. 39, No. 1, April 2007. [MMW 04] Müller-Schloer C., von der Malsburg C,, Würtz R.P.: Organic Computing. Informatik Spektrum, Band 27, Heft 4, Aug. 2004.

450

[MS 07]

Mahlmann P., Schindelhauer C.: Peer-to-Peer-Netzwerke, Algorithmen und Methoden. Springer Verlag 2007.

[NSG 04]

Nardi B. A., Schiano D.J., Gumbrecht M., Swartz L.: Why we Blog. Communications of the ACM, Vol. 47, No. 12, Dec. 2004.

[OCI 07]

Organic Computing Initiative: Home. http://www.organic-computing.de/, 2007

[OR 05]

O´Reilly T.: What is Web 2.0: Design Patterns and Business Models for the Next Generation of Software. http://www.oreillynet.com/pub/a/oreilly/tim/news/2005/0 9/30/what-is-web-20.html, 2005.

[OWO 04]

W3C: OWL Web Ontology Language Overview. http://www.w3.org/TR/owl-features/, 2004.

[OWR 04]

W3C: OWL Web Ontology Language Reference. http://www.w3.org/TR/owl-ref/, 2004

[PF 06]

Peschel-Findeisen T.: Nebenläufige und Verteilte Systeme. Theorie und Praxis. mitp-Verlag/Bonn 2006.

[Q 06]

Quadrics: http://www.quadrics.com, 2006.

[RDF 04]

W3C: Resource Description http://www.w3.org/RDF/, 2004.

[RSC 04]

W3C: RDF Vocabulary Description Language 1.0: RDF Schema. http://www.w3.org/TR/rdf-schema/, 2004.

[R 05]

Roth J.: Mobile Computing. Grundlagen, Technik, Konzepte. 2. aktualisierte Auflage. Dpunkt.verlag 2005.

{S 04]

Sunstein C. R.: Democracy and Filtering. Communications of the ACM, Vol. 47, No. 12, Dec. 2004.

[SS 07]

Schill A., Springer T.: Verteilte Systeme. Springer Verlag 2007.

[S 07]

Sun: Utility Computing. http://www.sun.com/service/sungrid/index.jsp, 2007.

Framework

(RDF).

1. Einführung und Grundlagen [SFT 02]

Schoder D., Fischbach K., Teichmann (Hrsg.): Peer-to-Peer, Ökonomische, technologische und juristische Perspektiven. Springer Verlag 2002.

[SO 07]

Soap Version 1.2: http://www.w3.org/TR/soap12, 2007.

[SPA 06]

W3C: SPARQL Query Language for http://www.w3.org/TR/rdf-sparql-query/, 2006.

[SW 04]

Steinmetz R., Wehrle K.: Peer-to-peer-Networking & Computing. Informatik Spektrum, Band 27, Heft 1, Febr. 2004.

[SW 05]

Steinmetz R., Wehrle K. (Eds.): Peer-to-Peer Systems and Applications. Springer Verlag 2005.

[T 02]

Thome R.: e-Business. Informatik Spektrum, Band 25, Heft 2, 2002.

[UDD 04}

OASIS: UDDI Version http://uddi.org/pubs/uddi_v3.htm, 2004.

[VIG 07]

VDE/ITG/GI: VDE/ITG/IG-Positionspapier Organic Computing. Computer- und Systemarchitektur im Jahr 2010. http://www.betriebssysteme.org/Betriebssysteme/FutureT rends/oc-positionspapier.pdf, 2007.

[WW 07]

Wikipedia: Wikipedia. http://de.wikipedia.org/wiki/Wikipedia, 2007.

[WE 07]

Wikipedia: Elektronischer Handel. http://de.wikipedia.org/wiki/Elektronischer_Handel, 2007.

[W3C 07]

W3C World Wide Web Consortium: http://www.w3.org/, 2007.

{WCL 05]

Weerawarana S., Curbera F., Leymann F., Storey T., Ferguson D.F.: Web Services Platform Architecture. Pearson Education, Inc., 2005.

[WSA 04]

W3C: Web Services Architecture. http://www.w3.org/TR/ws-arch/, 2004.

[XML 06]

W3C: Extensible Markup http://www.w3.org/XML/, 2006.

[ZLY 07]

Zhong N., Liu J., Yao Y.; Envisioning Intelligent Information Technologies through the Prism of Web Intelligence. Communications of the ACM, Vol. 50, No. 3, March 2007.

Language

RDF.

3.0.2

(XML).

451

Literatur

2. Rechnerarchitekturen [T 06]

Tanenbaum A. S.: Computerarchitektur. Strukturen Konzepte - Grundlagen. 5. Auflage. Pearson Studium 2006.

2.1 Simultaneous Multithreading [EEL 97]

Eggers S.J., Emer J.S., Levy H.M., Lo J.L., Stamm R.L., Tullsen D.M.: Simultaneous MultiThreading: A platform for Next-Generation Processors. IEEE Micro, Vol. 17, No. 5, Sept/Oct 1997.

[M 01]

Märtin C.: Rechnerarchitekturen, CPUs, Systeme, Software-Schnittstellen. Fachbuchverlag Leipzig 2001.

[M 02]

Marr D. et al.: Hyper-Threading Technology Architecture and Microarchitecture: A Hypertext History. Intel Technology Journal, Vol. 6, No. 3, Feb 2002.

[TEE 96]

Tullsen D.M., Eggers S. J., Emer J.S. et al.: Exploiting Choice: Instruction Fetch and Issue and Implementable Simultaneous Multithreading Processor. Proc. 23nd Annual Intern. Symp. On Computer Architecture, Philadelphia, PA 1996.

2.2 Enggekoppelte Multiprozessoren u. Multicoreprozessoren

452

[A 06]

AMD Processors for Servers and Workstations: AMD OpteronTM Processor. http://www.amdcompare.com.usen/Opteron/, 2006.

[AAK 06]

Ananian C.S., Asanovic K., Kuszmaul B. C., Leierson C. E., Leierson C.E., Lie S.: Unbounded Transactional Memory. IEEE Micro, Vol. 26, No. 1, Jan. Febr. 2006.

[AB 86]

Archibald J., Baer J.-L.: Cache Coherence Protocols: Evaluation Using a Multiprocessors Simulation Model. ACM Transactions on Computer Systems, Vol. 4, No. 4, 1986.

[AKS 07]

Adl-Tabatabai A.R., Kozyrakis C., Saha B.: Unlocking Concurrency, Multicore Programming with transactional Memory. ACM Queue Vol. 4, No. 10, December/January 2006-2007.

[ARJ 07]

Aggarwal N., Ranganathan P. Jouppi N.P., Smith J.E.: Isolation in Commodity Multicore Processors. IEEE Computer, Vol. 40, No. 6, June 2007.

2. Rechnerarchitekturen [B 78]

Backus J.: Can programming be liberated from the von Neumann style? A functional style and its algebra of programs. Communications of the ACM Vol. 21, No. 8, August 1978.

[BBN 89]

BBN Advanced Computers Inc, TC-2000 Technical Product Summary, 1989.

[BC 03]

Bovet D.P., Cesati M.: Understanding the Linux Kernel. Second Edition. O`Reilly & Associates Inc. 2003.

[BH 72]

Brinch Hansen P.: A comparison of two synchronising concepts. Acta Informatica, No. 1, 1972.

[BM 06]

Bauke H., Mertens S.: Cluster Computing, Praktische Einführung in das Hochleistungsrechnen auf Linux-Clustern. Springer Verlag 2006.

[Bo 06]

Bode A.: Multicore-Architekturen. Informatik Spektrum, Band 29, Heft 5, Okt. 2006.

[BPG 85]

Pfister G.F., Brantley W.C., George D. A., et al.: The IBM research parallel Processor prototype (RP3): Introduction and architecture. In Proceedings International Conference on Parallel Processing, pages 764 – 771, 1985.

[BTR 02]

Bossen D.C., Tendler J.M., Reick K.: Power4 System Design for High Reliabilty. IEEE Micro, Vol. 22, No. 2, March/April 2002.

[C 07]

The Cell Chip: Informationen über den Multi-CoreProzessor. http://www.the-cell-chip.de, 2007.

[CFK 90]

Chaiken D., Fields C., Kurihara K., Agarwal A.: DirectoryBased Cache Coherence in Large-Scale Multiprocessors. IEEE Computer, Vol. 23, No. 6, June 1990.

[D 65]

Dijkstra E.W.: Cooperating Sequential Processes. Technological University, Eindhoven, The Netherlands, 1965. (Reprinted in Great Papers in Computer Science. Laplante P. ed., IEEE Press, New York, NY, 1996)

[D 90]

Duncan R.: A Survey of Parallel Computer Architectures. IEEE Computer. Vol. 23, No. 2, February 1990.

[G 01]

Gelsinger, P.P.: Microprozessors for the New Millenium. Challenges, Opportunities and New Frontiers. ICSS February 2001.

453

Literatur

454

[GEM 07]

Gschwind M., Erb D., Manning S., Nutter M.; An Open Source Environment for Cell Broadband Engine System Software. IEEE Computer, Vol. 40, No. 6, 2007.

[GGK 83]

Gottlieb A., Grishman R., Kruskal C.P., McAuliffe K. P, Rudolph L., Snir M.: The NYU ultracomputer: Designing a MIMD, shared memory parallel computer. IEEE Transactions on Computers, Vol. 32, No. 2, 1983.

[GHF 06]

Gschwind M., Hofstee H.P., Flachs B., et. al.: Synergistic Processing in Cell’s Multicore Architecture. IEEE Micro, Vol. 26, No. 2, March/April 2006.

[GT 90]

Graunke G., Thakkar S.: Synchronization Algorithms for Shared Memory Multiprocessors. IEEE Computer, Vol. 23, No.6, June 1990.

[H 91]

Herlihy M.: Wait-Free Synchronisation. ACM Transaction on Programming Languages and Systems. Vol. 11, No. 1, Jan. 1991.

[H 93]

Handy J.: The Cache Memory Book. Academic Press Inc. 1993.

[HB 84]

Hwang K., Briggs F. A.: Computer Architecture and Parallel Processing. McGraw Hill 1984.

[HCU 77]

Harris T., Cristal A., Unsal O.S., et al.: Transactional Memory: An Overview. IEEE Micro, Vol. 27, No. 3, May/June 2007.

[HF 03]

Harris T., Fraser K.: Language Support for Lightweight Transactions. Proceedings of the 18th annual ACM SIGPLAN conference on Object-oriented programing, systems, languages, and applications. Anaheim, ACM SIGPLAN Notices Vol. 38, No. 11, 2003.

[HF 07]

Harris T., Fraser K.: Concurrent Programming Without Locks. ACM Transactions on Computer Systems, Vol. 25, No. 2, Articles 4-5, 2007.

[HM 93]

Herlihy M., Moss E.: Transactional memory; Architectural support for lock-free datastructures. In Proceedings of the 20th Annual International Symposium on Computer Architecture, San Diego, CA, May 1993.

[HMJ 05]

Harris T., Marlow S., Jones S.P. Herily M.: Composable Memory Transactions. ACM Conference on Principles and Practice of Parallelel Programming 2005.

2. Rechnerarchitekturen [Ho 72]

Hoare C.A.R: Towards a theory of parallel programming. In: Hoare C.A.R. and Perott R.H, Eds.: Operating Systems Techniques. Academic Press, New York, NY, 1972.

[HNO 97]

Hammond L., Nayfeh B.A., Olukotun K.: A Single-Chip Multiprocessor Computer. Vol. 30., No. 9, Sept. 1997.

[HP 06]

Hennessy J. L., Patterson D.A.: Computer Architecture, A Quantitative Approach, 4rd Edition, Morgan Kaufmann Publishing Co., Menlo Park, CA. 2006.

[I 06]

Intel CORETM Duo Processor - Technical Documents. http://www.intel.com/design/mobile/core/duodocumentat ion.html

[IRS 06]

IBM RS/6000 SP System. http://www.rs6000.ibm.com/hardware/largescale /index.html. 2006.

[JW 05]

Jerraya A., A., Wolf W.; Multiprocessor Systems–on-Chips. Elsevier Inc. 2005.

[KAO 05]

Kongetira P., Aingaran K., Olukoton K.: Niagara: A 32Way Multithreaded Sparc Processor. IEEE Micro, Vol. 25, No.2, March/April 2005.

[KDH 05]

Kahle J. A., Day M. N., Hofstee H.P. et. al.: Introduction to the Cell Multiprocessors. IBM J. Research and Development, Vol. 49, No. 4/5, 2005.

[KGA 03]

Keltcher, C. N., McGrath K. J., Ahmed A., Conway P.: The AMD Opteron Processor for Multiprocessor Servers. IEEE Micro, Vol. 23, No. 2, March/April 2003.

[KPP 06]

Kistler M., Perrone M., Petrini F.: Cell Multiprocessor Communictaion Network: Built for Speed. IEEE Micro Vol. 26, No. 3, May/June 2006.

[KR 81]

Kung H.T., Robison J. T.: On Optimistic Methods for Concurrency Control. ACM Trans. Database Systems, Vol. 6, No. 2, 1981.

[L 79]

Lamport L.: How to Make a Multiprocessor Computer that Correctly Executes Multiprocessor Programs. IEEE Trans. On Computers, Bd C-28, S. 690-691, Sept. 1979.

[L 93]

Lilja D. J.: Cache Coherence in Large-Scale SharedMemory Multiprocessors: Issues and Comparisons. ACM Computing Surveys Vol. 26, No. 3, Sept.1993.

455

Literatur [M 99]

Maurer C.: Grundzüge der Nichtsequentiellen Programmierung. Springer Verlag 1999.

[MMC 07] McDonald A., Carlstrom, B., Chung J.: Transactional Memory: The Hardware-Software Interface. IEEE Micro, Vol. 27, No. 1, Jan./Febr. 2007.

456

[P 90]

Przybylsku S. A.: Cache and Memory Hierarchy Design. A Performance-Directed Approach. Morgan Kaufmann Publisheres, Inc. 1990.

[RT 86]

Rettberg R., Thomas R.: Contention is no Obstacle to Shared-Memory Multiprocessing. Communications of the ACM, Vol.29, No, 12, Dec 1986.

[R 97]

Richter H.: Verbindungsnetzwerke für parallele und verteilte Systeme. Spektrum Akademischer Verlag 1997.

[S 90]

Stenström P.: A Survey of Cache Coherence Schemes for Multiprocessors. IEEE Computer, Vol. 23, No. 6, June 1990.

[S 97]

Sinha P., K.: Distributed Operating Systems. Concepts and Design. IEEE Press 1997.

[S 06]

Struck N.: Mehr Performance und Skalierbarkeit mit Multicore-Prozessoren. Betriebssysteme helfen beim Wechsel. WEKA Fachzeitschriften-Verlag GmbH Elektronik 06/2006. Auch verfügbar unter: http://www.elektoniknet.de/index.php?id=706&tx_jppaget easer_pi1[backId]=734.

[S 07]

Sun: Throughput Computing. http://www.sun.com/processors/throughput/, 2007.

[SGI 07]

SGI Altix Family. High Productivity Servers, Clusters and Supercomputers. http://www.sgi.com/products/servers/altix/. 2007.

[STM 07]

Software transactional memory. Wikipedia: http://en.wikipedia.org/wiki/Software_transactional_mem ory, 2007.

[T 95]

Tanenbaum A. S.: Distributed Operating Systems. Prentice Hall Inc., 1995.

[T 06]

Tanenbaum A. S.: Computerarchitektur, Strukturen – Konzepte – Grundlagen. 5. Auflage, Pearson Studium 2006.

[To 06]

Top500.org: http://www.top500.org/ 2006.

2. Rechnerarchitekturen

2.3 Lose gekoppelte Multiprozessoren und Multicomputer [AG 96]

Adve S.V., Gharachorloo K.: Shared Memory Consistency Models: A Tutorial. IEEE Computer, Vol. 29, No. 12, Dec. 1996.

[GGH 97]

Gonzalez R. Gordon B. Horowitz M.: Supply and Threshold Voltage Scaling for Low-Power CMOS. IEEE Jornal Solid-State Circuits, Vol. 32, No. 8, Aug 1997.

[HLH 92]

Hagerstein E., Landin A., Haridi S.: DDM – A Cache-Only Memory Architecture. IEEE Computer, Vol. 25, No. 9, Sept. 1992.

[PTM 98]

Protic J., Tomasevic M., Milutinovic V.: Distributed Shared Memory. Concepts and Systems. IEEE Computer Society Press, 1998.

[NL 91}

Nitzberg B. Lo V.: Distributed Shared Memory: A Survey of Issues and Algorithms. IEEE Computer Vol. 24, No. 6., August 1991.

[S 97]

Sinha P., K.: Distributed Operating Systems. Concepts and Design. IEEE Press 1997.

[SWG 06]

Salapura V., Walkup R., Gara A.: Exploiting Workload Parallelism for Performance and Power Optimization in Blue Gene. IEEE Micro Vol. 26, No. 5, Sept. Oct. 2006.

[SGI 07]

SGI Altix Family. High Productivity Servers, Clusters and Supercomputers. http://www.sgi.com/products/servers/altix/. 2007.

[T 95]

Tanenbaum A. S.: Distributed Operating Systems. Prentice Hall Inc., 1995.

[T 06]

Tanenbaum A. S.: Computerarchitektur, Strukturen – Konzepte – Grundlagen. 5. Auflage, Pearson Studium 2006.

[To 06]

Top500.org: http://www.top500.org/ 2006.

[UC 07]

University of Cambridge, Computer Laboratory: Practical lock-free data structures. http://www.cl.cam.ac.uk/netos/lock-free, 2007.

2.4 Load Balancing und High Troughput Cluster Google [BDH 03]

Barroso L.A., Dean J. Hölzle U.: Web Search for a Planet: The Goggle Cluster Architecture. IEEE Micro, Vol. 23, No. 2, 2003.

457

Literatur [BP 06]

Brin S., Page L:. The Anatomy of a Large Scale Hypertextual Web SearchEngine. http//:www-db.stanford.edu/pub/papers/google.pdf, 2006.

[GGL 03]

Ghernawatt S., Gobioff H., Leung S.: The Goggle File System. Proceeding of the 19th ACM Symposium on Operating Systems Principles. Oct. 2003.

[H1 06]

Hawking D.: Web Search Engines: Part 1: IEEE Computer, Vol. 39, No. 6, June 2006.

[H2 06]

Hawking D.: Web Search Engines: Part 2. IEEE Computer, Vol. 39, No. 8, August 2006.

[T 06]

Tanenbaum A. S.: Computerarchitektur, Strukturen – Konzepte – Grundlagen. 5. Auflage, Pearson Studium 2006.

[W 06]

Wikipedia: Inverted Index. 2006. http://en.wikipedia.org/wiki/Inverted_index, 2006.

[ZM 06]

Zobel J., Moffat A.: Inverted Files for Text Search Engines. ACM Computing Surveys, Vol. 38, No. 2, 2006.

3. Programmiermodelle [BA 06]

Ben-Ari M: Principles of Concurrent and Distributed Programming. 2nd Edition. Pearson Education Limited 2006.

[BGL 98]

Briot J.-P., Guerraoui R., Löhr K.-P.: Concurrency and Distribution in Object-Oriented Programming. ACM Computing Surveys, Vol. 30, No. 3, Sept. 1998.

[G 04]

Garg V. K.: Concurrent and Distributed Computing in Java. John Wiley & Sons, Inc. 2004.

3.1 Client-Server-Modell

458

[A 91]

Andrews G. R.: Paradigms for Process Interaction in Distributed Programs. ACM Computing Surveys, Vol. 23, No. 1, March 1991.

[B 04]

Bengel G.: Grundkurs Verteilte Systeme. 3. verbesserte und erweiterte Auflage. Vieweg Verlag 2004.

[PRP 06]

Puder A., Römer K, Pilhofer F.: Distributed Systems Architecture: A Middleware Approach. Morgan Kaufmann Publishers 2006.

3. Programmiermodelle

3.2 Service-orientierte Architekturen (SOA) [C 04]

Chappell D.: Enterprise Service Bus. O’ Reilly Media, 2004.

[C 07]

Curbera F.: Component Contracts in Service oriented Architectures. IEEE Computer Vol. 40, No. 11, Nov. 2007.

[E 07]

Elfatatry A.: Dealing with Change: Components versus Services. Communications of the ACM, Vol. 50, No. 8, August 2007.

[HHV 06]

Hess A., Humm B., Voß M.: Regeln für serviceorientierte Architekturen hoher Qualität. Informatik Spektrum, Band 29, Heft 6, Dezember 2006.

[BPEL 07]

IBM: Business Process Execution Language for Web Services version 1.1. http://www.ibm.com/developerworks/library/specificatio n/ws-bpel/, 2007

[L 07]

Liebhart D.: SOA goes real. Service-orientierte Architekturen erfolgreich planen und einführen. Carl Hanser Verlag 2007.

[M 07]

Masak D.: SOA? Serviceorientierung in Business und Software. Springer Verlag 2007.

[M 08]

Mathas C.: SOA intern. Praxiswissen zu serviceorientierten IT-Systemen. Carl Hanser Verlag 2008.

[MB 03]

Meredith L.G., Bjorg S.: Contracts and Types. Commmunicatons of the ACM, Vol. 46, No. 10, Oct. 2003.

[PG 03]

Papazoglou M. P., Georgakopoulus D.: Service-Oriented Computing. Communications of the ACM, Vol. 46, No. 10, Oct. 2003.

[PTDL 07]

Papazoglou M.P. Traverso P. Dustdar S. Leymann F.: Service-Oriented Computing: State of the Art and Research Challenges. IEEE Computer Vol. 40, No. 11, Nov. 2007.

{WSC 05]

W3C: Web Services Choreography Description Language Version 1.0. http://www.w3.org/TR/ws-cdl-10/, 2005.

3.3 Programmiermodelle für gemeinsamen Speicher [A 83]

The Programming Language Ada. Reference Manual. American National Standards Institute, Inc., ANSI/MIL-

459

Literatur STD-1815A-1983. Lecture Notes in Computer Science 155, Springer Verlag, 1983.

460

[A 95]

Adler R. M.: Distributed Coordination Models for Client/Server Computing. IEEE Computer, Vol. 28, No. 4, April 1995.

[A 07]

Ada Home: Ada 95 Reference Manual. http://www.adahome.com/rm95/, 2007

[ARB 07]

OpenMP Architecture Review Board. http://www.openmp.org, 2007

[B 90]

Bengel G.: Betriebssysteme. Aufbau, Architektur und Realisierung. Hüthig Verlag 1990.

[B 97]

Butenhof D.R.: Programming with POSIX Threads. Addison Wesley Longman, Reading, Massachusetts, 1997.

[B 06]

Barnes J.G.P.: Programming in Ada 2005. Addison Wesley 2006.

[BA 06]

Ben-Ari M: Principles of Concurrent and Distributed Programming. 2nd Edition. Pearson Education Limited 2006.

[BH 05]

Buhr P.A., Harji A.S.: Implicit-Signal Monitors. ACM Transaction on Programming Languages and Systems, Vol. 27, No. 6, Nov. 2005.

[BK 00]

Bull J. M., Kambites M. E.: JOMP – an OpenMp like interface for Java. Proceedings of the ACM 2000 Conference on Java Grande. San Francisco, California, USA, 2000.

[CD 88]

Cooper E.; Draves R.: C Threads. Technical Report; Departement of Computer Science, Carnegie Mellon University, Pittsburgh, Pennsylvania, Oct 1988.

[CDK 01]

Chandra R., Dagum L., Kohr D., et al.: Parallel Programming in OpenMP. Academic Press 2001.

[CS 98]

Carter J. R., Sanden Bo I.: Practical Use of Ada 95’s Concurrency Features. IEEE Concurrency. Parallel, Distributed & Mobile Computing. Vol. 6, No. 4, Oct.-Dec. 1998.

[DM 98]

Dagum L., Menon R.: OpenMP: An Industry-Standard API for Shared Memory Programming. IEEE Computational Science & Engineering. Vol. 5, No. 1. Jan/March 1998.

3. Programmiermodelle [EPCC 07]

Edinburgh Parallel Computng Centre (EPCC), Java Grande: JOMP Home Page. http://www2.epcc.ed.ac.uk/computing/research_acitivities /jomp/index_1.html, 2007.

[ECS 05]

El-Ghazawi T., Carlson W., Sterling T. Yelick K.: UPC. Distributed Shared Memory Programming. John Wiley & Sons, Inc. 2005.

[EV 01]

Eigenmann R. (Editor), Voss M. (Editor), OpenMP Shared Memory Parallel Programming: International Workshop on OpenMP Applications and Tools, WOMPAT 2001, West Lafayette, IN, USA, July 30-31, 2001. Lecture Notes in Computer Science, Springer Verlag 2001.

[GNU 07]

GNU: GNAT-GNU Project–Free Software Foundation (FSF) http://www.gnu.org/software/gnat/gnat.html, 2007.

[GYJ 97]

Gosling J.; Yellin F.: Java Team: Das Java API, Band 1: Die Basispakete. [Übers. aus dem Amerikan. von Birgit Kehl]. Addison Wesley Longman Verlag 1997.

[H 93]

P. Brinch Hansen P.: Monitors and Concurrent Pascal: A Personal History. In ACM SIGPLAN Notices, Vol. 28, No. 3, March 1993.

[H 78]

Hoare C. A. R.: Communicating Sequential Processes, Communications of the ACM, Vol. 21., No. 8, 1978.

[H 04]

Herold H.: Linux/Unix Systemprogrammierung. 3. aktualisierte Auflage. Addison Wesley 2004.

[Ha 75]

Brinch Hansen P.: The Programming Language Concurrent Pascal. IEEE Transaction on Software Engineering, SE-1; pp 199-207, 1975 .

[Ho 74]

Hoare C. A. R.: Monitors - An Operating Systems Structuring Concept. Communications of the ACM, Vol. 11, No. 10, 1974.

[HH 97]

Hughes C.; Hughes T.: Object-oriented Multithreading Using C++. John Wiley & Sons, Inc. 1997.

[KY 02]

Kredel H., Yoshida A.: Thread und Netzwerkprogrammierung mit Java. 2. aktualisierte und erweiterte Auflage. dpunkt.verlag, 2002.

[M 03]

Marowka A.: Extending OpenMP for Task Parallelismus. Parallel Processing Letters, Vol. 13, No. 3, Sept. 2003.

461

Literatur [M 07]

Marowka A.: Parallel Computing on Any Desktop. Communications of the ACM, Vol. 50, No. 9, Sept. 2007.

[N 03]

Nagl M.: Software Technik mit Ada 95. Entwicklung großer Systeme. 2. Auflage, Vieweg Verlag 2003.

[NBF 98]

Nichols B.; Buttlar D.; Farrell J.: Pthreads Programming. O’Reilly Associates Inc. 1998.

[O 01]

Oechsle R.: Parallele Programmierung mit Java Threads. Fachbuchverlag Leipzig im Carl Hanser Verlag 2001.

[O 07]

Oechsle R.: Parallele und verteilte Programmierung in Java. 2., vollständig überarbeitete und erweiterte Auflage. Carl Hanser Verlag 2007.

[OW 04]

Oaks S., Wong H.: Java Threads, Understanding and Mastering Concurrent Programming, 3rd Edition. O’Reilly 2004.

[Q 04]

Quinn M., J.: Parallel Programming in C with MPI and OpenMP. McGraw-Hill Inc., 2004.

[R 07]

Reinders J.: Intel Threading Building Blocks. Outfitting C++ for MultiCore Processor Parallelism. O’ Reilly Media, Inc. 2007.

[SR 07]

Sun Programming Language Research Group: Project Fortress Overview. http://research.sun.com/projects/plrg/, 2007.

[SS 07]

Sun Source.net: fortress Project home. http://fortress.sunsource.net, 2007.

[UPC 07]

The George Washington University, The High Performance Computing Laboratory: Unified Parallel C. http://upc.gwu.edu/, 2007.

[Z 06]

Zahn M. Unix-Netzwerkprogrammierung mit Threads, Sockets und SSL. Springer Verlag 2006.

[ZK 93]

Zimmermann Ch.; Kraas A.W.: Mach, Konzepte und Programmierung. Springer Verlag 1993.

3.4 Programmiermodelle für verteilten Speicher [A 07]

462

Abts D.: Masterkurs Client Server Programmierung mit Java. 2. erweiterte und aktualisierte Auflage. Vieweg Verlag 2007.

3. Programmiermodelle [Ap 07]

Apache.org: About Apache XML-RPC. http://ws.apache.org/xmlrpc/, 2007.

[B 04]

Bengel G.: Grundkurs Verteilte Systeme. 3. verbesserte und erweiterte Auflage. Vieweg Verlag 2004.

[BM 06]

Bauke H., Mertens S.: Cluster Computing, Praktische Einführung in das Hochleistungsrechnen auf Linux-Clustern. Springer Verlag 2006.

[BR 07]

Bachschat M., Rücker B.: Enterprise JavaBeans 3.0. Grundlagen – Konzepte – Praxis. 2. Auflage. Elsevier GmbH München 2007.

[Bo 96]

Bonner P.: Network Programming with Windows Sockets. Prentice-Hall Inc. 1996.

[CCM 07]

Object Management Group: CORBA Component Model, V 4.0. http://www.omg.org/technology/documents/formal/comp onents.htm, 2007.

[CGJ 00]

Carpenter B., Getov V., Judd G., Skjellum T., Fox G.: MPJ: MPI-like Message Passing for Java. Concurrency: Practice and Experience, Volume 12, Number 11, Sept. 2000.

[EE 98]

Eddon G., Eddon H.: Inside Distributed COM. Microsoft Press 1998.

[EE 00]

Eddon G., Eddon H.: Inside COM+. COM+ Architektur und Programmierung. Microsoft Press 2000.

[G 01]

Görzig S.: CPPvm – C++ and PVM. Lectures Notes in Computer Science. Vol. 2131/2001. Springer Verlag 2001.

[GBD 94]

Geist A., Beguelin A., Dongarra J. et al.: PVM: Parallel Virtual Machine. A Users’ Guide and Tutorial for Networked Parallel Computing. The MIT Press 1994. Auch verfügbar in Postscript- und HTML-Form unter http://www.netlib.org/pvm3/book/pvm-book.html

[GHL 00]

Gropp W, Huss-Lederman S., Lumsdaien A., et al.: MPI – The Complete Reference: Volume 2, The MPI-2 Extensions. The MIT Press, Cambridge, MA 2000.

[GLS 99]

Gropp W., Lusk E., S., Skjellum A.: Using MPI: Portable Parallel Programming with the Message Passing Interface, 2nd edition. The MIT Press Cambridge, MA 1999.

463

Literatur

464

[GLS 07]

Gropp W., Lusk E., S., Skjellum A.: MPI – Eine Einführung. Portable parallele Programmierung mit dem MessagePassing Interface. Oldenburg Verlag München Wien, 2007. Deutsche Übersetzung von [GLS 99].

[GLT 99]

Gropp W., Lusk Thakur R.: Using MPI-2: Advanced Features of the Message-Passing Interface. The MIT Press Cambridge, MA 1999.

[GOH 98]

Gropp W., Otto S., Huss-Lederman S., Lumsdaien A., et al.: MPI – The Complete Reference. (2-Volume Set). The MIT Press, Cambridge, MA 1998.

[H 78]

Hoare C. A. R.: Communicating Sequential Processes, Communications of the ACM, Vol. 21., No. 8, 1978.

[H 97]

Harold E.R.: Java Network Programming. O’Reilly & Associates Inc. 1997.

[HS 04]

Homer A. Sussmann D.: Distributed Data Applications with ASP.NET. Second Edition. Apress 2004.

[I 88]

Inmos Limited, Occam 2 Reference Manual, Prentice Hall International, 1988.

[IDL 07]

Object Management Group: OMG IDL: Details. http://www.omg.org/gettingStarted/omg-idl.htm, 2007.

[IIOP 07]

Sun Developer Network (SDN): Java over IIOP. http://java.sun.com/javase/technologies/core/basic/rmi/ind ex.jsp, 2007

[J 99]

Jobst F.: Programmieren in Java, 2., aktualisierte und erweiterte Auflage. Carl Hanser Verlag 1999.

[JGF 07]

Java Grande Forum: Java Grande Forum Homepage. http://www.javagrande.org, 2007.

[J 04]

Jones M.T.: BSD Sockets Programming from a MultiLanguage Perspective. Charles River Multimedia Inc. 2003.

[KB 07]

Kuhrmann M., Beneken G.: Windows Communication Foundation. Konzepte – Programmierung – Migration.Elsevier GmbH, Sektrum Akademischer Verlag 2007.

[KCH 04]

Kuhrmann M. Calame J. Horn E.: Verteilte Systeme mit .NET Remoting. Grundlagen – Konzepte – Praxis. Elsevier GmbH, Spektrum Akademischer Verlag, 2007.

3. Programmiermodelle [KLS 94]

Koelbel C. H., Loveman D.B., Schreiber R.S., Steele Jr. G.L., Zosel M. E.: The High Performance Fortran Handbook. The MIT Press 1994.

[LM 07]

LAM/MPI Parallel Computing. http://www.lam-mpi.org/, 2007

[MC 01]

Monson-Haefel R.; Chappell D.A.: Java Message Service. O’Reilly & Associates Inc. 2001.

[MDN 07]

Microsoft Developer Network: .NET Remoting 2.0. http://www.microsoft.com/germany/msdn/library/net/NE TRemoting20.mspx?mfr=true, 2007.

[MR 97]

Mowbray T.J.; Ruh W.A.: Inside CORBA, Distributed Object Standards and Applications. Addison Wesley Longman, Inc. 1997.

[MPC 07]

MPICH2. http://www-unix.mcs.anl.gov/mpi/mpich/, 2007

[MPG 07]

MPICH-G2. http://www3.niu.edu/mpi/, 2007

[MPI 94]

Message Passing Interface Forum. MPI: A MessagePassing Interface standard. International Journal of Supercomputerr Applications., Vol. 8, No. 3/4 1994.

[MPI 07]

MPI Forum: MPI Documents. http://www.mpiforum.org/docs/docs.html, 2007.

[MPII 07]

Intel: Intel MPI Library 3.1 for Linux or Microsoft Windows Compute Cluster (CCS). http://www3.niu.edu/mpi/, 2007.

[MPIS 07]

Scali: MPI Connect. http://www.scali.com/content/view/35/, 2007.

[MPIV1 07] Verari Systems Software: Verari Systems Software’s Commercial Version of MPI Standard. http://www.mpisofttech.com/documents/MPIPro_RevH.pdf, 2007. [MPIV2 07] Verari Systems Software: ChaMPIon/Pro. http://www.verarisoft.com/champion_pro.php, 2007. [NRS 04]

Neubauer B., Ritter T., Stoinski F.: CORBA Komponenten. Effektives Software-Design und Programmierung. Springer Verlag 2004.

[OM 07]

Open MPI: Open Source High Performance Computing. http://www.open-mpi.org/, 2007.

465

Literatur [OMA 07]

Object Management Group: Object Management Architecture. http://www.omg.org/oma/, 2007.

[OMG 07]

Object Management Group: The Object Management Group (OMG). http://www.omg.org/, 2007.

[OTE 07]

ORNL, University of Tennessee und Emory University: Heterogenous Adaptable Reconfigurable NEtworked Systems (HARNESS). http://www.csm.ornl.gov/harness/, 2007.

[P 93]

Padovano M.: Networking Applications on Unix System V Release 4. Prentice-Hall Inc. 1993.

[P 95]

Peterson M.T.: DCE. A Guide to Developing portable Applications. McGraw-Hill Inc. 1995.

[P 98]

Pope A.: The CORBA Reference Guide. Understanding the Common Object Request Broker Architecture. Addison Wesley 1998.

[PTL 07]

Pervasive Technology Labs at Indiana University: mpiJava Home Page. http://www.hpjava.org/mpiJava.html, 2007.

[PTLHP 07] Pervasive Technology Labs at Indiana University: HPJava Home Page. http://www.hpjava.org/index.html, 2007.

466

[PVM 07]

PVM home: PVM Parallel virtual Machine. http://www.csm.ornl.gov/pvm/pvm_home.html, 2007.

[Q 04]

Quinn M. J.: Parallel Programming in C with MPI and OpenMP. The Mc Graw Hill Companies, Inc., 2004.

[R 02]

Richter J.: Microsoft .NET Framework Programmierung. Microsoft Press 2002.

[R 04]

Rottmann H.: Warum ausgerechnet .NET? Fakten und Vergleiche mit Java und C++ - Beispielprogramme – Glasklare Entscheidungshife. Vieweg Verlag 2004.

[RMI 07]

Sun Developer Network (SDN): Remote Method Invocation Home. http://java.sun.com/javase/technologies/core/basic/rmi/ind ex.jsp, 2007

[S 92]

Stevens W.R.: Programmieren von Unix-Netzen. Coedition Carl Hanser Verlag, Prentice Hall International Inc. 1992.

4. Parallelisierung [S 01]

Siegel J.: CORBA 3. Fundamentals and Programming. John Wiley & Sons Inc., 2001.

[SO 07]

Soap Version 1.2: http://www.w3.org/TR/soap12, 2007.

[SOH 00]

Snir M., Otto S., Huss-Ledermann S. et al.: MPI – The Complete Reference. 2nd Edition. The MIT Press, Cambridge, MA, 2000.

[T 07]

The Transputer Archive. http:/vl.fmnet.info/transputer/, 2007.

[TO 07]

SGS-Thomson Microelectronics Limited: occam® 2.1 reference manual, 1995. http://www.wotug.org/occam/documentation/oc21refman .pdf, 2007.

[UDD 04}

OASIS: UDDI Version 3.0.2 http://uddi.org/pubs/uddi_v3.htm, 2004.

[V 07]

University of Virginia: JPVM The Java Virtual Machine. http://www.cs.virginia.edu/~ajf2j/jpvm.html, 2007

[W 07]

Wilson Partnership: MinML a minimal XMLParser. http://www.wilson.co.uk/xml/minml.html, 2007.

[W3C 07]

W3C World Wide Web Consortium: http://www.w3.org/, 2007.

[WJ 07]

WoTUG: Java Implementation of Occam. http://wotug.org./occam/#java, 2007.

[WSA 04]

W3C: Web Services Architecture. http://www.w3.org/TR/ws-arch/, 2004.

[XML 06]

W3C: Extensible Markup Language (XML). http://www.w3.org/XML/, 2006.

[XR 07]

XML-RPC.COM: XML-RPC Home Page. http://www.xmlrpc.com, 2007.

[Z 06]

Zahn M. Unix-Netzwerkprogrammierung mit Threads, Sockets und SSL. Springer Verlag 2006.

467

Literatur

4. Parallelisierung

468

[A 67]

Amdahl G.: Validity of the Single Processor Approach to Achieving Large-Scale Computing Capabilities. AFIPS Conference Proceedings, (30), pp. 483-485, 1967.

[A 85]

Akl S. G.: Parallel Sorting Algorithms. Academic Press Inc. 1985.

[A 97]

Akl S., G.: Parallel Computation: Models and Methods. Prentice Hall 1997.

[A 00]

Andrews G., R.: Foundations of Multithreaded, Parallel, and Distributed Programming. Addison-Wesley, 2000.

[A 05]

Alba E. (Ed.): Parallel Metaheuristics. A New Class of Algorithms. John Wiley & Sons 2005.

[ACK 02]

Anderson D.P., Cobb J., Korpela E., Lebofsky M., Werthimer D.: SET@home: An Experiment in Public Resource Computing. Communictaions of the ACM Vol. 45, No. 11, Nov. 2002.

[B 94]

Bräunl T.: Parallele Programmierung – Eine Einführung. McGraw Hill 1994.

[B 96]

Blelloch G.E.: Programming Parallel Algorithms. Communications of the ACM Vol. 39, No. 3, 1996

[B 01]

Bolzhauser P.: Performance Cluster mit PVM, MPI, LSF und DQS. Parallelisierung einer Monte Carlo Simulation. Diplomarbeit Fachhochschule Mannheim 2001.

[B 06]

Bilek M.: Parallelisierungsverfahren, Prinzipien, Modelle und Techniken für HPC-Anwendungen. Diplomarbeit Hochschule Mannheim, 2006.

[BDH 84]

Bitton D., DeWitt D.J., Hsiaio D.K., Menon J.: A Taxonomy of Parallel Sorting. ACM Computing Surveys, Vol. 16, No. 3, Sept. 1984.

[BG 88]

Benner, R.E., Gustafson, J.L., and Montry, G.R., Development and analysis of scientific application programs on a 1024-processor hypercube. SAND 88-0317, Sandia National Laboratories, Feb. 1988.

[BM 06]

Bauke H., Mertens S.: Cluster Computing. Springer Verlag 2006.

4.ȱParallelisierungȱ [Fȱ90]ȱ

FrommerȱA.:ȱLineareȱGleichungssystemeȱaufȱParallelrechȬ ner.ȱViewegȱVerlagȱ1990.ȱȱ

[Fȱ95]ȱ

Fosterȱ I.:ȱ Designingȱ andȱ Buildingȱ Parallelȱ Programs.ȱ AdȬ disonȱWesleyȱ1995.ȱAuchȱverfügbarȱinȱHTMLȬFormȱunterȱ http://wwwȬunix.mcs.anl.gov/dbpp/text/node1.html.ȱ

[CRQRȱ89]ȱ CosnardȱM.,ȱRobertȱY.ȱQuintonȱP.,ȱRaynalȱM.ȱ(EDs.):ȱParȬ allelȱ &ȱ Distributedȱ Algorithms.ȱ Proceedingsȱ ofȱ theȱ InterȬ nationalȱWorkshopȱonȱParallelȱ&ȱDistributedȱAlgorithms,ȱ ElsevierȱScieneȱPublisherȱB.V.ȱ1989.ȱ [Gȱ88]ȱȱ

Gustavsonȱ J.:ȱ Reevaluatingȱ Amdahl’sȱ Law.ȱ CommunicaȬ tionsȱofȱtheȱACM,ȱVol.ȱ31,ȱNo.ȱ5,ȱ1988.ȱ

[GGKȱ03]ȱȱ

GramaȱA.,ȱGuptaȱA.,ȱKarypisȱG.,ȱKumar,ȱV.:ȱIntroductionȱ toȱParallelȱComputingȱ(2ndȱEdition).ȱAddisonȱWesleyȱProȬ fessionalȱ2003.ȱȱȱ

[GOȱ96]ȱ

Goloub,ȱ G.H.;ȱ Ortegaȱ J.M.:ȱ Scientificȱ Computingȱ –ȱ Eineȱ EinführungȱinȱdasȱwissenschaftlicheȱRechnenȱundȱParalleȬ leȱNumerik.ȱTeubnerȱStuttgartȱ1996.ȱȱ

[GRȱ88]ȱ

Gibbonsȱ A.,ȱ Rytterȱ W.:ȱ Efficientȱ Parallelȱ Algorithms,ȱ CambridgeȱUniversityȱPressȱ1988.ȱ

[Hȱ83]ȱ

Hoßfeldȱ F.:ȱ Paralleleȱ Algorithmen.ȱ Informatikȱ –ȱ FachbeȬ richteȱ64.ȱSpringerȱVerlagȱ1983.ȱȱ

[HSȱ86]ȱ

Hillisȱ W.D.,ȱ Steeleȱ G.L.:ȱ Dataȱ Parallelȱ Algorithms.ȱ ComȬ municationsȱofȱtheȱACM,ȱVol.ȱ29,ȱNo.ȱ12,ȱDecȱ1986.ȱȱ

[Jȱ92]ȱ

JaJaȱ J.:ȱ Anȱ Introductionȱ toȱ Parallelȱ Algorithms.ȱ Addisonȱ Wesley,ȱReading,ȱMAȱ1992.ȱ

[KFȱ90]ȱ

Karpȱ A.H.,ȱ Flattȱ H.P.:ȱ Measuringȱ Parallelȱ Processorȱ PerȬ formance.ȱ Communictaionsȱ ofȱ theȱ ACM,ȱ Vol.ȱ 33,ȱ No.ȱ 5,ȱ Mayȱ1990ȱȱ

[Mȱ79]ȱȱ

Mehlhornȱ K.:ȱ Konzepteȱ derȱ Komplexitätstheorieȱ amȱ BeiȬ spielȱdesȱSortierens.ȱInformatikȱFachberichte,ȱGIȱ9.ȱJahresȬ tagung,ȱSpringerȱVerlagȱ1979.ȱȱ

[MBȱ05]ȱ

Millerȱ R.,ȱ Boxerȱ L.:ȱ Algorithmsȱ Sequentialȱ &ȱ Parallel.ȱ Aȱ Unifiedȱ Approach.ȱ Secondȱ Editionȱ Charlesȱ Riverȱ Mediaȱ Inc.ȱ2005.ȱȱ

[Qȱ87]ȱȱ

Quinnȱ M.:ȱ Designingȱ Efficientȱ Algorithmsȱ forȱ Parallelȱ Computers.ȱMcȱGrawȱHillȱInc.ȱ1987.ȱȱ

469ȱ

Literaturȱ [Qȱ94]ȱ

Quinnȱ M.:ȱ Parallelȱ Computing.ȱ Theoryȱ andȱ Practice.ȱ SecȬ ondȱEdition.ȱMcȬGrawȬHill,ȱInc.ȱ1994.ȱ

[QDȱ84]ȱ

Quinnȱ M.J.,ȱ Deoȱ N.;ȱ Parallelȱ Graphȱ Algorithms.ȱ ACMȱ ComputingȱSurveys,ȱVol.ȱ16,ȱNo.ȱ3,ȱSept.ȱ1984ȱ

[Sȱ03]ȱ

Schwandtȱ H.:ȱ Paralleleȱ Numerik.ȱEineȱ Einführung.ȱ TeubȬ nerȱVerlagȱ2003.ȱȱ

[RRȱȱ00]ȱȱ

RauberȱT,ȱRüngerȱG.:ȱParalleleȱundȱVerteilteȱProgrammieȬ rung.ȱSpringerȱVerlagȱBerlinȱHeidelbergȱ2000.ȱ

[Uȱ97]ȱȱȱ

Ungererȱ T.:ȱ Parallelrechnerȱ undȱ paralleleȱ ProgrammieȬ rung.ȱSpektrumȱAkademischerȱVerlagȱ1997.ȱ

[Wȱ95]ȱȱ

Waldschmittȱ K.ȱ (Hrsg.):ȱ Parallelrechner,ȱ Architekturenȱ Ȭȱ SystemeȱȬȱWerkzeuge.ȱB.G.ȱTeubnerȱStuttgartȱ1995.ȱ

5. Verteilte Algorithmen

470ȱ

[AWȱ04]ȱ

Attiyaȱ H.,ȱ Welchȱ J.:ȱ Distributedȱ Computing.ȱ FundamenȬ tals,ȱ Simulationsȱ andȱ Advancedȱ Topics.ȱ Johnȱ Wileyȱ andȱ SonsȱInc.ȱ2004.ȱ

[Bȱ04]ȱ

Bengelȱ G.:ȱ Grundkursȱ Verteilteȱ Systeme.ȱ 3.ȱ verbesserteȱ undȱerweiterteȱAuflage.ȱViewegȱVerlagȱ2004.ȱȱ

[Gȱ82]ȱ

GarciaȬMolinaȱ H.:ȱ Electionsȱ inȱ Distributedȱ Computingȱ Systems.ȱIEEEȱTransactionsȱonȱComputers,ȱVolȱ31.,ȱNo.ȱ1,ȱ 1982.ȱ

[Lȱ78]ȱ

Lamportȱ L.:ȱ Time,ȱ clocksȱ andȱ theȱ orderingȱ ofȱ eventsȱ inȱ aȱ distributedȱsystem.ȱCommunicationsȱofȱtheȱACM,ȱVol.21,ȱ No.ȱ7,ȱ1978.ȱ

[LSPȱ82]ȱ

LamportȱL.;ȱShostakȱR.;ȱPeaseȱM.:ȱTheȱByzantineȱGeneralsȱ Problem.ȱ ACMȱ Transactionȱ onȱ Programmingȱ Languagesȱ andȱSystems,ȱVol.ȱ4,ȱNo.ȱ3,ȱ1982.ȱ

[Lȱ96]ȱ

Lynchȱ N.A.:ȱ Distributedȱ Algorithms.ȱ Morganȱ Kaufmannȱ PublishersȱInc.,ȱ1996.ȱ

{Mȱ89]ȱ

Mattern,ȱ F.:Virtualȱ Timeȱ andȱ Globalȱ Statesȱ ofȱ Distributedȱ Systems.ȱInȱ[CRQRȱ89]:ȱCosnardȱM.,ȱRobertȱY.ȱQuintonȱP.,ȱ RaynalȱM.ȱ(EDs.):ȱParallelȱ&ȱDistributedȱAlgorithms.ȱProȬ ceedingsȱofȱtheȱInternationalȱWorkshopȱonȱParallelȱ&ȱDisȬ tributedȱAlgorithms,ȱElsevierȱScieneȱPublisherȱB.V.ȱ1989.ȱ

6.ȱRechenlastverteilungȱ [PFȱ06]ȱ

PeschelȬFindeisenȱT.:ȱNebenläufigeȱundȱVerteilteȱSysteme.ȱ TheorieȱundȱPraxis.ȱMitpȬVerlgȱ2006.ȱȱ

6. Rechenlastverteilung [ACȱ88]ȱ

Alonso,ȱR.,ȱCova,ȱL.L.:ȱSharingȱJobsȱamongȱIndependentlyȱ Ownedȱ Processors.ȱ Proceedingsȱ ofȱ theȱ 8thȱ Internationalȱ Conferenceȱ onȱ Distributedȱ Computingȱ Systems,ȱ IEEE,ȱ NewȱYork,ȱ282Ȭ288,ȱ1988.ȱ

[ACDȱ03]ȱ

Andrews,ȱT.,ȱCurbera,ȱF.,ȱDholakia,ȱH.,ȱGoland,ȱY.,ȱKlein,ȱ J.,ȱ Leymann,ȱ F.,ȱ Liu,ȱ K.,ȱ Roller,ȱ D.,ȱ Smith,ȱ D.,ȱ Thatte,ȱ S.,ȱ Trickovic,ȱI.,ȱWeerawarana,ȱS.:ȱBusinessȱProcessȱExecutionȱ Languageȱ forȱ Webȱ Services,ȱ Versionȱ 1.1.ȱ Specification,ȱ BEAȱSystems,ȱIBMȱCorp.,ȱMicrosoftȱCorp.,ȱSAPȱAG,ȱSiebelȱ Systems,ȱ2003.ȱ

[AHPȱ06}ȱ

Alt,ȱ M.,ȱ Hoheisel,ȱ A.,ȱ Pohl,ȱ H.ȬW.,ȱ Gorlatch,ȱ S.:ȱ Aȱ Gridȱ Workflowȱ Languageȱ Usingȱ HighȬLevelȱ Petriȱ Nets.ȱ R.ȱ Wyrzykowskiȱ etȱ al.ȱ (Eds.),ȱ PPAMȱ 2005,ȱ LNCSȱ 3911,ȱ pp.ȱ 715Ȭ722,ȱSpringer,ȱBerlin,ȱHeidelberg,ȱ2006.ȱ

[Bȱ02]ȱ

Buyya,ȱ R.:ȱ EconomicȬbasedȱ Distributedȱ Resourceȱ ManȬ agementȱ andȱ Schedulingȱ forȱ Gridȱ Computing.ȱ DissertaȬ tion,ȱ Monashȱ University,ȱ Melbourne,ȱ Australia,ȱ 12.ȱ Aprilȱ 2002.ȱ

[Bȱ07]ȱ

BruckerȱP.:ȱSchedulingȱAlgorithms.ȱFifthȱEdition.ȱSpringerȱ Verlagȱ2007.ȱȱ

[BKȱ06]ȱ

Bruckerȱ P.,ȱ Knustȱ S.:ȱ Complexȱ Scheduling.ȱ Springerȱ VerȬ lagȱ2006.ȱȱ

[BKȱ88]ȱ

Bonomi,ȱF.,ȱKumar,ȱA.:ȱAdaptiveȱOptimalȱLoadȱBalancingȱ inȱaȱHeterogeneousȱMultiserverȱSystemȱwithȱaȱCentralȱJobȱ Scheduler.ȱProceedingsȱ8thȱInt.ȱConf.ȱonȱDistributedȱComȬ putingȱ Systems,ȱ Sanȱ Jose,ȱ CA,ȱ 1988,ȱ Computerȱ Societyȱ Press,ȱWashington,ȱD.C.,ȱ500Ȭ508.ȱ

[BWCȱ03]ȱ

Berman,ȱF.,ȱWolski,ȱR.,ȱCasanova,ȱH.,ȱCirne,ȱW.,ȱDail,ȱH.,ȱ Faerman,ȱM.,ȱFigueira,ȱS.,ȱHayes,ȱJ.,ȱObertelli,ȱG.,ȱSchopf,ȱJ.,ȱ Shao,ȱ G.,ȱ Smallen,ȱ S.ȱ Spring,ȱ S.,ȱ Su,ȱ A.,ȱ Zagorodnov,ȱ D.:ȱ Adaptiveȱ computingȱ onȱ theȱ Gridȱ usingȱ AppLeS.ȱ IEEEȱ Trans.ȱ onȱ Parallelȱ andȱ Distributedȱ Systemsȱ (TPDS),ȱ 14(4):369ȬȬ382,ȱ2003.ȱ

471ȱ

Literaturȱ

472ȱ

[Cȱ07]ȱ

Condorȱ–ȱHighȱThroughputȱComputing,ȱ http://www.cs.wisc.edu/condor/,ȱ2007.ȱ

[CFKȱ99]ȱ

Czajkowski,ȱ K.,ȱ Foster,ȱ I.T.ȱ Kesselman,ȱ C.;ȱ Resourceȱ CoȬ AllocationȱinȱComputationalȱGrids.ȱProceedingsȱofȱtheȱ8thȱ IEEEȱInternationalȱSymposiumȱonȱHighȱPerformanceȱDisȬ tributedȱComputing,ȱS.ȱ37,ȱ1999.ȱ

[CKȱ88]ȱ

Casavant,ȱT.L.,ȱKuhl,ȱJ.G.:ȱEffectsȱofȱResponseȱandȱStabilȬ ityȱ onȱ Schedulingȱ inȱ Distributedȱ Computingȱ Systems.ȱ IEEEȱTrans.ȱSoftw.ȱEng.,ȱVol.ȱ14,ȱNo.ȱ2,ȱ141Ȭ154,ȱ1988.ȱ

[CLZȱ99]ȱ

Corradiȱ A.,ȱ Leonardiȱ L.,ȱ Zambonelliȱ F.:ȱ Diffuseȱ LoadȬ Balancingȱ Policiesȱ forȱ Dynamicȱ Applications.ȱ IEEEȱ ConȬ currency,ȱVol.ȱ7,ȱNoȱ1,ȱJan.ȬMarchȱ1999.ȱ

[CRMȱ07]ȱ

ClusterȱResourcesȱInc.:ȱMauiȱClusterȱScheduler®.ȱ http://www.clusterresources.com/pages/products/mauiȬ clusterȬscheduler.php,ȱ2007.ȱ

[CRSȱ07]ȱ

ClusterȱResourcesȱInc.:ȱMoabȱGridȱSuite®.ȱ http://www.clusterresources.com/pages/products/moabȬ gridȬsuite.php,ȱ2007.ȱ

[DAȱ06]ȱ

Dong,ȱF.,ȱAkl,ȱS.G.:ȱSchedulingȱAlgorithmsȱforȱGridȱComȬ puting:ȱStateȱofȱtheȱArtȱandȱOpenȱProblems.ȱTechnicalȱReȬ portȱ 2006Ȭ504,ȱ Schoolȱ ofȱ Computing,ȱ Queen’sȱ University,ȱ Kingston,ȱOntario,ȱJanuaryȱ2006.ȱ

[DFHȱ07]ȱ

Dörnemann,ȱT.,ȱFriese,ȱT.,ȱHerdt,ȱS.,ȱJuhnke,ȱE.,ȱFreisleben,ȱ B.:ȱ Gridȱ Workflowȱ Modellingȱ Usingȱ GridȬSpecificȱ BPELȱ Extensions.ȱ Germanȱ eȬScienceȱ 2007,ȱ BadenȬBaden;ȱ http://www.ges2007.deȱ

[DFMȱ95]ȱ

Dekeyser,ȱ J.L.,ȱ Fonlupt,ȱ C.,ȱ Marquet,ȱ P.:ȱ Analysisȱ ofȱ SynȬ chronuousȱ Dynamicȱ Loadȱ Balancingȱ Algorithms.ȱ ParCoȱ ȇ95,ȱGent,ȱBelgium,ȱAdvancesȱinȱParallelȱComputing,ȱVol.ȱ 11,ȱ455Ȭ462,ȱ1995.ȱ

[Fȱ96]ȱ

Ferguson,ȱ D.F.,ȱ Nikolaou,ȱ C.,ȱ Sairamesh,ȱ J.,ȱ Yemini,ȱ Y.:ȱ Economicȱ Modelsȱ forȱ Allocatingȱ Resourcesȱ inȱ Computerȱ Systems.ȱIn:ȱScottȱClearwater,ȱ(ed.),ȱMarketȬBasedȱControl:ȱ Aȱ Paradigmȱ forȱ Distributedȱ Resourceȱ Allocation,ȱ Scottȱ Clearwater.ȱWorldȱScientific,ȱHongȱKong,ȱ1996.ȱ

[FMDȱ98]ȱ

Fonlupt,ȱC.,ȱMarquet,ȱP.,ȱDekeyser,ȱJ.:ȱȈDataȬParallelȱLoadȱ Balancingȱ StrategiesȈ;ȱ Parallelȱ Computing,ȱ 24,ȱ 1665Ȭ1684,ȱ 1998.ȱ

6.ȱRechenlastverteilungȱ [FPVȱ98]ȱ

Fuggetta,ȱ A.,ȱ Picco,ȱ G.P.,ȱ Vigna,ȱ G.:ȱ Understandingȱ Codeȱ Mobility.ȱIEEEȱTrans.ȱSoftw.ȱEng.,ȱ24,ȱ5,ȱ342Ȭ361,ȱMayȱ1998.ȱ

[FQȱ05]ȱ

Fahringer,ȱ T.,ȱ Qin,ȱ J.,ȱ Hainzer,ȱ S.:ȱ Specificationȱ ofȱ Gridȱ Workflowȱ Applicationsȱ withȱ AGWL:ȱ Anȱ Abstractȱ Gridȱ WorkflowȱLanguage.ȱInȱProceedingsȱofȱIEEEȱInternationalȱ Symposiumȱ onȱ Clusterȱ Computingȱ andȱ theȱ Gridȱ 2005ȱ (CCGridȱ 2005),ȱ Cardiff,ȱ UK,ȱ Mayȱ 9Ȭ12ȱ 2005,ȱ IEEEȱ ComȬ puterȱSocietyȱPress.ȱ

[FRSȱ97]ȱ

Feitelson,ȱ D.G.,ȱ Rudolph,ȱ L.,ȱ Schwiegelshohn,ȱ U.,ȱ Sevcik,ȱ K.C.,ȱWong,ȱP.:ȱTheoryȱandȱPracticeȱinȱParallelȱJobȱSchedȬ uling.ȱIPPSȱȇ97ȱWorkshopȱonȱJobȱSchedulingȱStrategiesȱforȱ ParallelȱProcessing,ȱGeneva,ȱAprilȱ1997.ȱ

[FSYȱ06]ȱ

Franke,ȱ C.,ȱ Schwiegelshohn,ȱ U.,ȱ Yahyapour,ȱ R.:ȱ Jobȱ Schedulingȱ forȱ Computationalȱ Grids.ȱ Forschungsbericht,ȱ DortmundȱUniversity,ȱDepartmentȱofȱElectricalȱEngineerȬ ingȱandȱInformationȱTechnology,ȱ2006.ȱ

[Gȱ91]ȱ

Goscinskiȱ A.:ȱ Distributedȱ Operatingȱ Systemsȱ –ȱ Theȱ LogiȬ calȱDesign.ȱAddisonȱWesleyȱ1991.ȱ

[GGMȱ94]ȱ

Greenwood,ȱG.W.,ȱGupta,ȱA.,ȱMcSweeney,ȱK.:ȱSchedulingȱ Tasksȱ inȱ Multiprocessorȱ Systemsȱ Usingȱ Evolutionaryȱ Strategies.ȱ Internationalȱ Conferenceȱ onȱ Evolutionaryȱ Computation,ȱpp.ȱ345Ȭ349,ȱ1994ȱ

[GLȱ87]ȱ

Greenblattȱ B.,ȱ Linnȱ G.J.:ȱ Branchȱ andȱ Boundȱ Styleȱ AlgoȬ rithmsȱforȱSchedulingȱCommunicatingȱTasksȱinȱaȱDistribȬ utedȱ System.ȱ Proc.ȱ Ofȱ theȱ IEEEȱ Springȱ CompCon.ȱ Conf,ȱ 1987.ȱ

[GTȱ07]ȱ

TheȱGlobus®ȱAlliance,ȱhttp://www.globus.org/toolkit/mds/,ȱ 2007.ȱ

[Hȱ75]ȱ

Hollandȱ J.ȱ J.;ȱ Adaptionȱ inȱ Naturalȱ andȱ Artificalȱ Systems,ȱ Univ.ȱofȱMichiganȱPressȱ1975.ȱȱ

[HDȱ03]ȱ

Hoheisel,ȱ A.,ȱ Der,ȱ U.:ȱ Anȱ XMLȬbasedȱ Frameworkȱ forȱ Looselyȱ Coupledȱ Applicationsȱ onȱ Gridȱ Environments;ȱ P.M.A.ȱ Slootȱ etȱ al.ȱ (Eds.):ȱ ICCSȱ 2003,ȱ 245Ȭ254,ȱ SpringerȬ VerlagȱBerlinȱHeidelberg,ȱ2003.ȱ

[HKSȱ03]ȱ

Hovestadt,ȱM,ȱȱKeller,ȱO.A.,ȱStreit,ȱA.:ȱSchedulingȱinȱHPCȱ Resourceȱ Managementȱ Systems:ȱ Queuingȱ vs.ȱ Planning.ȱ Proceedingsȱ ofȱ theȱ 9thȱ Workshopȱ onȱ Jobȱ Schedulingȱ StrategiesȱforȱParallelȱProcessingȱ(JSSPP)ȱatȱGGF8,ȱSeattle,ȱ WA,ȱUSA,ȱJuneȱ24,ȱ2003,ȱLNCSȱ2862,ȱ1Ȭ20.ȱ

473ȱ

Literaturȱ

474ȱ

[HLAȱ95]ȱ

Hamidzadeh,ȱB.,ȱLaija,ȱD.J.,ȱAtif,ȱY.:ȱDynamicȱSchedulingȱ TechniquesȱforȱhetereogeneousȱComputingȱSystems.ȱConȬ currency:ȱpracticeȱandȱExperience,ȱVol.ȱ7,ȱ633Ȭ652,ȱ1995.ȱ

[IBMȱ01]ȱ

IBM:ȱWebȱServicesȱFlowȱLanguageȱ(WSFLȱ1.0).ȱ http://xml.coverpages.org/WSFLȬGuideȬ200110.pdf,ȱMayȱ 2001.ȱ

[IBMȱ03]ȱ

IBM,ȱBPEL4WS:ȱBusinessȱprocessȱExecutionȱLanguageȱforȱ WebȱServices.ȱ http://www.ibm.com/developerworks/library/specificatio n/wsȬbpel/,ȱ2003.ȱ

[Jȱ03]ȱ

Jansenȱ K.:ȱ Theȱ mutualȱ exclusionȱ schedulingȱ problemȱ forȱ Permutationȱ andȱ comparabilityȱ graphs.ȱ Informationȱ andȱ Computationȱ180,ȱ2ȱJanuaryȱ2003.ȱ

[Jȱ06]ȱ

Jakob,ȱ W:ȱ Towardsȱ anȱ Adaptiveȱ Multimemeȱ Algorithmȱ forȱParameterȱOptimisationȱSuitingȱtheȱEngineers’ȱNeeds.ȱ In:ȱ Runarsson,ȱ T.P.,ȱ etȱ al.ȱ (eds.):ȱ Conf.ȱ Proc.ȱ PPSNȱ IX,ȱ LNCSȱ4193,ȱSpringer,ȱBerlinȱ(2006)ȱ132Ȭ141.ȱ

[KAȱ97]ȱ

Kwokȱ Y.ȬK.,ȱ Ahmadȱ I.:ȱ Efficientȱ schedulingȱ ofȱ arbitraryȱ taskȱgraphsȱtoȱmultiprocessorsȱusingȱaȱparallelȱgeneticȱalȬ gorithm.ȱ Journalȱ ofȱ Parallelȱ andȱ Distributedȱ Computingȱ Vol.ȱ47ȱNumberȱ1ȱ1997.ȱȱ

[KAȱ99]ȱ

Kwok,ȱY.ȬK.,ȱAhmad,ȱI.:ȱStaticȱSchedulingȱAlgorithmsȱforȱ Allocatingȱ Directedȱ Taskȱ Graphsȱ toȱ Multiprocessors.ȱ ACMȱComputingȱSurveys,ȱ31ȱ(4),ȱ406Ȭ471,ȱDecemberȱ1999.ȱ

[Lȱ92]ȱ

Ludwig,ȱ T.:ȱ Lastverwaltungsverfahrenȱ fürȱ MehrprozesȬ sorsystemeȱ mitȱ verteiltemȱ Speicher.ȱ Dissertation,ȱ TechniȬ scheȱUniversitätȱMünchen,ȱ1992.ȱ

[LAAȱ02]ȱ

vonȱLaszewski,ȱG.,ȱAlunkal,ȱB.,ȱAmin,ȱK.,ȱHampton,ȱS,,ȱ Nijsure,ȱS.:ȱGridAntȱȬȱClientȱSideȱGridȱWorkflowȱManaȬ gementȱwithȱAnt.ȱhttp://wwwȬ unix.globus.org/cog/projects/gridant/,ȱ2002ȱ

[LEEȱ92]ȱ

Leeȱ K.G.:ȱ Efficientȱ parallelizationȱ ofȱ simulatedȱ annealingȱ usingȱ multipleȱ Markovȱ chains:ȱ anȱ applicationȱ toȱ graphȱ partition.ȱProc.ȱofȱtheȱ1992ȱInt’lȱConf.ȱonȱParallelȱProcessȬ ingȱ1992.ȱ

[LHFȱ91]ȱ

LeeȱB.,ȱHursonȱA.R.,ȱFengȱT.ȬY.:ȱAȱVerticallyȱLayeredȱAlȬ locationȱSchemeȱforȱDataȱFlowȱSystems.ȱJournalȱofȱParallelȱ andȱDistributedȱSystemȱVol.ȱ11,ȱNo.ȱ3,ȱ1991.ȱȱ

6.ȱRechenlastverteilungȱ [LKȱ98]ȱ

Li,ȱ J.,ȱ Kameda,ȱ H.:ȱ ȈLoadȱ Balancingȱ Problemsȱ forȱ MultiȬ classȱ Jobsȱ inȱ Distributed/Parallelȱ Computerȱ SystemsȈ;ȱ IEEEȱTransactionȱonȱComputers,ȱVol.ȱ47,ȱNo.ȱ3,ȱppȱ322Ȭ332,ȱ 1998.ȱ

[LLȱ01]ȱ

S.ȱKannanȱetȱal.,ȱIBM:ȱhttp://www.redbooks.ibm.ȱ com/redbooks/pdfs/sg246038.pdf,ȱ2001.ȱ

[LMȱ92]ȱ

Lülingȱ R.ȱ andȱ B.ȱ Monienȱ B.:ȱ Loadȱ Balancingȱ forȱ DistribȬ utedȱBranchȱ&ȱBoundȱAlgorithms.ȱIntern.ȱPar.ȱProcessingȱ Symp.,ȱIPPSȱ1992.ȱȱȱ

[LSFȱ07]ȱ

PlatformȱComputingȱInc.:ȱhttp://www.platform.ȱ com/Products/Platform.LSF.Family/Platform.LSF/ȱ Home.htm,ȱ2007.ȱ

[LTȱ86]ȱ

Lee,ȱ K.J.,ȱ Towsley,ȱ D.:ȱ Aȱ Comparisonȱ ofȱ PriorityȬBasedȱ DecentralizedȱLoadȱBalancingȱPolicies.ȱProceedingsȱofȱtheȱ 10thȱSymposiumȱonȱOperatingȱSystemȱPrinciple,ȱAssociaȬ tionȱforȱComputingȱMachinery,ȱNewȱYork,ȱ70Ȭ77,ȱ1986.ȱ

[Mȱ94]ȱ

Michalewicz,ȱ Z.:ȱ Geneticȱ Algorithmsȱ +ȱ Dataȱ Structuresȱ =ȱ EvolutionȱPrograms.ȱSpringer,ȱBerlin,ȱ2ndȱedition,ȱ1994.ȱ

[MSȱ01]ȱ

Microsoft:ȱ XLANGȱ –ȱ Webȱ Servicesȱ forȱ Businessȱ Processȱ Design.ȱhttp://xml.coverpages.org/XLANGȬCȬ200106.html,ȱ 2001.ȱ

[NSWȱ04]ȱ

Nabrzyski,ȱ J.,ȱ Schopf,ȱ J.M.,ȱ Weglarz,ȱ J.ȱ (Hrsg.):ȱ Gridȱ ReȬ sourceȱManagementȱ–ȱStateȱofȱtheȱArtȱandȱFutureȱTrends.ȱ KluwerȱAcademicȱPublishers,ȱ2004.ȱ

[OAȱ02]ȱ

Osman,ȱ A.,ȱ Ammar,ȱ H.:ȱ Dynamicȱ Loadȱ Balancingȱ StrateȬ giesȱ forȱ Parallelȱ Computers,ȱ Internationalȱ Symposiumȱ onȱ Parallelȱ andȱ Distributedȱ Computingȱ (ISPDC),ȱ Romania,ȱ Julyȱ2002.ȱ

[Pȱ07]ȱ

AltairȱEngineering,ȱInc.:ȱPBS®ȱGridWorks®.ȱ http://www.pbsgridworks.com,ȱ2007.ȱ

[Rȱ94]ȱ

Rechenberg,ȱ I.:ȱ Evolutionsstrategieȱ ȇ94.ȱ FrommannȬ HolzboogȱVerlag,ȱStuttgart,ȱ1994.ȱ

[Sȱ90]ȱ

Starke,ȱ P.H.:ȱ Analyseȱ vonȱ PetriȬNetzȬModellen.ȱ B.G.ȱ Teubner,ȱStuttgart,ȱ1990.ȱ

[Sȱ94]ȱ

Singhal,ȱ M.,ȱ Shivaratri,ȱ N.G.:ȱ Advancedȱ Conceptsȱ inȱ OpȬ eratingȱSystems.ȱMcGrawȬHill,ȱInc.,ȱ1994.ȱ

[Sȱ96]ȱ

SinhaȱP.ȱK.:ȱDistributedȱOperatingȱSystems,ȱConceptsȱandȱ Design.ȱIEEEȱPressȱ1996.ȱȱ

475ȱ

Literaturȱ [SJQȱ06]ȱ

Stucky,ȱ K.ȬU.,ȱ Jakob,ȱ J.,ȱ Quinte,ȱ A.,ȱ Süß,ȱ W.:ȱ Solvingȱ Schedulingȱ Problemsȱ inȱ Gridȱ Resourceȱ Managementȱ UsȬ ingȱanȱEvolutionaryȱAlgorithm.ȱR.ȱMeersman,ȱZ.ȱTariȱetȱal.ȱ (Eds.):ȱ OTMȱ 2006,ȱ LNCSȱ 4276,ȱ pp.ȱ 1252ȱ –ȱ 1262,ȱ SpringerȬ VerlagȱBerlinȱHeidelberg,ȱ2006ȱ

[SKȱ90]ȱ

Hivaratri,ȱN.G.,ȱKrueger,ȱP.:ȱTwoȱAdaptiveȱLocationȱPoliȬ ciesȱforȱGlobalȱScheduling.ȱProc.ȱofȱtheȱ10thȱInternationalȱ ConferenceȱonȱdistributedȱComputingȱSystems,ȱ1990,ȱ502Ȭ 509.ȱ

[STȱ85]ȱ

Shen,ȱ C.C.,ȱ Tsai,ȱ W.H.:ȱ Aȱ Graphȱ Matchingȱ Approachȱ toȱ OptimalȱTaskȱAssignmentȱinȱDistributedȱComputingȱSysȬ temsȱwithȱMinimaxȱCriterion.ȱIEEEȱTransactionsȱonȱComȬ puters,ȱCȬ94,ȱ197Ȭ203,ȱ1985.ȱ

[Tȱ95]ȱ

Tanenbaumȱ A.:ȱ Distributedȱ Operatingȱ Systems.ȱ PrenticeȬ Hallȱ1995.ȱȱ

[TLȱ89]ȱ

Theimer,ȱ M.M.,ȱ Lantz,ȱ K.A.:ȱ Findingȱ Idleȱ Machinesȱ inȱ aȱ WorkstationȬBasedȱDistributedȱSystem.ȱIEEEȱTransactionsȱ onȱSoftwareȱEngineering,ȱVolȱ15,ȱ1444Ȭ1458,ȱ1989.ȱ

[TSȱ06]ȱ

Tanenbaum,ȱ A.S.,ȱ vanȱ Steen,ȱ M.:ȱ Distributedȱ Systemsȱ –ȱ PrinciplesȱandȱParadigms.ȱPearsonȱ–ȱPrenticeȱHall,ȱ2006.ȱ

[TTLȱ04]ȱ

Thain,ȱ D.,ȱ Tannenbaum,ȱ T.,ȱ Livny,ȱ M.:ȱ Distributedȱ comȬ putingȱ inȱ practice:ȱ Theȱ condorȱ experience.ȱ Concurrencyȱ andȱComputation:ȱPracticeȱandȱExperience,ȱ2004.ȱ

[Wȱ97]ȱ

Wu,ȱJ.:ȱDimensionȬExchangeȬBasedȱGlobalȱLoadȱBalancingȱ inȱ Faultyȱ Hypercubes.ȱ Parallelȱ Processingȱ Practiceȱ andȱ Experience,ȱ9,ȱ1,ȱ41Ȭ61,ȱ1997.ȱ

[Wȱ98]ȱ

Weberȱ M.:ȱ Verteilteȱ Systeme.ȱ Spektrumȱ Akademischerȱ VerlagȱGmbHȱHeidelberg,ȱ1998.ȱȱ

[Wȱ99]ȱ ȱȱȱȱȱȱȱȱȱWuȱJ.:ȱDistributedȱSystemȱDesign.ȱCRCȱPressȱ1999.ȱ

476ȱ

[Wȱ07]ȱ

Wieczorek,ȱM.,ȱProdan,ȱR.,ȱHoheisel,ȱA.:ȱTaxonomiesȱofȱ theȱMultiȬcriteriaȱGridWorkflowȱSchedulingȱProblem.ȱCoȬ reGRIDȱTechnicalȱReportȱNumberȱTRȬ0106,ȱAugustȱ21,ȱ 2007,ȱInstituteȱonȱResourceȱManagementȱandȱScheduling,ȱ CoreGRIDȱȬȱNetworkȱofȱExcellence,ȱURL:ȱ http://www.coregrid.net,ȱ2007ȱ

[WSHȱ99]ȱ

Wolski,ȱ R,ȱ Spring,ȱ N.,ȱ Hayes,ȱ J.:ȱ Theȱ Networkȱ Weatherȱ Service:ȱ Aȱ Distributedȱ Resourceȱ Performanceȱ Forecastingȱ

7.ȱVirtualisierungstechnikenȱ ServiceȱforȱMetacomputing.ȱFutureȱGenerationȱComputerȱ Systems,ȱ15,ȱ5Ȭ6,ȱ757Ȭ768,ȱ1999.ȱ [ZLPȱ96]

Zaki,ȱM.J.,ȱLi,ȱW.,ȱParthasarathy,ȱS.;ȱCustomizedȱDynamicȱ Loadȱ Balancingȱ forȱ aȱ Networkȱ ofȱ Workstations.ȱ ProceedȬ ingsȱofȱtheȱ5thȱIEEEȱInt.ȱSymp.,ȱHPDC,ȱ1996,ȱ282Ȭ291.7.ȱȱ

7. Virtualisierungstechniken [Aȱ06]ȱ

AMDȱSecureȱVirtualizationȱTechnique,ȱ2006.ȱ

[Bȱ02]ȱ

Böhmerȱ W.:ȱ ȱ VPNȱ Virtualȱ Privateȱ Networks.ȱ Dieȱ realeȱ WeltȱderȱvirtuellenȱNetze.ȱCarlȱHanserȱVerlag,ȱ2002.ȱȱ

[Cȱ05]ȱ

Clarkȱ T.:ȱ Storageȱ Virtualization.ȱ Technologiesȱ forȱ SimpliȬ fyingȱ DataȱStorageȱandȱ Management.ȱ Pearsonȱ Education,ȱ 2005.ȱȱ

[Cȱ06]ȱ

Craigȱ I.D.:ȱ Virtualȱ Machines.ȱ ȱ Springerȱ Verlagȱ Londonȱ Limited,ȱ2006.ȱȱ

[CBȱ07]ȱ

Crosbyȱ S.,ȱ Brownȱ D.:ȱ Theȱ Virtualizationȱ Reality.ȱ ACMȱ QueueȱVol.4,ȱNo.ȱ10,ȱDecember/Januaryȱ2006Ȭ2007.ȱȱ

ȱ

[DMTFȱ07]ȱ DistributedȱManagementȱTaskȱForce,ȱInc.: CommonȱInȬ formationȱModelȱ(CIM)ȱStandards.ȱ http://www.dmtf.org/standards/cim/,ȱ2007.ȱ [Iȱ06]ȱ

IntelȱVirtualizationȱTechnology,ȱIntelȱTechnologyȱJournal,ȱ Volumeȱ10/03,ȱ2006.ȱ

[IBMȱ72]ȱ

IBMȱCorporation,ȱIBMȱVirtualȱMachineȱFacility/370ȱIntroȬ duction,ȱGC20Ȭ1800,ȱ1972.ȱ

[IBMȱ07]ȱ

IBM:ȱz/VM®ȱtheȱnewestȱVMȱhypervisorȱbasedȱonȱ64Ȭbitȱ z/Architecture.ȱȱwww.vm.ibm.com,ȱ2007.ȱȱ

[IBMȱ08]ȱ

IBM:ȱIBMȱPowerVMȱTheȱvirtualizationȱplatformȱforȱUNIX,ȱ Linuxȱandȱi5/OSȱcustomers.ȱhttp://wwwȬ 03.ibm.com/systems/power/software/virtualization/index. html,ȱ2008.ȱ

[Kȱ99]ȱ

Köhlerȱ R.:ȱ Aufȱ demȱ Wegȱ zuȱ MultimediaȬNetzenȱ:ȱ VPNȱ;ȱ VLANȬTechnikenȱ;ȱ Datenpriorisierung.ȱ FOSSILȬVerlag,ȱ Köln,ȱ1999.ȱ

[Kȱ07]ȱ

KnermannȱC.:ȱPCȱvs.ȱThinȱClient,ȱFraunhoferȱGesellschaftȱ CCȬASPȱ2007,ȱȱhttp://ccȬ asp.fraunhofer.de/docs/PCvsTCsummaryȬde.pdf,ȱ2007.ȱ

477ȱ

Literaturȱ [KWȱ07]ȱ

KampȱP.ȬH.,ȱWatsonȱR.N.M.:ȱJails:ȱConfiningȱtheȱomnipoȬ tentȱ root.ȱ http://phk.freebsd.dk/pubs/sane2000Ȭjail.pdf,ȱ 2007.ȱȱ

[Lȱ05]ȱ

Larischȱ D.:ȱ Citrixȱ Presentationȱ ServerGrundlagenȱ undȱ Profiwissen.ȱCarlȱHanserȱVerlagȱ2005.ȱ

[Lȱ07}ȱ

Larischȱ D.:ȱ Praxisbuchȱ VMwareȱ Server.ȱ Dasȱ praxisorienȬ tierteȱ Nachschlagewerkȱ zuȱ VMwareȱ Server.ȱ Carlȱ Hanserȱ Verlag,ȱ2007.ȱ

[Liȱ07]ȱ

LinuxȱVServer.org:ȱWelcomeȱtoȱLinuxȬVServer.org.ȱ http://linuxȬvserver.org/Welcome_to_LinuxȬVServer.org,ȱ 2007.ȱȱȱ

[MRMȱ06]ȱ Marshallȱ D.,ȱ Reynoldsȱ W.A.,ȱ McCroryȱ D.:ȱ Advancedȱ ServerȱVirtualization.ȱVMwareȱandȱMicrosoftȱPlatformsȱinȱ theȱ Virtualȱ Dataȱ Center.ȱ Auerbachȱ Publications,ȱ Taylorȱ FrancisȱGroupȱ2006.ȱ [Pȱ08]ȱ

Parallels:ȱParallelsȱVirtuozzoȱContainersȱ4.0.ȱ http://www.parallels.com/de/products/virtuozzo/?from=h omepage,ȱ2008.ȱ

[RMȱ06]ȱ

RadonicȱA.,ȱMeyerȱF.:ȱXen3.ȱFranzisȱVerlagȱ2006.ȱ

[Sȱ07]ȱ

Schenkerȱ T.:ȱ Opensolaris:ȱ Hochverfügbarkeit,ȱ VirtualisieȬ rung,ȱ Containertechnologie.ȱ Diplomarbeit,ȱ Hochschuleȱ Mannheimȱ2007.ȱ

[VMVȱ07]ȱ

vmwareȱ:ȱTransformȱITȱInfrastructureȱwithȱEnterpriseȬ ClassȱVirtualization.ȱ http://www.vmware.com/products/vi/,ȱ2007.ȱȱ

[VMPȱ07]ȱȱ vmware:ȱExpandȱtheȱPowerȱofȱYourȱPCȱwithȱVirtualizaȬ tion.ȱhttp://www.vmware.com/products/ws/,ȱ2007.ȱȱ [VMSȱ07]ȱ

vmware:ȱExperienceȱServerȱVirtualization.ȱ http://www.vmware.com/products/server/,ȱ2007.ȱȱ

[VNȱ06]ȱ

VaughanȬNicholsȱ S.J.:ȱ Newȱ Approachȱtoȱ Virtualizationȱ Isȱ aȱLightweight.ȱIEEEȱComputerȱVol.ȱ39,ȱNo.ȱ11,ȱNov.ȱ2006.ȱ

8. Cluster [BaMeȱ06]ȱ BaukeȱH.,ȱMertensȱS.:ȱClusterȱComputing.ȱSpringerȱȱ2006.ȱȱ [BGȱ07]ȱ

478ȱ

IBMȱBlueȱGene.ȱ2007.ȱ http://www.research.ibm.com/bluegene/,2007.ȱ

9.ȱGridȱ [BLRȱ03]ȱ

BiancoȱJ.,ȱLeesȱP.,ȱRabitoȱK.:ȱSunȱClusterȱ3ȱProgramming.ȱ PrenticeȱHallȱTechnicalȱReference,ȱ2003.ȱ

[BMȱ06]ȱ

BaukeȱH.ȱMertensȱS.:ȱClusterȱComputing.ȱSpringerȱVerlag,ȱ 2006.ȱȱ

[Diȱ00]ȱ

Diedrichȱ O.:ȱ Einigkeitȱ machtȱ stark.ȱ Preiswerteȱ HochleisȬ tungsrechnerȱmitȱClustern.ȱcȇtȱmagazinȱfürȱcomputerȱtechȬ nik,ȱNoȱ22,ȱ2000.ȱȱ

[GLSȱ02]ȱ

Groppȱ W.,ȱ Luskȱ E.,ȱ Sterlingȱ T.:ȱ Beowulfȱ Clusterȱ ComputȬ ingȱwithȱLinux.ȱMITȱPressȱ2002.ȱȱ

[Haȱ01]ȱ

Harmsȱ U.:ȱ Alterȱ Wein.ȱ Clusterlandschaftȱ historischȱ beȬ trachtet.ȱ iXȱ Magazinȱ fürȱ Professionelleȱ InformationstechȬ nik,ȱNo,ȱ7,ȱ2001.ȱȱ

[LHAȱ07]ȱȱ LinuxȬHA.ȱhttp://linuxȬha.org/,ȱ2007.ȱ [MEȱ07]ȱ

MEGWAREȱComputerȱVertriebȱundȱServiceȱGmbH.ȱ http://www.megaware.de/,ȱ2007.ȱ

[Pfiȱ98]ȱ

PfisterȱG.:ȱInȱSearchȱOfȱClusters.ȱPrenticeȬHallȱ1998.ȱȱ

[Riȱ10]ȱ

Diksȱ R.:ȱ Gerechtȱ verteilt.ȱ iXȱ Magazinȱ fürȱ Professionelleȱ InformationstechnikȱNo.ȱ10,ȱ2004.ȱȱ

[ScStȱ07]ȱȱ

Schlagenhaufȱ H.,ȱ Stadelȱ S.:ȱ Knotenȱ geplatzt.ȱ Microsoftsȱ HighȬPerformanceȬComputing.ȱ iXȱ Magazinȱ fürȱ ProfessioȬ nelleȱInformationstechnikȱ9/2007.ȱȱ

[SGLȱ03]ȱ

Sterlingȱ T.,ȱ Groppȱ W.,ȱ Luskȱ E.:ȱ Beowulfȱ Clusterȱ computȬ ingȱ withȱ Linux.ȱ 2ndȱ Edition.ȱ Theȱ MITȱ Pressȱ Cambridge,ȱ MA,ȱ2003.ȱ

[Solȱ02]ȱ

SoltauȱM.:ȱUnix/LinuxȱHochverfügbarkeit.ȱmitpȱ2002.ȱȱ

[Tanȱ01]ȱ

Tanenbaumȱ Andrewȱ S.:ȱ Computerarchitektur.ȱ Pearsonȱȱ Studiumȱ2001.ȱȱ

[Toȱ01]ȱ

TolkienȱJ.R.R.:ȱBeowulf.ȱKlettȬCotta,ȱ2001.ȱȱ

[Topȱ500]ȱ TOP500:ȱTOP500ȱSupercomputerȱSites.ȱ http://www.top500.org/,ȱ2007.ȱ

9. Grid [Ahmȱ04]ȱ AbbasȱA.:ȱGridȱComputing:ȱaȱpracticalȱguideȱtoȱtechnologyȱ andȱapplications.ȱCharlesȱRiverȱMedia.ȱ2004.ȱȱ [DAIweb]ȱȱTheȱOGSAȬDAIȱProject.ȱhttp://www.ogsadai.org.uk/,ȱ2007.ȱ

479ȱ

Literaturȱ [Fosȱ02]ȱ

Fosterȱ I.:ȱ Whatȱ isȱ theȱ Grid?ȱ Aȱ Threeȱ Pointȱ Checklist.ȱ http://wwwȬ fp.mcs.anl.gov/~foster/Articles/WhatIsTheGrid.pdf,ȱ2002.ȱ

[Globus]ȱ TheȱGlobusȱAlliance:ȱhttp://www.globus.org/toolkit/ȱ,2007.ȱ [EGEE]ȱ

EnablingȱGridsȱforȱEȬSciencE:ȱhttp://www.euȬegee.org/,2007.ȱȱ

[FoKeȱ99]ȱ Fosterȱ I.,ȱ Kesselmanȱ C.:ȱ Theȱ Grid:ȱ Blueprintȱ forȱ aȱ Newȱ Computingȱ Infrastructure.ȱ Morganȱ Kaufmannȱ Publishers.ȱ 1999.ȱȱ [RiMaȱ06]ȱ Riedelȱ M.,ȱ Mallmannȱ D.:ȱ Standardizationȱ Processesȱ ofȱ theȱ UnicoreȱGridȱSystem.ȱ2006.ȱȱ [OGSA]ȱ

OGF:ȱTheȱOpenȱGridȱServicesȱArchitecture,ȱ http://www.gridforum.org/documents/GWDȬIȬE/GFDȬ I.030.pdf,ȱ2007.ȱ

[SRBweb]ȱ StorageȱResourceȱBroker.ȱ http://www.sdsc.edu/srb/index.php,ȱ2007ȱȱ [Unicore]ȱ ForschungszentrumȱJülich:ȱhttp://www.unicore.eu/,ȱ2007ȱ

480ȱ

[Wieȱ04]ȱ

Wiegelmannȱ H.:ȱ Radiostar.ȱ Radioteleskopȱ inȱ denȱ NiederȬ landenȱperȱGridȱgesteuert.ȱiXȱMagazinȱfürȱProfessionelleȱInȬ formationstechnikȱ,ȱNo.ȱ11,ȱ2004.ȱȱ

[WSRF]ȱ

OGF:ȱOGSAȱWSRFȱBasicȱProfile,ȱ http://www.gridforum.org/documents/GFD.72.pdf,ȱ2007.ȱ

Schlagwortverzeichnis

. .NET · 297 .NET 3.0 · 303 .NET Framework · 299 .NET-Remoting · 302

1 1:1-Kommunikation · 142 10 Gbit-Ethernet · 5 10 Gigabit-Ethernet Standard · 6 16-Bit-Xerox-NS-Zeichensatz · 198

8 80 Core-Prototyp · 59

A Ablaufplaner (Scheduler) · 24 abort · 75, 77 Abstract Syntax Notation 1 (ASN.1) · 198 accept · 182, 245, 246, 247, 251 Access-Point · 11 Active · 68 Ad hoc Mode · 11 Ad Server (Advertisement Server) · 101 Ada · 111, 182, 274 Ada 83 · 134 Ada-Rendezvous · 135, 182, 183, 222

einseitig anonym · 183 selektiv · 135, 185, 186 Administration-To-Administration (A2A) · 18 Administration-To-Consumer (A2C) · 18 Administrative Skalierbarkeit · 31 Adminstration-To-Business (A2B) · 18 Agglomeration · 329 Aktivenliste · 346 aktives Warten · 69, 70, 74, 109 Algorithmus kostenoptimal · 316 paralleler Anteil · 317 sequentieller Anteil · 317, 319 suboptimal · 316 zentraler · 333 ALIGN · 192 all-to-one mapping · 145 Alpha Chip · 5 ALT · 222 Alternative gesperrt · 186 offen · 186 Amazon · 14 AMD Pacifica · 405, 406 Amdahls Gesetz · 317, 318, 319, 320 Anforderung (request) · 107 Annahmeanweisung · 182 Anwendung · 320 skalierbar · 320 ASP.NET · 14, 301 Asymmetric Multiprocessing (AMP) · 56 Asynchronous Transfer Mode (ATM) · 5

481

Schlagwortverzeichnis at least once · 113 at most once · 113 atomare Aktion · 77 atomare Block · 181 atomic · 75, 181 Atomic_Add · 73 Attacken Denial of Service (DOS) · 119 Attribut Bedingungsvariable · 156 Mutex · 153 Thread · 151 Ausfallsicherheit · 422, 423 Ausfalltoleranz · 27 Ausgangsparameter (out) · 274 Auskunfts-Server · 115 Ausnahmebehandlung (exception handling) · 110 Auswahlalgorithmus · 342 bullybasiert · 342 ringbasiert · 345 Authentifikation · 195 Autonomic Computing · 22

B Backend-Server · 2 Bandbreite · 8 barrier Pragma · 167 Barriere · 162, 164, 165, 166, 167, 172, 190, 217, 222, 233 Barriersynchronisation · 190 Basic Object Adapter (BOA) · 282 Basisblock · 136 Batch Processing System · 1 Batchjob · 24 bcmp · 235 bcopy · 235, 244, 249 Bedeutungsumfang (Comprehension) · 174

482

Bedingte kritische Regionen (conditional critical regions) · 75 Bedingungsvariable (condition variable) · 131, 156 Befehlspipeline · 325 Benutzerthread · 147 Beowulf · 429 Beowulf-Cluster · 428 Berechnungsbaum · 326, 327 Beschleunigung · Siehe Speedup bewachten Eingabe-Kommandos (Guards) · 222 bind · 233, 237, 238, 239, 242, 246, 247, 249, 251, 287, 294, 295 Binden dynamisch · 194 statisch · 194 Binder · 194, 195, 285 BitTorrent · 3, 12 BLOCK · 192 Blogs · Siehe Web Logs Bluetooth · 10 Bluetooth Special Interest Group (Bluetooth SIG) · 10 Broker · 195 forwarding · 279 Broker-Server · 115 Bully-Algorithmus · 342 Business on Demand · 20 Business Process Execution Language for Web Services (BPEL4WS) · 128 Business-To-Administration (B2A) · 18 Business-To-Business (B2B) · 18 Business-To-Consumer (B2C) · 18 Business-To-Employee (B2E) · 18 Bus-Snooping · 50 Butterfly-Maschine · 55 Bytecode · 402 Byte-Ordnung big endian · 196, 197, 198, 235

Schlagwortverzeichnis little endian · 196, 197, 235 BytesMessage · 253 Byzantine Generals Problem · 347 bzero · 235, 242

C C · 51, 57, 65, 71, 106, 107, 111, 132, 133, 135, 136, 137, 150, 161, 170, 174, 191, 192, 193, 199, 204, 206, 207, 209, 226, 235, 270, 273, 299, 306, 327, 337, 338, 339, 403, 449, 453, 455 C++ · 111, 161 C+S-System · 106 Cache Controller · 50 Cache Only Memory Architecture (COMA) · 80 Cache-Coherent NUMA (CC NUMA) · 80 Cache-Zeile (Cache Line) · 41 call-by-copy/restore · 273, 274 Can_Not_Enter · 68 CAS-Befehl · 72, 73 Cell Broadband Engine Architecture (CBEA) · 57 Cell Linux · 58 Cell, · 57 channel bottleneck · 119 Chip-Multiprozessoren · 55 chmod · 142 Choreographie · 125 Citrix · 404 Client Stummel (Stub) · 272 Client-Server-Modell · 105, 106, 271 close · 240, 242, 246, 250, 251, 256, 258, 261, 262, 263, 265 close(fd[0]) · 141 Cluster · 105, 415, 436, Siehe Cluster-System

Active/Active-Cluster · 424 Active/Passive-Cluster · 423 Anwendungen · 428 Aufstellungskonzepte · 419 Beowulf · 428 Campus-Wide · 419 Clusterlink · 426 Definition · 416 Enclosed · 432 Exposed · 432 Failback · 424 Failover · 424 Feierabendcluster · 421 Glass-House · 419 Heterogene · 417 High Availability · 33 High Performance (HPC) · 33, 427, 430 High Throughput · 430 Hochverfügbarkeits-Cluster · 422, 423 Homogene · 417 Hot-Standby · 423 Masterknoten · 434 Nachteile · 417 Quorum · 426 Shared Disk · 427 Shared Noting · 425 Skalierbare · 431 Vernetzung · 418 Vorteile · 417 Wulfpack · 430 Cluster Interconnect · 415 Cluster of Workstations · 95, 421 Clusterdatenbank · 426 Clusterlink · 426 Cluster-System · 2 Cocoon · 14 Collaberation-Web · 13 Collection Service · 278 commit · 75, 77, 258

483

Schlagwortverzeichnis Commodity of the shelf (COTS) · 96 Commodity-Cluster · 96 Common Data Representation (CDR) · 284 Common Information Model · 399 Common Intermediate Language · 403 Common Language Runtime · 401, 403 Common Object Request Broker Architecture (CORBA) · 276 Communicating Sequential Processes (CSP) · 25, 191 Compare and Swap-CPUInstruktion (CAS CMPXCHG) · 71 Compiler parallelisierend · 136 Compiler rmic · 285, 295 Completion-Unit · 36 Computational Grids · 437 Computer Farm · 331 Computer System organisch · 23 Computing Grid · Siehe Rechengrid Concurrency Control Service · 278 connect · 245, 246, 247, 249 Connection · 256 ConnectionFactory · 255, 265 ConnectionMetaData · 256 Consumer · 200 Consumer-To-Administration (C2A) · 18 Consumer-To-Business (C2B) · 18 Consumer-To-Consumer (C2C) · 18 Container · 123 Containervirtualisierung · 398 conversational continuity · 116 CORBAdomain · 279

484

CORBAfacility · 278 CORBAservices · 277, 279 Cray · 421 createBrowser · 259 createBytesMessage · 257 createConnectionConsumer · 256, 257 createDurableConnectionConsumer · 257 createDurableSubscriber · 259 createMapMessage · 257 createMessage · 257 createObjectMessage · 257 createPublisher · 259 createQueue · 258 createQueueConnection · 255, 266, 268 createQueueSession · 256, 266 createReceiver · 258, 268 createSender · 258, 266 createStreamMessage · 257 createSubscriber · 259 createTemporaryQueue · 258 createTemporaryTopic · 259 createTextMessage · 257, 266 createTopic · 259 createTopicConnection · 255 createTopicSession · 257 critical Pragma · 166 Crossbar Switch · 7 CYCLIC · 193

D Dämon-Prozess · 226 DARPA (Defense Advanced Research Projects Agency) · 199 Data Parallel Algorithms · 328 Datagram Socket · 7, 238 Datagram-Server · 241 Datenabhängigkeit · 137

Schlagwortverzeichnis Datengrid (Data Grid) · 3 Datenklausel (data clause) · 163 Datenkohärenz · 42 Datenkonsistenz · 42 Datenübertragungsrate · Siehe Bandbreite Datenzerlegung · 325, 328 DCE · 150 DCE environment specfic interORB protocol (DCE ESIOP) · 284 DCE-RPC · 275 Decode-Unit · 35 delete · 260 Deregistrierung · 195 Destination · 200, 259 Device Exclusion Vector · 406 Dienstleistungsservice · Siehe Web Service Digital Enhanced Cordless Telecommunications (DECT) · 10 Directory-Server · 115 disable-Interrupt-Instruktion · 68 Dispatcher · Siehe Prozessumschaltung Dispatch-Unit · 35 DISTRIBUTE · 192 Distributed Computing Environment (DCE) · 275 Distributed Memory · 420 Distributed Object Management (DOM) · 276 Distributed Shared Memory (DSM) · 82 Distributed Shared Virtual Memory (DSVM) · 82 Divide and Conquer · 322, 323, 327 DIX-Ethernet · 6 document identifier (docid) · 102 Domain decompostion · 325 Domain Name System (DNS) · 27, 99

Domäne (domain) Internet · 234 Unix · 234 Xerox-XNS · 234 Doppelkern-Prozessor (Dual-CoreProzessor) · 55 Double Compare and Swap (DCAS) · 73 Dragon Protocol · 50 Dual Core Opteron · 57 Durchschreiben (write through, store through) · 42 Dynamic Invocation Interface (DII) · 281 Dynamic Skeleton Interface (DSI) · 281

E E-Applikationen · 17 Ebay · 14 E-Business · 17, 18 E-Business Intelligence · 19 Echo-Server · 241 echt parallel Programme (true parallel) · 23 E-Community · 20 eDonkey · 3 Effizienz · 316, 321 E-Finance · 19 E-Government · 20 E-Health · 20 Ein-Ausgangsparameter in out · 274 Eingangsaufruf · 182 Eingangsparameter (in) · 274 Einprozessor · 105 Eintritts Konsistenz (Entry Consistency) · 85 E-Learning · 19 Elektronische Beschaffung (EProcurement) · 18

485

Schlagwortverzeichnis Elektronischer Handel (ECommerce) · 18 Element Interconnect Bus (EIB) · 57, 58 Emacs · 133 E-Mail · 12 Emulation · 396 enable-Interrupt-Instruktion · 68 Enclosed-Konzept · 434 Energie pro eine Million Instruktion (EPMI) · 96 Energie pro Instruktion (EPI) · 96 Enterprise Service Bus (ESB) · 128 entferntes Objekt (remote object) · 285 entry · 182 entry call · 182 equals() · 290 Ereignis · 336, 338 Ereignisse konkurrent · 336 Erzeuger · 25, 140, 141, 142, 151, 158, 186, 200, 201, 252, 264, 267 Erzeuger-Verbraucher-Problem · 158, 264 E-Science · 19 E-Service · 19 Ethernet · 5, 6 Ethernet Standard IEEE 802.3 · 6 Etikett · 209 Event Service · 278 E-World · 17 exactly once · 113 ExceptionListener · 255, 256, 264 Exchange (XCHG) · 69 Execution-Unit · 36 Exentsible Markup Language Remote Procedure Call (XMLRPC) · 306 exit · 138 expliziten-signal · 131 Exposed-Konzept · 432

486

Extended Mark Up Language (XML) · 303 Extensible Markup Language (XML). · 306 eXternal Data Representation (XDR) · 198 Externalization Service · 278 Extra-Grids · 438

F Fabric · 410 Faden · Siehe Thread Failback · 424, 431 Failover · 424, 431 failure byzantine · 347, 349 fail stop · 347 Fast Ethernet Standard · 6 Fast-Ethernet · 5, 418 FastTrack · 3 Fehler- und Ausfalltransparenz · 31 Fehlertoleranz · 27, 29, 344 Fehlertransparenz · 31 Feierabendcluster · 419, 421 Fetch-Unit · 35 Fiber Distributed Data Interconnect (FDDI) · 5 File Transfer Protocol (ftp) · 12 File-Server · 2, 113, 116, 117 zustandslos (stateless) · 117 zustandsspeichernd (stateful) · 116 Filter · 141 Firefly Protocol · 50 Flickr · 14 Fließbandverarbeitung · 324 Floating Master · 65, 67 Folding@home · 437 for Pragma · 164, 167

Schlagwortverzeichnis fork · 130, 137, 138, 139, 160, 161, 222, 251 fork-join Parallelismus · 137 Fortran · 132, 133, 136, 191, 192, 194, 204 Fortress · 133, 173, 178 Framework Class Library (FCL) · 301 FreeBSD Jails · 400 Freigabe Konsistenz (Release Consistency) · 84 ftp-Server · 115 funktionale Zerlegung · 324 Funkverbindung · 5

G General Inter-ORB protocol (GIOP) · 283 Geographische Skalierbarkeit · 31 geschützte Objekte (Protected Objects) · 135 geschützte Objekte (protected type) · 188 getClientHost · 291 getClientID · 256 getClientPort · 291 getDeliveryMode · 260 getDisableMessageID · 260 getDisableMessageTimestamp · 260 getEnumeration · 263 getErrorCode · 263 getExceptionListener · 256 getFloat · 253 gethostbyname · 209, 240, 241, 243, 244, 248, 249 getLinkedException · 263 getMessageListener · 258, 262 getMessageSelector · 263 getMetadata · 256 getNoLocal · 263

getObject · 253 getPriority · 261 getQueue · 261, 262, 263 getQueueName · 260 getRegistry · 289, 290 getservbyname · 248, 249, 250 getText · 253 getTimeToLive · 261 getTopic · 261, 263 getTopicName · 260 getTransacted · 258 Gigabit-Ethernet · 5, 7 Gigabit-Ethernet Standard · 6 Giga-Ethernet · 418 Gitter · 421 Gitterrechnen · Siehe Grid Computing gLite · 440 Nachteile · 440 Portabilität · 440 Vorteile · 440 Global System for Mobile Communication (GSM) · 10 globale Ordnung · 337 globale Zeit · 334 globaler Zustand · 333 Globus Toolkit · 439 Nachteile · 439 Vorteile · 439 Gnutella · 3 Google · 14, 97 Google Cluster · 332 Google Maps · 14 Google Web Servers (GWSs) · 101 Google-Cluster · 97 Grid Middleware · 438 Grid Services Architecture OGSA) · 439 Grid-Computing · 3, 435 Accounting · 436 Authentifikation · 436 Authentifizierung · 444

487

Schlagwortverzeichnis Autorisierung · 436, 444 Billing · 436 Computational Grids · 437 Data Grids · 437 Datenmanagement · 445 Datenschutz · 436 Definition · 435 Dienste · 438, 446 Distinguished Names · 442 Erste Generation · 437 Extra-Grids · 438 Föderation · 444 gLite · 440 Globus Toolkit · 439 Grid Application Toolkit (GAT) · 446 Grid Middleware · 438 Inter-Grids · 438 Intra-Grids · 438 Middleware · 438 Monitoring · 436 OGSA-DAI · 446 Protokolle · 436, 438 RC5-72 · 437 Ressourcen · 436 Schnittstellen · 436 Services · 446 Sicherheit · 436 Single Sign On · 436 SRM/dCache · 445 Storage Resource Broker · 445 Stromnetz · 437 Virtuelle Organisationen (VO) · 435, 440 VOMRS · 445 VOMS · 445 Grid-Infrastrukturen · 438 GridSphere · 444 Grid-System · 3 Großrechner · 196, 427 Gustafsons Gesetz · 319

488

H Hardware assisted Software Transactional Memory (HaSTM) · 75 Hardware Transactional Memory (HTM) · 75, 78 hashCode · 290 Hauptspeichervirtualisierung · 407 Heartbeat · 424 Herstellerunabhängigkeit · 427 High Availability (HA) Cluster · 2 High Performance (HPC) · 430 High Performance Computing (HPC) Cluster · 2 High Performance Fortran (HPF) · 192 High Performance Java (HPJava) · 193 High Performance Switch (HPS) · 53 High Throughput Clustering (HTC) · 430 höchstens einmal · Siehe at most once Hochverfügbarkeit · 424 Hochverfügbarkeitscluster · 422 Host Bus Adapter · 410 htonl · 235, 242, 250 htons · 235, 242, 244 HTT · Siehe Hyperthreading Technology HT-Tech · Siehe Hyper-Threading Technology Hybrid Transactional Memory (HyTM) · 75 Hypercube · 95, 190 Hypertext Transfer Protocol (HTTP) · 12 Hyper-Threading Technology · 34 Hypervisor · 397, 400 Hyperwürfel · 421

Schlagwortverzeichnis

I IBM RS/6000 SP · 53 IDL Skeleton · 281, 282 Implementation Repository · 281, 283 implizte Barriere · 167 Independent Computing Architecture · 404 index shards · 102 InfiniBand · 8, 418 Informationsabruf-Server · 115 Infrared Data Association (IrDA) · 9 Infrarot · 9 Infrastructure Mode · 11 InitialContext · 264 Inmos · 190 In-Order-Completion · 35 In-Order-Execution · 35 Insellösung · 1 Instant Messaging (IM) · 13 Intel 4004-Prozessor · 6 Intel 486-Prozessor · 6 Intel Core 2 Duo · 6 Intel MPI Library · 205 Intel Pentium 4 · 34 Intel Pentium III-Prozessor · 6 Intel Vanderpool · 406 Intel Xeon · 34 Interaktion asynchron · 109 blockierend · 108 entfernt · 108, 110 lokal · 108, 110, 111 nicht blockierend · 109 synchron · 108 unzuverlässig · 111 zuverlässig · 111, 112 Interface Definition File · 293 Interface Implementation File · 293, 294

Interface Repository · 283 Inter-Grids · 438 Internet · 5, 11, 234, 284 Internet Message Access Protocol (IMAP) · 12 Internet Relay Chat (IRC) · 12 Internet Telefonie Voice over IP (VoIP) · 12 interoperable Objektreferenz (IOR) · 284 Inter-ORB Protocol (IIOP) · 284 Intra-Grids · 438 invertierter Index · 101 IP · 234 ISO RPC · 276

J J2SDK · 296 Java · 462, 463, 464, 26, 106, 111, 133, 150, 173, 191, 193, 194, 200, 202, 206, 251, 253, 264, 269, 270, 284, 285, 287, 288, 292, 293, 295, 296, 299, 300, 301, 302, 306, 307, 308, 396, 401, 402, 403 Java 5 (Tiger) · 150 Java Grande Forum (JGF) · 194 Java Message Queue (JMQ) · 270 Java Message Service (JMS) · 200 Java Naming and Directory Interface (JNDI) · 264 Java Runtime Environment · 442 Java Server Faces · 444 Java Software Development Kit (JSDK) · 295, 296 Java Virtual Machine (JVM) · 26, 401, 403 Java Virtuelle Maschine (JVM) · 285 java.io.Serializable · 292 java.lang · 290 java.lang.Object · 290

489

Schlagwortverzeichnis java.lang.SecurityManager · 288 java.rmi · 285, 286, 287, 288, 289, 290, 291, 293, 294, 295, 297 java.rmi.dgc · 286 java.rmi.Naming · 287, 289, 295 java.rmi.registry · 285 java.rmi.registry.LocateRegistry · 289, 290 java.rmi.registry.Registry · 289 java.rmi.registry.RegistryHandler · 289 java.rmi.Remote · 291, 293 java.rmi.server · 286, 290 Java-Thread · 150 javax.jms.Message · 252 JMS API · 251 JMS Provider · 200, 252, 255, 256, 264, 269, 270 JMS-Applikation · 200 JMSCorrelationID · 252 JMSDeliveryMode · 252 JMSDestination · 252 JMSException · 263 JMSExpiration · 252 JMSMessageID · 252 JMSPriority · 252 JMSRedelivered · 252 JMSReplyTo · 252 JMSTimestamp · 252 JMSType · 252 join · 130, 137, 138, 139, 151, 160, 161, 222

K Kademlia · 3 Kanal · 222 Karp-Flatt Metrik · 320, 321 Kernel Mode · 406 Kernelthread · 147

490

kollektive Kommunikationsfunktion · 216 Kommunikation asynchron · 110 Auslegung · 329 blockierend · 108 Ein-Weg (one-way) · 109, 110 entfernt · 110 lokal · 110 paketorientiert (datagram) · 7 synchron · 108, 110 unzuverlässig · 111, 347, 348 verbindungsorientiert (stream) · 7 zurückgestellt synchron · 110 zuverlässig · 112 Kommunikationsservice · 279 Kommunikationszeit · 313, 321 Kommunikator · 208, 217 Komponente · 122 konkurrent · 341 kooperativ · 28 kooperierend (cooperating) · 25 Koordinator · 343, 345, 346 Kosten · 315 Kostenoptimalität · 316 Kreuzschienenschalter (Crossbar Switch) · 41, 52 kritischer Abschnitt · 68

L LAM/MPI · 205 Lamport-Zeit · 339 Lastausgleich · 399 Lastausgleicher (Load Balancer) · 101 Lastverteiler · 424 Latenz · 8, 9 Latenzzeit · 37, 38 Laufzeit · 313, 314

Schlagwortverzeichnis Laufzeitmessung · 314 Laufzeitreduktion · 313 leichtgewichtige Prozesse (lightweight processes) · 145 Leistungssteigerung · 325, Siehe Speedup Leistungstransparenz · 30 LHC Computing Grid · 440 libpvm3.a · 226 liegt-vor (happens before) · 336 Lifecycle Services · 278 Linearer Adressraum · 407 Linux · 63, 70 list · 288 listen · 234, 245, 246, 251 Load Balancing Cluster · 2 Local Area Multicomputer (LAM) · 205 Local Area Network (LAN) · 5 Lock · 41, 74, 278 Lock-Free/Wait-Free-KonkurrenzKontroll-Konstrukt, · 74 Logical Units · 410 logische Uhren (logical clocks) · 336, 337 lokale Netzwerke · 5 lookup · 264, 265, 287

M m:n Kommunikation · 142 Mach · 147, 150 Mach-Kernel · 147 Mainframes · 427 Makro-Pipeline · 325 MapMessage · 253 Mapping · 329 Massively Parallel Processors · 421 Massively Parallel Systems (MPSs · 95 Master · 326 master Pragma · 166

Master Worker Schema · 138, 326, 327 Master-Dämon · 226 may be · 111 Mean Time Between Failures · 422 Mean Time to Repair · 422 Mehrebenennetzwerk · 41, 53 Mehrkern-Prozessor ( MulticoreProzessor). · 55 Memory Flow Controller (MFC) · 58 Memory-Mangement Units (MMU) · 82 Merge Sortieralgorithmus · 327 MESI-Protokoll · 46, 47, 50 Message · 253 Message Passing in Java (MPJ) · 206 Message Passing Interface (MPI) · 132, 190, 204 MessageConsumer · 262 MessageListener · 255, 263, 267 MessageProducer · 260 Message-Queue (Nachrichtenwarteschlange) · 142 Message-Server · 200, 252, 256, 257, 258, 259, 264, 265 Messaging Domains · 200 Messprogramm · 314 mgssnd · 142 MicroVAX · 415 Middleware · 416, 438 Migrationstransparenz · 30 Million Instructions per second durch Watt (MIPS/Watt). · 96 Million Instruktionen pro Sekunde (MIPS) · 6 MIMD · 420 mindestens einmal · Siehe at least once Minicomputer · 196

491

Schlagwortverzeichnis Mobile Computing · 4 mobiles Ad-Hoc Netz · 4 mobiles Endgerät (Micro Device) · 27 mobiles Netz · 5 MOESI-Protokoll · 53 Monitor · 41, 131 impliziten-signal · 131 Monitorkonzept · Siehe Monitor Monte-Carlo-Simulation · 322 more · 141 MPI · 429, 430 MPI, · 416 mpi.h · 206 MPI/Pro · 205 MPI_Allgather · 217 MPI_Allreduce · 217 MPI_Alltoall · 217 MPI_ANY_SOURCE · 210 MPI_Barrier · 216 MPI_Bcast · 216, 217 MPI_Bsend · 211 MPI_Comm · 208 MPI_Comm_create · 218 MPI_Comm_dup · 217 MPI_Comm_free · 218 MPI_Comm_group · 218 MPI_Comm_rank · 208 MPI_Comm_size · 208 MPI_Comm_split · 218 MPI_COMM_WORLD · 208, 217 MPI_Finalize · 208 MPI_Gather · 217 MPI_Gatherv · 217 MPI_Get_count · 210 MPI_Get_processor_name · 209 MPI_Group_compare · 220 MPI_Group_difference · 220 MPI_Group_excl · 219 MPI_Group_free · 220 MPI_Group_incl · 219 MPI_Group_intersection · 220

492

MPI_Group_range_excl · 219 MPI_Group_range_incl · 219 MPI_Group_rank · 220 MPI_Group_size · 220 MPI_Group_union · 220 MPI_Init · 207 MPI_Initialized · 208 MPI_Irecv · 212 MPI_Isend · 212 MPI_Probe · 210 MPI_Recv · 209 MPI_Recv_init · 215 MPI_Request_free · 215 MPI_Rsend · 211 MPI_Scan · 217 MPI_Scatter · 217 MPI_Scatterv · 217 MPI_Send · 209, 211 MPI_Send_init · 214 MPI_Sendrecv · 211 MPI_Sendrecv_replace · 212 MPI_Ssend · 211 MPI_Start · 215 MPI_Startall · 215 MPI_Status · 210 MPI_Test · 213 MPI_Testall · 213 MPI_Testany · 213 MPI_Testsome · 214 MPI_Wait · 213 MPI_Waitall · 213 MPI_Waitany · 213 MPI_Waitsome · 214 MPI-1 · 204 MPI-2 · 204 MPICH · 205 MPICH G2 · 205 MPICH2 · 205 MPICH-GM · 205 mpiJava · 206 MPI-Reduce · 217 MPI-Standard · 204

Schlagwortverzeichnis MQSeries · 269 MS Message Queue · 302 msgctl · 143 msgget · 142 msgrcv · 142 Mulicoreprozessor asymmetrisch · 56 symmetrisch · 56 Multicomputer · 105 Multicoreprozessor heterogen · 56 homogen · 56 Multiprocessing asymmetrisch · 62, 63, 64 gebündelt · 61 Master Slave · 61, 62 symmetrisch · 62, 64 Multiprocessor Systems-on-Chip (MPSoc) · 55 Multiprozessor eng gekoppelt · 34, 105 heterogen · 63 homogen · 63 lose gekoppelt · 34, 105 Multiprozessorsysteme · 420 Multiword Compare and Swap (MCAS) · 78 mutual exclusion · Siehe wechselseitiger Ausschluss Myrinet · 418 Myrinet 2000 · 7 MYTHREAD · 168

N Nachrichtenübertragung mit TLI (Transport Layer Interface) · 199 Sockets · 199 Namens-Server · 115 Naming Service · 278 Napster · 3

Nebeneinanderschreibung (juxtapostion) · 176 nebenläufig · 36, 106, 137, 151, 189, 190 nebenläufig (concurrent) · 25 Nebenläufigkeitstransparenz · 29 Network Data Representation (NDR) · 198 Network File System (NFS) · 275 Network Filesystem · 411 Network of Workstations · 419, 421 Network of Workstations (NOW) · 95 Netz drahtlos · 9 Netzwerk Blockierend · 54 Netzwerkbetriebssystem · 2 Netzwerk-Hilfsfunktion · 240 Netzwerkprogrammierung · 199 Niagara Chip · 57 nicht oder höchstens einmal · Siehe may be Non Cache Coherent NUMA (NCC NUMA) · 80 NonUniform Memory Access (NUMA) · 80 Non-Uniform Memory Architecture (NUMA). · 80 NRMBs-Strategie · 87 NRNMB-Strategie · 87 ntohl · 235 ntohs · 235 NUMBER_OF_PROCESSORS · 193 Nutzdaten (payload) · 253 NYU-Ultracomputer · 55

O Object Adapter · 281, 282 Object Management Architecture (OMA) · 276, 277

493

Schlagwortverzeichnis Object Management Group (OMG) · 276 Object Request Broker (ORB) · 276, 277, 279 Object-based Software Transactional Memory (OSTM) · 78 ObjectMessage · 253 Occam · 190, 221 Offenheit · 31 Omega-Netzwerk · 53 omp_destroy_lock · 167 OMP_DYNMIC · 162 omp_init_lock · 167 omp_set_dynamic() · 162 omp_set_lock · 167 omp_set_num_threads() · 162 omp_test_lock · 167 omp_unset_lock · 167 On Demand Computing (ODC) · 21 one-to-one mapping · 147 onException · 264 onMessage · 253, 263, 267, 268 Ontologie · 15 Open MPI · 204 Open Network Computing (ONC) · 275 OpenMP · 132, 133, 160, 161, 163, 167, 204 OpenMP (Open Multi-Processing) · 132 OpenMP for Java (JOMP) · 133 OpenSolaris · 199, 400 optimistische Konkurrenzprotokoll · 77 ORB-Interface · 281 Orchestrierung · 125 Organic Computing · 23 Ortstransparenz · 29, 30, 279 OS/2 · 150 OSF/1 · 147, 150

494

Oueued Lock · 70 Out-of-Order-Execution · 35 Overhead · 316, 320 Overheadzeit · 314 Overnet · 3

P P2P · Siehe Peer-to-Peer Packet Socket · 238 PAR · 221 Parallel Network File System · 445 parallel problem · 319 embarrassingly · 319 Parallel Virtual Machine (PVM) · 191, 226 parallele Algorithmen · 332 allgemein · 332 Graphen · 332 Metaheuristiken · 332 Numerik · 332 Sortieren · 332 Suchen · 332 paralleles Programm · 315 Kosten · 315 kostenoptimal · 315 Parallelismus · 322 inhärent · 321, 322 Instruction Level · 38 Thread Level · 34, 38 Thread-Level · 58 Parallelismus) Instruction Level · 34 Parallelität · 318 eingeschränkt · 74 massiv · 318 parameter marshalling · 273 Paravirtualisierung · 398, 400 Participation-Web · Siehe Collaberation-Web

Schlagwortverzeichnis partielle Ordnung der Ereignisse · 338 Partitionierung · 328, 405 Peer-to-Peer · 3 Peer-to-Peer-Applikation · 437 Peer-to-Peer-Netz · 1, 3 Peer-to-Peer-System · 2 Pentium 4 · 6 Pentium 4-Prozessor · 6 Pentium D · 57 Pentium II · 6 performance bottleneck · 118 Perl · 199 Persistence Service · 278 Personal Computer (PC) · 1, 196 Pfister · 415 Physical Queue · 260 physikalische Uhren (physical clocks) · 336 Ping · 9 Pipe · 25, 131, 137, 140, 141, 142, 158, 186, 190, 264, 324 pipe(fd[2]) · 141 Pipeline · 324, 325 Befehl · 35 PLACED PAR · 190, 225 Platzierungszeit · 314 Playstation 3 · 57 Pluralismus · 31 Point-to-Point Modell (PTP) · 200 P-Operation · 70 Portable Operating System Interface (POSIX) · 150 POSIXthread (Pthread) · 150 Post Office Protocol Version 3 (POP3) · 12 Power Grid · 3 Power Processor Element (PPE) · 58 Power4 Prozessor · 57 Pragma Shared · 135 Primary Cache (Level 1 Cache) · 43

Print-Server · 2 PrintStream · 291 Prioritätsumkehr (Priority Inversion) · 74 PROCESSORS · 193 Producer · 200 Programmiermodell gemeinsamer Speicher · 106, 130 kooperativ · 106 Programmierung hybrid · 132 Properties Service · 278 Prozess leichtgewichtig · 59 nebenläufig · 106, 130 Prozessidentifikationsnummer (PID) · 139 Prozesskontrollblock (Process Control Block - PCB) · 143 Prozessor Konsistenz (Processor Consistency) · 84 Prozessumschaltung (Dispatching) · 1, 24 P-Thread · 131 pthread_cancel · 152 pthread_cond_broadcast · 156, 158 pthread_cond_destroy · 156, 159 pthread_cond_init · 156, 159 pthread_cond_signal · 156, 157, 159, 160 pthread_cond_timedwait · 157 pthread_cond_wait · 156, 157, 159, 160 pthread_create · 150, 151, 153, 155, 160 pthread_detach · 151, 153, 156, 160 pthread_exit · 151, 152 pthread_get_expiration_np · 157 pthread_join · 151, 153, 155, 160 pthread_mutex_destroy · 154, 156, 159 pthread_mutex_init · 153, 155, 159

495

Schlagwortverzeichnis pthread_mutex_lock · 65, 154, 155, 157, 159, 160 pthread_mutex_trylock · 154 pthread_mutex_unlock · 65, 154, 155, 157, 159, 160 pthread_setcancel · 152 pthread_spin_lock · 65 pthread_spin_unlock · 65 Pthread-API · 65 publish · 201, 260, 261, 262 Publish · 13, 201 Publish/Subscribe Modell (Pub/Sub) · 201 Push · 13 PVM · 416, 429 pvm_addhosts · 228 pvm_barrier · 233 pvm_bcast · 233 pvm_delhosts · 228 pvm_exit · 228 pvm_freebuf · 230 pvm_getinst · 233 pvm_getrbuf · 230 pvm_getsbuf · 230 pvm_gsize · 233 pvm_initsend · 230 pvm_joingroup · 232 pvm_kill · 228 pvm_lvgroup · 232 pvm_mkbuf · 229 pvm_mytid · 228 pvm_parent · 228 pvm_pkstr · 231 pvm_pkTYPE · 231 pvm_psend · 232 pvm_recv · 232 pvm_reduce · 233 pvm_send · 231 pvm_sendsig · 228 pvm_setrbuf · 230 pvm_setsbuf · 230 pvm_spawn · 227

496

pvm_tidtohost · 229 pvm_upkstr · 231 pvm_upkTYPE · 231 pvmd3 · 226 Python · 199

Q QeueSender · 265 QNX Neutrino RTOS · 63 QsNet · 8 Quad-Core-Prozessor · 55 Quadrics · 8 Quality of Service (QoS) · 121 Query Service · 278 Queue · 200, 252, 255, 256, 258, 259, 260, 261, 262, 263, 265, 266, 267, 268 QueueBrowser · 263 QueueConnection · 256 QueueConnectionFactory · 255, 264, 265, 266, 267, 268 QueueReceiver · 258, 262 QueueSender · 258, 261 QueueSession · 258 Quicksort-Algorithmus · 327 parallel · 327 quit · 138 Quorumressource · 426

R Race Condition · Siehe Wettlaufsituation Rang · 208 RAW Socket · 238 RDF Schema · 16 read · 234, 242, 246, 247, 248, 253 Read/Write Spin Locks · 70 Read/Write-Web · Siehe Collaberation-Web

Schlagwortverzeichnis Realzeit-Betrieb · 24 rebind · 287, 294, 295 receive · 262 receiveNoWait · 262 Rechengrid · 3 Rechenzeit · 313 Reconfigurable NEtworked Systems (HARNESS) · 191 recover · 258 recv · 248 recvfrom · 237, 239, 242, 244, 248 REDISTRIBUTE · 193 Reduktions-Variable · 181 Redundanz · 422 Registrierung · 195, 282, 285, 295 Registry · 285, 286, 287, 288, 289, 290, 293, 295, 296 REGISTRY_PORT · 288 Relationship Service · 278 Remote · 286 Remote Desktop Protocl · 404 Remote Function Call (RFC) · 276 Remote Interface · 294 remote login · 248, 249 Remote Method Invocation (RMI) · 285 Remote Procedure Call (RPC) · 270, 274 RemoteObject · 290, 291 RemoteServer · 290, 291, 292 Rendezvous · 209 Replikationstransparenz · 30 Resource Description Framework (RDF) · 16 Ressourcen Heterogen · 436 Homogen · 436 retry · 77 Risikoanalyse · 322 RMBs-Strategie · 90 rmi.Naming · 286 rmi.registry · 288, 294

rmic · 285, 288, 293, 295, 296 RMISecurityManager · 287, 288 RNMBs-Strategie · 94 Röhre (Pipe) · 25, 137 rollback · 258 Round Robin · 431 RP3 · 55 RPC-System · 271 Ruby · 199 Ruby On Rails · 14 Rückantwort (reply) · 107 Rückrufe (callbacks) · 109 Rüstzeit · 314, 326

S Sandbox · 402 Scalable Coherent Interconnect · 418 Scalable Coherent Interconnect (SCI) · 7 Scali MPI Connect · 205 Scheduling dynamisch · 36 Round Robin · 431 statisch · 36 Scheme · 133 Schwache Konsistenz (Weak Consistency) · 84 schwergewichtige Prozesse (heavyweight processes) · 145 Secondary Cache (Level 2 Cache) · 43 section Pragma · 165 Secure Socket Layer · 414 Security Service · 278 SecurityManager · 288, 296 Selbst-Anpassung · 126 Selbst-Heilend (Self-Healing) · 22 Selbst-Heilung · 126 Selbst-Konfiguration · 126

497

Schlagwortverzeichnis Selbst-Konfiguration (SelfConfiguration) · 22 Selbst-Optimierend (SelfOptimization) · 22 Selbst-Optimierung · 126 Selbst-Schutz · 127 Selbst-Schützend (Self-Protection) · 22 select) · 185 Selectanweisung · 185 Semaphor · 41, 70, 130, 137, 140, 153, 154, 156, 184, 189 send · 248, 261 sendto · 237, 239, 242, 244, 248 SEQ · 221 Sequenzielle Konsistenz (Sequential Consistency) · 83 Serialisieren · 292 Server parallel · 33, 105 Port · 241 Registrierung · 195 sequentiell · Siehe Server iterativ Stummel (Stub) · 197, 272, 274 zentral · 105 Zustand · 115 zustandsändernd · 115 zustandsinvariant · 115, 116 zustandslos (stateless) · 116, 117 zustandsspeichernd (stateful) · 116, 117 Server Cluster · 331 Server Farm · 331 Server Message Block · 411 Server-Betrieb · 24 Server-Fabric · 411 Server-Farm · 2 Serverkonsolidierung · 395 Service · 121 Aggregator · 125 Behaviour · 121 Capability · 121

498

Composition · 123 Contract · 121 Description · 121 Implementation · 121 Interface · 121 Operator · 126 zustandslos · 124 Service Level Agreement · 21 Service Provider · 120, 304 Service Registry · 304 Service Requestor · 304 Serviceaufruf idempotent · 124 Servicekomposition · 125 Service-orientierte Architekturen (SOA) · 14, 120 Session · 256, 257 set · 161 setClientID · 256 setDeliveryMode · 261 setDisableMessageID · 261 setDisableMessageTimestamp · 261 setExceptionListener · 256 setFloat · 253 SETI@home · 437 Seti-Projekt · 322 setLinkedException · 264 setlog · 291 setMessageListener · 258, 262, 267, 268 setObject · 253 setPriority · 261 setText · 253, 266 setTimeToLive · 261 Shared Memory · 420 Shibboleth · 444 shmat · 140 shmctl · 140 shmget · 140 signal · 131

Schlagwortverzeichnis Simple Mail Transfer Protocol (SMTP) · 12 Simple Object Access Protocol (SOAP) · 127, 303 Simultaneous Multithreading · 33, 34, 38, 39 single point of attack · 119 single point of failure · 119, 422 single Pragma · 165 Single Program Multiple Data (SPMD) · 133 Single System Image · 417 skalierbar · 320 Skalierbare Cluster · 431 Skalierungstransparenz · 29 Skeleton · 285 Skype · 3 Slave-Dämon · 226 SMP · 417, 420 Snoopy Cache · 50 Snoopy Cache Invalidation Protocol (MESI-Protocol) · 46, 47 Snoopy Cache Protocol · 45 SOA-Pyramide · 127 Social-Web · Siehe Collaberation Web socket · 233, 236, 238, 240, 241, 242, 243, 244, 246, 248, 250, 251 Socket Datagram · 236 Raw · 236 Seqpacket · 236 Stream · 236 Socket-Interface · 7 SoftGrid · 405 Software Agenten · 15, 16 Software Transactional Memory (STM) · 75, 77 some-to-one mapping · 149 soziale Software · 13 SPARQL Protocol and RDF Query Language (SPARQL) · 16

Speedup · 314, 315, 316, 317, 318, 320, 321, 322, 325, 326, 327 linear · 315, 321, 325 maximal · 317, 318 superlinear · 315, 316, 322 Speicher-Fabric · 411 Speicher-Server · 278 spin_lock() · 69, 70 Spin_Locks · 70 spin_unlock() · 69, 70 Spinlocking · 69 Spinning · 69 Split-Phase Barriere · 172 stabiler Speicher (stable storage) · 113 start · 256, 265 Startzeit · 314 stop · 256, 265 Storage Area Network · 409 Stream Socket · 7, 238 StreamMessage · 253 Strikte Konsistenz (Strict Consistency) · 83 Stromversorgung Unterbrechungsfreie · 423 Struts · 14 Stub · 285, Siehe Client-Stummel (Stub) oder Server-Stummel (Stub) IDL · 280 Subscribe · 13, 201 Sun Grid · 22 Sun RPC · 275 Superskalar-Architekturen ·36, 325 Superskalarität · Siehe Superskalarität Superskalarverarbeitung · 35 Symmetric Multiprocessing (SMP) · 56 symmetrisches Multiprocessing (SMP) · 64

499

Schlagwortverzeichnis Synchronisationszeit · 313, 320, 321 Synergistic Processor Elements (SPE) · 57 Synergistische Architektur · 58 System selbstorganisierend · 22 System.setSecurityManager() · 288 Systemdurchsatz · 33 Systeme selbstorganisierend · 20

T Takt-Frequenz · 55 Tannenbaum Taxonomie · 420 Tapestry · 14 Task · 24, 182 task body · 182 task type · 182 Tcl · 199 TCP · 234 TCP/IP · 199, 284 TCP/IP-Protokoll · 11, 12 TCP-Protokoll · 7 Teile und Herrsche Strategie · 322 Telematik · 17 TEMPLATE · 192 TemporaryQueue · 260 TemporaryTopic · 260 Terminal-Services · 404 Test und Set (TAS) · 68 TextMessage · 253 Thin Clients · 403 Thread · 24, 36, 37, 59, 60, 74, 131, 143, 150 thread_func · 151 Threadbibliothek · 146 ThreadGroup · 150 THREADS · 168 Tim Berners-Lee · 15 Time Service · 278

500

Timesharing System · 1 Timesharing-Betrieb · 24 Token · 5 Token Bus · 5 Token Ring · 5 Topic · 201, 252, 257, 259, 260, 261, 262, 269 TopicConnection · 269 TopicConnectionFactory · 255, 269 TopicPublisher · 259, 261 TopicSession · 257, 259, 269 TopicSubscriber · 259, 263 Top-level Funktion · 178 Torus · 190 toString · 260, 290 Total Cost of Ownership (TCO) · 20 totale Ordnung der Ereignisse · 338 Trader Service · 278 Träge Freigabe Konsistenz (Lazy Release Consistency) · 85 Trait · 176 Traits (Charakterzüge) · 177 Transaction Service · 278 Transactional Memory (TM) · 74 Transaktion · 74, 111 Konkurrenzproblem · 339 Transparenz · 29 Transputer · 190 Tread Control Block (TCB) · 145 triple-modular redundancy · 350 tryatomic · 181 two-level Scheduler · 145 Typing explizit · 198 implizit · 198

U Ubiquitous Computing · 4

Schlagwortverzeichnis UDP · 234 UDP-Protokoll · 7 Umlaufpuffer · 140 unbalanced load distribution · 118 Unbegrenzter Nichtdeterminismus · 31 unbind · 287 Unbounded Transactional Memory (UTM) · 79 unfaires Scheduling · 147 UnicastRemoteObject · 290, 291, 292, 294, 295 Unicore · 440 Client · 442 Komponenten · 441 Nachteile · 442 Network Job Supervisor · 441 Target System Interface · 441 Usite · 441 Voraussetzungen · 442 Vorteile · 441 Unified Parallel C (UPC) · 133, 168 Uniform Memory Access (UMA) · 79 Uniform Resource Locator (URL) · 287 Uniprozessor · 416 Universal Description, Discovery and Integration (UDDI) · 128, 304 Universal Mobile Telecomunications System (UMTS) · 10 Unix · 67, 111, 130, 137, 147, 150, 233, 234, 235 4.3 BSD (Berkley Software Distribution) · 199 SVR4 (System V Release 4) · 199 unscribe · 259 UPC Lock · 171 upc_all_lock_alloc · 171 upc_forall-Schleife · 170

upc_global_lock_alloc · 171 upc_lock · 172 upc_lock_attempt · 172 upc_lock_free · 172 upc_lock_t · 171 upc_notify · 172 upc_unlock · 172 upc_wait · 172 Ursache-Wirkungsrelation · 335 User Mode · 406 Utility Computing · 21

V VAX · 415 Vektoruhr · 339 Verbraucher · 3, 18, 25, 140, 141, 142, 158, 186, 263, 264, 267 Verbreitungs-Monotonie · 31 Verfügbarkeit · 28, 422, 423 Verklemmungen (Deadlocks) · 74, 86, 211 Vermittlungs-Server · 115 Versionsnummer · 195 Verteilte Verarbeitung · Siehe Verteiltes Rechnen Verteilter gemeinsamer Speicher (Distributed Shared Memory (DSM)) · 81 verteilter Speicher · 105 Verteiltes Rechnen · 26 Verteiltes System · 333 Very Fast Infrared (VFIR) · 9 Verzeichnis (Directory) · 51 Verzeichnis Schema (Directory Scheme) · 51 Verzögerte Rückschreiben (deferred write) · 42 Vi · 133 Virtual Local Area Network · 413 Virtual Private Network (VPN) · 413

501

Schlagwortverzeichnis Virtualisierung · 395 Anwendungsvirtualisierung · 405 Betriebssystemvirtualisierung · 396 Container · 400 Containervirtualisierung · 398, 400 Control Program · 397 Datenspeicherkonsolidierung · 408 Datenspeichervirtualisierung · 408 ESX Server · 399 FreeBSD Jails · 400 Hardware · 395 Hardwarevirtualisierung · 396 Hauptspeichervirtualisierung · 407 Hochverfügbarkeit · 399 Hypervisor · 397, 398, 400 In-Band-Virtualisierung · 411 Instant Copy · 410 Intel Vanderpool · 406 Lastausgleich · 399 Lifecycle-Management · 409 Mirroring · 410 Netwerke · 412 Out-of-Band-Virtualisierung · 411, 412 Over-Commitment · 409 Pacifica · 406 Paravirtualisierung · 398, 400 Partitionierung · 405 Prozessoren · 406 Secure Virtual Machine · 406 Serverkonsolidierung · 395 Services · 403 Sicherheit · 396 Snapshots · 410 Software · 395

502

Softwarevirtualisierung · 396, 403 Speichermanagement · 410 Speicherpools · 408 Speicherverwaltung · 408 Speichervirtualisierung · 410 Virtual Machine Extensions · 406 VirtualCenter · 399 virtualisierte Anwendungen · 405 Virtuelle Maschine · 397, 401 Virtueller Maschinen Monitor · 396 VMotion · 399 VMware · 399, 406 VMware Workstation · 398 Vollvirtualisierung · 398 Vorteile · 395 Xen Hypervisor · 401 Virtuelle Adresse · 407 Virtuelle Maschine · 401 Virtuelle Speicherverwaltung · 408 Virtueller Adressraum · 408 Virtueller Maschinen Monitor · 396 Virtueller Speicher · 407 VMware Server · 399 Vollvirtualisierung · 398 von-Neumann-Falschenhals · 40 V-Operation · 70

W Wächter (Guard) · 185 wait · 131, 138 waitpid · 138 Warteschlange (Queue) · 25, 131, 137 Wartezeit · 313, 320, 321 Wearable Computing · 4 Web · Siehe World Wide Web

Schlagwortverzeichnis Web 1.0 · 13 Web 2.0 · 12 Web 2.0 Framework · 14 Web 3.0 · 15 Web Farm · 332 Web Intelligence (WI) · 16 Web Logs · 13 Web Ontology Language (OWL) · 16 Web Server Farm · 332 Web Service Description Language (WSDL) · 304 Web Service-Architektur · 304 Web Services · 14, 303, 399 Web Services Choreography Description Language (WSCDL) · 128 Web Services Description Language (WSDL) · 128 Web Services Resource Framework · 439 Web-Based Training (WBT) · 19 Web-Browser · 258, 263 Web-Server · 115 wechselseitiger Ausschluss · 68, 83, 130, 153, 158, 339 Wettlaufsituation (Race Condition) · 74, 86, 130 Wiki · 14 Wikipedia · 13 WikiWeb · Siehe Wiki WikiWiki · Siehe Wiki Win 32 · 150 Windows Communication Foundation (WCF) · 303 Windows NT · 150 Windows Presentation Foundation (WPF) · 303 Windows Workflow Foundation (WF) · 303 Wireless Local Area Network (WLAN) · 11

Wireless Personal Area Networks (WPANs) · 9 WLAN Standard IEEE 802.11 · 11 WLAN Standard IEEE 802.11a · 11 Word-based Software Transactional Memory (WSTM) · 78 Worker · 326 Workstation · 1 World Wide Web (WWW) · 12, 27 World Wide Web Consortium (W3C) · 303 World Wide Wisdom Web (W4) · 17 write · 234, 246, 247, 248, 253 Write Invalidate Snoopy Cache Protocol · 46 Write invalidate Strategie · 43, 45 Write update Snoopy Cache Protocol · 50 Write update Strategie · 43, 45 Write-first Protocol · 45 Write-once Protocol · 45 Wulfpack · 430 Wulfpack-Cluster · 430

X Xeon DP · 57 XML · 16 XML Schema · 16 XNS · 234 XPVM · 226

Z Zeitstempel · 337, 338, 339, 341 Zeitwert · Siehe Zeitstempel Zerlegung · 328 Zugriffstransparenz · 29 Zusammenballung · 329

503