Shared-Memory Programmiermodelle

Transkript

1 Shared-Memory Programmiermodelle mehrere, unabhängige Programmsegmente greifen direkt auf gemeinsame Variablen ( shared variables ) zu Prozeßmodell gemäß fork/join Prinzip, z.b. in Unix: fork: Erzeugung eines neuen Kind-Prozesses (komplette Kopie des Elternprozesses zum Zeitpunkt der Erzeugung) wait: Elternprozess kann auf Terminierung der Kindprozesse warten Kommunikation der Prozesse über Signale, Sockets und ggf. auch über ein gemeinsames Speichersegment, das durch Systemfunktionen wie z.b. shmget, shmat, shmdet und shmop kontrolliert wird Threadmodell: mehrere unabhängige Kontrollflüsse in einem Programm bilden jeweils einen Thread Threads teilen sich einen globalen Adressraum Implementierung von Threads durch Bibliotheken, z.b. Pthreads (POSIX-Threads) für Unix 25 Shared-Memory Programmiermodelle (Forts.) Möglichkeiten der Implementierung von Threads: 1) auf Anwender-Ebene: alle Anwender-Threads werden auf einen Prozeß abgebildet; Vorteil: sehr schneller Thread-Wechsel ohne Beteiligung des Betriebssystems 2) auf Betriebssystem-Ebene: jeder Anwender-Thread entspricht einem Betriebssystem-Thread; Vorteile: Umschaltung auf anderen Thread bei E/A-Blockierung möglich; Zuordnung meherer Prozessoren für Threads; Nachteil: nicht jedes Betriebssystem unterstützt Threads! 3) auf Anwender- und Betriebssystem-Ebene: ein Scheduler der Thread- Bibliothek bildet Anwender-Threads auf Betriebssystem-Threads ab; Betriebsystem bildet letztere ggf. auf Prozessoren ab heutige Implementierungen i.a. gemäß Variante 3 Thread-Programmierung ist sehr aufwendig! Alternative: Verwendung von OpenMP zur automatischen Generierung von Threads 26 1

