02.08.2013 Aufrufe

Grundlagen paralleler Architekturen

Grundlagen paralleler Architekturen

Grundlagen paralleler Architekturen

MEHR ANZEIGEN
WENIGER ANZEIGEN

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

YUMPU macht aus Druck-PDFs automatisch weboptimierte ePaper, die Google liebt.

Vorlesung Rechnerarchitektur 2 Seite 14<br />

Einleitung<br />

Lehrstuhl für Rechnerarchitektur - Universität Mannheim<br />

<strong>Grundlagen</strong> <strong>paralleler</strong> <strong>Architekturen</strong><br />

Das Ziel der Entwicklung <strong>paralleler</strong> Rechnerarchitekturen ist die Überwindung der Einschränkungen,<br />

die durch die sequentielle Verarbeitung nicht-<strong>paralleler</strong> <strong>Architekturen</strong> vorgegeben<br />

sind. Als wichtigste Einschränkung ist hier die Leistung eines Rechnersystems zu<br />

nennen. Neben weiteren funktionalen Eigenschaften von Parallelrechnern, (wie z.B. Fehlertoleranz,<br />

Modularität, Anwendungsspezialisierung, etc.) ist die Leistungssteigerung, möglichst<br />

proportional zur Anzahl der parallelen Einheiten, die entscheidende Anforderung an<br />

die Entwicklung von parallelen Rechnerarchitekturen. (-> Skalierbarkeit)<br />

Hierzu ist ein grundsätzliches Umdenken der Personen erforderlich, die Anwendungen, Algorithmen<br />

und Software entwickeln, um das Potential der parallelen <strong>Architekturen</strong> für konkrete<br />

Anwendungen ausschöpfen zu können. Der Hardwareentwurf <strong>paralleler</strong> <strong>Architekturen</strong><br />

sollte die verschiedenen Anforderungen mit seinen parallelen Funktionseinheiten optimal<br />

unterstützen, wobei die Randbedingung der Kosteneffektivität bei der Realisierung eines<br />

parallelen Systems starke Berücksichtigung finden sollte (Verwendung preiswerter Technologie).<br />

Der aktuelle Trend, immer mehr Komponenten aus dem Bereich der Massenproduktion<br />

(COTS, commodity off the shelf) einzusetzen, führte zu dem Aufkommen von Clustersystemen,<br />

bestehend aus Knoten mit PCs oder Workstations und der Entwicklung von Verbindungsnetzwerken,<br />

die für diese Systeme optimiert wurden.<br />

Getrieben wird die Entwicklung auf dem Gebiet der parallelen <strong>Architekturen</strong> durch die Anforderungen<br />

an immer höhere Rechenleistungen, die mit sequentiellen <strong>Architekturen</strong> entweder<br />

gar nicht oder aber nur durch einen sehr hohen technologischen Aufwand erzielbar sind.<br />

Die hohen Anforderungen an die Rechenleistung werden von Anwendungen bestimmt, deren<br />

Lösung zu den großen Herausforderungen (‘Grand Challenges’) der Wissenschaft gehören.<br />

Die Anwendungen von Parallelrechnern können in zwei wesentliche Gruppen unterteilen<br />

werden, die numerischen und die nicht-numerischen.<br />

Verteilte Datenbanken, Suchmaschinen und die digitale Schaltkreissimulation sind nur<br />

einige Beispiele für die Gruppe der nicht-numerischen Anwendungen.<br />

Als Beispiel für die numerischen Anwendungen stehen mathematische Probleme und Simulationen.<br />

((UN-)Wettervorhersagen, Erdbeben, Crash-Tests, bio-chem. Simulation,<br />

Atombomben-Simulation, ...)<br />

WS03/04


Vorlesung Rechnerarchitektur 2 Seite 15<br />

Parallelität in Algorithmen<br />

Lehrstuhl für Rechnerarchitektur - Universität Mannheim<br />

<strong>Grundlagen</strong> <strong>paralleler</strong> <strong>Architekturen</strong><br />

Die Lösung von solchen umfangreichen Aufgaben kann durch Aufteilung in Teilaufgaben<br />

und deren parallele Bearbeitung beschleunigt werden.<br />

Die wichtigsten Voraussetzungen für die Ausnutzung von Parallelität sind:<br />

