Parallele Programmierung mit OpenMP

Transkript

1 Parallele Programmierung mit OpenMP Wolfgang Dautermann FH Joanneum Chemnitzer Linuxtage 2009

2 1 Motivation 2 OpenMP Übersicht 3 Hello World - der erste Code 4 OpenMP-Compilerdirektiven Threaderzeugung Lastverteilung auf mehrere Threads Gültigkeitsbereiche von Daten Gemeinsam an einem Gesamtergebnis arbeiten Synchronisation 5 OpenMP Funktionen 6 Umgebungsvariablen 7 Compiler, die OpenMP unterstützen 8 Praktische Vorführung

3 Parallelisieren wozu? Eine CPU immer schneller machen, gelingt heute nicht mehr, stattdessen werden Dual- und Quadcore CPUs in die Rechner (inzwischen auch in handelsübliche PCs/Laptops) eingebaut. Normalerweise nutzt Software aber nur eine CPU - v.a. bei rechenintensiven Aufgaben eine Verschwendung. Software wird standardmässig Step-by-Step abgearbeitet muss daher parallelisiert werden.

4 Parallelisierungsmethoden Distributed Memory mehrere einzelne Rechner in einem Cluster. (Message Passing Interface (MPI)) Shared Memory mehrere CPUs in einem Rechner, die auf einen gemeinsamen Speicher zugreifen können (OpenMP, POSIX Threads) Implizit automatisch durch den Compiler, keine speziellen Anweisungen, Funktionen, etc. notwendig. Explizit macht der Programmierer durch spezielle Anweisungen, Funktionen, etc.

5 OpenMP - Übersicht Explizite shared Memory Parallelisierung Erweiterung für existierende Programmiersprachen (C/C++/Fortran) Hauptsächlich über Compiler Direktiven Einige wenige Library-Funktionen Inkrementelle Parallelisierung (Parallelisierung eines existierenden seriellen Programms). Schwerpunkt: Parallelisierung von Loops.

6 OpenMP Fork-Join Ausführungsmodell Abbildung: Fork-join Modell von OpenMP 1 1 Grafik von Wikipedia

7 OpenMP Architecture Review Board (... von der OpenMP Homepage) The OpenMP Architecture Review Board or the OpenMP ARB or just the ARB, is the non-profit corporation that owns the OpenMP brand, oversees the OpenMP specification and produces and approves new versions of the specification. Etliche Firmen sind darin vertreten herstellerunabhängiger Standard zur Parallelprogrammierung Permanent Members of the ARB: AMD, Cray, Fujitsu, HP, IBM, Intel,Microsoft, NEC, The Portland Group, SGI, Sun Auxiliary Members of the ARB: ASC/LLNL, compunity, EPCC, NASA, RWTH Aachen

8 Ein Hello World Programm mit OpenMP (C) # ifdef _OPENMP # include <omp.h> # endif # include <stdio.h> int main ( void ) { int i; # pragma omp parallel for for ( i = 0; i < 4; ++ i) { int id = omp_ get_ thread_ num (); printf (" Hello World von thread %d\n", id ); if (id ==0) printf ("Es gibt %d threads \n", omp_get_num_threads ()); } return 0; }

9 Ein Hello World Programm mit OpenMP (Fortran) PROGRAM HELLO USE omp_ lib INTEGER ID, NTHRDS, I C $OMP PARALLEL DO PRIVATE (ID,I, NTHRDS ) DO I=1,4 ID = OMP_ GET_ THREAD_ NUM () PRINT *, HELLO WORLD VON THREAD, ID IF ( ID. EQ. 0 ) THEN NTHRDS = OMP_ GET_ NUM_ THREADS () PRINT *, Es GIBT, NTHRDS, THREADS END IF END DO C $OMP END PARALLEL DO END

10 Compilerdirektiven OpenMP wird hauptsächlich über Compilerdirektiven definiert. Direktivenformat in C/C++ # pragma omp direktivenname [ klauseln...] Direktivenformat in Fortran C234567! $OMP direktivenname [ klauseln...] [! Kommentar ] (in Fortran sind auch andere Sentinels erlaubt 2 (C$OMP, *$OMP). 2 nur in fixed source form

