Architektur paralleler Rechnersysteme - Effiziente HPC Systeme -

Architektur paralleler Rechnersysteme - Effiziente HPC Systeme - WS 13/14 Nr. L.079.05722 Master-Studiengang Informatik, V2/Ü1 www.uni-paderborn.de/pc2 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 1 Dozent: Jens Simon (PC²) Organisatorisches Vorlesungen: Mittwochs, 13:15 14:45, O2.267 Übungen: Mittwochs, 15:00-15:45, O2.267 Aktuelle Informationen zur Veranstaltung: http://www.uni-paderborn.de/pc2/people/jens-simon/courses/ Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 2 1

Leistungsnachweise Teilnahme an Vorlesungen (2 SWS) Übungen (1 SWS) Lösung der Übungsaufgaben Musterlösungen? Falls ja, dann durch Teilnehmer erarbeitet. Prüfung Mündliche Modulprüfung Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 3 Vorlesungsbetrieb Folien liegen nach der Vorlesung auf der Web- Seite der Veranstaltung Es wird kein Skript zur Vorlesung geben Zielsetzung der Vorlesung Kurzeinführung in parallele Programmiersprachen und Programmiermethoden Überblick über Architekturen von Parallelrechnern Unterschiedliche Aspekte der Effizienz Vom Prozessoren bis hin zum Kommunikationsnetzwerk Vom Server bis hin zum Data-Center Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 4 2

Übungsbetrieb Theoretische Aufgaben begleitend zur Vorlesung Praktische Übungen auf Rechnersysteme des PC² Anmeldung bitte per Email an mich (Name, IMTaccount) Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 5 Zur Person Dr. rer. nat. Jens Simon Werdegang: 1992 bis 1998: Universität Paderborn / PC² 1999 bis 2001: Konrad-Zuse Institut Berlin (ZIB) seitdem: PC² Lehre: Vorlesungen Projektgruppen Forschung: Rechnersysteme, Spezialprozessoren Kommunikationsnetzwerke Middleware für HPC-Systeme Dienstleistung: Anträge schreiben Projektarbeit HPC-Beratung Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 6 3

Literatur Rechnerarchitektur Culler, D. E.; Singh, J. P.; Gupta, A.: Parallel computer architecture : A hardware/software approach, 1999 Rauber, T.; Rünger, G.: Parallele Progammierung, Springer, 2012 Hwang, K.: Advanced Computer Architecture, 1993 Hennessy, J.; Patterson D.: Computer Architecture A Quantitative Approach, 1996 Tanenbaum, A.; Computerarchitektur Strukturen Konzepte Grundlagen, 2005 Barros L.A., Hölzle U; Datacenter As A Computer, 2009 Kaxiras S., Martonosi, M.; Computer Architecture Techniques for Power-Efficiency, 2008 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 7 Parallele Programmierung Literatur Andrews, G. R.: Multithreaded, Parallel, and Distributed Programming, 2000 Leopold, C.: Parallel and Distributed Computing a survey of models, paradigms, and approaches, 2001 Tanenbaum, A.: Moderne Betriebssysteme, 2009 Groop, W.; Lusk, E.; Skjellum, A.: Using MPI Portable Parallel Programming with the Message-Passing Interface, 1999 Groop, W.; Lusk, E.; Thakur, R.: Using MPI-2 Advanced Features of the Message-Passing Interface, 1999 Chapman, B.; Jost, G.; van der Pas, R.: Using OpenMP Portable Shared Memory Parallel Programming, 2007 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 8 4

Danksagung Einige Teile der Vorlesung sind angelehnt an das Buch und die Unterlagen zu "Parallel Computer Architecture - A Hardware / Software Approach" von Culler, Singh und Gupta Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 9 Paralleles Rechnen aus Sicht eines Anwenders Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 10 5

