Parallele Programmierung

Transkript

1 Parallele Programmierung PThreads OpenMP MPI Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 1 PThread Programmierung Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 2 1

2 PThreads PThreads ist ein POSIX-Standard für Threads. Bietet Funktionen zur Verwaltung von Threads. Schnittstelle zu vielen sequentiellen Programmiersprachen. Besteht aus einer Bibliothek und Header-Dateien Header-Datei #include <pthread.h> Bibliothek libpthread.a Compiler-Aufruf gcc pthread file.c icl /pthreads file.c # GNU Compiler, Linux # Intel Compiler, Windows Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 3 PThread-Bibliothek Erzeugen eines POSIX Threads int pthread_create (pthread_t *thread_id, const pthread_attr_t *attributes, void *(*thread_function)(void *), void *arguments); Terminieren eines POSIX Threads nach dem Rückkehr aus der Funktion durch Aufruf der Rückkehrfunktion int pthread_exit (void *status); Warten auf Terminierung eines Threads int pthread_join (pthread_t thread, void **status_ptr); Rückgabe der Identität des Threads pthread_t pthread_self (); Vergleich von Thread-Ids int pthread (pthread_t t1, pthread_t t2); Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 4 2

3 Beispiel: POSIX Threads /* Zuerst wird die Pthread-Bibliothek eingebunden */ #include <pthread.h>... /* Definiton der Thread-Routine */ void *routine(void *arg) { printf("hello World!\n"); pthread_exit ((void *) 0); }... int main() { /* Definition der benötigten Variablen */ pthread_t thread; pthread_attr_t attr = NULL;... /* Endlich der Aufruf */ err = pthread_create (&thread, attr, routine, (void *)arg); if (err) { printf ("FEHLER! pthread_create() : %d\n", err); exit(-1); } } Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 5 PThreads: Join 1 #include <pthread.h> 2 #include <stdio.h> 3 #define NUM_THREADS /* Thread-Routine */ 6 void *routine(void *arg) { 7 sleep(1); 8 printf("thread Nummer: %d.\n", arg); 9 pthread_exit ((void *) 0); 10 } int main() { 13 /* Definition der Variablen */ 14 pthread_t thread[num_threads]; 15 pthread_attr_t attr; 16 int i, status, err; /* set detach status to JOINABLE */ 19 pthread_attr_init (&attr); 20 pthread_attr_setdetachstate (&attr, 21 PTHREAD_CREATE_JOINABLE); 22 /* Starte alle Threads */ 23 for(i=0; i < NUM_THREADS; i++) { 24 err = pthread_create (&thread[i], &attr, 25 routine, (void *) (i+1)); 26 if (err) printf("(main) ERROR - Creation failed...\n"); 27 } /* Join mit allen Threads */ 31 for(i=0; i < NUM_THREADS; i++) { 32 err = pthread_join (thread[i], (void **)&status); 33 if (err) printf("(main) ERROR - No join...\n"); 34 } 35 printf("alle Threads sind erfolgreich durchgelaufen!\n"); 36 } Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 6 3

4 Problem: Synchronisation Anforderung: Geregelter und sicherer Zugriff auf Daten und Methoden, die von mehreren Threads genutzt werden. Beispiel: Thread1 Bank.account Thread2 Wert auslesen dazu addieren 0 Wert auslesen 300 zurückschreiben dazu addieren Zeit 400? 400 zurückschreiben Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 7 Mutex unter POSIX Threads Mutex hat zwei grundlegende Funktionen. Lock: ist Mutex frei, dann belegt der Thread den Mutex ist Mutex belegt, dann blockiert der Thread bis der Mutex frei wird Unlock: gibt Mutex frei Initialisierung int pthread_mutex_init (pthread_mutex_t *mut, const pthread_mutexattr_t *attr); Destruktion int pthread_mutex_destroy (pthread_mutex_t *mut); Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 8 4