2 OpenMP seit 1998 Standard ( für die Shared-Memory Programmierung; (Prä-)Compiler für viele Systeme kommerziell oder frei (z.b. Omni von phase.etl.go.jp/omni) verfügbar Idee: automatische Generierung mehrerer Threads aus einem sequentiellem Programm, die gemäß dem fork/join Prinzip erzeugt und beeendet werden Schnittstellen für C, C++ und Fortran OpenMP basiert auf Compiler-Direktiven, die der Programmierer in das sequentielle Quell-Programm einfügt, um Berechnungen (vor allem in Schleifen) auf mehrere Threads aufzuteilen und die Threads zu synchronisieren Bibliotheksfunktionen und Umgebungsvariablen zur Kontrolle der Threads zur Laufzeit 27 Master-Thread führt Programm aus, bis durch folgende Direktive ein Team parallel arbeitender Threads generiert wird: #pragma omp parallel [options]... nach Beendigung des Anweisungblocks... werden alle Threads des Teams synchronisiert und nur der Master-Thread setzt die Abarbeitung des sequentiellen Programmes fort weitere Direktive innerhalb eines Anweisungsblocks dienen der Aufteilung der Arbeit auf die Threads und der Synchronisation Schachtelung von parallel-direktiven prinzipiell gestattet, oft (z.b. auf Sun) aber nicht implementiert Parallelitätsgrad, d.h. Anzahl der Threads, wird entweder durch die Umgebungsvariable OMP_NUM_THREADS oder durch Aufruf einer Bibliotheks-Funktion festgelegt 28 2

3 OpenMP: Beispiel 1 #include omp.h int i, myid, numthreads, npoints, mypoints float x[10000]; int main() printf("calculating x in parallel...\n"); #pragma omp parallel shared (x) \ private (myid, numthreads, mypoints) numthreads=omp_get_num_threads(); myid=omp_get_thread_num(); mypoints = 10000/numthreads; mystart = myid * mypoints; compute_subdomain(x, mystart, mypoints); for (i=0;i<10000;i++) printf("%f ", x[i]); 29 Folgende drei Direktive steuern die parallele Bearbeitung innerhalb eines parallelen Anweisungsblocks: Aufteilung der Iterationen einer Schleife auf mehrere Threads #pragma omp for [options] for (i = <lower_bound>; i <op> <upper_bound>; incr_expr)... mit op <,<=,>,>= und incr_expr nur auf + und basierend explizite Zuteilung von Aufgaben auf mehrere Threads: #pragma omp sections [options] #pragma omp section... #pragma omp section... Ausführung von Instruktionen durch einen beliebigen einzelnen Thread: #pragma omp single [options]

4 Auswahl einiger Optionen: uninitialisierte private Variablen: für die angegebenen bereits deklarierten Variablen wird auf dem Stack eines jeden Threads eine neue Kopie angelegt private (<variable>, <variable>,...) private Variablen werden mit Wert aus Master-Thread initialisiert: firstprivate (<variable>, <variable>,...) Master-Thread übernimmt den Wert der letzten Iteration bzw. Sektion: lastprivate (<variable>, <variable>,...) globale Variablen: Variablen wird explizit als global deklariert, d.h. jeder Thread greift hier (konkurrierend) auf die gleiche Speicherstelle zu shared (<variable>, <variable>,...) Deklaration aller (nicht privater) Variablen als global: default (shared) Verzicht auf Synchronisation am Ende der Bearbeitung eines Konstruktes: nowait 31 Scheduling-Optionen für for-schleifen: statische Aufteilung: block_size aufeinanderfolgende Iterationen je Thread; bei fehlender Angabe von block_size bearbeitet jeder Thread ungefähr 1/numthreads aller Iterationen schedule(static, block_size) dynamische Zuteilung: nach Abarbeitung der zugewiesenen Iterationen erhält jeder Thread dynamisch einen neuen Block mit jeweils block_size weiteren Iterationen; bei fehlender Angabe von block_size werden einzelne Iterationen zugeteilt schedule(dynamic, block_size) dynamische Zuteilung mit abnehmender Blockgröße: die ersten Threads bearbeiten 1/numthreads aller Iterationen; restliche Iterationen werden in Blöcken exponentiell abnehmender Größe (jedoch > block_size) verteilt schedule(guided, block_size) Festlegung der Scheduling-Parameter zur Laufzeit: schedule(runtime) 32 4

5 Reduktion in OpenMP: in einer for-, section- oder parallel-direktive ist als Option folgender Parameter möglich: reduction (op: variable) mit Reduktionsoperator op +,*,&,,&&, eine weder als private noch als shared deklarierte variable, die nach Beendigung der Direktiven das Reduktionsergebnis enthält Bemerkung: in OpenMP Version 1.0 ist Reduktion nur für skalare Variable definiert! existiert in einer parallelen Region nur eine einzelne for- oder section-direktive, so ist auch folgende Notation möglich: #pragma omp parallel for [options] #pragma omp parallel section [options] 33 OpenMP: Beispiel 2 parallele Berechnung des Skalarproduktes x zweier Vektoren a und b in OpenMP: #define DIM int main() float a[dim], b[dim], x; int i; x = 0; #pragma omp parallel for shared(a,b) lastprivate(i) \ reduction(x) schedule(dynamic,10) for (i=0; i < DIM; i++) a[i] = compute_a(i); b[i] = compute_b(i); x = x + a[i] * b[i]; printf("dim = %d, x = %f\n", i, x); 34 5

6 weitere OpenMP-Direktive zur Synchronisation von Threads: Barrieren-Synchronisation (nur in einem Anweisungsblock): #pragma omp barrier Kritischer Bereich, z.b. zur Steuerung des schreibenden Zugriffs mehrerer Threads auf eine Datenstruktur; nur ein Thread darf sich zu einem Zeitpunkt in einem kritischen Bereich befinden: #pragma omp critical Ausführung von Anweisungen nur durch den Master-Thread: #pragma omp master Erzwingen einer konsistenten Darstellung der Inhalte von Variablen in allen Threads (Vorsicht bei Zeigern!); wird keine Variable angegeben, so erhalten alle globalen Variablen einen konsistenten Wert #pragma omp flush (variable, variable,...) Bemerkung: erfolgt implizit bei barrier, critical sowie beiverlassen einer for-, section- und single-direktive (falls kein nowait) 35 Auswahl einiger OpenMP Bibliotheks-Funktionen: (erfordern #include <omp.h>) void omp_set_num_threads(int num_threads) int omp_get_num_threads(void) int omp_get_thread_num(void) int omp_set_dynamic(int dynamic_threading) (ist Parameter 0, so passt Laufzeitsystem die Threadanzahl dynamisch an) int omp_get_dynamic(void) void omp_set_nested(int nested) (ist Parameter 0, so werden geschachtelte Konstrukte parallel ausgeführt) Auswahl einiger OpenMP Umgebungsvariablen: OMP_NUM_THREADS (Anzahl Threads) OMP_SCHEDULE (Scheduling-Strategie, z.b. "static,10") OMP_DYNAMIC (TRUE: dynamische Anpassung der Threadanzahl) OMP_NESTED (TRUE: parallele Ausführung geschachtelter Konstrukte) 36 6

7 OpenMP: Beispiel 3 #include <omp.h> #define DIM main() float M[DIM][DIM], x[dim], y[dim], total; int i, j, tid; total = 0; #pragma omp parallel shared(m,x,y,total) private(tid,i) tid = omp_get_thread_num(); #pragma omp for private(j) schedule(static) for (i=0; i < DIM; i++) for (j=0; j < DIM; j++) y[i] += (M[i][j] * x[i]); #pragma omp critical total = total + y[i]; printf("y[%d]=%.2f computed by thread %d\n",i,y[i],tid); printf("total sum of all y[] = %.2f\n",total); 37 Thread-Programmierung Möglichkeiten der Arbeitsverteilung auf Threads: Master/Slave: ein Master-Thread steuert Programm, erzeugt mehrere Slave-Threads und verteilt Arbeit gleichmäßig auf Threads Pipelining: Thread i produziert Daten für Thread i +1 Pool: mehrere Threads holen sich nach Abarbeitung einer Aufgabe eine neue Aufgabe aus einem Aufgaben-Pool Divide-and-Conquer: jeder Thread erzeugt rekursiv einen weiteren Thread, bis Aufgabe ausreichend fein zerlegt ist Wettbewerb: jeder Thread führt eine andere Strategie aus jeder Thread hat Zugriff auf alle globalen Variablen und dynamisch erzeugte Objekte im globalen Adreßraum, besitzt jedoch lokalen Laufzeitstack für private Variablen explizite Synchronisation beim Zugriff aus globale Variablen über Semaphore (Mutex-Variablen) 38 7