seminar: parallele und verteilte programmierung datenparallele algorithmische skelette in muesli...

Seminar: Parallele und Verteilte Programmierung

Datenparallele Algorithmische Skelette in Muesli

Dominik PfeifferMünster, 31. Mai 2007

2

Gliederung

1. Motivation

2. Grundlegende Begriffe

3. Die Skelettbibliothek Muesli

4. Beispielprogramm

5. Zusammenfassung und Bewertung

3

Motivation

Probleme in der parallelen Programmierung:Synchronisation von Prozessen

Deadlocks

Starvation

Mögliche Lösung des Problems:Von der Parallelität der Ausführung abstrahieren

Auf einer höheren Ebene Funktionen zur parallelen Verarbeitung von Aufgaben und Daten bereitstellen

Motivation – Grundlegende Begriffe – Die Skelettbibliothek Muesli – Beispielprogramm – Zusammenfassung

4

Gliederung

1. Motivation

2. Grundlegende Begriffe1. Funktionen höherer Ordnung

2. Partielle Applikationen

3. Algorithmische Skelette


4. Beispielprogramm


5

Funktionen höherer Ordnung

Funktionen mit Funktionen als Parameter oder Rückgabewerte

Gleichstellung von Funktionen und Werten

Beispiel:map (funktion, [liste])

map wendet eine Funktion sukzessiv auf jedes Element einer Liste an

Realisierung bspw. in C++ durch Funktionszeiger


6

Partielle Applikationen (1/2)

Anwendung von weniger Argumenten auf eine Funktion als erwartet werden

Umwandeln dieser Funktion in neue Funktion mit nur noch den fehlenden Argumenten

Anwendung beliebiger Werte auf restliche Argumente führt zum selben Ergebnis wie Auflösen der Ursprungsfunktion

Lässt sich beliebig frei und tief verschachteln


7

Partielle Applikationen (2/2)

Realisierung durch die Hilfsfunktion curry()

Beispiel:Ausgangsfunktion:

map (funktion, [liste])

Hilfsfunktion:

mult(x, y)

Anwendung von curry() auf mult(x,y) mit dem Parameter 2 liefert mult2(y)

Partielle Applikation:

map(curry(mult)(2), [liste])

Ergebnis:

Alle Elemente der Liste werden mit 2 multipliziert


8

Algorithmische Skelette (1/2)

Stellen ein Gerüst für bestimmte Operationen und Kommunikationsmuster bereit

Verbergen die parallele AusführungVermeiden unnötige SpezialisierungKönnen in der sequentiellen Programmierung genutzt werden

Kümmern sich um Low-Level-ProblemeDeadlocksStarvationSynchronisation

Implementierung unter Verwendung von:PolymorphismusFunktionen höherer OrdnungPartielle Applikationen


9

Algorithmische Skelette (2/2)

Taskparallele SkeletteTeilen Probleme in sequentiell und parallel abzuarbeitende Aufgaben

Datenparallele SkeletteFühren Operationen auf verteilten Datenstrukturen aus

Laufen intern parallel ab

RechenskeletteBearbeiten die Inhalte der verteilten Datenstruktur

KommunikationsskeletteVersenden Daten

Synchronisieren Prozesse

Ändern die Verteilung der Partitionen auf einzelne Prozesse


10

Gliederung

1. Motivation


3. Die Skelettbibliothek Muesli1. Übersicht

2. Verteilte Datenstrukturen

3. Map

4. ZipWith

5. Fold

4. Beispielprogramm


11

Übersicht

Muesli ist eine SkelettbibliothekAlgorithmische Skelette

Verteilte Datenstrukturen

Keine eigene Programmiersprache

ImplementierungC++

Interprozesskommunikation mit MPI

Funktionen höherer Ordnung

Partielle Applikationen

Polymorphismus (Templates)


12

Verteilte Datenstrukturen (1/2)

Verteilte Datenstrukturen Array und MatrixAufteilung in Partitionen

Verteilung der Partitionen auf mehrere Prozesse

KonstruktorenGröße der Matrix

Größe der Partition

Initialwert oder –funktion

Hilfsfunktionenget

set

show

…


13

Verteilte Datenstrukturen (2/2)

Kommunikation ist nicht erforderlich

Alle Prozesse führen den gleichen Code ausPartition wird anhand der ProzessID bestimmt

Alle Prozesse haben die gleiche Datenbasis


Prozess 1

44434241

34333231

24232221

14131211

xxxx

xxxx

xxxx

xxxx

2221

1211

xx

xx

2423

1413

xx

xx

4241

3231

xx

xx

4443

3433

xx

xx

Prozess 2