Warum Paralleles Rechnen? Die Welt ist höchst parallel ein bewährtes Prinzip Physikalische Abläufe sind parallel Kristallwachstum, Gravitationsfelder, Chemische Reaktionen, Soziale und Arbeitsprozesse sind parallel Ameisenkolonie, Straßenverkehr, Produktionsstätten, Finanzwirtschaft, Universitäten, Politik, Menschliches Gehirn, Sensorik, Lernverhalten sind parallel Denken, Sehen, Fühlen, Evolutionsprozesse, Eine Koordination der größtenteils unabhängigen Prozesse ist aber in den meisten Fällen notwendig Das Prinzip der Parallelität bereits bei der Beschreibung der Abläufe nutzen Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 11 Warum Parallelverarbeitung? Einzelprozessorsysteme bieten nicht genügend Ressourcen für viele Anwendungsbereiche Trotz des rasanten Geschwindigkeitszuwachses bei PCs. Sogenannte Grand-Challange Anwendungen benötigen bereits heute um einige Größenordnungen mehr Rechenleistung als die eines einzelnen PCs. Klimaveränderung, Bioinformatik, Astrophysik, Kopplung verschiedener Methoden für das Auffinden einer besseren Lösung Kooperative Systeme Höhere Anforderungen an Sicherheit und Verfügbarkeit Redundante Systeme Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 12 6

Einsatzgebiete von Parallelrechnern Forschung Klimawandel, Astrophysik, Produktentwicklung Mikrochip-Entwurf, Werkstofftests, Virtuelle Prototypen, Informationssysteme Datenbanken, Suchmaschinen, Wetterdienste, Virtuelle Umgebungen Fahrzeugsimulationen, Architekturplanungen, Gesundheitswesen Medikamentenentwicklung, Genomanalyse, Finanzdienstleistungen Fonds- u. Risikoanalysen, High-Frequency-Trading, Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 13 HPC in der Forschung Simulation dritte Säule in der Forschung, neben Theorie und Experiment sehr rechenintensiv und teilweise mit sehr hohem Speicherbedarf zur Untersuchung von sehr langsam oder sehr schnell ablaufenden Prozessen ohne störende äußere Einflüsse zur Vermeidung gefährlicher Experimente Nutzung unterschiedlicher Skalen Z.B. Physik: Astrophysik bis hin zur Quantenmechanik Kontinuumsmethode Molekulardynamik Quantenmechanik Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 14 7

Most Powerful Supercomputer 06/2013 Name: Tianhe-2 Place: Guangzhou, China Vendor: National University of Defense Technology, Inspur Purpose: Research and Education LINPACK: 33.86 Petaflops Floor Space: 720 m² Racks: 162 (125 compute, 13 Arch switches, 24 storage) Nodes: 16,000 (2 CPU sockets, 3 Xeon-Phi cards, 64GB) Sockets: 32,000 Intel Ivy Bridge Xeon,2.2GHz and 48,000 Xeon Phi Cores 3,120,000 Memory: 1.4PB (1024TB CPU, 384TB Xeon PHI) Power consumption: 17.8MW (plus 24MW cooling) OS: Kylin Linux Source: top500.org Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 15 Fastest European Supercomputer 6/2013 JuQueen, Blue Gene/Q, IBM Forschungszentrum Jülich(FZJ) 5.01 PetaFLOP/s Linpack performance (5.9 PFlop/s peak) 28,672 nodes, each with one IBM PowerPC A2 (16 cores) 5 D torus 40 Gbit/s interconnect total 458,752 cores with 1.6 GHz 448 TByte main memory 2.3 MWatt power consumption Floorspace ca. 80 m² Investment: ca.?? Mio. Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 16 8