5 Mutex Lock int pthread_mutex_lock (pthread_mutex_t *mut); Unlock int pthread_mutex_unlock (pthread_mutex_t *mut); Mutex Test int pthread_mutex_trylock (pthread_mutex_t *mut); falls Mutex frei, belege den Mutex, andernfalls gebe Wert EBUSY zurück Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 9 1 #include <pthread.h> 2 3 /* define Mutex-variable */ 4 pthread_mutex_t mutex_sum = 5 PTHREAD_MUTEX_INITIALIZER; 6 int sum = 100; 7 8 void *minus(void *arg) { 9 int i = 0; for(i=0; i < ; i++) { 12 pthread_mutex_lock (&mutex_sum); 13 random(); 14 sum = sum - 1; 15 pthread_mutex_unlock (&mutex_sum); 16 } 17 } void *plus(void *arg) { 20 int i = 0; for(i=0; i < ; i++) { 23 pthread_mutex_lock (&mutex_sum); 24 random(); 25 sum = sum + 1; 26 pthread_mutex_unlock (&mutex_sum); 27 } 28 } PThreads: Mutex 29 int main() { 30 // Definition der Variablen 31 pthread_t thread[2]; 32 pthread_attr_t attr; 33 int i, status, err; pthread_attr_init (&attr); 36 pthread_attr_setdetachstate (&attr, 37 PTHREAD_CREATE_JOINABLE); /* start threads */ 40 pthread_create (&thread[0], &attr, minus, 41 (void *) NULL); 42 pthread_create (&thread[1], &attr, plus, 43 (void *) NULL); 44 /* Warte auf beide Threads */ 45 for(i=0; i < 2; i++) { 46 err = pthread_join (thread[i], (void **)&status); 47 if (err) printf("no join...\n"); 48 } 49 printf("summe : %d\n",sum); 50 } Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 10 5

6 Conditions Wie kann die Nutzung von Mutex-Variablen gesteuert werden? Signalisierung von Ereignissen Problem: Blockierendes Warten und anschließendes Wecken Lösung: Condition-Variables Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 11 Beispiel Thread 1 pthread_mutex_lock(&m1); pthread_mutex_lock(&m2); pthread_mutex_unlock(&m2); pthread_mutex_unlock(&m1); Thread 2 for (; ;) { pthread_mutex_lock(&m2); if(pthread_mutex_trylock(&m1)==0) /* got it! */ break; /* didn't get it */ pthread_mutex_unlock(&m2); } /* get locks; no processing */ pthread_mutex_unlock(&m1); pthread_mutex_unlock(&m2); Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 12 6

7 Condition Variablen (1) Initialisierung int pthread_cond_init (pthread_cond_t *cond, pthread_condattr_t *attr); Destruktion int pthread_cond_destroy (pthread_cond_t *cond); Warten int pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mut); blockierendes Warten mit Freigabe des Mutex Signalisierung int pthread_cond_signal (pthread_cond_t *cond); mindestens einen Thread aufwecken und nachfolgende Mutex- Aquirierung Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 13 Condition Variablen (2) Broadcast Signalisierung int pthread_cond_broadcast (pthread_cond_t *cond); alle Threads aufwecken mit nachfolgender Mutex-Aquirierung Warten mit Time-Out int pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mut, const struct timespec *abstime); identisch zu pthread_cond_wait(), mit Zeitschranke Rückgabe von ETIMEDOUT falls Zeitschranke überschritten struct timespec to { time_t tv_sec; long tv_nsec; }; Erzeugen / Entfernen int pthread_cond_init (pthread_cond_t *cond, pthread_condattr_t *attr); oder statisch, phtread_cond_t cond = PTHREAD_COND_INITIALIZER; int pthread_cond_destroy (pthread_cond_t *cond); Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 14 7