Prozess 3

Prozess 4

14

Map (1/2)

Rechenskelett

Wendet eine Funktion sukzessiv auf jedes Element einer Datenstruktur an

Die Anwendung kann parallel von jedem Prozess auf seiner Partition erfolgen


Skelettdefinition in Muesli:DistributedMatrix<R> map (R (*f)(E))

VariantenDistributedMatrix<R> mapIndex(R (*f)(int,int,E))

void mapInPlace(E (*f)(E))

void mapIndexInPlace(E (*f)(int,int,E))


15

Map (2/2)

BeispielMultiplikation aller Elemente der Matrix mit 2

16151413

1211109

8765

4321

32302826

24222018

16141210

8642


P1

65

21

87

43

1413

109

1615

1211

P2

P3 P4

1210

42

1614

86

2826

2018

3230

2422

16

ZipWith (1/2)

Rechenskelett

Kombiniert zwei gleiche DatenstrukturenGleiche Größe der Matrix

Gleiche Partitionierung

Elementweise Kombination


Skelettdefinition in Muesli:DistributedMatrix<R> zipWith (

const DistributedMatrix<E2>& b, R (*f)(E,E2))


17

ZipWith (2/2)Beispiel: Kombination durch element-

weise Multiplikation

4321

4321

4321

4321

16151413

1211109

8765

4321

64452813

4833209

3221125

16941


&

&

&

&

&

=

=

=

=

=

Prozess 4

Prozess 3

Prozess 1

Prozess 2

65

21

87

43

1413

109

1615

1211

21

21

43

43

21

21

43

43

125

41

3221

169

2813

209

6445

4833

18

Fold (1/3)

Rechenskelett

Vereint alle Elemente einer Datenstruktur Nacheinander Vereinigung jedes Elements mit dem bisherigen Zwischenergebnis

Die Art der Vereinigung wird durch Parameter bestimmt:Assoziative Funktion f

f erwartet 2 Parameter vom Typ der Elemente der Datenstruktur

Ergebnis liegt danach bei jedem Prozess vorErgebnis = f(Elem1, f(Elem2, … f(Elemn-1, Elemn)…))

Kommunikation erforderlich


19

Fold (2/3)

BeispielSchritt 1: Vereinigung der Elemente jeder lokalen Partition

Schritt 2: Austausch der Zwischenergebnisse zwischen den Prozessen

65

21

87

43

1413

109

1615

1211

(1 + (2 + (5 + 6))) = 14

(3 + (4 + (7 + 8))) = 22

(9 + (10 + (13 + 14))) = 46

(11 + (12 + (15 + 16))) = 54

P1

P3

P2

P4


Sen

d/R

ecei

ve

Sen

d/R

ecei

ve

Send/Receive

Send/Receive

Send/ReceiveSend/Receive

20

Fold (3/3)

BeispielSchritt 3: Vereinigung der Zwischenergebnisse durch jeden Prozess

Skelettdefinition in Muesli:E fold (E (*f)(E,E))


(14 + (22 + (46 + 54))) = 136

P1

(14 + (22 + (46 + 54))) = 136

P2

(14 + (22 + (46 + 54))) = 136

P3

(14 + (22 + (46 + 54))) = 136

P4

21

Gliederung

1. Motivation



4. Beispielprogramm1. Hintergrund

2. Programmablauf

3. Implementierung


22

Hintergrund

Beispielprogramm unter Verwendung der hier vorgestellten Skelette

Anwendungskontext:Verschmelzen von zwei Übergangsmatrizen aus der Wahrscheinlichkeitstheorie

Praktische Anwendung in der Physik bei der Beschreibung physikalischer Zustandsveränderungen


23

Programmablauf

1. Erstellen zweier 4x4-ÜbergangsmatrizenMatrix 1: Die ersten beiden Zeilen mit 0,5 und der Rest

mit 0 belegt

Matrix 2: Einheitsmatrix

2. Kombinieren der Matrizen

3. Berechnung der Summe aller Werte der Ergebnismatrix

Die Werte müssen in der Summe 4 ergeben

Stellt ansatzweise die Korrektheit der Vereinigung sicher


24

Implementierung (1/5)

Initialisieren der SkelettbibliothekInitSkeletons(argc, argv);

Initialisieren der ersten ÜbergangsmatrixDistributedMatrix<double> m1(4,4,1,4);

m1.mapIndexInPlace(&firsttwo);

Hilfsfunktion firsttwodouble firsttwo(const int a, const int b, const double d) {

return (a == 0 || a == 1) ? 0.5 : 0;

}


m1=

25