Supercomputer wird zum Mobiltelefon Bestimmung der Leistungsfähigkeit durch den Linpack-Benchmark 1979: Cray 1 und Fortran 3.4 MFlop/s $5 - $9 Mio. 5.25 t 115 kw 32 Jahre 1 : 38 12.000 : 1 40.000 : 1 25.000 : 1 2012: Smartphone Samsung Galaxy S3 mit Android 4.1.2 und Java 130 MFlop/s $600 133 g ca. 5 Watt Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 17 Der Weg zum optimalen Supercomputer Das Vorbild Rechenleistung des Gehirns angenommen als 100 TFlop/s (H. Moravec) oder auch 10 PFlop/s (R. Kurzweil) Speicherleistung der Synapsen ca. 2 Petabyte Gehirn: ca. 1,4 kg Gewicht, 20 Milliarden Nervenzellen, 15 20 Watt chemische Leistungsaufnahme Trotz der rasanter Entwicklung von Technik und Wissenschaft (im Wesentlichen exponentielles Wachstum) noch keine derart effiziente Maschine in Aussicht Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 18 9

Beispiel: LHC Computing Grid Beschleunigerring, Kollision unterschiedlicher Elementarteilchen für Higgs-Boson Nachweis Large Hadron Collider (LHC) im CERN liefert Messdaten ( Events ) >140 Rechenzentren in 33 Ländern 100.000 Server-Prozessoren für die Analyse der Messdaten 15 PetaBytes Gesamtspeicherkapazität (15 10 15 Byte) Mehrebenenstruktur Tier-0: CERN: Rohdaten Tier-1: vorberechnete Daten Tier-2: Datenverteilung und zentrale Rechenkapazitäten Tier-3: lokale Rechenzentren Tier-4: PCs der Wissenschaftler Simon, CERN 2006 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 19 Beispiel: Google Data Center 45 Container, jeder mit Ca. 1 000 Server 250 kw Stromverbrauch ~ 4 bis 5 kw pro Rack Quelle: Google Google Server-Knoten (Stand 2010) 2 Prozessoren Proprietäre double-wide DIMMs einzelner Lüfter pro Knoten (im Netzteil) nur 12 Volt Stromversorgung zum Knoten 12 Volt USV (Batterie) Verkabelung nur von der Frontseite Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 20 10

Wird dieses immer so weitergehen? 1 Exaflop/s Supercomputer Begrenzung: Energieverbrauch 1 TFlop/s Laptop Mein Laptop 2014 2016 2018 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 21 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 22 11

Programmierung von Parallelrechnern Speichermodelle Gemeinsamer Speicher Verteilter Speicher Programmiermethoden Speichergekoppelt Nachrichtengekoppelt Programmierkonzepte Annotierung sequentieller Programme (OpenMP) Mehrere Ausführungsfäden - Threads (PThreads) Expliziter Nachrichtenaustausch - Message-Passing (MPI) Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 23 Speichermodell für Shared-Memory Programme virtueller Adressbereich der Prozesse P n physikalischer Adressbereich der Maschine P n private P 0 P 1 P 2 common physical addresses shared portion of address space private portion of address space P 2 private P 1 private P 0 private Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 24 12

Speichermodell für Message-Passing Programme Match Adresse Y Adresse X Send Q,X,t Receive P,Y,t lokaler Prozessadressbereich lokaler Prozessadressbereich Prozess P Prozess Q Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 25 Programmiermethoden Nachrichtengekoppelte Multiprozessorsysteme Prozesse kommunizieren mittels expliziten Nachrichtenaustausch Prozess 1 : send(x); Prozess 2 : receive(x); Standards: MPI-1 und MPI-2 Speichergekoppelte Multiprozessorsysteme Zugriff auf gemeinsame Variablen y = x; oder shmem_get/shmem_put; Synchronisation notwendig lock(mutex_x);... unlock(mutex_x); Nutzung von Multithreading: leichtgewichtige Prozesse POSIX-Threads als Standard (PThreads) durchgängiges Konzept für Workstations, Multiprozessor- Workstations (SMPs) und für die großen verteilten Multiprozessorsysteme aller Arten Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 26 13