8 Beispiel: Condition Variable (1) 1 #include <pthread.h> 2 #define NUM_THREADS pthread_mutex_t mutex; 5 pthread_cond_t cond; 6 7 /* Eine Kondition für jeden Thread */ 8 /* 0 : starten */ 9 /* 1 : stoppen */ 10 int flag[num_threads]; void *work(void *arg) { 13 int id = (int) arg; 14 int sum, i; /* Mutex Variable sperren */ 17 pthread_mutex_lock (&mutex); 18 /* In einer Schleife wird jetzt geprüft, */ 19 /* ob der Thread laufen darf */ 20 while (flag[id]) { 21 printf("(thread %d) Muss noch warten...\n", id); 22 pthread_cond_wait (&cond, &mutex); 23 } pthread_mutex_unlock (&mutex); printf("(thread %d) Jetzt geht's los!\n", id); /* Hier würde im Normalfall die eigentliche */ 30 /* Threadfunktion stehen; eine Schleife tut's auch. */ 31 for(i=0; i < 10000; i++) { 32 sum = sum + (int) (100*random()); 33 } pthread_exit (NULL); 36 } Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon int main() { Beispiel: Condition Variable(2) 38 /* Definition der Variablen */ 39 pthread_t thread[num_threads]; 40 pthread_attr_t attr; int i, status, err; for(i=0; i < NUM_THREADS; i++) 45 flag[i] = 1; pthread_attr_init (&attr); 48 pthread_attr_setdetachstate (&attr, 49 PTHREAD_CREATE_JOINABLE); pthread_mutex_init (&mutex, NULL); 52 pthread_cond_init (&cond, NULL); for(i=0; i < NUM_THREADS; i++) { 55 pthread_create (&thread[i], &attr, 56 work, (void *) i); 57 } 58 /* Alle Threads sind hochgefahren und warten */ 59 printf("(main) Sende das Signal\n"); 60 /* Sende das Signal, dass die Threads starten können */ 61 pthread_mutex_lock (&mutex); 62 for(i=0; i < NUM_THREADS; i++) 63 flag[i] = 0; /* Wecke sie auf */ 66 pthread_cond_broadcast (&cond); 67 pthread_mutex_unlock (&mutex); /* Warte auf alle Threads */ 70 for(i=0; i < NUM_THREADS; i++) { 71 err = pthread_join (thread[i], (void **)&status); 72 if (err) printf("(main) ERROR - No join...\n"); 73 } /* Aufräumen */ 76 pthread_attr_destroy (&attr); 77 pthread_mutex_destroy (&mutex); 78 pthread_cond_destroy (&cond); pthread_exit (NULL); 81 } Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 16 8

9 Wechselseitiger Ausschluss und Synchronisation Mutex Das Mutex wird verwendet für den wechselseitigen Ausschluss. Der Konstruktor von mutex initialisiert das binäre Semaphor automatisch auf unlocked. Mit lock versucht man in den kritischen Abschnitt einzutreten, mit unlock verlässt man diesen. Condition Variable Eine Condition Variable ist immer mit mindestens einem Mutex verbunden. Die Wait Operation gibt das Mutex frei und blockiert die Aktivität. Die Wait Operation kann nicht unterbrochen werden. Die Signal Operation hat nur eine Auswirkung, falls mindestens eine Aktivität blockiert ist: in diesem Falle wird mindestens eine Aktivität aufgeweckt. Die Broadcast Operation funktioniert wie Signal außer, dass alle blockierten Aktivitäten aufgeweckt werden. Sobald eine auf Wait blockierte Aktivität aufgeweckt wird, so wird von dieser erneut die Lock Operation auf dem Mutex ausgeführt und fährt anschließend mit seiner Arbeit fort. Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 17 OpenMP Programmierung Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 18 9

10 Was ist OpenMP? OpenMP (Open Multi Processing) ist ein Standard für die Realisierung des Shared-Memory Programmiermodells compilerbasiert eine Erweiterung bestehender Programmiersprachen durch Direktiven für den Compiler einige wenige Bibliotheksroutinen Umgebungsvariablen (z.b. Anzahl Prozesse, Umgebungsvariablen) Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 19 Möglichkeiten von OpenMP OpenMP bietet Portabilität auf Shared-Memory Architekturen Skalierbarkeit inkrementelle Parallelisierung Unterstützt Daten-Parallelisierung Erweiterungen für FORTRAN und C/C++ Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 20 10

