Grundlagen der Programmierung 2 Parallele Verarbeitung

Grundlagen der Programmierung 2
Parallele Verarbeitung
Prof. Dr. Manfred Schmidt-Schauÿ
Künstliche Intelligenz und Softwaretechnologie
27. Mai 2009
Parallele Algorithmen und Ressourcenbedarf
Themen:
Nebenläufigkeit,
Parallelität,
Ressourcenverbrauch
Parallelisierung von Algorithmen
Amdahl-Gesetz
Gustafson-Barsis Gesetz
Beispielalgorithmen in Haskell
Grundlagen der Programmierung 2
- 1 -
Nebenläufigkeit und Parallelität
Prozesse und Kommunikation
Prozess:
eigenständig ablaufende Rechnung mit eigenem Speicher
wie Rechner; kann interne Berechnungen
und Ein-Ausgabe durchführen
P,Q
nebenläufig wenn diese unabhängig voneinander ausgeführt
(concurrent) werden können.
P,Q
parallel,
Grundlagen der Programmierung 2
wenn sie nebenläufig sind und gleichzeitig ablaufen.
- 2 -
Klassifikation der parallelen Rechnerarchitekturen nach Flynn
Bezüglich paralleler Instruktionssequenzen und Parallelität der Verarbeitung von Daten:
•
•
•
•
SISD: Single instruction, single data stream (SISD): Sequentieller
Rechner ohne Parallelität.
MISD:Multiple instruction, single data stream: kommt so gut wie
nicht vor: Man kö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.
Grundlagen der Programmierung 2
- 3 -
Parallele und verteilte Berechnungen
•
PRAM: parallel random access machine
•
Verteilte Berechnung, lose Kopplung
•
massiv parallel, enge Kopplung
•
Grid-Computing
•
Cloud-Computing
•
Vektorrechner, Feldrechner
•
Pipelining
•
Multi-Core-Prozessoren
Grundlagen der Programmierung 2
- 4 -
PRAM: parallel random access machine
•
Mehrere Prozesse (Prozessoren),
gemeinsamer Hauptspeicher,
•
unabhängiges Lesen und Schreiben
Grundlagen der Programmierung 2
- 5 -
Verteilte Berechnungen, lose Kopplung
•
•
•
•
Mehrere unabhängige Rechner kommunizieren über ein Netzwerk
arbeiten gemeinsam an einer Berechnung
Programme / Programmteile können völlig verschieden sein.
Weitere Unterscheidung:
Gleichberechtigte Rechner; oder
hierarchisch (Master/ Slave) bzw. (Client / Server).
•
Z.B. PVM: Parallel Virtual Machine
Grundlagen der Programmierung 2
- 6 -
massiv parallel, enge Kopplung
•
•
•
•
•
Viele unabhängige, gleiche Prozessoren
Kopplung über ein schnelles Netzwerk
arbeiten gemeinsam an einer Berechnung.
I.a: Gleiches Programm, verschiedene Daten.
Oft feste Topologie:
Hyperwürfel, ähnliche Netzwerke,
Z.B. Hardware für künstliche neuronale Netze.
Grundlagen der Programmierung 2
- 7 -
Grid-Computing
•
Viele Workstations/ PCs rechnen gemeinsam an einer Aufgabe
•
verschiedene Hardware / Betriebssystem ist möglich
•
I.a. : Rechner haben das gleiche Programm, aber verschiedene Daten
Grundlagen der Programmierung 2
- 8 -
Vektorrechner
•
Ein Programm steuert parallele Berechnungen auf HW-Arrays:
•
Gleiche Prozedur, verschiedene Datenelemente
•
Sinnvoller Einsatz: Wettersimulationen, numerische Berechnungen
•
SIMD (single instruction, multiple data)
Grundlagen der Programmierung 2
- 9 -
Pipelining
•
•
•
•
I.a. parallele Ausfü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
Grundlagen der Programmierung 2
- 10 -
Maße für den parallelen Ressourcenverbrauch
Modell auf der Programmiersprachenebene:
Auswertung durch einzelne Reduktionsschritte (z.B. Haskell)
•
sequentieller Einzelschritt
•
paralleler Einzelschritt =
Grundlagen der Programmierung 2
mehrere unabhängige, gleichzeitige
Einzelschritte
- 11 -
Maße fü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
Grundlagen der Programmierung 2
- 12 -
Beispiel: Parallele Auswertung
Skalarproduktberechnung:
(a1, . . . , an) ∗ (b1, . . . , bn) = a1 ∗ b1 + . . . + an ∗ bn
1. Schritt:
2. Schritt:
Werte die Produkte parallel aus
Addiere die Ergebnisse
Grundlagen der Programmierung 2
- 13 -
Parallele Reduktion; konservativ / spekulativ
• Die Parallelisierung ist konservativ, wenn nur Auswertungen durchgeführt werden, die für das Erreichen des Resultats notwendig sind.
• Die Parallelisierung ist spekulativ, wenn auch Reduktionen durchgeführt werden können, von denen zum Zeitpunkt der Ausführung
nicht bekannt ist, ob diese für das Berechnen des Resultats notwendig sind.
Grundlagen der Programmierung 2
- 14 -
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
Grundlagen der Programmierung 2
- 15 -
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 unabhä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
für die Anzahl gleichzeitiger Reduktionen
(#Prozessoren) gibt.
τ (E, 1)
Optimistische Erwartung: τ (E, p) ≈
.
p
Grundlagen der Programmierung 2
- 16 -
Parallele Reduktion: Beschleunigung
Vereinfachende Annahme im folgenden:
die Kennzahlen hängen nur vom Algorithmus ab;
proportional zur Eingabegröße E;
D.h., für alle p: τ (E, p) = |E| ∗ τ (p);
meist kann |E| gekü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.
Grundlagen der Programmierung 2
- 17 -
Parallele Reduktion: Beschleunigung
maximale parallele Beschleunigung
τ (1)
τ (1)
q :=
= lim
.
p→∞ τ (p)
τ (∞)
parallele Beschleunigung bei unbeschränkter Anzahl von Prozessoren.
sequentieller Zeit-Anteil des Algorithmus := 1/q.
Grundlagen der Programmierung 2
- 18 -
Parallele Reduktion: Effizienz
parallele Effizienz :=
=
τ (1)
p ∗ τ (p)
Anteil der für den Algorithmus nutzbaren gesamten Leistung
aller Prozessoren
Beispielhafte Zahlen:
Zeit
Beschleunigung
Effizienz
Grundlagen der Programmierung 2
τ (1)
1000
1
1
τ (3)
500
2
66,6%
τ (4)
400
2,5
62,5%
- 19 -
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
Grundlagen der Programmierung 2
- 20 -
Amdahls Gesetz
Begrenzung der parallelen Beschleunigung
Amdahl-Annahmen zur Problemstruktur (≈ für alle Eingaben)
T = Tpar + Tseq
Gesamtzeit T hat parallelen und sequentiellen Anteil
Tpar
Verhältnis
ist konstant.
Tseq
Beispiel
map f xs
Sequentieller Anteil: mindestens ein Listendurchlauf
Grundlagen der Programmierung 2
- 21 -
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
Grundlagen der Programmierung 2
- 22 -
Gustafson-Barsis Gesetz
Gustafson-Barsis-Annahme: T = Tseq + p ∗ Tp
T
Tseq
p ∗ Tp
Zeit für einen Prozessor
fester sequentiellen Anteil, z.B. Initialisierung
auf p Prozessoren verteilbare Berechnungszeit
Tseq
ergibt sich:
Mit α =
Tp
Beschleunigung
Grundlagen der Programmierung 2
=
α+p
Tseq + p ∗ Tp
=
Tseq + Tp
α+1
- 23 -
Gustafson-Barsis Gesetz: Beispiel
Anwendung von f auf alle Elemente eines Arrays der Lä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 =
Grundlagen der Programmierung 2
1+n
2
- 24 -
Beispiele: Algorithmen und Parallelisierung in
Haskell
•
•
•
•
•
•
vereinfachtes Modell: wie könnte man in Haskell parallelisieren?
unabhängige Transformationen können parallel durchgeführt werden.
Annahme: beliebig viele Prozessoren
Wir benutzen verzögerte Reduktion und Sharing bzw. letDarstellung.
Jede Transformation benötigt eine Zeiteinheit.
Anzahl parallel mögliche Transformationen
= Anzahl der Prozessoren
Grundlagen der Programmierung 2
- 25 -
Beispiele
quadratsumme 3 4 −→ (3*3)+(4*4) −→ 9+16 −→ 25.
2 Prozessoren; 3 Zeiteinheiten werden benötigt
Grundlagen der Programmierung 2
- 26 -
Beispiel: Fakultä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.
Grundlagen der Programmierung 2
- 27 -
Beispiel: Fakultä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.
Grundlagen der Programmierung 2
- 28 -
Beispiel
map quadrat [1..n].
Auswertungssequenz:
map quadrat [1..n]
1: map quadrat [2..n]
1: 4: (map quadrat [3..n])
Benötigt O(n) parallele Schritte.
Grundlagen der Programmierung 2
- 29 -
Summation von n Zahlen in einer Liste
Zwei Algorithmen für Summe im Vergleich:
sum [] = 0
sum (x:xs) = x+ (sum xs)
Benötigt
O(n) parallele Reduktionsschritte.
Grundlagen der Programmierung 2
- 30 -
Summation von n Zahlen in einem balancierten
binä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 für parallele Verarbeitung geeignet
Grundlagen der Programmierung 2
- 31 -
Summation von n Zahlen in einem balancierten
binä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
Grundlagen der Programmierung 2
- 32 -
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 benötigt an parallelen Reduktionen
2 ∗ n + 2 ∗ (n/2) + 2 ∗ (n/4) + . . . = 4 ∗ n D.h. O(n).
Grundlagen der Programmierung 2
- 33 -
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 benötigen.
Parallele Sortieralgorithmen: Sortiernetzwerke
Grundlagen der Programmierung 2
- 34 -
Parallelisierung: Bemerkungen
Divide-and-COnquer (Teile-und Herrsche) kann sehr gut parallelisierbare Algorithmen ergeben
Aber nicht immer:
Sequentielle optimierte Algorithmen (Scan)
ergeben i.a. schlecht parallelisierbare Algorithmen
Hand-Parallelisierung auf der Programmiersprachenebene:
nur sehr spezielle Anwendungen
Stete Beschleunigung der CPUs holt den Vorteil
paralleler S.W.-Architekturen immer wieder ein
Grundlagen der Programmierung 2
- 35 -
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
Grundlagen der Programmierung 2
- 36 -