11 Compilerdirektiven II für nicht OpenMP-fähige Fortran Compiler erscheinen diese Direktiven als Kommentar. nicht OpenMP-fähige C-Compiler ignorieren unbekannte Direktiven: $ gcc - Wall test. c # ( alte gcc Version ( < 4. 2)) test.c: In function main : test. c : 12: warning : ignoring # pragma omp parallel $ Werden OpenMP Compilerdirektiven in ein Programm eingefügt werden, kann das Programm weiterhin von jedem (auch nicht OpenMP-fähigen) Compiler compiliert werden.

12 Bedingte Compilierung C/C++: Das Makro _OPENMP wird definiert. # ifdef _ OPENMP /* Openmp spezifischer Code, z.b. */ nummer = omp_ get_ thread_ num () ; # endif Fortran: OpenMP erlaubt die bedingte Compilierung in Fortran. C234567! $ NUMMER = OMP_ GET_ THREAD_ NUM () Erscheint als Kommentar, wenn OpenMP nicht aktiviert ist (bzw. bei einem nicht OpenMP-fähigen Compiler), wird normal compiliert, wenn OpenMP aktiviert ist.

13 omp parallel Erzeugen zusätzlicher Threads, die Arbeit wird von allen Threads ausgeführt. Der originale Thread (master thread) bekommt die Thread ID 0. C/C++: # pragma omp parallel [ klauseln ] /* strukturierter Block ( keine gotos...) */ Fortran:! $OMP PARALLEL [ klauseln ] block! $OMP END PARALLEL

14 Arbeitsaufteilung zwischen den Threads I Loops: omp for (C/C++) Die Arbeit wird unter den Threads aufgeteilt (Beispiel: bei zwei Threads bearbeitet einer die Schleife 3 von 1 ( N 2 1), der zweite von N 2 N)4 # pragma omp parallel [ klauseln...] # pragma omp for [ klauseln...] for (i =0;i<N;i ++) a[i]= i*i; Dies kann auch zusammengefasst werden (omp parallel for): # pragma omp parallel for [ klauseln...] for (i =0;i<N;i ++) a[i]= i*i; 3 Bei OpenMP 2.5 muß die Schleifenvariable vom Typ int sein. 4 Das Verhalten kann durch Verwendung der schedule()-klausel (static, dynamic, guided, runtime) beeinflusst werden...

15 Arbeitsaufteilung zwischen den Threads I Loops: omp do (Fortran) Die Arbeit von DO-Loops wird von allen Threads gemeinsam bearbeitet.! $OMP PARALLEL [ klauseln...]! $OMP DO [ klauseln...] DO I=1,N A(I) = I*I END DO! $OMP END DO! $OMP END PARALLEL Auch hier wieder möglich:! $OMP PARALLEL DO [ klauseln...] [...]! $OMP END PARALLEL DO!$OMP PARALLEL i=1 i=2 i=3 i=4!$omp DO i=5 i=6 i=7 i=8!$omp END DO i=9 i=10 i=11 i=12!$omp END PARALLEL (implizite) Barrier Abbildung: (par.) DO Schleife

16 Arbeitsaufteilung zwischen den Threads II Parallele Sections (C/C++) Die Arbeit wird unter den Threads aufgeteilt. Jeder bearbeitet eine Section. # pragma omp parallel [ klauseln...] # pragma omp sections [ klauseln...] { # pragma omp section [... Programmteil A läuft parallel zu B...] # pragma omp section [... Programmteil B läuft parallel zu A...] } Auch hier kann man das kombinieren: # pragma omp parallel sections [ klauseln...]

17 Arbeitsaufteilung zwischen den Threads II Parallele Sections (Fortran) Die Arbeit wird unter den Threads aufgeteilt. Jeder bearbeitet eine Section.! $OMP PARALLEL [ klauseln...]! $OMP SECTIONS [ klauseln...]! $OMP SECTION [... Programmteil A läuft parallel zu B...]! $OMP SECTION [... Programmteil B läuft parallel zu A...]! $OMP END SECTIONS! $OMP END PARALLEL Auch hier kann man das kombinieren:! $OMP PARALLEL SECTIONS [ klauseln...]

18 Arbeitsaufteilung zwischen den Threads III Parallel Workshare (nur Fortran) Für Operationen mit Arrays, z.b. REAL, DIMENSION (100,100) :: A, B, C [...]! $OMP PARALLEL WORKSHARE A = B + C! $OMP END PARALLEL WORKSHARE