11 Quellen zu OpenMP R. Chandra et al.: Parallel Programming in OpenMP, Academic Press 2001, ISBN Intel Compiler (Linux non commercial use) icc openmp file.c # Linux x86 ecc openmp file.c # Linux x86-64 Icl /openmp file.c # Windows Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 21 OpenMP Programming Modell OpenMP basiert auf dem Shared-Memory Modell Die Arbeitslast wird zwischen Threads verteilt Variablen können gemeinsam (shared) für alle Threads sein für jeden Thread dupliziert werden (private Nutzung) Threads kommunizieren durch gemeinsame Variablen Unbeabsichtigt gemeinsame Variablen können zu sogenannten race conditions führen: race condition: Das Ergebnis des Programms ändert sich, wenn sich das Laufzeitverhalten (scheduling) der Threads ändert Kontrolle von race conditions durch Synchronisierung, um Datenkonflikte zu vermeiden Nachlässige Verwendung von Synchronisierungsanweisungen kann zu dead locks führen Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 22 11

12 Umgebungsvariablen OMP_NUM_THREADS gibt die Anzahl der Threads während des Programmlaufs an ist die dynamische Anpassung der Anzahl der Threads aktiviert, so gibt sie die Zahl maximal verfügbarer Threads an setenv OMP_NUM_THREADS 4 OMP_SCHEDULE betrifft nur die for-schleife und parallelen for Direktiven die den Scheduling Type RUNTIME haben setzt den Scheduling Typ und die chunk size aller Schleifen setenv OMP_SCHEDULE GUIDED, 4 Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 23 OpenMP Direktiven #pragma Direktiven Format: #pragma omp directive_name [clause [[,] [clause],..] Unterscheidung von Gross- und Kleinbuchstaben bedingte Compilation #ifdef _OPENMP block #endif Include-File für Bibliotheksroutinen: #include <omp.h> Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 24 12

13 OpenMP Laufzeitbibliothek Benutzerfunktionen der Laufzeitbibliothek Anzahl der Threads numthreads = omp_get_num_threads(); Identifikation eines Threads myid = omp_get_thread_num(); Systemfunktionen der Laufzeitbibliothek Thread-Verwaltung starten, halten, stoppen, Thread-Steuerung Scheduling, Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 25 Parallele Region Block des Programms, der durch mehrere Threads parallel ausgeführt werden soll. Jeder Thread führt denselben Code aus C/C++: #pragma omp parallel [clause [clause].. ] new line structured block Clause kann eine der folgenden sein: private (list) shared (list) reduction (operator,list) - Reduktion auf den Variablen schedule (type [, chunk]) - Aufteilung der Itertionen auf Threads nowait - Thread nicht am Schleifenende synch Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 26 13

14 Beispiel: OpenMP hello #include <stdio.h> # ifdef _OPENMP # include <omp.h> # endif int main(int argc, char** argv) { int myid, numthreads; myid = -1; numthreads = 0; #pragma omp parallel private(myid) { # ifdef _OPENMP myid = omp_get_thread_num(); numthreads = omp_get_num_threads(); # endif printf("hello, world says thread %d of %d threads.\n", myid, numthreads); /* end omp parallel */ } return 0; } Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 27 Fork-and-Join-Modell (1) Fork-Join Modell dient der parallelen Ausführung Begin der Ausführung mit einem einzigen Prozess (master process) paralleles Konstrukt geht aus Master Prozess hervor Start: Master Thread erzeugt Team von Threads Abschluss: Die Threads des Teams werden synchronisiert (implizite Barriere) Nur der Master Thread fährt mit der Ausführung fort Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 28 14

