Grundlagen paralleler Architekturen
Grundlagen paralleler Architekturen
Grundlagen paralleler Architekturen
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