19 Gültigkeitsbereiche von Daten - shared(), private(),... Achtung: Häufige Fehlerquelle! Klauseln, die bei OpenMP-Direktiven angegeben werden, regeln wie Variablen zwischen den Threads ausgetauscht werden... shared(): Die Daten werden unter allen parallelen Regionen geshared, d.h. sie sind in allen Threads les- und schreibbar. Wenn ein Thread eine Variable ändert, ist sie auch in allen anderen Threads modifiziert. Default: Alle Variablen sind shared() ausser Schleifenvariablen bei OMP DO/omp for. private(): Jeder Thread bekommt eine private Kopie der Variablen, diese wird nicht initialisiert. Default: Nur Schleifenvariablen sind privat. default(shared private none): legt den Defaultwert fest. none: Jede Variable muss shared() oder private() deklariert werden.

20 Gültigkeitsbereiche von Daten II firstprivate(): wie private(), aber alle Kopien werden mit dem Wert der Variablen vor der parallelen Schleife/Region initialisiert. lastprivate(): Die Variable wird nach der parallelen Schleife/Region mit dem Wert aus dem Thread initialisiert, der (sequentiell) am spätesten drangekommen wäre.

21 Gemeinsam an einem Gesamtergebnis arbeiten reduction() Aufsummieren eines Arrays, etc. a = 0 ; b = 0 ; # pragma omp parallel for private (i) shared (x, y, n) \ reduction (+: a, b) for (i =0; i<n; i ++) { a = a + x[i] ; b = b + y[i] ; } Eine lokale Kopie jeder Variable in reduction() wird erzeugt und abhängig vom Operator initialisiert (z.b. 0 für + ). Wenn dann (z.b.) 3 Threads je ein Drittel der Schleife bearbeiten, werden am Ende die Teilsummen aller Threads vom Master-Thread aufsummiert.

22 Synchronisation Barrier Alle Threads warten, bis alle diesen Punkt erreicht haben # pragma omp barrier (C/C ++)!$OMP BARRIER ( Fortran ) z.b. bei zwei parallelisierten for-schleifen # pragma omp parallel { # pragma omp for nowait for (i =0; i < N; i ++) a[i] = b[i] + c[i]; # pragma omp barrier # pragma omp for for (i =0; i < N; i ++) d[i] = a[i] + b[i]; } Pause Pause

23 Synchronisation II Critical/Atomic alle Threads führen den Code aus, aber nur einer zu einem Zeitpunkt. # pragma omp critical [ name ] { code - block } # pragma omp atomic [ name ] statement! $OMP CRITICAL [ name ] code - block! $OMP END CRITICAL! $OMP ATOMIC [ name ] statement Abbildung: CRITICAL Region Alle Threads warten am Beginn der critical Region, bis kein anderer Thread eine critical Region mit demselben Namen ausführt. critical Regionen ohne Namen werden alle demselben (nicht spezifizierten) Namen zugeordnet.

24 Synchronisation III Critical Codebeispiel # ifdef _OPENMP # include <omp.h> # endif # include <stdio.h> int main () { double a [ ]; int i; # pragma omp parallel for for (i=0; i < ; i++) a[i]=i; double summe = 0; # pragma omp parallel for shared ( summe ) private (i) for ( i =0; i < ; i ++) { GrosseBerechnung (i); } summe = summe + a[i]; } printf (" summe =% lf\n",summe ); Summiert (ähnlich wie reduction()) die Elemente des Arrays auf. Was ist das Problem?

25 Synchronisation III Critical Codebeispiel (korrekt) # ifdef _OPENMP # include <omp.h> # endif # include <stdio.h> int main () { double a [ ]; int i; # pragma omp parallel for for (i=0; i < ; i++) a[i]=i; double summe = 0; # pragma omp parallel for shared ( summe ) private (i) for ( i =0; i < ; i ++) { GrosseBerechnung (i); /* sonst würde nichts parallelisiert */ # pragma omp critical ( summierung ) summe = summe + a[i]; } printf (" summe =% lf\n",summe ); } Bei der Summierung kann eine Race-Condition auftreten. Diese muss mit #pragma omp critical vermieden werden.