15 Data Scope Clauses private (list) erklärt die Variablen in der Liste list zu privaten Variablen der einzelnen Threads des Teams shared (list) erklärt die Variablen in der Liste list zu gemeinsamen Variablen aller Threads des Teams ohne explizite Vereinbarung: Default shared aber Stack- (lokale) Variablen in einem aufgerufenen Unterprogramm sind private die Schleifenvariable der parallelen for-schleife ist private Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 29 OpenMP-Beispiel: Berechnung von Pi 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <math.h> 4 #include <omp.h> 5 6 #define PI L 7 8 double f(double a) { 9 return (double)4.0/((double)1.0+(a*a)); 10 } int main(int argc, char *argv[]) 13 { 14 long n, i; 15 double h, pi, sum, x; 16 for (;;) { 17 printf("enter the number of intervals: (0 quits) "); 18 scanf("%u",&n); 19 if (n==0) 20 break; 21 h = ((double)1.0)/(double)n; 22 sum = 0.0; #pragma omp parallel for private(i,x) reduction(+:sum) 25 for(i=1;i<=n;i++) { /* parallel loop */ 26 x = h*((double)i-(double)0.5); 27 sum += f(x); 28 } 29 /* end omp parallel for */ pi = h*sum; 32 printf("pi is approximatly: %.16f Error is: %.16f\n", 33 pi, fabs(pi-pi)); 34 } return EXIT_SUCCESS; 37} Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 30 15

16 Weitere Direktiven critical Direktive Beschränkung des Zugriffs auf den eingeschlossenen Code auf nur einen Thread zur selben Zeit #pragma omp critical [ (name) ] structured block Jeder Thread wartet am Anfang einer critical-region bis kein anderer Thread des Teams die Region dieses Namens ausführt. Alle unbenannten Regionen critical-anweisungen zeigen auf den selben unspezifizeirten Namen parallel for Direktive Parallele Region mit nur einer einzigen parallelen for-schleife #pragma omp parallel for [ clause [[,] clause] ] for loop Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 31 Weitere Direktiven single Direktive Ausführung eines Teils einer parallelen Region durch nur einen zwar den schnellsten Thread: #pragma omp single structured block barrier Direktive Synchronisation innerhalb einer parallelen Region #pragma omp barrier sections Direktive Synchronisation innerhalb einer parallelen Region Verteilt unabhängige Programmteile auf Threads #pragma omp sections [ clause [[,] clause] ] { structured block 1 structured block 2 } Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 32 16

17 MPI Programmierung Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 33 Punkt zu Punkt Senden und Empfangen Message-Passing Mechanismus Erzeugung von Prozessen. Übertragung einer Nachricht zwischen den Prozessen durch send() und recv() Funktionen. Prozess 1 Object x;.. send (&x, 2);... Datentransfer Prozess 2 Object y;.. recv (&y, 1);... Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 34 17

18 Message Passing Interface (MPI) Bibliothek (C, C++, Fortran) für den Austausch von Nachrichten zwischen Prozessen. Prozesse werden statisch allokiert und mit 0,...,N-1 nummeriert. Jeder Prozess startet das gleiche Programm (Single Program Multiple Data - SPMD). Stellt Funktionen und Datentypen beginnend mit MPI_ bereit. (logische) Topologie: Clique Jeder Prozessor kann direkt mit jedem anderen kommunizieren Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 35 SPMD Ausführungsmodell Single Program Multiple Data (SPMD) lässt sich aber auch erweitern: #include <mpi.h> main (int argc, char *argv[]) { MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, & myrank); /* find process rank */ if (myrank == 0) master(); else slave();... MPI_Finalize(); } Dabei sind master() und slave() Funktionen die durch einen Master- und ggf. mehrere Slave-Prozesse ausgeführt werden sollen. Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 36 18