Programmierkonzepte POSIX Threads Gemeinsamer Speicher und Threads OpenMP Erweiterung der Programmiersprachen C/C++ und Fortran Message Passing Interface (MPI) Standardisierter Nachrichtenaustausch PGAS Partitioned Global Address Space Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 27 Ausführungsfäden Im Shared-Memory-Modell laufen mehrere Tasks (Threads), oftmals mit unterschiedlichen Funktionalitäten parallel ab. Die Tasks kommunizieren untereinander durch Schreiben und Lesen auf einem gemeinsamen Speicher. Zeit Struktur eines Multi-Threading- Programms Struktur eines OpenMP-Programms Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 28 14

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 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 29 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); Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 30 15

PThread-Bibliothek Mutex Variablen int pthread_mutex_init (mutex, attr); int pthread_mutex_destroy (mutex); int pthread_mutexattr_init (attr); int pthread_mutexattr_destroy (attr); int pthread_mutex_lock (mutex); int pthread_mutex_trylock (mutex); int pthread_mutex_unlock (mutex); Condition Variablen int pthread_cond_init (cond, attr); int pthread_cond_destroy (cond); int pthread_condattr_init (attr); int pthread_condattr_destry (attr); int pthread_cond_wait (cond, mutex); int pthread_cond_signal (cond); int pthread_cond_broadcast (cond); Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 31 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); } } Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 32 16

PThreads: Join 1 #include <pthread.h> 2 #include <stdio.h> 3 #define NUM_THREADS 3 4... 5 /* Thread-Routine */ 6 void *routine (void *arg) { 7 sleep(1); 8 printf("thread Nummer: %d.\n", arg); 9 pthread_exit ((void *) 0); 10 } 11... 12 int main() { 13 /* Definition der Variablen */ 14 pthread_t thread[num_threads]; 15 pthread_attr_t attr; 16 int i, status, err; 17 18 /* 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 } 28 29... 30 /* 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 } Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 33 Problem: Synchronisation Anforderung: Geregelter und sicherer Zugriff auf Daten und Methoden, die von mehreren Threads genutzt werden. Beispiel: Thread1 Bank.account Thread2 Wert auslesen 0 300 dazu addieren 0 Wert auslesen Summe zurückschreiben 300 400 dazu addieren Zeit 400? Summe zurückschreiben Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 34 17

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); Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 35 Mutex Lock int pthread_mutex_lock (pthread_mutex_t *mut); falls Mutex frei, belege den Mutex falls Mutex belegt, warte bis Mutex frei wird, danach belege den Mutex Unlock int pthread_mutex_unlock (pthread_mutex_t *mut); Mutex freigeben Mutex Test int pthread_mutex_trylock (pthread_mutex_t *mut); falls Mutex frei, belege den Mutex, andernfalls gebe Wert EBUSY zurück Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 36 18

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; 10 11 for(i=0; i < 1000000; i++) { 12 pthread_mutex_lock (&mutex_sum); 13 random(); 14 sum = sum - 1; 15 pthread_mutex_unlock (&mutex_sum); 16 } 17 } 18 19 void *plus (void *arg) { 20 int i = 0; 21 22 for(i=0; i < 1000000; 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; 34 35 pthread_attr_init (&attr); 36 pthread_attr_setdetachstate (&attr, 37 PTHREAD_CREATE_JOINABLE); 38 39 /* 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 } Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 37 Conditions Wie kann die Nutzung von Mutex-Variablen gesteuert werden? Signalisierung von Ereignissen Problem: Blockierendes Warten und anschließendes Wecken Lösung: Condition-Variables Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 38 19

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 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 39 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); Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 40 20

Beispiel: Condition Variable (1) 1 #include <pthread.h> 2 #define NUM_THREADS 3 3 4 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]; 11 12 void *work (void *arg) { 13 int id = (int) arg; 14 int sum, i; 15 16 /* Mutex Variable sperren */ 17 pthread_mutex_lock (&mutex); mutex koordiniert den Zugriff auf Variable flag 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 } 24 25 pthread_mutex_unlock (&mutex); 26 27 printf("(thread %d) Jetzt geht's los!\n", id); 28 29 /* 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 } 34 35 pthread_exit (NULL); 36 } main Funktion auf der folgenden Folie Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 41 Beispiel: Condition Variable(2) 37 int main() { 38 /* Definition der Variablen */ 39 pthread_t thread[num_threads]; 40 pthread_attr_t attr; 41 42 int i, status, err; 43 44 for(i=0; i < NUM_THREADS; i++) 45 flag[i] = 1; 46 47 pthread_attr_init (&attr); 48 pthread_attr_setdetachstate (&attr, 49 PTHREAD_CREATE_JOINABLE); 50 51 pthread_mutex_init (&mutex, NULL); 52 pthread_cond_init (&cond, NULL); 53 54 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; 64 65 /* Wecke sie auf */ 66 pthread_cond_broadcast (&cond); 67 pthread_mutex_unlock (&mutex); 68 69 /* 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 } 74 75 /* Aufräumen */ 76 pthread_attr_destroy (&attr); 77 pthread_mutex_destroy (&mutex); 78 pthread_cond_destroy (&cond); 79 80 pthread_exit (NULL); 81 } Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 42 21