• die Existenz ausnutzbarer Parallelität<br />

• die Erkennung der Parallelität<br />

• die (sinnvolle) Aufteilbarkeit in Teilaufgaben<br />

• das Vorhandensein von parallelen Verarbeitungseinheiten<br />

Die obere Grenze des Leistungsgewinns, den man durch Parallelisierung erhalten kann, ist<br />

vom Grad der Parallelität bestimmt, der in der Applikation enthalten ist. Dieser ist natürlich<br />

sehr stark von dem verwendeten Lösungsalgorithmus abhängig. Aufgaben, die bisher sequentiell<br />

ausgeführt wurden, müssen zur Parallelisierung in unabhängige Teilaufgaben zerlegt<br />

werden, was bei sequentiellen Algorithmen nicht immer möglich ist. Für eine<br />

Steigerung des Leistungsgewinn ist oft auch die Entwicklung neuer ‘<strong>paralleler</strong>er’ Algorithmen<br />

erforderlich. Wie gut die Ausnutzung der Parallelität gelingt, wird von der gewählten<br />

Systemarchitektur und der Effizienz der Abbildung des Algorithmus auf diese bestimmt.<br />

Die verschiedenen Ebenen, auf denen die Parallelität genutzt werden kann, wird im folgenden<br />

Abschnitt dargestellt und die sich daraus ergebenden Rechnerarchitekturen aufgezeigt.<br />

Die Parallelisierbarkeit eines Algorithmus hängt sehr stark vom Algorithmus selbst ab, nicht<br />

so sehr von den Eigenschaften der gewählten Rechnerarchitektur.<br />

WS03/04


Vorlesung Rechnerarchitektur 2 Seite 16<br />

Die Ebenen der Parallelität<br />

Lehrstuhl für Rechnerarchitektur - Universität Mannheim<br />

<strong>Grundlagen</strong> <strong>paralleler</strong> <strong>Architekturen</strong><br />

In Parallelrechnern ist die Ausnutzung aller Ebenen der Parallelität von ausschlaggebender<br />

Bedeutung. Nur ein ausgewogenes System bietet dem Benutzer den höchsten Leistungsgewinn.<br />

Die unterscheidbaren Ebenen der Parallelität erfordern auch verschiedene Maßnahmen,<br />

um einen Leistungsgewinn zu erreichen. Benutzt werden die im folgenden<br />

beschriebenen Ebenen. Sie sind uneinheitlich, nach verschiedenen Merkmalen aufgeteilt<br />

und überlappen sich zum Teil. Zu jeder Ebene ist eine kurze Beschreibung der Maßnahmen<br />

zur Ausnutzung der Parallelität angefügt.<br />

1. Maschinenbefehle (Instruction Level Parallelism (ILP))<br />

a) Parallelität im organisatorischen Ablauf (Überlappen von Operationen)<br />

b) Operationen innerhalb einzelner Anweisungen (chaining, micropipelining)<br />

2. Anweisungen eines Benutzerprogramms (fine grain dataflow)<br />

3. Datenstrukturen (medium grain dataflow)<br />

4. Kooperierende Prozesse (coarse grain dataflow, Thread-Level Parallelism (TLP))<br />

5. einzelne Benutzerprogramme (multi computing)<br />

Multi-Computing<br />

Die Parallelitätsebene mehrerer parallel ablaufender Benutzerprogramme (‘tasks’) wird<br />

durch den Mehrbenutzerbetrieb (‘multi user mode’) von Rechnern ausgenutzt. Diese Betriebsart<br />

ist von Betriebssystemen sequentieller Rechner bestens bekannt und wird auf ihnen<br />

durch ein Zeitscheibenverfahren (‘time-multiplex’) emuliert. Durch den erhöhten Zeitaufwand<br />

der Betriebssystemfunktionen für den Mehrbenutzerbetrieb wird die Laufzeit der einzelnen<br />

Tasks verlängert. Die Ausnutzung dieser Parallelitätsebene steigert im wesentlichen<br />

den Durchsatz an Benutzerprozessen, nicht aber die Abarbeitungsgeschwindigkeit eines<br />

Programms. In parallelen Systemen mit wenigen Prozessoren können die Benutzerprozesse<br />

