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 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ȱ 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 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 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
EreignisAufrufkodierung dekodierung
EreignisAufrufdekodierung kodierung
Kommunikationskomponente
Kommunikationskomponente
EreignisAufrufü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)ȱ