26 Synchronisation IV Nur ein Thread soll eine Region ausführen z.b. für I/O # pragma omp master { [ Code der nur einmal ( nur vom Master Thread ) ausgeführt wird ] } # pragma omp single { [ Code der nur einmal ( nicht unbedingt vom Master Thread ) ausgeführt wird ] } Im OpenMP-Hello-World-Programm am Beginn hätte man statt der if-abfrage auch #pragma omp master verwenden können.

27 Synchronisation V Flush, Ordered FLUSH: sorgt für eine konsistente Sicht auf den Speicher. # pragma omp flush ( variablen )! $OMP FLUSH ( variablen ) ORDERED: Legt fest, dass die Reihenfolge der Ausführung der Iterationen des betreffenden Blocks die gleiche wie bei serieller Programmausführung sein muss zulässig nur innerhalb einer for-schleife # pragma omp for ordered {... } ;

28 OpenMP-Funktionen OpenMP stellt div. Library Funktionen zur Verfügung. Settings mit diesen Funktionen haben Vorrang vor den entsprechenden Umgebungsvariablen. Empfehlung: Verwendung nur mit #ifdef _OPENMP bzw. bedingter Compilierung (Fortran), damit der Code auch ohne OpenMP lauffähig bleibt. C/C++: #include <omp.h> Fortran: USE omp_lib

29 OpenMP-Funktionen II Threading int omp_get_num_threads() int omp_get_thread_num() int omp_in_parallel() void omp_set_num_threads(int)... Locking (Achtung bei Locking-Funktionen: Deadlock-Gefahr) void omp_init_lock(omp_lock_t*): Lock initialisieren void omp_set_lock(omp_lock_t*): Lock setzen (blockierend) int omp_test_lock(omp_lock_t*): Lock setzen (nicht blockierend) void omp_unset_lock(omp_lock_t*): Lock löschen void omp_destroy_lock(omp_lock_t*): Lock deinitialisieren......

30 Umgebungsvariablen OMP_NUM_THREADS=integer Maximale Anzahl der OpenMP-Threads OMP_SCHEDULE= kind[,chunk_size] (static, dynamic, guided) betrifft das Aufteilen der Arbeit in Loops: static: jeder Thread bekommt statisch gleich viele Iterationen zugeteilt dynamic: jeder Thread holt sich neue Arbeit ab, sobald er arbeitslos ist guided: wie dynamic, nur werden die zugewiesenen Pakete laufend kleiner OMP_DYNAMIC= true false (kann die Anzahl der Threads dynamisch modifiziert werden?) OMP_NESTED= true false

31 Compiler - gcc ab Version ist möglicherweise (noch) nicht bei der eigenen Distribution dabei, aber selbstcompilieren ist kein grosses Kunststück: Download der aktuellen Release von ftp://ftp.gnu.org/gnu/gcc/. Selbstcompilieren von gcc a a Vorraussetzungen (benötigte Tools und Libraries, etc.) auf $ tar xvjf gcc tar. bz2 $ mkdir gcc - build ; cd gcc - build $../ gcc / configure -- prefix =/ opt /gcc \ --enable - languages = fortran,c,c++ $ make # das dauert, Zeit für eine Tasse Kaffee... $ make install # als root

32 gcc - Verwenden des selbstcompilierten GCC Verwendung des selbstcompilierten GCC $ / opt /gcc / bin / gcc -Wall - fopenmp helloworld.c $ export LD_LIBRARY_PATH =/ opt /gcc / lib64 $ export OMP_ NUM_ THREADS =4 $./a. out Hello World from thread 3 Hello World from thread 0 Hello World from thread 1 Hello World from thread 2 There are 4 threads

33 gcc - Verwenden des selbstcompilierten GCC (mit -rpath) Die Linker-option -rpath codiert den Suchpfad für Libraries in das Binary. Vorteil: läuft (am eigenen System) ohne $LD_LIBRARY_PATH Hacks... Nachteil: läuft (möglicherweise) nur am eigenen System (Auf einigen Unixen (z.b. IRIX) wird rpath vor $LD_LIBRARY_PATH durchsucht) Verwendung des selbstcompilierten GCC $ / opt /gcc / bin / gcc -Wall - fopenmp \ -Wl,- rpath =/ opt /gcc / lib64 helloworld.c $ export OMP_ NUM_ THREADS =4 $./a. out Hello World from thread 3 Hello World from thread 0 There are 4 threads Hello World from thread 1 Hello World from thread 2