Condition Variable Achtung: Signale werden nicht gespeichert Falls kein Thread im Condition-Wait, dann gilt ein zu dem Zeitpunkt gesendetes Signal als verloren Threads können somit verhungern, falls auf ein Signal gewartet wird das nicht mehr gesendet wird Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 43 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. Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 44 22

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) Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 45 OpenMP bietet Möglichkeiten von OpenMP Portabilität auf Shared-Memory Architekturen Skalierbarkeit inkrementelle Parallelisierung Unterstützt Daten-Parallelisierung Erweiterungen für FORTRAN und C/C++ Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 46 23

Geschichte von OpenMP OpenMP entwickelte sich aus Erweiterungen bestehender Programmiersprachen durch einzelne Hersteller wurde mit dem Ziel der Portabilität entwickelt ist ein Standard sein 1997 wurde von Cray, SGI, Digital Equipment Corporation, IBM, Intel und wird von vielen Hard- und Softwarefirmen unterstützt, darunter Sun, HP, Fujitsu. Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 47 Quellen zu OpenMP R. Chandra et al.: Parallel Programming in OpenMP, Academic Press 2001 Chapman, B.; Jost, G.; van der Pas, R.: Using OpenMP Portable Shared Memory Parallel Programming, 2007 http://www.openmp.org Intel Compiler (Linux non commercial use) http://www.intel.com/software/products/global/eval.htm icc openmp file.c # Linux x86 ecc openmp file.c # Linux x86-64 icl /Qopenmp file.c # Windows GCC Compiler Version 4.2 gcc fopenmp file.c Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 48 24

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 gemeinsam genutzte 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 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 49 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 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 50 25

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> Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 51 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, Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 52 26

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 Iterationen auf Threads nowait - Thread nicht am Schleifenende synch Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 53 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 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 54 27

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; } Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 55 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 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 56 28

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 3.14159265358979323L 7 8 double f (double a) 9 { 10 return (double)4.0/((double)1.0+(a*a)); 11 } 12 13 int main(int argc, char *argv[]) 14 { 15 long n, i; 16 double h, pi, sum, x; 17 for (;;) { 18 printf("enter the number of intervals: (0 quits) "); 19 scanf("%u",&n); 20 if (n==0) 21 break; 22 h = ((double)1.0)/(double)n; 23 sum = 0.0; 24 25 #pragma omp parallel for private(i,x) reduction(+:sum) 26 for(i=1;i<=n;i++) { /* parallel loop */ 27 x = h*((double)i-(double)0.5); 28 sum += f(x); 29 } 30 /* end omp parallel for */ 31 32 pi = h*sum; 33 printf("pi is approximatly: %.16f Error is: %.16f\n", 34 pi, fabs(pi-pi)); 35 } 36 37 return EXIT_SUCCESS; 38} Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 57 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 unspezifizierten Namen parallel for Direktive Parallele Region mit nur einer einzigen parallelen for- Schleife #pragma omp parallel for [ clause [[,] clause] ] for loop Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 58 29

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 } Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 59 Parallele Bibliotheken: Beispiele Intel-Bibliotheken: Math Kernel Library mathematische Funktionen der Linearen Algebra über OpenMP parallelisierte Routinen Funktionen: Matrix-Operationen, Löser für Gleichungssysteme, FFTs, Threading Building Blocks Konstrukte: parallel_for, parallel_do, parallel_reduce, pipeline, parallel_sort, parallel_scan NAG-Bibliothek: Differentialgleichungen, Optimierung, Lineare Algebra, statistische Methoden, Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 60 30

Message-Passing: Einführung Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 61 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);... Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 62 31

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 ist eine Clique Jeder Prozessor kann direkt mit jedem anderen kommunizieren Kommunikatoren regeln die Kommunikation zwischen den Prozessen Jeder Prozess gehört zu mindestens einem Kommunikator Jede Nachricht wird in einem Kommunikator transportiert Kommunikatoren können beliebig neu erzeugt werden Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 63 Version 1.0: (1994) 129 MPI-Funktionen C und Fortran77 Version 1.1 Spezifikation verfeinert Version 1.2 Weitere Eindeutigkeiten MPI Versionen Version 2.0: (1997) Mehr Funktionalitäten, 193 weitere Funktionen Dynamische Generierung von Prozessen Einseitige Kommunikation MPI-Funktionen für I/O C++ und Fortran90 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 64 32

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 worker();... MPI_Finalize(); } Dabei sind master() und worker() Funktionen die durch einen Master- und ggf. mehrere Worker-Prozesse ausgeführt werden sollen. Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 65 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 *) Rückgabe: Eigene Prozessnummer innerhalb Des Kommunikators. Menge von MPI-Prozessen, die Nachrichten austauschen können. MPI_COMM_WORLD enthält alle Prozesse MPI_Comm_size( MPI_Comm, int *) Rückgabe: Anzahl der Prozesse innerhalb Des Kommunikators. Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 66 33

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 - Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 67 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!) Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 68 34

