Grundlagen der Programmierung 2 Parallele Verarbeitung

Transcrição

Grundlagen der Programmierung 2
Parallele Verarbeitung
Prof. Dr. Manfred Schmidt-Schauÿ
Künstliche Intelligenz und Softwaretechnologie
31. Mai 2006
Teile und Herrsche (Divide and Conquer)
Entwurfsmethode für Algorithmen
1.
2.
3.
Teile das Problem in kleinere Unterprobleme (Divide)
Löse rekursiv die entstehenden Unterprobleme (Conquer)
Setze die Lösungen zusammen.
Instanzen :
•
•
•
•
Mergesort
Quicksort
Intervallhalbierung (kein Zusammensetzen)
schnelle Berechnung ganzzahliger Potenzen
- 1 -
Divide-and-Conquer: Laufzeiten
Bei sequentiellen Programmen kann man oft erreichen, dass
ein O(n) Laufzeitanteil verbesserbar ist zu O(log(n))
Notwendig dazu:
Summe der Größen der Teilprobleme
≤ Größe des Problems
- 2 -
Beispiel: Türme von Hanoi
Gegeben
Stapel von verschieden großen Scheiben
von oben nach unten größer werdend
Aufgabe:
Umstapeln auf einen anderen Stapel.
Erlaubt ist ein weiterer Hilfsstapel
Bedingung: Es darf niemals eine Scheibe auf einer kleineren
liegen
Lösung: mittels Teile-und-Herrsche:
- 3 -
Beispiel: Türme von Hanoi
1
n-1
n
2
n
n-1
3
n-1
n
- 4 -
Beispiel: Türme von Hanoi (2)
Notwendige Bewegungen für n:
1. n − 1 Scheiben von 1 nach 3 mit 2 als Hilfsstapel
2. Scheibe n von 1 nach 2
3. n − 1 Scheiben von 3 nach 2 mit 1 als Hilfsstapel
- 5 -
Beispiel: Türme von Hanoi (2)
Haskell-Algorithmus zum Ermitteln der Bewegungen.
Die Nr. der Stapel wird als Argument mitübergeben.
-hanoi: Stapel, Stapelnr, Zielstapelnr Hilfstapelnr:
hanoi xs a b c = hanoiw (reverse xs) a b c
hanoiw [] _ _ _ = []
hanoiw
xa a b c =
(hanoiw
(tail xa) a c b)
++
((head xa ,(a,b))
:
(hanoiw
(tail xa) c b a))
- 6 -
Parallele Algorithmen und deren Ressourcenbedarf
Themen:
Nebenläufigkeit,
Parallelität,
Ressourcenverbrauch
Parallelisierung von Algorithmen
Amdahl-Gesetz
Gustafson-Barsis Gesetz
Beispielalgorithmen in Haskell
- 7 -
Nebenläufigkeit und Parallelität
Prozesse und Kommunikation
Prozess:
eigenständig ablaufende Rechnung mit eigenem Speicher
wie Rechner; kann interne Berechnungen
und Ein-Ausgabe durchführen
P,Q
nebenläufig wenn diese unabhängig voneinander ausgeführt
(concurrent) werden können.
P,Q
parallel,
wenn sie nebenläufig sind und gleichzeitig ablaufen.
- 8 -
Klassifikation der parallelen Rechnerarchitekturen nach Flynn
Bezüglich paralleler Instruktionssequenzen und Parallelität der Verarbeitung von Daten:
•
•
•
•
SISD: Single instruction, single data stream (SISD): Sequentieller
Rechner ohne Parallelität.
MISD:Multiple instruction, single data stream: kommt so gut wie
nicht vor: Man könnte redundante (Doppel-) Verarbeitung hier
einordnen.
SIMD: Single instruction, multiple data streams: Gleiche Verarbeitung. viele gleichartige Daten: z.B. Vektorprozessor.
MIMD:Multiple instruction, multiple data streams: Mehrere Prozessoren lassen verschiedene Programme auf verschiedenen Daten ablaufen: Verteilte Systeme.
- 9 -
Parallele und verteilte Berechnungen
•
PRAM: parallel random access machine
•
Verteilte Berechnung, lose Kopplung
•
massiv parallel, enge Kopplung
•
Grid-Computing
•
Vektorrechner, Feldrechner
•
Pipelining
- 10 -
PRAM: parallel random access machine
•
Mehrere Prozesse (Prozessoren),
gemeinsamer Hauptspeicher,
•
unabhängiges Lesen und Schreiben
•
Unterscheidung verschiedener Modelle:
Lesen- und/oder Schreiben;
exklusiv oder konkurrierend
(EREW, CRCW, CREW).
- 11 -
Verteilte Berechnungen, lose Kopplung
•
•
•
•
Mehrere unabhängige Rechner kommunizieren über ein Netzwerk
arbeiten gemeinsam an einer Berechnung
Programme / Programmteile können völlig verschieden sein.
Weitere Unterscheidung:
Gleichberechtigte Rechner; oder
hierarchisch (Master/ Slave) bzw. (Client / Server).
•
Z.B. PVM: Parallel Virtual Machine
- 12 -
massiv parallel, enge Kopplung
•
•
•
•
•
Viele unabhängige, gleiche Prozessoren
Kopplung über ein schnelles Netzwerk
arbeiten gemeinsam an einer Berechnung.
I.a: Gleiches Programm, verschiedene Daten.
Oft feste Topologie:
Hyperwürfel, ähnliche Netzwerke,
Z.B. Hardware für künstliche neuronale Netze.
- 13 -
Grid-Computing
•
Viele Workstations/ PCs rechnen gemeinsam an einer Aufgabe
•
verschiedene Hardware / Betriebssystem ist möglich
•
I.a. : Rechner haben das gleiche Programm, aber verschiedene Daten
- 14 -
Vektorrechner
•
Ein Programm steuert parallele Berechnungen auf HW-Arrays:
•
Gleiche Prozedur, verschiedene Datenelemente
•
Sinnvoller Einsatz: Wettersimulationen, numerische Berechnungen
•
SIMD (single instruction, multiple data)
- 15 -
Pipelining
•
•
•
•
I.a. parallele Ausführung von Maschinenkode
auf der Hardware eines Prozessor
Befehlsbearbeitung wird in kleinere Einheiten zerlegt,
die dann nacheinander, versetzt abgearbeitet werden.
Weitere Beschleunigung durch
Mehrfachauslegung von internen Einheiten
- 16 -
Maße für den parallelen Ressourcenverbrauch
Modell auf der Programmiersprachenebene:
Auswertung durch einzelne Reduktionsschritte (z.B. Haskell)
•
sequentieller Einzelschritt
•
paralleler Einzelschritt =
mehrere unabhängige, gleichzeitige
Einzelschritte
- 17 -
Maße für den parallelen Ressourcenverbrauch
Basis ist das PRAM-Modell:
• mehrere, nicht unterscheidbare Prozessoren
• gemeinsamer Hauptspeicher
• Befehlsabarbeitung ist synchron getaktet.
• pro Einzelschritt einer parallelen Auswertung
•
ist ein Prozessor notwendig
#parallele Reduktionsschritte
=
#paralleler Schritte bis zum Ergebnis
#notwendige Prozessoren
=
maximale Anzahl gleichzeitiger
sequentieller Einzelschritte
in einem parallelen Schritt
- 18 -
Beispiel: Parallele Auswertung
Skalarproduktberechnung:
(a1, . . . , an) ∗ (b1, . . . , bn) = a1 ∗ b1 + . . . + an ∗ bn
1. Schritt:
2. Schritt:
Werte die Produkte parallel aus
Addiere die Ergebnisse
- 19 -
Parallele Reduktion; konservativ / spekulativ
• Die Parallelisierung ist konservativ, wenn nur Auswertungen durchgeführt werden, die für das Erreichen des Resultats notwendig sind.
• Die Parallelisierung ist spekulativ, wenn auch Reduktionen durchgeführt werden können, von denen zum Zeitpunkt der Ausführung
nicht bekannt ist, ob diese für das Berechnen des Resultats notwendig sind.
- 20 -
Parallele Reduktion: Beispiel
spekulativ:
Die parallele Reduktion von s und t in
if cond then s else t
konservativ:
Die parallele Reduktion von s und t in
s * t
- 21 -
Parallele Reduktion: Maßzahlen
Algorithmus sei gegeben, sei E die Eingabe, und p die Anzahl der
erlaubten Prozessoren.
τ (E, p)
τ (E, 1)
τ (E, ∞)
minimale Anzahl der parallelen Reduktionsschritte bis
zum Ergebnis, wenn man p unabhängige Reduktionsschritte gleichzeitig pro Schritt machen darf
ist die Anzahl der Einzel-Reduktionsschritte bei sequentieller Auswertung.
entspricht dann der Anzahl der parallelen Reduktionsschritte bis zum Ergebnis, wenn es keine obere Schranke
für die Anzahl gleichzeitiger Reduktionen
(#Prozessoren) gibt.
τ (E, 1)
Optimistische Erwartung: τ (E, p) ≈
.
p
- 22 -
Parallele Reduktion: Beschleunigung
Vereinfachende Annahme im folgenden:
die Kennzahlen hängen nur vom Algorithmus ab;
proportional zur Eingabegröße E;
D.h., für alle p: τ (E, p) = |E| ∗ τ (p);
meist kann |E| gekürzt werden.
(relative) parallele Beschleunigung :=
τ (1)
τ (p)
Die parallele Beschleunigung ist eine Zahl zwischen 1 und p
≥ 1,
≤ p,
da man sequentiell reduzieren kann,
da maximal p Prozessoren und man eine parallele
Reduktion zu einem Ergebnis sequentiell nachvollziehen kann.
- 23 -
Parallele Reduktion: Beschleunigung
maximale parallele Beschleunigung
τ (1)
τ (1)
q :=
= lim
.
p→∞ τ (p)
τ (∞)
parallele Beschleunigung bei unbeschränkter Anzahl von Prozessoren.
sequentieller Zeit-Anteil des Algorithmus := 1/q.
- 24 -
Parallele Reduktion: Effizienz
parallele Effizienz :=
=
τ (1)
p ∗ τ (p)
Anteil der für den Algorithmus nutzbaren gesamten Leistung
aller Prozessoren
Beispielhafte Zahlen:
Zeit
Beschleunigung
Effizienz
τ (1)
1000
1
1
τ (3)
500
2
66,6%
τ (4)
400
2,5
62,5%
- 25 -
Parallele Effizienz
τ (1)
ist eine Zahl zwischen 1 und 1/p.
p ∗ τ (p)
1
optimal: alle Prozessoren tragen zur zur Berechnung bei
1/p
schlecht: Berechnung ist im wesentlichen sequentiell
- 26 -
Weitere Maßzahlen
w(p)
die verrichtete Arbeit
Gesamt-Anzahl von Einzelschritten
Es gilt stets: w(p) ≥ τ (1)
w(p)
τ (p)
mittlere Anzahl beschäftigter Prozessoren
w(p)
p ∗ τ (p)
mittlere Auslastung
- 27 -
Amdahls Gesetz
Begrenzung der parallelen Beschleunigung
Amdahl-Annahmen zur Problemstruktur (≈ für alle Eingaben)
T = Tpar + Tseq
Gesamtzeit T hat parallelen und sequentiellen Anteil
Tpar
Verhältnis
ist konstant.
Tseq
Beispiel
map f xs
Sequentieller Anteil: mindestens ein Listendurchlauf
- 28 -
Amdahls Gesetz (2)
Beschleunigung durch p Prozessoren:
Tpar + Tseq
(1/p) ∗ Tpar + Tseq
Bei unendlich vielen Prozessoren:
Tpar + Tseq
Beschleunigung ≤
Tseq
Beispiel
Wenn sequentieller Anteil = 5%,
dann ist Beschleunigung maximal 20
- 29 -
Gustafson-Barsis Gesetz
Gustafson-Barsis-Annahme: T = Tseq + p ∗ Tp
T
Tseq
p ∗ Tp
Zeit für einen Prozessor
fester sequentiellen Anteil, z.B. Initialisierung
auf p Prozessoren verteilbare Berechnungszeit
Tseq
ergibt sich:
Mit α =
Tp
Beschleunigung
=
α+p
Tseq + p ∗ Tp
=
Tseq + Tp
α+1
- 30 -
Gustafson-Barsis Gesetz: Beispiel
Anwendung von f auf alle Elemente eines Arrays der Länge n
a[1], . . . , a[n]
Tseq
Tp
→
f a[1], . . . , f a[n]
Initialisierungszeit
Zeit zum Berechnen von f x.
Wenn Tseq = Tp,
dann Beschleunigung mit n Prozessoren =
1+n
2
- 31 -
Beispiele: Algorithmen und Parallelisierung in
Haskell
vereinfachtes Modell in Haskell:
unabhängige Transformationen können parallel durchgeführt werden.
Annahme: beliebig viele Prozessoren
verzögerte Reduktion und gerichteter Graph bzw. let-Darstellung.
Jede Transformation benötigt eine Zeiteinheit.
#parallel mögliche Transformationen = #Prozessoren
- 32 -
Beispiele
quadratsumme 3 4 −→ (3*3)+(4*4) −→ 9+16 −→ 25.
2 Prozessoren; 3 Zeiteinheiten werden benötigt
- 33 -
Beispiel: Fakultät
fakt 3
−→ if 3 == 1 then 1 else 3*(fakt (3-1))
−→ if False then 1 else 3*(if 2 == 1 then 1 else 2*(fakt (2-1) )
−→ 3*(if False then 1 else 2*(if 1 == 1 then 1 else 1*(fakt (1-1)))
−→ 3*(2*(if True then 1 else 1*(if 0 == 1 then 1 else 1*(fakt0)))
−→ 3*(2*(1))
−→ 3*(2)
−→ 6
7 parallele Auswertungsschritte bei 4 Prozessoren.
Die parallele Zeit ist O(n).
Mehr Prozessoren helfen nicht.
- 34 -
Beispiel: Fakultät
Man kann (fakt n) in paralleler Zeit O(log(n)) berechnen:
Idee:
Benutze Divide-and-Conquer:
1 ∗ 2 ∗ 3... ∗ n
= 1 ∗ 2 ∗ . . . ∗ (n/2) ∗ (n/2 + 1) ∗ . . . ∗ n
usw.
- 35 -
Beispiel
map quadrat [1..n].
Auswertungssequenz:
map quadrat [1..n]
1: map quadrat [2..n]
1: 4: (map quadrat [3..n])
Benötigt O(n) parallele Schritte.
- 36 -
Summation von n Zahlen in einer Liste
Zwei Algorithmen für Summe im Vergleich:
sum [] = 0
sum (x:xs) = x+ (sum xs)
Benötigt
O(n) parallele Reduktionsschritte.
- 37 -
Summation von n Zahlen in einem balancierten
binären Baum:
data
BBaum a = BBlatt a | Bknoten (BBaum a) (BBaum a)
sumbt (Bblatt x) = x
sumbt (Bknoten bl br) = (sumbt bl) + (sumbt br)
Bei Tiefe h:
2 ∗ (h + 1) parallele Schritte, d.h.,
log2(n) + 1 .
sehr gut für parallele Verarbeitung geeignet
- 38 -
Summation von n Zahlen in einem balancierten
binären Baum mittels schnellem foldbt
foldbt (+) 0 "(((1,2),3),(4 ,5))"
--> foldbt (+) (foldbt (+) 0 "(4 ,5)")
"((1,2),3)"
--> foldbt (+) (foldbt (+) (foldbt (+) (foldbt (+) 0 "5")
.................
-->
"4") "3")
1+ (2+ (3+ (4+ 5))))
Die Problematik ist:
Obwohl sich die foldbt exponentiell ausbreiten:
Die Summe 1+ (2+ (3+ (4+ 5))) ist sequentiell
D.h., man braucht mindestens O(n) parallele Schritte
foldbt nicht geeignet zur Parallelisierung
- 39 -
Paralleles Sortieren von (verschiedenen) Zahlen
Nachweis: Parallelisierung kann Sortieren beschleunigen.
Merge-Sort: die zerlegten Listen sind parallel sortierbar.
Aber: Mischen ist sequentiell, Zerlegen ebenfalls
Man benötigt an parallelen Reduktionen
2 ∗ n + 2 ∗ (n/2) + 2 ∗ (n/4) + . . . = 4 ∗ n D.h. O(n).
- 40 -
Eine Parallelisierung des Bubble-Sort
Gegeben: Array der Länge n
odd-even transposition sort:
Vergleiche benachbarte Elemente und vertausche, falls nötig
Notwendig sind (n + 1) ‘div‘ 2 Prozessoren.
Im ersten Schritt
vergleiche Werte mit Indizes (1,2), (3,4), (5,6) . . . ,
im zweiten Schritt (2,3), (4,5), (6,7), (8,9),. . . .
Man kann nachweisen, dass nach n Schritten das Feld sortiert ist.
Man erhält:
• parallele Laufzeit: O(n)
• parallele Beschleunigung: ∼ log(n))
• parallele Effizienz: ∼ log(n)/n
• Gesamtanzahl an Operationen: ∼ n ∗ n
- 41 -
Paralleles Sortieren
Es gibt Parallelisierungen, die in O((log(n))2) laufen.
Es gibt komplizierte Parallelisierungen, die laut Experten sogar
nur O(log(n)) Zeit benötigen.
Parallele Sortieralgorithmen: Sortiernetzwerke
- 42 -
Parallelisierung: Bemerkungen
Teile-und Herrsche kann sehr gut parallelisierbare Algorithmen ergeben
Aber nicht immer: z.B. hanoi
Sequentielle optimierte Algorithmen (Scan)
ergeben i.a. schlecht parallelisierbare Algorithmen
Hand-Parallelisierung auf der Programmiersprachenebene:
nur Anwendungsnische
Stete Beschleunigung der sequentiellen CPUs holt den Vorteil
paralleler Architekturen immer wieder ein
- 43 -
Parallelisierung: Bemerkungen
Wo ist Parallelisierung aktuell lohnend?
• auf Prozessorebene
• implizit durch den Compiler
• Number Crunching: wie z.B. Wettervorhersage
• Grid Computing: viele gleichartige Daten, gleiches Programm
Supercomputer sind Parallelrechner mit (aktuell) bis zu 131.072 Prozessoren.
- 44 -
Ein Ausflug in die Komplexitätstheorie
Theoretische Klassifikation von Problemklassen:
Effizient Parallelisierbare Probleme:
Pippenger)
NC ( Nick’s Class“)
”
(Nikolaus
Definition: Eine Problemklasse is in NC,
wenn die Probleme in polylogarithmischer Zeit, O(log c(n)) für ein c > 0
mit polynomiell vielen Prozessoren bearbeiten werden können.
Es gilt N C ⊆ PTime. d.h. NC-Probleme haben einen Polynomial-ZeitAlgorithmus
Vermutung: N C ⊂ PTime.
Dadurch ist es manchmal möglich, nachzuweisen, dass man eine Problemklasse nicht auf diese günstige Weise parallelisieren kann.
- 45 -
Beispiel: NC
NC-Probleme (d.h. gutartig parallelisierbar):
Sortieren von Zahlen.
Summation von n Zahlen in einem balancierten Baum.
Zeitschätzung:
• n Prozessoren
• in Zeit O(log (n)) die Blätter ermitteln
• die Ergebnisse in Zeit log (n) (parallel) addieren.
- 46 -
Beispiel: nicht in NC
Ein Problem nicht in NC:
(Vermutlich)
D.h. nicht effizient parallelisierbar
Gegeben ein Schaltnetz
(UND/ ODER / NICHT-Knoten, Gerichteter Graph)
Boolesche Werte an den Eingängen
Berechne die Wert an den Ausgängen
- 47 -

Grundlagen der Programmierung 2 Parallele Verarbeitung

Transcrição

Documentos relacionados

Profil - Diplom-Informatiker Frank Seitz

Art. 300651 Lektor CNC-TECHNIK

Jeep Cherokee 2.5 TD 115PS

CV als PDF

1.1 Anforderungen an Software

Musterklausur

Anlernen der Fernbedienung - dr

Unity3D Programmer - Promotion Software GmbH

Kurzanleitung zum Tytera MD-380 / Retevis RT-3

Informationstechnologie Web

Daten- und Wissensmanagement (DWM)