34 Compiler - Sun Studio 12 Download von (Registrierung nötig) Verwendung des Sun CC $ cd / opt $ tar xvjf SunStudio12ml - linux -x ii.tar. bz2 $ cd $HOME $ / opt / sunstudio12 / bin /cc - xopenmp helloworld.c $ export OMP_ NUM_ THREADS =4 $./a. out Hello World from thread 0 There are 4 threads Hello World from thread 2 Hello World from thread 3 Hello World from thread 1

35 Compiler Intel Compiler Linux-Version für nichtkommerziellen Gebrauch ist gratis. Download von download/download/ (Registrierung nötig) Verwendung des Intel CC $ icc - openmp helloworld. c helloworld.c (8): ( col. 1) remark : OpenMP DEFINED LOOP WAS PARALLELIZED. $ export OMP_ NUM_ THREADS =4 $./a. out Hello World from thread 0 There are 4 threads Hello World from thread 1 Hello World from thread 3 Hello World from thread 2

36 Links OpenMP Homepage: OpenMP auf Wikipedia: OpenMP Spezifikationen:

37 Fragen? Ausblicke - was ich nicht behandelt habe... weitere OpenMP Direktiven und Funktionen (es gibt noch mehr,... ) 5 Vergleich mit anderen Modellen zur Parallelprogrammierung, z.b. MPI Vielen Dank für Ihre Aufmerksamkeit Wolfgang Dautermann wolfgang.dautermann[at]fh-joanneum.at 5 das war auch eine OpenMP-Einführung, kein Expertenvortrag

38 Praktische Vorführung Das Beispiel wurde im Hörsaal live vorgeführt, die dazugehörigen Folien entstanden später für die Webseiten der Chemnitzer Linuxtage Ein einfaches Programm um π mit der Formel vom Leibnitz zu berechnen (Dies ist nicht die schnellste Methode um π zu berechnen, aber als einfache Demonstration der Möglichkeiten, die OpenMP bietet gut geeignet): ( 1) k k=0 2k + 1 = = π 4 Das folgende Programm 6 wurde sowohl mit als auch ohne OpenMP-Unterstützung compiliert und dann mit einer oder zwei CPUs (= verschiedenen Werten von OMP_NUM_THREADS ausgeführt. 6 Programm & Hardware sind bei diesen Folien etwas anders als live bei den CLT2009, aber der Effekt ist trotzdem gut zu sehen.

39 Praktische Vorführung II # include <stdio.h> # include <math.h> # define SCHRITTZAHL int main ( int argc, char * argv []) { long i; double pi = 0; # pragma omp parallel for reduction (+: pi) for ( i = 0; i < SCHRITTZAHL ; i ++) { /* pi /4 = 1/1-1/3 + 1/5-1/ */ pi -= pow (-1,i) / (i * ); } pi = pi * 4.0; printf ("Pi = %lf\n",pi ); return 0; }

40 Praktische Vorführung III Compilierung und Ausführung ohne OpenMP Hier hätte man die Zeile 8 des Programms auch weglassen können, die wird ignoriert. $ gcc -lm -Wall pi - openmp.c pi - openmp.c: In function main : pi - openmp. c :8: warning : ignoring # pragma omp parallel $ time./a. out Pi = real user sys 0 m s 0 m s 0m0.136 s Das Programm benötigt ca. 25 Sekunden ohne OpenMP.

41 Praktische Vorführung IV Compilierung und Ausführung mit OpenMP OpenMP wird aktiviert: $ gcc -lm - fopenmp -Wall pi - openmp.c $ export OMP_NUM_THREADS =1 $ time a. out Pi = real 0 m s user 0 m s sys 0m0.008 s $ export OMP_NUM_THREADS =2 $ time a. out Pi = real user sys 0 m s 0 m s 0m0.068 s

42 Praktische Vorführung V Der Speedup ist bei diesem rechenintensiven Beispielprogramm linear 7. Nicht schlecht für eine zusätzliche Zeile Code und eine zusätzliche Compileroption... (Dieses Beispiel ist sehr gut parallelisierbar, bei anderen Programmen wird der Speedup in der Regel nicht so gut ausfallen - das Amdahlsches Gesetz wird sich bemerkbar machen)... Zusätzlich wurde die CPU-Auslastung mit dem Programm top beobachtet. 7 doppelt soviele CPUs benötigen die halbe Ausführungszeit