und unter Umständen auch die Betriebssystemprozesse auf die parallelen Prozessoren verteilt<br />

werden. Dadurch kann für ein solches System die Zuteilungszeit für einen lauffähigen<br />

Benutzerprozeß deutlich gesteigert werden und damit die Laufzeit der Applikation verringert<br />

werden, aber leider nicht unter die Laufzeit des Prozesses auf einem sequentiellen System<br />

mit einem Prozessor ohne Zeitscheibenverfahren. Auf Grund der komplexen<br />

Kontrollvorgänge, insbesondere im Betriebssystem, kann bei massiv parallelen Systemen<br />

diese Ebene der Parallelität selten mit dem notwendigen Leistungsgewinn ausgenutzt werden<br />

und wird hier nicht weiter betrachtet.<br />

WS03/04


Vorlesung Rechnerarchitektur 2 Seite 17<br />

Lehrstuhl für Rechnerarchitektur - Universität Mannheim<br />

<strong>Grundlagen</strong> <strong>paralleler</strong> <strong>Architekturen</strong><br />

Architekturformen für die Parallelitätsebenen<br />

Parallelitätsebene<br />

kooperierende<br />

Prozesse<br />

Datenstrukturen<br />

Anweisungen<br />

und Schleifen<br />

Maschinenbefehle<br />

Table 1: Parallelitätsebenen und ihre Architekturformen<br />

potentieller<br />

Parallelitäts<br />

grad<br />

Erkennung der<br />

Parallelität und<br />

Aufteilung in<br />

Teilaufgaben<br />

durch<br />

hoch Anwender<br />

Algorithmus<br />

hoch Anwender<br />

Sprachebene<br />

Compiler<br />

niedrig bis<br />

hoch<br />

Architekturformen<br />

- Multiprozessorsysteme<br />

mit verteiltem Speicher<br />

- Nachrichtenorientierte<br />

Parallelrechner<br />

- Vektorrechner<br />

- Feldrechner<br />

Compiler - Multiprozessorsysteme<br />

mit gemeinsamen Speicher<br />

- ’Multi-threaded’<br />

<strong>Architekturen</strong><br />

niedrig Compiler - superskalare Prozessoren<br />

- VLIW-Prozessoren<br />

- Datenflußrechner<br />

Kommunikation<br />

Synchronisation<br />

hoch niedrig<br />

niedrig hoch<br />

niedrig /<br />

nicht<br />

vorhanden<br />

Die Nutzung mehrerer verschiedener Parallelitätsebenen in den Architekturformen ist<br />

durchaus möglich und nur eine Frage des erreichbaren Leistungsgewinns. Die Pfeile in der<br />

Tabelle deuten diese übergreifenden Nutzungen an. Nachfolgend werden die einzelnen<br />

Parallelitätsebenen ausführlicher beschrieben.<br />

hoch<br />

WS03/04


Vorlesung Rechnerarchitektur 2 Seite 18<br />

Kooperierende Prozesse<br />

Lehrstuhl für Rechnerarchitektur - Universität Mannheim<br />

<strong>Grundlagen</strong> <strong>paralleler</strong> <strong>Architekturen</strong><br />

Die Parallelitätsebene der kooperierenden Prozesse ist eine häufig genutzte Ebene. Sie beruht<br />

auf dem grundlegenden Konzept des Prozesses. Die Definition des Prozesses ist für die<br />

nachfolgende Beschreibung hilfreich.<br />

Definition : Ein Prozeß ist eine funktionelle Einheit, bestehend aus einem zeitlich<br />

invarianten Programm, einem Satz von Daten, mit dem der Prozeß initialisiert<br />

wird und einem zeitlich varianten Zustand [Gil93].<br />

Auf sequentiellen Rechnern ist der Prozeß im wesentlichen eine Einheit, dessen Adressraum<br />

gegenüber anderen Prozessen geschützt ist. Ein solcher Prozeß mit Adressraumschutz wird<br />

als schwergewichtiger Prozeß bezeichnet und ist auch die Einheit, die auf der Benutzerprozeßebene<br />

verwendet wird. Die Kommunikation der Prozesse erfolgt durch die Mechanismen<br />

der Prozeßkommunikation (‘inter process communication’, IPC). Beim Client-Server Modell<br />