19 Basisroutinen MPI_Init(int *,char ***); Startet MPI. Muss erste MPI-Routine sein, die aufgerufen wird MPI_Finalize(); Beendet MPI und schließt die Kommunikationskanäle. MPI_Comm_rank( MPI_Comm, int *) Eigene Prozessnummer innerhalb des Kommunikators. Menge von MPI-Prozessen, die Nachrichten austauschen können. MPI_COMM_WORLD alle Prozesse MPI_Comm_size( MPI_Comm, int *) Anzahl der Prozesse innerhalb des Kommunikators. Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 37 Basisroutinen MPI_Send(void *, int, MPI_Datatype, int, int, MPI_Comm); Zeiger auf Message- s. Tab. Ziel- Tag s.o. Message länge pro- Im Speicher zess(or) MPI_Datatype C-Datentyp MPI_CHAR char MPI_SHORT short MPI_INT int MPI_LONG long MPI_UNSIGNED_CHAR (unsigned) char MPI_UNSIGNED_SHORT unsogned short MPI_UNSIGNED unsigned int MPI_UNSIGNED_LONG unsigned long MPI_FLOAT float MPI_DOUBLE double MPI_DOUBLE_LONG long double MPI_BYTE - MPI_PACKED - Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 38 19

20 Basisroutinen MPI_Recv(void *, int, MPI_Datatype, int, int, MPI_Comm, MPI_Status*); Zeiger auf Buffer- s. Tab. Tag s.o. Status der Message größe Sender Empfangs- Im Speicher operation MPI_ANY_SOURCE + MPI_ANY_TAG sind Wildcarts Tag und Communicator des MPI_Send und MPI_Recv müssen übereinstimmen MPI_Status enthält u.a.: status MPI_SOURCE (Sender der Nachricht) status MPI_TAG (Message-Tag) status MPI_ERROR (0, falls kein Fehler) MPI_Send/MPI_Recv blockiert (eventuell!) Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 39 Kommunikationsmethoden buffernd bzw. nicht buffernd buffernd: Nachricht wird (beim Sender) zwischengespeichert synchron bzw. nicht synchron synchron: Programmflusskontrolle wird nicht zurückgegeben, bis die zu sendende Nachricht angekommen ist. blockierend bzw. nicht blockierend blockierend: Programmflusskontrolle wird nicht zurückgegeben, bis die zu sendende Nachricht gesichert ist, d.h. entweder beim Empfänger angekommen, oder in einem Systembuffer zwischengespeichert ist. User-Speicher ist danach wieder frei. Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 40 20

21 Send Kommunikationsmodi (1) Standard Mode Send passendes Recv muss nicht vor Send ausgeführt werden. Größe des Buffers nicht im MPI-Standard definiert. Falls Buffer genutzt, kann das Send beendet werden bevor das passende Recv erreicht ist. Buffered Mode Send kann vor dem passenden Recv starten und beenden. Speicher für Buffer muss explizit allokiert werden MPI_Buffer_attach(). Synchronous Mode Send und Recv können beliebig starten, beenden aber gemeinsam. Ready Mode Send kann nur starten, wenn passendes Recv bereits erreicht wurde. Ansonsten kommt eine Fehlermeldung zurück. Muss mit Vorsicht eingesetzt werden. Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 41 Send Kommunikationsmodi (2) Alle vier Modi können mit einem blocking oder non-blocking Send kombiniert werden. Nur der Standardmodus ist für das blocking und nonblocking Recv möglich. Jeder Send Typ kann mit jedem Recv Typ matchen. Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 42 21