MPI für Java Objekt-orientiertes Java-Interface für MPI entwickelt im HPJava Projekt mpijava 1.2 unterstützt MPI 1.1 http://www.hpjava.org/mpijava.html unterstützt u.a. MPICH unter Linux http://www.mcs.anl.gov/research/projects/mpi/mpich1/ import mpi.*; public class MPI_HelloWorld { public static void main(string[] args) { System.out.println( Hello, world ); } } Ausführung javac MPI_HelloWorld.java prunjava 4 MPI_HelloWorld Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 69 Further MPI bindings MPI for Python http://pympi.sourceforge.net/ http://mpi4py.scipy.org/ and more Common LISP Ruby Perl Caml Common Language Infrastructure (CLI) Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 70 35

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. Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 71 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. Muss mit Vorsicht eingesetzt werden. Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 72 36

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 non-blocking Recv möglich. Jeder Send Typ kann mit jedem Recv Typ matchen. Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 73 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); } Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 74 37

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- / Recv-routine (beendet bzw. nicht-beendet) zurück Dafür muss der request Parameter verwendet werden Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 75 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); }... Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 76 38

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 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 77 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 0 1 2 3 RANK 0 1 2 3 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 78 39

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);... Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 79 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 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 80 40

Message-Passing-Modell Pro s: Programmierer bestimmt Daten- und Arbeitsverteilung Eindeutigkeit der Lokalität Con s: Relativ hoher Kommunikationsaufwand bei kleinen Nachrichten Korrektheit der Programme schwer zu überprüfen Beispiel: Message Passing Interface (MPI) Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 81 Shared-Memory-Modell Pro s: Einfache Befehle Lesen / Schreiben des entfernten Speichers durch Bilden eines Ausdrucks bzw. einfache Wertzuweisung Programmierwerkzeuge vorhanden Con s: Manipulation von gemeinsam genutzten Speicherzellen erfordern meistens doch explizite Synchronizationspunkte Keine Eindeutigkeit der Lokalität Beispiele: OpenMP POSIX Threads Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 82 41