[Tan92] liegt die Aufteilung der Prozesse in dienstanfordernde (‘client’) und diensterbringende<br />

(‘server’) bereits vor und kann dadurch speziell auf dem Server einfach genutzt<br />

werden.<br />

Threads<br />

Wird die Zerlegung einer Anwendung für die parallele Ausführung auf einem Parallelrechner<br />

vorgenommen, so ist ein Adressraumschutz für diese Prozesse unerwünscht, da<br />

sie ja in einem gemeinsamen Adressraum miteinander kooperieren sollen.<br />

Solche kooperierenden Prozesse im gleichen Adressraum bezeichnet man als leichtgewichtige<br />

Prozesse. Die Bezeichnung thread (Kontrollfaden) ist eine häufig anzutreffende<br />

für den leichtgewichtigen Prozess.<br />

Sind diese Prozesse voneinander datenunabhängig, so können sie parallel ausgeführt werden<br />

und sind damit konkurrent. Die Kommunikation der kooperierenden Prozesse kann entweder<br />

durch gemeinsame Daten (‘memory sharing’) oder durch expliziten Nachrichtenaustausch<br />

(‘message passing’) erfolgen. Im Abschnitt Kommunikation und Synchronisation<br />

wird auf diese Problematik noch näher eingegangen.<br />

WS03/04


Vorlesung Rechnerarchitektur 2 Seite 19<br />

Kooperierende Prozesse<br />

Lehrstuhl für Rechnerarchitektur - Universität Mannheim<br />

<strong>Grundlagen</strong> <strong>paralleler</strong> <strong>Architekturen</strong><br />

Threads besitzen genau wie Prozesse einen eigenen Programm-Counter (PC), einen Registersatz<br />

und einen Stack. Der wesentliche Unterschied zu Prozessen ist daß Threads keinen<br />

eigenen Adressraum haben, sondern den des übergeordneten Prozesses mit nutzen.<br />

Threads werden in der Regel so implementiert, daß ein Prozess aus n Threads bestehen kann<br />

(1-n Modell). Zumindest ist dies das für den Anwender sichtbare Modell, für die eigentliche<br />

Implementierung innerhalb des Betriebssystems gibt es viele Ansätze, die hier nicht behandelt<br />

werden.<br />

Prozess<br />

Thread PC<br />

Drei Prozesse mit je einen Thread Ein Prozess mit drei Threads<br />

Leistungsgewinn durch kooperierende Prozesse<br />

Um einen Leistungsgewinn auf dieser Ebene zu erzielen, muß man die in kooperierende<br />

Prozesse aufgeteilte Applikation auf entsprechende Verarbeitungseinheiten verteilen<br />

(‘mapping’) und die Prozesse dürfen keine zu starken Datenabhängigkeiten aufweisen.<br />

Als Verarbeitungseinheiten verwendet man parallel arbeitende Prozessoren mit jeweils<br />

eigenem Instruktionsstrom. Diese Architekturform wird nach Flynn [Fly72] als Parallelrechner<br />

mit mehrfacher Instruktionsverarbeitung und mehrfacher Datenverarbeitung<br />

(‘multiple instruction - multiple data stream’, MIMD) bezeichnet.<br />

Weiterführende Info:<br />

• Tanenbaum, Moderne Betriebssysteme<br />

• Vorlesung Betriebssysteme<br />

WS03/04


Vorlesung Rechnerarchitektur 2 Seite 20<br />

Datenstrukturen<br />

Lehrstuhl für Rechnerarchitektur - Universität Mannheim<br />

<strong>Grundlagen</strong> <strong>paralleler</strong> <strong>Architekturen</strong><br />

Datenstrukturen bieten eine weitere Ebene der Nutzung von Parallelität. Als Beispiel sei die<br />

Verwendung von Vektoren und Matrizen angeführt, die für die Lösung von numerischen<br />

Problemen oft benutzt werden. Die Addition oder Multiplikation zweier Vektoren besteht<br />

aus datenunabhängigen Teiloperationen auf den Elementen des Vektors und kann damit<br />

konkurrent ausgeführt werden. Desweiteren ist die Adressierungsfunktion für den Zugriff<br />