22 Beispiel: Blockierendes Senden Blockierendes Senden eines Werts x von Prozess 0 zu Prozess 1 int myrank; int msgtag = 4711; int x;... MPI_Comm_rank (MPI_COMM_WORLD, & myrank); /* find process rank */ if (myrank == 0) MPI_Send (&x, 1, MPI_INT, 1, msgtag, MPI_COMM_WORLD); else if (myrank == 1) { int status; int x; MPI_Recv (&x, 1, MPI_INT, 0, msgtag, MPI_COMM_WORLD, status); } Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 43 Non-Blocking Routinen Non-blocking Send: MPI_Isend(buf, count, datatype, dest, tag, comm, request) Kommt sofort zurück, auch wenn die zu versendenden Daten noch nicht geändert werden dürfen. Non-blocking Receive: MPI_Irecv(buf, count, datatype, dest, tag, comm, request) Kommt sofort zurück, auch wenn noch keine Daten vorliegen Beendigung durch MPI_Wait() und MPI_Test() erkennen MPI_Waits() wartet bis Operation beendet ist und kehrt danach zurück. MPI_Test() kommt sofort mit dem Zustand der Send- / Recvroutine (beendet bzw. nicht-beendet) zurück Dafür muss der request Parameter verwendet werden Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 44 22

23 Beispiel: Nichtblockierendes Senden Nichtblockierendes Senden eines Werts x von Prozess 0 zu Prozess 1, wobei Prozess 0 mit Ausführung unmittelbar fortfahren kann. int myrank; int msgtag = 4711; MPI_Comm_rank (MPI_COMM_WORLD, & myrank); /* find process rank */ if (myrank == 0) { int status; int x; MPI_Isend (&x, 1, MPI_INT, 1, msgtag, MPI_COMM_WORLD, req1); compute(); MPI_Wait (req1, status); } else if (myrank == 1) { int status; int x; MPI_Recv (&x, 1, MPI_INT, 0, msgtag, MPI_COMM_WORLD, status); }... Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 45 Kollektive Kommunikation Kommunikation innerhalb einer Gruppe aus Prozessen. Keine Message-Tags verwendet. Broadcast- und Scatter-Routinen MPI_Bcast() - Broadcast from root to all other processes MPI_Gather() - Gather values for group of processes MPI_Scatter() - Scatters buffer in parts to group of processes MPI_Alltoall() - Sends data from all processes to all processes MPI_Reduce() - Combine values on all processes to single value MPI_Reduce_Scatter() - Combine values and scatter results MPI_Scan() - Compute prefix reductions of data on processes Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 46 23

24 Kollektive Kommunikation Vorher Nachher root B MPI_BCAST B B B B root A B C D MPI_SCATTER A B C D A B C D MPI_GATHER root A B C D A B C D A B C D MPI_ALLGATHER A B C D A B C D A B C D A B C D A B C D A B C D A B C D E F G H I J K L M N O P MPI_ALLTOALL A B C D E F G H I J K L M N O P A E I M B F J N C G K O D H L P RANK Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 47 Beispiel: MPI_Gather Beachte, dass MPI_Gather von allen Prozessen inkl. Root aufgerufen werden muss! int data[10]; (* data to be gathered from processes */ MPI_Comm_rank (MPI_COMM_WORLD, & myrank); /* find process rank */ if (myrank == 0) { MPI_Comm_Size(MPI_COMM_WORLD, &grp_size); buf = (int*)malloc(grp_size*10*sizeof(int)); /* allocate memory /* } MPI_Gather (data, 10, MPI_INT, buf, grp_size*10, MPI_INT, 0, MPI_COM_WORLD);... Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 48 24

25 Einseitige Kommunikation Verfügbar in MPI Version 2 Remote Memory Access, put + get Operationen Initialisierungen MPI_Alloc_mem, MPI_Free_mem MPI_Win_create, MPI_Win_free Kommunikationsroutine MPI_Put MPI_Get MPI_Accumulate Synchronizationen MPI_Win_fence MPI_Win_post, MPI_Win_start, MPI_Win_complete, MPI_Win_wait MPI_Win_lock, MPI_Win_unlock Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 49 Message-Passing-Modell Pro s: Programmierer bestimmt Datenund Arbeitsverteilung Eindeutigkeit der Lokalität Con s: Relativ hoher Kommunikationsaufwand bei kleinen Nachrichten Nicht einfach anwendbar Übung: Architektur Paralleler Rechnersysteme WS08/09 J.Simon 50 25