Hybrides Modell: Shared Mem. + Message Passing Beispiele: POSIX Threads innerhalb der Knoten und MPI zwischen Knoten OpenMP für Intra- und MPI für Inter-Knoten- Kommunikation Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 83 Hybride Programmierung processes message passing MPI threading shared memory OpenMP Pthreads Domain decomposition accelerated operations SIMD MIC GPU FPGA Libraries CUDA OpenCL OpenACC Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 84 42

OpenCL Open Computing Language parallel execution on single or multiple processors for heterogeneous platforms of CPUs, GPUs, and other processors Desktop and handheld profiles works with graphics APIs such as OpenGL based on a proposal by Apple Inc. supported processors: Intel, AMD, Nvidia, and ARM work in progress: FPGA Design Goals Data- and task-parallel compute model based on C99 language Implements a relaxed consistency shared memory model with multiple distinct address spaces OpenCL 1.2 Device partitioning, separate compilation and linking, Enhanced image support, Built-in kernels, DirectX functionality Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 85 OpenCL Implements a relaxed consistency shared memory model Multiple distinct address spaces Address space can be collapsed depending on the device s memory subsystem Address qualifiers private local constant / global Example: global float4 *p; Built-in Data Types Scalar and vector data types Pointers Data-type conversion functions Image type (2D/3D) Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 86 43

OpenACC Open Accelerator High level gateway to lower level CUDA GPU programming language accelerate C and FORTRAN code directives identifies parallel regions Initially developed by PGI, Cray, Nvidia supported processors: AMD, NVIDIA, Intel? Design Goals No modification or adaption of programs to use accelerators OpenACC compiler First compilers from Cray, PGI, and CAPS 1Q2012 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 87 MPI + X X = OpenMP, Pthreads, spezielle Bibliotheken Pros Wenige MPI-Prozesse Ggf. bessere Skalierung Weniger Overhead für die Zwischenspeicherungen von Daten Schnellere Synchronisation in (Unter-) Gruppen Cons Zwei unterschiedliche Programmierparadigmen Portabilität könnte problematisch sein Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 88 44

Partitioned Global Address Space - PGAS PGAS ist ein Modell für paralleles Programmieren verwendet einen global adressierbaren Speicherbereich kennt aber auch lokal nutzbare Speicherbereiche Affinitäten von Threads zu Bereichen des globalen Speichers möglich Sprachen Unified Parallel C http://upc.lbl.gov Co-array Fortran http://www.co-array.org/ Titanium http://titanium.cs.berkeley.edu/ Fortress http://labs.oracle.com/projects/plrg/ Chapel http://chapel.cray.com/ X10 http://x10-lang.org/ Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 89 Quelle: David Grove (IBM) PGAS: Beispiel X10 PGAS: Replicated Data Local Heap Remote Heap Locality Rule: Any access to a mutable datum must be performed by a local activity remote data accesses can be performed by creating remote activities Place = collection of resident activities and objects Activity = sequential computation that runs at a place Locally Synchronous: Guaranteed coherence for local heap sequential consistency Globally Asynchronous: No ordering of inter-place activities use explicit synchronization for coherence Storage classes: Activity-local Place-local Partitioned global Immutable Ordering Constraints (Memory Model) Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 90 45

Abstraktionsebenen der Programmierung Programmiersprache PGAS Pthreads OpenMP MPI Threads Shared-Memory Message-Passing verteiltes Shared-Memory MPP Cluster SMP CC-NUMA Cray-Link 3d-Netz IB MyriNet Ethernet Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 91 46