auf die Elemente vorgegeben und ermöglicht damit auch den parallelen Zugriff auf die Elemente.<br />

Die Ausnutzung der Datenparallelität erfordert entweder Programmiersprachen mit<br />

Datenstrukturtypen [Gil93] und darauf definierten Operationen [For90] oder vektorisierende<br />

Compiler, die aus den Schleifen für die Beschreibung der Vektoroperationen die Maschinenbefehle<br />

für die Vektorverarbeitung erzeugen.<br />

Diese Datenparallelität bei strukturierten Daten führt zu der Architekturform, in der mit einer<br />

Instruktion mehrere Datenoperationen ausgeführt werden und die als SIMD-Architektur<br />

(‘single instruction - multiple data stream’) bezeichnet wird.<br />

Als eines der wesentlichen Werkzeuge kann hier der vektorisierende Compiler genannt werden.<br />

Sprachen wie High-Performance Fortran und Fortran-90 stellen schon Konstrukte für<br />

Operationen auf Vektoren bereit, die von entsprechenden Compilern parallelisiert werden.<br />

Anweisungen und Schleifen<br />

Die Parallelitätsebene der Anweisungen und Schleifen enthält, betrachtet man nur die Basisblöcke<br />

(Anweisungen zwischen zwei Kontrollflußverzweigungen), relativ wenig Parallelität<br />

(2-3). Versucht man die Beschränkungen durch die Kontrollflußverzweigungen zu<br />

überwinden, so ergeben sich wesentlich größere Parallelitätsgrade [NiF84]. Hier kommen<br />

Methoden wie speculative Execution, Predication und Loop-Unrolling zum Einsatz.<br />

Bei dieser Betrachtung sollte man immer berücksichtigen, daß die meisten Schleifen nur die<br />

Datenparallelität in der sequentiellen Programmiersprache ausdrücken.<br />

WS03/04


Vorlesung Rechnerarchitektur 2 Seite 21<br />

Lehrstuhl für Rechnerarchitektur - Universität Mannheim<br />

<strong>Grundlagen</strong> <strong>paralleler</strong> <strong>Architekturen</strong><br />

Maschinenbefehle - Instruction Level Parallelism (ILP)<br />

Analyseverfahren von Compilern, die über Kontrollflußgrenzen hinausgehen, wurden zur<br />

Erkennung und Nutzung dieser Parallelitätsebene entwickelt [Nic85] [Gas89] [Ess90].<br />

Auch Schleifeniterationen von Berechnungen [Lil94] kann man auf diese Weise für die Ausnutzung<br />

der Parallelität heranziehen und dann ergeben sich erhebliche Gewinne, die zum<br />

Teil natürlich von den zugrunde liegenden Datenstrukturtypen stammen. Im Gegensatz zu<br />

den Vektoroperationen können aber auf dieser Ebene die Anweisungen innerhalb der Schleifen<br />

von größerer Allgemeinheit sein und müssen nicht auf Vektoroperationen abbildbar<br />

sein.<br />

Die Nutzung dieser Parallelitätsebene führt zu mehreren recht unterschiedlichen Architekturformen.<br />

Ihre gemeinsame Eigenschaft ist die enge Kopplung der Verarbeitungseinheiten,<br />

die den Aufwand für die Ablaufsteuerung und die Synchronisation zwischen den Verarbeitungseinheiten<br />

gering hält. Auch die mehrfädigen <strong>Architekturen</strong> (multi-threaded Architectures,<br />

MTA) nutzen diese Parallelitätsebene und versuchen die Latenzzeit der<br />

Synchronisation in der Bearbeitungszeit weiterer Basisblöcke zu verstecken.<br />

Die Parallelitätsebene der Maschinenbefehle enthält die Elementaroperation, die zur Lösung<br />

von arithmetischen Ausdrücken benötigt werden. Da diese Datenabhängigkeiten aufweisen,<br />

ist eine der wichtigsten Aufgaben des Compilers eine Datenabhängigkeitsanalyse zu erstellen,<br />

die es ermöglicht, den Abhängigkeitsgraph so zu transformieren [Kuc78], daß sich ein<br />

hohes Maß an konkurrenten Operationen ergibt.<br />

Die Ausnutzung dieser Parallelität geschieht durch parallele Funktionseinheiten innerhalb<br />

