Universität Karlsruhe (TH)

Transkript

1 Universität Karlsruhe (TH) Forschungsuniversität gegründet 1825 OpenMP-Programmierung Teil II Multikern-Praktikum Wintersemester 06-07

2 Inhalt Was ist OpenMP? Parallele Regionen Konstrukte zur Arbeitsteilung Sichtbarkeit / Schutz privater Daten Konstrukte zur Synchronisation Ablaufplanung bei Schleifen Andere nützliche Konstrukte Überlegungen zur Performanz Clauses / Directives- Zusammenfassung Umgebungsvariabeln 2

3 Beispiel: Skalarprodukt (1) float dot_prod(float* a, float* b, int N) { float sum = 0.0; #pragma omp parallel for shared(sum) for(int i=0; i<n; i++) { sum += a[i] * b[i]; return sum; Was ist falsch? 3

4 Beispiel: Skalarprodukt (2) Der Zugriff auf gemeinsam genutzte, veränderliche Daten muss geschützt werden: float dot_prod(float* a, float* b, int N) { float sum = 0.0; #pragma omp parallel for shared(sum) for(int i=0; i<n; i++) { #pragma omp critical sum += a[i] * b[i]; return sum; 4

5 kritische Abschnitte #pragma omp critical [(Name der Sperre)] definiert einen kritischen Abschnitt. Kontrollfäden müssen warten, bis sie an der Reihe sind. consum() wird immer nur von einem Faden gleichzeitig aufgerufen. Die Angabe eines Namens für die Sperre des kritischen Abschnitts ist optional. float RES; #pragma omp parallel { float B; #pragma omp for for(int i=0; i<niters; i++){ B = big_job(i); #pragma omp critical (RES_lock) consum (B, RES); 5

6 Single Direktive In einer parallelen Region kann Code vorkommen, der nur von einem Faden ausgeführt werden soll (z.b. für E/A-Operationen). Dieser Codebereich kann mit eine single-region eingeklammert werden. Es wird der erste Faden ausgewählt, der diese Stelle erreicht. Implizite Barriere am Ende (es sei, denn nowait wurde angegeben). #pragma omp parallel { DoManyThings(); #pragma omp single { ExchangeBoundaries(); // andere Fäden warten hier DoManyMoreThings(); 6

7 Master Direktive Markiert einen Code-Block, der nur vom Hauptfaden ausgeführt werden soll. Keine implizite Barriere am Ende. #pragma omp parallel { DoManyThings(); #pragma omp master { // springe weiter falls nicht Master ExchangeBoundaries(); DoManyMoreThings(); 7

8 Barriere Explizite Barrierensynchronisation. Jeder Faden wartet, bis alle anderen Fäden die Barriere erreichen. #pragma omp parallel shared (A, B, C) { DoSomeWork(A,B); printf( Processed A into B\n ); #pragma omp barrier DoSomeWork(B,C); printf( Processed B into C\n ); 8

9 Implizite Barrieren Einige OpenMP-Konstrukte beinhalten implizite Barrieren: parallel for single Unnötige Barrieren beeinträchtigen die Leistung Wartende Kontrollfäden erledigen keine Arbeit! Man kann unnötige Barrieren (auf eigene Gefahr!) mit der nowait Direktive unterdrücken. 9

10 Nowait Direktive #pragma omp for nowait for(...) {...; #pragma single nowait { [...] Verwendung beispielsweise wenn die Fäden zwischen unabhängigen Berechnungen warten müssten: #pragma omp for schedule(dynamic,1) nowait for(int i=0; i<n; i++) a[i] = bigfunc1(i); #pragma omp for schedule(dynamic,1) for(int j=0; j<m; j++) b[j] = bigfunc2(j); 10

11 Konditionale Schleifen Die for-schleife wird solange ausgeführt, bis die bestimmte Bedingung zutrifft: #pragma omp for schedule(dynamic,1) if (n>100) for(int i=0; i<n; i++) a[i] = bigfunc1(i); 11

12 Beispiel: for & nowait #include <omp.h> #define CHUNKSIZE 100 #define N 1000 main () { int i, chunk; float a[n], b[n], c[n]; /* Some initializations */ for (i=0; i < N; i++) a[i] = b[i] = i * 1.0; chunk = CHUNKSIZE; #pragma omp parallel shared(a,b,c,chunk) private(i) { #pragma omp for schedule(dynamic,chunk) nowait for (i=0; i < N; i++) c[i] = a[i] + b[i]; /* end of parallel section */ 12

13 Atomic Direktive Spezialfall eines kritischen Abschnitts. Wirkt nur für die eine einfache Aktualisierung einer Speicherstelle (d.h. eine Zuweisung). #pragma omp parallel for shared(x, y, index, n) for (i = 0; i < n; i++) { #pragma omp atomic x[index[i]] += work1(i); y[i] += work2(i); nur die (schreibenden) Zugriffe auf dasselbe Element von x[] werden serialisiert, Zugriffe auf unterschiedliche Elemente von x[] können weiterhin parallel ausgeführt werden. 13

14 Ordered Direktive zulässig nur innerhalb einer for-schleife ordered: Legt fest, dass die Reihenfolge der Ausführung der Iterationen des betreffenden Blocks die gleiche wie bei serieller Programmausführung sein muss Nur ein Thread kann jeweils den Code des mit ordered markierten Bereiches ausführen. In jeder Schleifeniteration wird der ordered Bereich nur einmal ausgeführt und es darf auch nur einen solchen Bereich geben Die Verwendung von #pragma omp ordered muss durch das Schlüsselwort ordered in #pragma omp for angekündigt werden: #pragma omp for ordered {...; 14

15 Flush Direktive Sorgt für eine konsistente Sicht auf den Speicher. Threadlokale Variablen und die ihnen zugeordneten Speicherbereiche haben danach identischen Inhalt. #pragma omp flush(list)newline Die FLUSH Direktive ist implizit in den folgenden Direktiven enthalten : barrier parallel - upon entry and exit critical - upon entry and exit ordered - upon entry and exit for - upon exit sections - upon exit single - upon exit Die Direktive ist nicht implizit falls NOWAIT verwendet wurde. 15

16 Inhalt Was ist OpenMP? Parallele Regionen Konstrukte zur Arbeitsteilung Sichtbarkeit / Schutz privater Daten Konstrukte zur Synchronisation Ablaufplanung bei Schleifen Andere nützliche Konstrukte Überlegungen zur Performanz Clauses / Directives- Zusammenfassung Umgebungsvariabeln 16

17 Aufteilung von Schleifendurchläufen (1) Mit der schedule Direktive kann festgelegt werden, wie die Iterationen auf die verfügbaren Kontrollfäden verteilt werden sollen. schedule(static [,chunk]) Weist reihum Blöcke von Iterationen (der Größe chunk ) zu. Round-robin Verteilung schedule(dynamic[,chunk]) Weist Blöcke der Größe chunk zu. Fäden fordern einen neuen Block an, wenn sie mit dem alten Block fertig sind schedule(guided[,chunk]) Dynamische Verteilung von Blöcken wie bei dynamic. Startet mit großen Blöcken, Blöcke werden immer kleiner, aber nicht kleiner als chunk 17

18 Aufteilung von Schleifendurchläufen (2) schedule(runtime) Verlagert die Entscheidung über die Verteilstrategie auf die Laufzeit Scheduling-typ und chunk werden während der Laufzeit spezifiziert (Umgebungsvariable: OMP_SCHEDULE) Beispiel: set OMP_SCHEDULE "guided, 4" Anwendung (in C/C++) nur auf parallel for 18

19 Beispiel :Ablaufplanung Schleifen-Scheduling: 19

20 Welche Strategie ist zu wählen? Ablaufstrategie Einsatz STATIC DYNAMIC GUIDED STATIC Weniger Overhead und bessere Datenlokalität DYNAMIC und GUIDED: Bessere Lastbalancierung Vorhersagbare, gleich verteilte Menge an Arbeit pro Durchlauf Unvorhersagbare, stark schwankend Menge an Arbeit pro Durchlauf Spezialfall von dynamic mit geringerem Overhead. 20

21 Beispiel für die Ablaufplanung #pragma omp parallel for schedule (static, 8) for( int i = start; i <= end; i += 2 ) { if ( TestForPrime(i) ) gprimesfound++; Schleifendurchläufe werden in Blöcken zu je acht Durchläufen verteilt. Wenn start = 3 ist, besteht der erste Block aus den Durchläufen für i={3,5,7,9,11,13,15,17. 21

22 Statische Verteilung ( von Hand ) Vorgegeben: Anzahl der Fäden (Nthrds) Nummer des jeweiligen Fadens (id) Berechnung der Start- und Endwerte der Iteration: #pragma omp parallel { int i, istart, iend; istart = id * N / Nthrds; iend = (id+1) * N / Nthrds; for(i=istart;i<iend;i++){ c[i] = a[i] + b[i]; Mit OpenMP ist eine solche händische Aufteilung normalerweise nicht nötig, aber möglich. 22

23 #include <omp.h> Beispiel: reduction & schedule main () { int i, n, chunk; float a[100], b[100], result; /* Some initializations */ n = 100; chunk = 10; result = 0.0; for (i=0; i < n; i++) { a[i] = i * 1.0; b[i] = i * 2.0; #pragma omp parallel for default(shared) private(i) schedule(static,chunk) \ reduction(+:result) for (i=0; i < n; i++) result = result + (a[i] * b[i]); printf("final result= %f\n",result); 23

24 Beispiel: Scheduling (Bubble Sort Performance) seconds no scheduling static static,100 static,1000 dynamic,100 dynamic,1000 guided, threads Rechner: Quad PIII Xeon (500Mhz 2 GB RAM) Source:

25 Parallele Abschnitte Unabhängige Code-Abschnitte können parallel ausgeführt werden. #pragma omp parallel sections { #pragma omp section phase1(); #pragma omp section phase2(); #pragma omp section phase3(); Seriell Parallel 25

26 Inhalt Was ist OpenMP? Parallele Regionen Konstrukte zur Arbeitsteilung Sichtbarkeit / Schutz privater Daten Konstrukte zur Synchronisation Ablaufplanung bei Schleifen Andere nützliche Konstrukte Überlegungen zur Performanz Clauses / Directives- Zusammenfassung Umgebungsvariabeln 26

27 Firstprivate Direktive Kennzeichnet private Variable, aber im Gegensatz zu private ist die Variable nicht uninitialisiert, sondern wird mit dem Wert der gemeinsamen Variable aus dem umgebenden Block initialisiert. C++ Objects werden mit dem Copy-Konstruktor erzeugt. incr=0; #pragma omp parallel for firstprivate(incr) for (I=0;I<=MAX;I++) { if ((I%2)==0) incr++; A(I)=incr; 27

28 Lastprivate Direktive Die gemeinsame (äußere) Variable wird mit dem Wert aus dem sequentiell letzten Schleifendurchlauf (letzter Iterationsindex) aktualisiert, wenn alle Fäden die Barriere erreicht haben. In C++ geschieht dies per Zuweisungsoperator. void sq2(int n, double *lastterm) { double x; int i; #pragma omp parallel #pragma omp for lastprivate(x) for (i = 0; i < n; i++){ x = a[i]*a[i] + b[i]*b[i]; b[i] = sqrt(x); lastterm = x; 28

29 Noch ein Beispiel zu lastprivate void a30 (int n, float *a, float *b) { int i; #pragma omp parallel { #pragma omp for lastprivate(i) for (i=0; i<n-1; i++) a[i] = b[i] + b[i+1]; a[i]=b[i]; /* i == n-1 here */ i verhält sich wie private, aber kopiert den Wert aus dem letzten Schleifendurchlauf. 29

30 Threadprivate Direktive Globale Lebensdauer für fadenlokale Variablen. Nur erlaubt für Variablen mit File- oder Namespace- Scope. Mittels copyin kann mit dem Wert der Variable im Hauptfaden initialisiert werden. struct Astruct A; #pragma omp threadprivate(a) #pragma omp parallel copyin(a) do_something_to(&a); #pragma omp parallel do_something_else_to(&a); Private Kopien von A bleiben zwischen den parallelen Regionen erhalten. 30

31 #include <omp.h> int a, b, i, tid; float x; Beispiel: Threadprivate #pragma omp threadprivate(a, x) main () { /* Explicitly turn off dynamic threads */ omp_set_dynamic(0); printf("1st Parallel Region:\n"); #pragma omp parallel private(b,tid) { tid = omp_get_thread_num(); a = tid; b = tid; x = 1.1 * tid +1.0; printf("thread %d: a,b,x= %d %d %f\n",tid,a,b,x); /* end of parallel section */ 31

32 Beispiel: Threadprivate printf("************************************\n"); printf("master thread doing serial work here\n"); printf("************************************\n"); printf("2nd Parallel Region:\n"); #pragma omp parallel private(tid) { tid = omp_get_thread_num(); printf("thread %d: a,b,x= %d %d %f\n",tid,a,b,x); /* end of parallel section */ 32

33 Beispiel: Threadprivate Output: 1st Parallel Region: Thread 0: a,b,x= Thread 2: a,b,x= Thread 3: a,b,x= Thread 1: a,b,x= ************************************ Master thread doing serial work here ************************************ 2nd Parallel Region: Thread 0: a,b,x= Thread 3: a,b,x= Thread 1: a,b,x= Thread 2: a,b,x=

34 OpenMP Bibliotheksfunktionen (1) Normalerweise für OpenMP Programme nicht benötigt. Kann zu Code führen, der nicht seriell konsistent ist. Sinnvoll z.b. bei der Fehlersuche. int omp_get_num_threads(void): Anzahl der parallelen Threads nur >1 in parallelen Abschnitten int omp_get_thread_num(void): gibt den Rang diese Threads zurück immer 0 für den Master Thread int omp_get_num_procs(void): Anzahl der CPUs, die dem Programm zur Verfügung stehen Einbinden der OpenMP Deklarationsdatei erforderlich: #include <omp.h> 34

35 OpenMP Bibliotheksfunktionen (2) OMP_SET_NUM_THREADS OMP_GET_NUM_THREADS OMP_GET_MAX_THREADS Gibt Maximum wert der Funktion OMP_GET_NUM_THREADS zurück OMP_GET_THREAD_NUM OMP_GET_NUM_PROCS OMP_IN_PARALLEL Bestimmt ob dieses Teil der Ausführende Code parallel ist oder nicht OMP_SET_DYNAMIC Aktiviert oder deaktiviert die dynamische Anpassung der Anzahl des Threads OMP_GET_DYNAMIC 35

36 OpenMP Bibliotheksfunktionen (3) OMP_SET_NESTED Aktiviert oder deaktiviert verschachtelte Parallelismus. OMP_GET_NESTED OMP_INIT_LOCK Initialisiert ein Lock assoziiert mit Lock Variable. Beispiel: void omp_init_lock (omp_lock_t *lock) OMP_DESTROY_LOCK OMP_SET_LOCK Die Ausführende Thread wartet (blockiert), bis das bestimmte lock verfügbar ist. 36

37 OpenMP Bibliotheksfunktionen (4) OMP_UNSET_LOCK : Das Lock wird von Thread freigegeben OMP_TEST_LOCK : Wie OMP_SET_LOCK, aber das Thread wird nicht blockiert falls das lock nicht verfügbar ist. OMP_GET_WTIME : Bietet portable Wall Clock timing routine (zeit zwischen zwei Punkten im Programm in double-precision floating point Format) #include <omp.h> double start; double end; start = omp_get_wtime();... work to be timed... end = omp_get_wtime(); printf("work took %f sec. time.\n", end-start); OMP_GET_WTICK : Zeit zwischen Processor clock ticks. 37

38 OpenMP Bibliotheksfunktionen (5) OMP_SET_NUM_THREADS OMP_GET_NUM_THREADS OMP_GET_MAX_THREADS OMP_GET_THREAD_NUM OMP_GET_NUM_PROCS OMP_IN_PARALLEL OMP_SET_DYNAMIC OMP_GET_DYNAMIC OMP_SET_NESTED OMP_GET_NESTED OMP_INIT_LOCK OMP_DESTROY_LOCK OMP_SET_LOCK OMP_UNSET_LOCK OMP_TEST_LOCK OMP_GET_WTIME OMP_GET_WTICK 38

39 Buckup Slides 39

40 Aufgabe 2: Bucket Sort Elements are distributed among bins : Then, elements are sorted within each bin