Initialisieren der zweiten ÜbergangsmatrixDistributedMatrix<double> m2(4,4,&identmx,1,4);

Hilfsfunktion identmxdouble identmx(const int a, const int b) { return (a == b) ? 1 : 0;}

Kombinieren der Matrizenm1.zipWithInPlace(m2,&combine);

Hilfsfunktion combinedouble combine(const double a, const double b) { return ((a + b) / 2);}


m2=

m1=

26


Berechnung der Summe aller Werte der Ergebnismatrix

double sum = m1.fold(&add);

Hilfsfunktion adddouble add(const double a, const double b) {

return a + b;

}

Skelettbibliothek beendenTerminateSkeletons();


m1=

27

Implementierung (4/5)Vollständiger Quellcode (Teil 1)

#include "Skeleton.h"

double firsttwo(const int a, const int b, const double d) { return (a == 0 || a == 1) ? 0.5 : 0;}

double identmx(const int a, const int b) { return (a == b) ? 1 : 0;}

double combine(const double a, const double b) { return ((a + b) / 2);}

double add(const double a, const double b) { return a + b;}

(…)


28


int main(int argc, char **argv) {

InitSkeletons(argc, argv); // Initialisieren der Skelette DistributedMatrix<double> M1(4, 4, 1, 4); // Initialisieren der Matrizen M1.mapIndexInPlace(&firsttwo); DistributedMatrix<double> M2(4, 4, &identmx, 1, 4); M1.zipWithInPlace(M2, &combine); // Kombinieren der Matrizen

double sum = M1.fold(&add); // Summe der Werte bilden

TerminateSkeletons(); // Skelettbibliothek beenden}


Vollständiger Quellcode (Teil 2)

29

Gliederung

1. Motivation



4. Beispielprogramm


30

Bewertung (Positiv)

Abstraktion von Low-Level-ProgrammierungDeadlocks, Starvation, Synchronisation

Jedes Skelett als Funktion höherer Ordnung und als partielle Applikation verfügbar

Einheitliche Namensgebung bei Endungen-Index

-InPlace

Programmierer kann weiterhin sequentiell arbeiten

Nur noch Bereitstellen einer adäquaten problemspezifischen Funktion durch den Entwickler


31

Bewertung (Negativ)

Anzahl beteiligter Prozesse muss Potenz zur Basis 2 sein

Keine freie PartitionierungGröße der Partition muss Teiler der Größe der Datenstruktur sein

Anzahl der Partitionen muss gleich Anzahl der Prozesse sein

Alle Partitionen müssen gleich groß sein

Keine automatische Partitionierung

Mögliche Schwierigkeiten beim KompilierenGNU Compiler G++ 3.3.3

MPI 1.2.x


32

Zusammenfassung

Algorithmische SkeletteGerüst für die parallele Verarbeitung

Hohes Abstraktionsniveau

Effizient implementiert

Polymorphismus, Funktionen höherer Ordnung und partielle Applikationen

Nutzung wie bei sequentieller Programmierung möglich

MuesliKeine eigene Programmiersprache, sondern Bibliothek

Verteilte Datenstrukturen Array und Matrix

Konstruktoren und Hilfsfunktionen

Rechen- und Kommunikationsskelette

Bereitstellen einer adäquaten problemspezifischen Funktion durch den Entwickler


Seminar: Parallele und Verteilte Programmierung

Vielen Dank für eure Aufmerksamkeit!

34

PermutePartitionKommunikationsskelett

Ändert die Verteilung der Partitionen auf die ProzesseErwartet bijektive Funktionen als Parameter

4343

2121

4343

2121

ccdd

ccdd

bbaa

bbaa

43

21

aa

aa

43

21

bb

bb

43

21

cc

cc

43

21

dd

dd

43

21

aa

aa

43

21

bb

bb

43

21

cc

cc

43

21

dd

dd

4343

2121

4343

2121

ddcc

ddcc

aabb

aabb

P1

P2

P3

P4

permutePartition

35

Global vs. Lokal

Wahl zwischen der Betrachtungsweise des Problems

GlobalIndex der verteilten Datenstruktur

Geeignet für die Lösung eines Problems im Gesamtzusammenhang

LokalIndex der lokalen Partition

Geeignet für Optimierungen


44434241

34333231

24232221

14131211

xxxx

xxxx

xxxx

xxxx

1 2 3 4

2

1

2

1

4

3

2

1

1 21 2lokal

global

seminar: parallele und verteilte programmierung datenparallele algorithmische skelette in muesli...

Documents

die skelettbibliothek

motivation probleme

die anwendung kann

map funktion

funktionen und werten

matrix mit

muesli dominik pfeiffer

curry auf multx