der Verarbeitungseinheiten. Die Ablaufsteuerung wird vom Compiler bereits zur Übersetzungszeit<br />

geplant oder zur Laufzeit von effizienten Hardwareresourcen innerhalb der Verarbeitungseinheiten<br />

ausgeführt. Beispiele hierfür sind VLIW-Prozessoren (‘very long<br />

instruction word’), superskalare Prozessoren und Pipeline-Prozessoren. Allerdings sind die<br />

Verarbeitungseinheiten, mit denen diese Parallelitätsebene gut ausnutzbar ist, immer nur so<br />

gut, wie der Compiler die dafür notwendigen Optimierungen beherrscht.<br />

Die feinkörnigen Datenflußsysteme nutzen ebenfalls diese Ebene, erkennen aber die parallel<br />

ausführbaren Operationen zur Laufzeit durch die in Hardware realisierte Datenflußsynchronisation.<br />

(Datenfluss vs. Kontrollfluss)<br />

WS03/04


Vorlesung Rechnerarchitektur 2 Seite 22<br />

Granularität<br />

Lehrstuhl für Rechnerarchitektur - Universität Mannheim<br />

<strong>Grundlagen</strong> <strong>paralleler</strong> <strong>Architekturen</strong><br />

Den Ebenen der Parallelität entsprechend kann man eine Körnigkeit oder Granularität der<br />

Parallelarbeit feststellen. Jede Ebene besitzt eine ihr eigene Granularität, die im folgenden<br />

nach [KrS88] definiert wird.<br />

Definition : Grob-körnige Parallelität ist die Art von Parallelität, die zwischen<br />

großen Teilen von Programmen, weit oberhalb der Prozedurebene, im<br />

gemeinsamen Adressraum der Applikation existiert (‘coarse-grain<br />

parallelism’).<br />

Definition : Fein-körnige Parallelität ist die Art von Parallelität, die man auf der<br />

Ebene von Instruktionen innerhalb eines oder auch zwischen wenigen<br />

Basisblöcken (‘basic blocks’) von sequentiellen Programmen findet<br />

(fine-grain parallelism’).<br />

Für die bei numerischen Problemen sehr häufig auftretenden Schleifeniterationen, die eine<br />

der wesentlichen Quellen der Parallelität in numerischen Programmen ist, wird häufig auch<br />

noch die Definition der mittel-körnigen Granularität verwendet.<br />

Definition : Mittel-körnige Parallelität ist die Art von Parallelität, die zwischen<br />

längeren Sequenzen von Instruktionen existiert. Sie tritt hauptsächlich<br />

bei Schleifeniterationen auf und stammt im wesentlichen von der<br />

datenparallelen Verarbeitung von strukturierten Datenobjekten<br />

(‘loop-level parallelism’, ’medium-grain parallelism’).<br />

Granularität des Algorithmus<br />

Je kleiner die Granularität des Algorithmus, desto schwieriger wird die Parallelisierung sein.<br />

Feine Granularität bevorzugt <strong>Architekturen</strong> bzw. Implementierungen mit kurzen ’start up’-<br />

Zeiten und leistungsfähiger Kommunikation.<br />

Als grundlegende Regel gilt, daß die Kosten (d.h. die Bearbeitungszeit) der Teiloperation<br />

wesentlich grösser als die Kosten der Kommunikation/Synchronisation sein sollte.<br />

WS03/04


Vorlesung Rechnerarchitektur 2 Seite 23<br />

Lehrstuhl für Rechnerarchitektur - Universität Mannheim<br />

<strong>Grundlagen</strong> <strong>paralleler</strong> <strong>Architekturen</strong><br />

Ebenen der Parallelarbeit (Beispiele) - Übersicht<br />

Parallelität im organisatorischen Ablauf, Überlappen von Operationen<br />

Aufruf eines Unterprogramms<br />

Aufteilung in Teilaufgaben (Phasen)<br />

• Parameter-Übergabe<br />

• PC und Status retten<br />

• Platz für lokale Variablen bereitstellen<br />

Überlappen der einzelnen Phasen mit anderen vorlaufenden oder nachfolgenden Operationen<br />

(Pipelining).<br />

stark sprachenabhängig<br />

