Architektur paralleler Rechnersysteme - Effiziente HPC Systeme -
|
|
- Leon Vincent Lehmann
- vor 8 Jahren
- Abrufe
Transkript
1 Architektur paralleler Rechnersysteme - Effiziente HPC Systeme - WS 13/14 Nr. L Master-Studiengang Informatik, V2/Ü1 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: Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 2 1
2 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
3 Übungsbetrieb Theoretische Aufgaben begleitend zur Vorlesung Praktische Übungen auf Rechnersysteme des PC² Anmeldung bitte per 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
4 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
5 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
6 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
7 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
8 Most Powerful Supercomputer 06/2013 Name: Tianhe-2 Place: Guangzhou, China Vendor: National University of Defense Technology, Inspur Purpose: Research and Education LINPACK: 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
9 Supercomputer wird zum Mobiltelefon Bestimmung der Leistungsfähigkeit durch den Linpack-Benchmark 1979: Cray 1 und Fortran 3.4 MFlop/s $5 - $9 Mio t 115 kw 32 Jahre 1 : : : : : Smartphone Samsung Galaxy S3 mit Android und Java 130 MFlop/s $ 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, 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
10 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 Server-Prozessoren für die Analyse der Messdaten 15 PetaBytes Gesamtspeicherkapazität ( 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 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
11 Wird dieses immer so weitergehen? 1 Exaflop/s Supercomputer Begrenzung: Energieverbrauch 1 TFlop/s Laptop Mein Laptop Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 21 Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 22 11
12 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
13 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
14 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
15 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
16 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
17 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 } 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 dazu addieren 0 Wert auslesen Summe zurückschreiben dazu addieren Zeit 400? Summe zurückschreiben Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 34 17
18 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
19 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 } 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
20 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
21 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); 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 } 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 } 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; 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 } Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 42 21
22 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
23 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
24 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, Intel Compiler (Linux non commercial use) 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
25 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
26 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
27 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
28 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
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 { 10 return (double)4.0/((double)1.0+(a*a)); 11 } 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; #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 */ pi = h*sum; 33 printf("pi is approximatly: %.16f Error is: %.16f\n", 34 pi, fabs(pi-pi)); 35 } 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
30 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
31 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
32 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
33 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
34 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
35 MPI für Java Objekt-orientiertes Java-Interface für MPI entwickelt im HPJava Projekt mpijava 1.2 unterstützt MPI unterstützt u.a. MPICH unter Linux 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 and more Common LISP Ruby Perl Caml Common Language Infrastructure (CLI) Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 70 35
36 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
37 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
38 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
39 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 RANK Vorlesung: Architektur Paralleler Rechnersysteme WS13/14 J.Simon 78 39
40 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
41 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
42 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
43 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
44 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
45 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 Co-array Fortran Titanium Fortress Chapel X10 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
46 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
Parallele Programmierung
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 PThreads
MehrMessage-Passing: Einführung
Message-Passing: Einführung Architecture of Parallel Computer Systems WS15/16 JSimon 1 Punkt zu Punkt Senden und Empfangen Message-Passing Mechanismus Erzeugung von Prozessen Übertragung einer Nachricht
MehrArchitektur paralleler Rechnersysteme - Effiziente HPC Systeme -
Architektur paralleler Rechnersysteme - Effiziente HPC Systeme - WS 12/13 Nr. L.079.05706 Master-Studiengang Informatik, V2/Ü1 www.uni-paderborn.de/pc2 Vorlesung: Architektur Paralleler Rechnersysteme
MehrProgrammierung von Parallelrechnern
Programmierung von Parallelrechnern Speichermodelle Gemeinsamer Speicher Verteilter Speicher Programmiermethoden Speichergekoppelt Nachrichtengekoppelt Programmierkonzepte Annotierung sequentieller Programme
MehrArchitecture of Parallel Computer Systems - Efficient HPC Systems -
Architecture of Parallel Computer Systems - Efficient HPC Systems - WS 15/16 L.079.05722 Master Course for Informatik and Computer Engineering V2/Ü1 www.uni-paderborn.de/pc2 Architecture of Parallel Computer
MehrMessage-Passing: Einführung
Message-Passing: Einführung Vorlesung: Architektur Paralleler Rechnersysteme WS14/15 J.Simon 1 Punkt zu Punkt Senden und Empfangen Message-Passing Mechanismus Erzeugung von Prozessen. Übertragung einer
MehrThreads Einführung. Zustände von Threads
Threads Einführung Parallelität : Zerlegung von Problemstellungen in Teilaufgaben, die parallelel ausgeführt werden können (einfachere Strukturen, eventuell schneller, Voraussetzung für Mehrprozessorarchitekturen)
MehrDas Message Passing Paradigma (1)
Das Message Passing Paradigma (1) Das Message Passing Paradigma (2) Sehr flexibel, universell, hoch effizient Programm kann logisch in beliebig viele Prozesse aufgeteilt werden Prozesse können unterschiedlichen
MehrParalleles Rechnen: MPI
Münster Paralleles Rechnen: MPI 11.12.2015 Top 500 Münster Paralleles Rechnen: MPI 2 /23 32 Großrechner in Deutschland unter den Top 500 davon 5 Systeme unter den Top 50 8 Hazel Hen (HLRS Stuttgart) 11
MehrArchitecture of Parallel Computer Systems - HPC Architecture -
Architecture of Parallel Computer Systems - HPC Architecture - J. Simon, C. Plessl SoSe 18 L.079.05810 Master Course for Informatik and Computer Engineering Embedded Systems, Wirtschaftsinformatik V2/Ü1
MehrKurzübersicht über die wichtigsten MPI-Befehle
Kurzübersicht über die wichtigsten MPI-Befehle Hans Joachim Pflug Rechen- und Kommunkationszentrum der RWTH Aachen Inhalt MPI_Init / MPI_Finalize...2 MPI_Comm_size / MPI_Comm_rank...3 MPI_Send / MPI_Recv...4
MehrExkurs: Paralleles Rechnen
Münster Exkurs: Paralleles Rechnen Münster Exkurs: Paralleles Rechnen 2 /21 Konzepte für Parallelrechner P P P C C C Gemeinsamer Speicher Verteilter Speicher Verbindungsnetzwerk Speicher M, Münster Exkurs:
MehrMessage-Passing: Einführung
Message-Passing: Einführung Vorlesung: Architektur Paralleler Rechnersysteme WS09/10 J.Simon 1 Punkt zu Punkt Senden und Empfangen Message-Passing Mechanismus Erzeugung von Prozessen. Übertragung einer
MehrShared-Memory Programmiermodelle
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
MehrParallele Programmierung mit OpenMP
Parallele Programmierung mit OpenMP - Eine kurze Einführung - 11.06.2003 RRZN Kolloquium SS 2003 1 Gliederung 1. Grundlagen 2. Programmiermodell 3. Sprachkonstrukte 4. Vergleich MPI und OpenMP 11.06.2003
MehrOpenMP Data Scope Clauses
OpenMP 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
MehrPThreads. Pthreads. Jeder Hersteller hatte eine eigene Implementierung von Threads oder light weight processes
PThreads Prozesse und Threads Ein Unix-Prozess hat IDs (process,user,group) Umgebungsvariablen Verzeichnis Programmcode Register, Stack, Heap Dateideskriptoren, Signale message queues, pipes, shared memory
MehrSysteme 1. Kapitel 6. Nebenläufigkeit und wechselseitiger Ausschluss
Systeme 1 Kapitel 6 Nebenläufigkeit und wechselseitiger Ausschluss Threads Die Adressräume verschiedener Prozesse sind getrennt und geschützt gegen den Zugriff anderer Prozesse. Threads sind leichtgewichtige
MehrArchitektur paralleler Rechnersysteme - Effiziente HPC Systeme -
Architektur paralleler Rechnersysteme - Effiziente HPC Systeme - WS 11/12 Nr. L.079.05701 Master-Studiengang Informatik, V2/Ü1 www.uni-paderborn.de/pc2 Vorlesung: Architektur Paralleler Rechnersysteme
Mehr4.4. MPI Message Passing Interface
4.4. MPI Message Passing Interface Ferienakademie 2009 Franz Diebold Agenda 1. Einführung, Motivation 2. Kommunikationsmodell 3. Punkt-Zu-Punkt-Kommunikation 4. Globale Kommunikation 5. Vergleich MPI und
MehrParallele Programmierung mit MPI
Parallele Programmierung mit MPI Marc-Oliver Straub entstanden aus: Parallele Programmierung mit MPI - ein Praktikum Warum Parallelprogrammierung große numerische Probleme (Simulation) optische Bildverarbeitung
MehrThreads. Foliensatz 8: Threads Folie 1. Hans-Georg Eßer, TH Nürnberg Systemprogrammierung, Sommersemester 2015
Sep 19 14:20:18 amd64 sshd[20494]: Accepted rsa for esser from ::ffff:87.234.201.207 port 61557 Sep 19 14:27:41 amd64 syslog-ng[7653]: STATS: dropped 0 Sep 20 01:00:01 amd64 /usr/sbin/cron[29278]: (root)
MehrComputergrundlagen Moderne Rechnerarchitekturen
Computergrundlagen Moderne Rechnerarchitekturen Axel Arnold Institut für Computerphysik Universität Stuttgart Wintersemester 2010/11 Aufbau eines modernen Computers DDR3- Speicher Prozessor Prozessor PEG
MehrComputergrundlagen Moderne Rechnerarchitekturen
Aufbau eines modernen Computers Computergrundlagen Moderne Rechnerarchitekturen Axel Arnold Institut für Computerphysik Universität Stuttgart DDR3- Speicher Prozessor Prozessor PEG Graphikkarte(n) weitere
MehrDie Programmiersprache Java. Dr. Wolfgang Süß Thorsten Schlachter
Die Programmiersprache Java Dr. Wolfgang Süß Thorsten Schlachter Eigenschaften von Java Java ist eine von der Firma Sun Microsystems entwickelte objektorientierte Programmiersprache. Java ist......a simple,
MehrModelle der Parallelverarbeitung
Modelle der Parallelverarbeitung Modelle der Parallelverarbeitung 12. Message Passing Interface Thomas Worsch Fakultät für Informatik Karlsruher Institut für Technologie Sommersemester 2017 1 / 36 Überblick
MehrEinführung in das parallele Programmieren mit MPI und Java
Einführung in das parallele Programmieren mit und Java Seite 1 Übersicht Parallele Prozesse und Erste Schritte mit Kollektive Kommunikation Weitere Möglichkeiten Seite 2 Literatur (1) Homepage des 2-Forums
Mehr4D Server v12 64-bit Version BETA VERSION
4D Server v12 64-bit Version BETA VERSION 4D Server v12 unterstützt jetzt das Windows 64-bit Betriebssystem. Hauptvorteil der 64-bit Technologie ist die rundum verbesserte Performance der Anwendungen und
MehrPraktikum: Paralleles Programmieren für Geowissenschaftler
Praktikum: Paralleles Programmieren für Geowissenschaftler Prof. Thomas Ludwig, Hermann Lenhart hermann.lenhart@zmaw.de MPI Einführung I: Einführung Nachrichtenaustausch mit MPI MPI point-to-point communication
MehrBinäre Bäume. 1. Allgemeines. 2. Funktionsweise. 2.1 Eintragen
Binäre Bäume 1. Allgemeines Binäre Bäume werden grundsätzlich verwendet, um Zahlen der Größe nach, oder Wörter dem Alphabet nach zu sortieren. Dem einfacheren Verständnis zu Liebe werde ich mich hier besonders
MehrThreads und OpenMP. Frank Mietke <frank.mietke@informatik.tu-chemnitz.de> Cluster- & Gridcomputing Frank Mietke 7/4/04
Threads und OpenMP Frank Mietke 1 Ziel der Vorlesungen Einführung in Threads Programmierung mit Threads Einführung in OpenMP Programmierung mit OpenMP 2 Was ist
MehrÜbersicht. Nebenläufige Programmierung. Praxis und Semantik. Einleitung. Sequentielle und nebenläufige Programmierung. Warum ist. interessant?
Übersicht Aktuelle Themen zu Informatik der Systeme: Nebenläufige Programmierung: Praxis und Semantik Einleitung 1 2 der nebenläufigen Programmierung WS 2011/12 Stand der Folien: 18. Oktober 2011 1 TIDS
MehrKlassenentwurf. Wie schreiben wir Klassen, die leicht zu verstehen, wartbar und wiederverwendbar sind? Objektorientierte Programmierung mit Java
Objektorientierte Programmierung mit Java Eine praxisnahe Einführung mit BlueJ Klassenentwurf Wie schreiben wir Klassen, die leicht zu verstehen, wartbar und wiederverwendbar sind? 1.0 Zentrale Konzepte
MehrEinführung in Java. PING e.v. Weiterbildung Andreas Rossbacher 24. März 2005
Einführung in Java PING e.v. Weiterbildung Andreas Rossbacher 24. März 2005 Gliederung 1. Was ist Java / Geschichte von Java 2. Prinzip der Plattformunabhängigkeit 3. Wie kommt man vom Quellcode zum Programm
MehrMPI-Programmierung unter Windows mit MPICH2. Installieren von MPICH2, Übersetzen, Ausführen und Debuggen von MPI-Programmen. Christian Terboven
MPI-Programmierung unter Windows mit MPIH2 Installieren von MPIH2, Übersetzen, Ausführen und Debuggen von MPI-Programmen hristian Terboven Rechen- und Kommunikationszentrum RWTH Aachen 1 02/2007 luster-installationsworkshop
MehrTutorium Rechnerorganisation
Woche 2 Tutorien 3 und 4 zur Vorlesung Rechnerorganisation 1 Christian A. Mandery: KIT Universität des Landes Baden-Württemberg und nationales Grossforschungszentrum in der Helmholtz-Gemeinschaft www.kit.edu
MehrÜbung 9 - Lösungsvorschlag
Universität Innsbruck - Institut für Informatik Datenbanken und Informationssysteme Prof. Günther Specht, Eva Zangerle Besprechung: 15.12.2008 Einführung in die Informatik Übung 9 - Lösungsvorschlag Aufgabe
MehrEin kleiner Einblick in die Welt der Supercomputer. Christian Krohn 07.12.2010 1
Ein kleiner Einblick in die Welt der Supercomputer Christian Krohn 07.12.2010 1 Vorschub: FLOPS Entwicklung der Supercomputer Funktionsweisen von Supercomputern Zukunftsvisionen 2 Ein Top10 Supercomputer
MehrObjektorientierte Programmierung
Objektorientierte Programmierung 1 Geschichte Dahl, Nygaard: Simula 67 (Algol 60 + Objektorientierung) Kay et al.: Smalltalk (erste rein-objektorientierte Sprache) Object Pascal, Objective C, C++ (wiederum
MehrFakultät Angewandte Informatik Lehrprofessur für Informatik 23.01.2012
WS 2011/2012 Fakultät Angewandte Informatik Lehrprofessur für Informatik 23.01.2012 Prof. Dr. Robert Lorenz Musterlösung zur Vorlesung Informatik I, Extrablatt zu komplexen Datenstrukturen Aufgabe 45 **
MehrEinige Grundlagen zu OpenMP
Einige Grundlagen zu OpenMP Stephanie Friedhoff, Martin Lanser Mathematisches Institut Universität zu Köln 22. Juni 2016 Überblick Was ist OpenMP? Basics Das OpenMP fork-join-modell Kompilieren und Ausführen
MehrParallel Processing in a Nutshell OpenMP & MPI kurz vorgestellt
Parallel Processing in a Nutshell & kurz vorgestellt 16. Juni 2009 1 / 29 1 Das Problem 2 2 / 29 1 Das Problem 2 3 2 / 29 1 Das Problem 2 3 4 2 / 29 1 Das Problem 2 3 4 2 / 29 Multi-Core Prozessoren halten
MehrProjektseminar Parallele Programmierung
HTW Dresden WS 2014/2015 Organisatorisches Praktikum, 4 SWS Do. 15:00-18:20 Uhr, Z136c, 2 Doppelstunden o.g. Termin ist als Treffpunkt zu verstehen Labore Z 136c / Z 355 sind Montag und Donnerstag 15:00-18:20
MehrEinführung in die C-Programmierung
Einführung in die C-Programmierung Warum C? Sehr stark verbreitet (Praxisnähe) Höhere Programmiersprache Objektorientierte Erweiterung: C++ Aber auch hardwarenahe Programmierung möglich (z.b. Mikrokontroller).
MehrLizenzierung von Windows Server 2012
Lizenzierung von Windows Server 2012 Das Lizenzmodell von Windows Server 2012 Datacenter und Standard besteht aus zwei Komponenten: Prozessorlizenzen zur Lizenzierung der Serversoftware und CALs zur Lizenzierung
MehrDynamic Ressource Management
best Open Systems Day Fall 2006 Dynamic Ressource Management Unterföhring Marco Kühn best Systeme GmbH kuehn@best.de Agenda Überblick Dynamic Resource Pools und FSS Dynamic Resource Memory RCAP Oracle
MehrObjektbasierte Entwicklung
Embedded Software Objektbasierte Entwicklung Objektorientierung in C? Prof. Dr. Nikolaus Wulff Objektbasiert entwickeln Ohne C++ wird meist C im alten Stil programmiert. => Ein endlose while-schleife mit
MehrSoftwaresysteme I Übungen Jürgen Kleinöder Universität Erlangen-Nürnberg Informatik 4, 2007 U9.fm
U9 9. Übung U9 9. Übung U9-1 Überblick Besprechung Aufgabe 6 (printdir) Posix-Threads U9.1 U9-2 Motivation von Threads U9-2 Motivation von Threads UNIX-Prozesskonzept: eine Ausführungsumgebung (virtueller
MehrMaster-Thread führt Programm aus, bis durch die Direktive
OpenMP seit 1998 Standard (www.openmp.org) für die Shared-Memory Programmierung; (Prä-)Compiler für viele Systeme kommerziell oder frei (z.b. Omni von phase.hpcc.jp/omni) verfügbar Idee: automatische Generierung
MehrVorkurs C++ Programmierung
Vorkurs C++ Programmierung Klassen Letzte Stunde Speicherverwaltung automatische Speicherverwaltung auf dem Stack dynamische Speicherverwaltung auf dem Heap new/new[] und delete/delete[] Speicherklassen:
MehrEinführung in die C++ Programmierung für Ingenieure
Einführung in die C++ Programmierung für Ingenieure MATTHIAS WALTER / JENS KLUNKER Universität Rostock, Lehrstuhl für Modellierung und Simulation 14. November 2012 c 2012 UNIVERSITÄT ROSTOCK FACULTY OF
MehrPropädeutikum. Dipl.-Inf. Frank Güttler
Propädeutikum 2015 Vorbereitungskurs Informatikstudium Erfolgreich Studieren Programmieren (C-Kurs) guettler@informatik.uni-leipzig.de Universität Leipzig Institut für Informatik Technische Informatik
MehrProgrammierkurs Java
Programmierkurs Java Dr. Dietrich Boles Aufgaben zu UE16-Rekursion (Stand 09.12.2011) Aufgabe 1: Implementieren Sie in Java ein Programm, das solange einzelne Zeichen vom Terminal einliest, bis ein #-Zeichen
MehrC++ Grundlagen. ++ bedeutet Erweiterung zum Ansi C Standard. Hier wird eine Funktion eingeleitet
C++ Grundlagen ++ bedeutet Erweiterung zum Ansi C Standard Hier wird eine Funktion eingeleitet Aufbau: In dieser Datei stehen die Befehle, die gestartet werden, wenn das Programm gestartet wird Int main()
MehrHomogene Multi-Core-Prozessor-Architekturen
Homogene Multi-Core-Prozessor-Architekturen Praktikum Parallele Rechnerarchitekturen Stefan Potyra Lehrstuhl für Informatik 3 (Rechnerarchitektur) Friedrich-Alexander-Universität Erlangen-Nürnberg WS 2009
MehrI 7. Übung. I-1 Überblick. Besprechung Aufgabe 5 (mysh) Online-Evaluation. Posix Threads. Ü SoS I I.1
I 7. Übung I 7. Übung I-1 Überblick Besprechung Aufgabe 5 (mysh) Online-Evaluation Posix Threads I.1 I-2 Evaluation I-2 Evaluation Online-Evaluation von Vorlesung und Übung SOS zwei TANs, zwei Fragebogen
Mehr2A Basistechniken: Weitere Aufgaben
2A Basistechniken: Weitere Aufgaben 2A.3 Programmierung unter UNIX/Linux 1. Gegeben sind einige Ausschnitte von C-Programmen, die unter UNIX/Linux ausgeführt werden sollen. Beantworten Sie die zugehörigen
MehrMonitore. Klicken bearbeiten
Sascha Kretzschmann Institut für Informatik Monitore Formatvorlage und deren Umsetzung des Untertitelmasters durch Klicken bearbeiten Inhalt 1. Monitore und Concurrent Pascal 1.1 Warum Monitore? 1.2 Monitordefinition
MehrProgrammieren in C. Felder, Schleifen und Fließkommaarithmetik. Prof. Dr. Nikolaus Wulff
Programmieren in C Felder, Schleifen und Fließkommaarithmetik Prof. Dr. Nikolaus Wulff Addition von Zahlen 1 2 3 4 5 #include int main() { int x,y,z,sum; x = 1; y = 2; z = 4; sum = x + y + z;
MehrComputeranwendung und Programmierung (CuP)
Computeranwendung und Programmierung (CuP) VO: Peter Auer (Informationstechnologie) UE: Norbert Seifter (Angewandet Mathematik) Organisatorisches (Vorlesung) Vorlesungszeiten Montag 11:15 12:45 Freitag
MehrKonzepte der parallelen Programmierung
Fakultät Informatik, Institut für Technische Informatik, Professur Rechnerarchitektur Konzepte der parallelen Programmierung Parallele Programmiermodelle Nöthnitzer Straße 46 Raum 1029 Tel. +49 351-463
MehrSynchronisations- Assistent
TimePunch Synchronisations- Assistent Benutzerhandbuch Gerhard Stephan Softwareentwicklung -und Vertrieb 25.08.2011 Dokumenten Information: Dokumenten-Name Benutzerhandbuch, Synchronisations-Assistent
MehrInstallation der SAS Foundation Software auf Windows
Installation der SAS Foundation Software auf Windows Der installierende Benutzer unter Windows muss Mitglied der lokalen Gruppe Administratoren / Administrators sein und damit das Recht besitzen, Software
MehrProtected User-Level DMA in SCI Shared Memory Umgebungen
Protected User-Level DMA in SCI Shared Memory Umgebungen Mario Trams University of Technology Chemnitz, Chair of Computer Architecture 6. Halle Chemnitz Seminar zu Parallelverarbeitung und Programmiersprachen
MehrUnterprogramme. Funktionen. Bedeutung von Funktionen in C++ Definition einer Funktion. Definition einer Prozedur
Unterprogramme Unterprogramme sind abgekapselte Programmfragmente, welche es erlauben, bestimmte Aufgaben in wiederverwendbarer Art umzusetzen. Man unterscheidet zwischen Unterprogrammen mit Rückgabewert
MehrComputerarithmetik ( )
Anhang A Computerarithmetik ( ) A.1 Zahlendarstellung im Rechner und Computerarithmetik Prinzipiell ist die Menge der im Computer darstellbaren Zahlen endlich. Wie groß diese Menge ist, hängt von der Rechnerarchitektur
MehrProgrammieren in Java
Programmieren in Java objektorientierte Programmierung 2 2 Zusammenhang Klasse-Datei In jeder *.java Datei kann es genau eine public-klasse geben wobei Klassen- und Dateiname übereinstimmen. Es können
MehrGPGPU mit NVIDIA CUDA
01.07.12 GPGPU mit NVIDIA CUDA General-Purpose on Formatvorlagecomputing des Graphics Processing durch Units Untertitelmasters mit KlickenCompute bearbeiten NVIDIA Unified Device Architecture Gliederung
MehrDistributed Computing Group
JAVA TUTORIAL Distributed Computing Group Vernetzte Systeme - SS 06 Übersicht Warum Java? Interoperabilität grosse und gut dokumentierte Library weit verbreitet Syntax sehr nahe an C Erfahrung: Java wird
MehrEinfache Arrays. Annabelle Klarl. Einführung in die Informatik Programmierung und Softwareentwicklung
Annabelle Klarl Zentralübung zur Vorlesung Einführung in die Informatik: http://www.pst.ifi.lmu.de/lehre/wise-13-14/infoeinf WS13/14 Action required now 1. Smartphone: installiere die App "socrative student"
MehrZählen von Objekten einer bestimmten Klasse
Zählen von Objekten einer bestimmten Klasse Ziel, Inhalt Zur Übung versuchen wir eine Klasse zu schreiben, mit der es möglich ist Objekte einer bestimmten Klasse zu zählen. Wir werden den ++ und den --
MehrGrundlagen von Python
Einführung in Python Grundlagen von Python Felix Döring, Felix Wittwer November 17, 2015 Scriptcharakter Programmierparadigmen Imperatives Programmieren Das Scoping Problem Objektorientiertes Programmieren
MehrProjektseminar Parallele Programmierung
HTW Dresden WS 2017/2018 Organisatorisches Praktikum, 4 SWS Do. 15:10-18:30 Uhr, Z136c, 2 Doppelstunden Labor Z 136c ist Donnerstag 15:10-18:30 reserviert, gemeinsam mit anderen Projektseminaren Selbständige
Mehr1. Übung zu "Numerik partieller Differentialgleichungen"
1. Übung zu "Numerik partieller Differentialgleichungen" Simon Gawlok, Eva Treiber Engineering Mathematics and Computing Lab 22. Oktober 2014 1 / 15 1 Organisatorisches 2 3 4 2 / 15 Organisatorisches Ort:
MehrDLLs (dynamic loaded libraries) mit MingW erstellen
DLLs (dynamic loaded libraries) mit MingW erstellen Autor: Michel D. Schmid Datum: April 2, 2009 Contents 1 Einführung 1 1.1 Open-Source Tools.......................................... 1 2 Beispiel 1:
MehrII. Grundlagen der Programmierung. 9. Datenstrukturen. Daten zusammenfassen. In Java (Forts.): In Java:
Technische Informatik für Ingenieure (TIfI) WS 2005/2006, Vorlesung 9 II. Grundlagen der Programmierung Ekkart Kindler Funktionen und Prozeduren Datenstrukturen 9. Datenstrukturen Daten zusammenfassen
MehrSoftwarelösungen: Versuch 4
Softwarelösungen: Versuch 4 Nichtstun in Schleife wird ersetzt durch zeitweilige Zurücknahme der Anforderung, um es anderen Prozessen zu erlauben, die Ressource zu belegen: /* Prozess 0 */ wiederhole flag[0]
MehrU9-3 Vergleich von Thread-Konzepten. U9-2 Motivation von Threads. U9-3 Vergleich von Thread-Konzepten (2) U9-1 Überblick
U9 9. Übung U9 9. Übung U9-1 Überblick Besprechung Aufgabe 6 (printdir) Posix-Threads U9.1 User-Level Threads: Federgewichtige Prozesse Realisierung von Threads auf Anwendungsebene innerhalb eines Prozesses
MehrPOSIX-Threads. Aufgabe 9 SP - Ü U10.1
U10 10. Übung U10 10. Übung POSIX-Threads Aufgabe 9 U10.1 U10-1 Motivation von Threads U10-1 Motivation von Threads UNIX-Prozesskonzept: eine Ausführungsumgebung (virtueller Adressraum, Rechte, Priorität,...)
MehrEinführung in die Programmiersprache C
Einführung in die Programmiersprache C Marcel Arndt arndt@ins.uni-bonn.de Institut für Numerische Simulation Universität Bonn Der Anfang Ein einfaches Programm, das Hello World! ausgibt: #include
MehrDie Programmiersprache C99: Zusammenfassung
Die Programmiersprache C99: Zusammenfassung Jörn Loviscach Versionsstand: 7. Dezember 2010, 19:30 Die nummerierten Felder sind absichtlich leer, zum Ausfüllen in der Vorlesung. Videos dazu: http://www.youtube.com/joernloviscach
MehrEinführung in die Java- Programmierung
Einführung in die Java- Programmierung Dr. Volker Riediger Tassilo Horn riediger horn@uni-koblenz.de WiSe 2012/13 1 Wichtig... Mittags keine Pommes... Praktikum A 230 C 207 (Madeleine + Esma) F 112 F 113
MehrDomänenmodell: Fadenkommunikation und -synchronisation
Domänenmodell: Fadenkommunikation und -synchronisation Alexander Humphreys, Reinhard Rösch, Fabian Scheler 15. Mai 2003 Inhaltsverzeichnis 1 Domänendefinition 1 2 Domänenlexikon 1 3 Konzeptmodelle 4 4
MehrProgrammieren in C. Macros, Funktionen und modulare Programmstruktur. Prof. Dr. Nikolaus Wulff
Programmieren in C Macros, Funktionen und modulare Programmstruktur Prof. Dr. Nikolaus Wulff Der C Präprozessor Vor einem Compile Lauf werden alle Präprozessor Kommandos/Makros ausgewertet. Diese sind
MehrBitte verwenden Sie nur dokumentenechtes Schreibmaterial!
VO 182.711 Prüfung Betriebssysteme 8. November 2013 KNr. MNr. Zuname, Vorname Ges.)(100) 1.)(35) 2.)(20) 3.)(45) Zusatzblätter: Bitte verwenden Sie nur dokumentenechtes Schreibmaterial! 1 Synchronisation
MehrStep by Step Webserver unter Windows Server 2003. von Christian Bartl
Step by Step Webserver unter Windows Server 2003 von Webserver unter Windows Server 2003 Um den WWW-Server-Dienst IIS (Internet Information Service) zu nutzen muss dieser zunächst installiert werden (wird
MehrÜbung: Verwendung von Java-Threads
Übung: Verwendung von Java-Threads Ziel der Übung: Diese Übung dient dazu, den Umgang mit Threads in der Programmiersprache Java kennenzulernen. Ein einfaches Java-Programm, das Threads nutzt, soll zum
MehrAbamsoft Finos im Zusammenspiel mit shop to date von DATA BECKER
Abamsoft Finos im Zusammenspiel mit shop to date von DATA BECKER Abamsoft Finos in Verbindung mit der Webshopanbindung wurde speziell auf die Shop-Software shop to date von DATA BECKER abgestimmt. Mit
MehrNative Zeichenketten (C-Strings)
Native Zeichenketten (C-Strings)... sind in C/C++ char-arrays. D.h. die Deklaration char msg[80]; kann Zeichenketten bis zur Länge 79 enthalten. (Direkte Zuweisungen wie msg="hallo!" sind jedoch nicht
MehrAufgabenblatt 6 Musterlösung
Prof. Dr. rer. nat. Roland Wismüller Aufgabenblatt 6 Musterlösung Vorlesung Betriebssysteme I Wintersemester 2018/19 Aufgabe 1: Implementierung von Threads (Bearbeitung zu Hause) Der größte Vorteil ist
MehrTapps mit XP-Mode unter Windows 7 64 bit (V2.0)
Tapps mit XP-Mode unter Windows 7 64 bit (V2.0) 1 Einleitung... 2 2 Download und Installation... 3 2.1 Installation von WindowsXPMode_de-de.exe... 4 2.2 Installation von Windows6.1-KB958559-x64.msu...
MehrTechnische Universität München SS 2006 Fakultät für Informatik 12. Oktober 2006 Prof. Dr. A. Knoll. Aufgabe 1 Transferfragen (Lösungsvorschlag)
Technische Universität München SS 2006 Fakultät für Informatik 12. Oktober 2006 Prof. Dr. A. Knoll Lösungsvorschläge der Klausur zu Einführung in die Informatik II Aufgabe 1 Transferfragen (Lösungsvorschlag)
MehrModellierung und Programmierung 1
Modellierung und Programmierung 1 Prof. Dr. Sonja Prohaska Computational EvoDevo Group Institut für Informatik Universität Leipzig 19. November 2015 Gültigkeitsbereich (Scope) von Variablen { int m; {
MehrMPI Message Passing Interface. Matus Dobrotka Jan Lietz
MPI Message Passing Interface Matus Dobrotka Jan Lietz 25.5.2016 MPI Ein Standard, der den Nachrichtenaustausch bei parallelen Berechnungen auf verteilten Computersystemen beschreibt MPI-Applikation mehrere
MehrDas erste Programm soll einen Text zum Bildschirm schicken. Es kann mit jedem beliebigen Texteditor erstellt werden.
Einfache Ein- und Ausgabe mit Java 1. Hallo-Welt! Das erste Programm soll einen Text zum Bildschirm schicken. Es kann mit jedem beliebigen Texteditor erstellt werden. /** Die Klasse hello sendet einen
MehrÜbungen zu Einführung in die Informatik: Programmierung und Software-Entwicklung: Lösungsvorschlag
Ludwig-Maximilians-Universität München WS 2015/16 Institut für Informatik Übungsblatt 9 Prof. Dr. R. Hennicker, A. Klarl Übungen zu Einführung in die Informatik: Programmierung und Software-Entwicklung:
Mehr1 Vom Problem zum Programm
Hintergrundinformationen zur Vorlesung GRUNDLAGEN DER INFORMATIK I Studiengang Elektrotechnik WS 02/03 AG Betriebssysteme FB3 Kirsten Berkenkötter 1 Vom Problem zum Programm Aufgabenstellung analysieren
MehrDämon-Prozesse ( deamon )
Prozesse unter UNIX - Prozessarten Interaktive Prozesse Shell-Prozesse arbeiten mit stdin ( Tastatur ) und stdout ( Bildschirm ) Dämon-Prozesse ( deamon ) arbeiten im Hintergrund ohne stdin und stdout
MehrVerhindert, dass eine Methode überschrieben wird. public final int holekontostand() {...} public final class Girokonto extends Konto {...
PIWIN I Kap. 8 Objektorientierte Programmierung - Vererbung 31 Schlüsselwort: final Verhindert, dass eine Methode überschrieben wird public final int holekontostand() {... Erben von einer Klasse verbieten:
Mehr