Operationen innerhalb einzelner Anweisungen:<br />

R:= (A+B) * C/D + (E+F)<br />

Datenabhängigkeitsgraph<br />

+ / +<br />

*<br />

+<br />

R<br />

evtl. Ressourcenkonflikt<br />

Lösen eines<br />

arithmetischen Ausdrucks<br />

WS03/04


Vorlesung Rechnerarchitektur 2 Seite 24<br />

Lehrstuhl für Rechnerarchitektur - Universität Mannheim<br />

<strong>Grundlagen</strong> <strong>paralleler</strong> <strong>Architekturen</strong><br />

Ebenen der Parallelarbeit (Beispiele) - Medium-grain parallelism<br />

Parallelausführung der Teiloperationen innerhalb von Operationen auf Datenstrukturtypen<br />

Ri := Ai * Bi , i = 1 .. n<br />

(automatische Adressrechnung, da Zugriffsfunktion auf strukturiertes Datenobjekt im voraus<br />

bekannt ist)<br />

=> Ausnutzung der Parallelität durch Vektorverarbeitung<br />

Ausnutzung der Parallelität durch Überlappen (Pipelining) der Teilschritte in mehreren Stufen<br />

Ai Bi t ges = 300 ns<br />

t start<br />

t flush<br />

A i B i<br />

*<br />

R i<br />

Gewinn einer Pipeline<br />

für n -> oo => G -> k<br />

t step = t ges /4 ~75 ns<br />

1<br />

2<br />

3<br />

k = 4<br />

R i<br />

n = Anzahl der Werte<br />

k = Anzahl der Pipelinestufen<br />

}*<br />

WS03/04


Vorlesung Rechnerarchitektur 2 Seite 25<br />

Lehrstuhl für Rechnerarchitektur - Universität Mannheim<br />

<strong>Grundlagen</strong> <strong>paralleler</strong> <strong>Architekturen</strong><br />

Ebenen der Parallelarbeit (Beispiele) - Fine-grain parallelism<br />

Ausnutzung der Parallelität in Anweisungen und Schleifen eines Benutzerprogramms, aufteilbar<br />

in 2 Phasen:<br />

• Erkennen von datenunabhängigen Anweisungen<br />

• Verteilen der Instruktionen an parallele Verarbeitungseinheiten<br />

Erkennen von datenunabhängigen Anweisungen<br />

zur Compilezeit zur Ausführungszeit<br />

VLIW, Transputer intelligent instruction issue logic (I 3 L)<br />

Datenflussrechner, Scoreboarding<br />

Verteilen der Instruktionen an parallele Verarbeitungseinheiten<br />

zur Compilezeit zur Auführungszeit<br />

VLIW I 3 L, Scoreboarding, dataflow synchronisation<br />

WS03/04


Vorlesung Rechnerarchitektur 2 Seite 26<br />

Lehrstuhl für Rechnerarchitektur - Universität Mannheim<br />

<strong>Grundlagen</strong> <strong>paralleler</strong> <strong>Architekturen</strong><br />

Ebenen der Parallelarbeit (Beispiele) - Coarse-grain parallelism<br />

Ausnutzung der Parallelität in kooperierenden Prozessen<br />

Impliziert das Aufteilen des Algorithmus in mehrere zusammenarbeitende Prozesse<br />

"kooperierende Prozesse"<br />

send receive<br />

Prozess A Prozess B<br />

receive<br />

Möglichkeiten der Kommunikation:<br />

• memory sharing<br />

• message passing<br />

Sinnvoll ist die Verteilung der Prozesse (A,B, ..) auf einzelne Prozessoren (mapping)<br />

Wichtig:<br />

Je geringer der Overhead für die Kommunikation, desto größer der Gewinn der Aufteilung<br />

(ermöglicht damit eine feinere Aufteilung)<br />

send<br />

Es macht keinen Sinn ein Problem soweit aufzuteilen, daß die Bearbeitungszeit für eine<br />

Kommunikation die Bearbeitungszeit einer Teilaufgabe überschreitet.<br />

WS03/04

Hurra! Ihre Datei wurde hochgeladen und ist bereit für die Veröffentlichung.

Erfolgreich gespeichert!

Leider ist etwas schief gelaufen!