Tafelübung zu BS 2. Threadsynchronisation
|
|
- Insa Hartmann
- vor 5 Jahren
- Abrufe
Transkript
1 Tafelübung zu BS 2. Threadsynchronisation Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund Agenda Besprechung Aufgabe 1: Prozesse verwalten Fortsetzung Grundlagen C-Programmierung Aufgabe 2: Threadsynchronisation POSIX UNIX-Prozesse vs. POSIX-Threads Funktionen von Pthreads Mutex Condition Variables Vergleich: exec..(), fork(), pthread_create() Betriebssysteme: U2 Threadsynchronisation 2
2 Besprechung Aufgabe 1 Foliensatz Besprechung Betriebssysteme: U2 Threadsynchronisation 3 Grundlagen C-Programmierung Foliensatz C-Einführung (Folie 41 bis Ende) Betriebssysteme: U2 Threadsynchronisation 4
3 POSIX Portable Operating System Interface von IEEE entwickelte Schnittstellenstandardisierung unter UNIX ermöglicht einfache Applikationsportierung POSIX definiert u.a. eine standardisierte API zwischen Betriebssystem und einer Applikation Betriebssysteme: U2 Threadsynchronisation 5 UNIX-Prozess vs. POSIX-Threads UNIX-Prozesse: schwergewichtig (haben einen eigenen Adressraum) POSIX-Threads (kurz Pthreads): leichtgewichtig ein Prozess kann mehrere Threads haben (teilen sich den gleichen Adressraum) im Linux Kernel sind sogenannte linux_threads deklariert (je nach Kernel unterschiedlich) Pthreads bieten standardisierte Schnittstelle Pthreads verwenden intern Systemaufrufe jeder Pthread hat eine eigene ID (Typ pthread_t: unsigned long int) Betriebssysteme: U2 Threadsynchronisation 6
4 Funktionen für Pthreads (Übersicht) pthread_create( ); pthread_exit( ); pthread_join( ); pthread_self(); benötigen: #include <pthread.h> Main-Thread wartet auf Beendung des PThread bar Betriebssysteme: U2 Threadsynchronisation 7 Pthread Beispiel #include <pthread.h> #include <stdio.h> void* Hello(void *arg) { printf("hello! It's me, thread! ); pthread_exit(null); int main(void) { int status; pthread_t thread; status = pthread_create(&thread, NULL, &Hello, NULL); if (status) { /*Fehlerbehandlung*/ status = pthread_join(thread, NULL); if (status) { /*Fehlerbehandlung*/ pthread_exit(null); Betriebssysteme: U2 Threadsynchronisation 8
5 Funktionen für Pthreads (1) int pthread_create(pthread_t *thread, NULL, *start_routine, *arg); erstellt einen neuen Thread Argumente: thread: ID die dem Thread zugewiesen wird (muss eindeutig sein) attr: Attributobjekt (in unserem Fall: NULL) start_routine: Zeiger auf auszuführende Funktion arg: Zeiger auf Argument welches start_routine übergeben wird Rückgabewerte: 0, wenn erfolgreich 0, wenn Fehler Vorgeschriebene Signatur: void* threadfunc(void* args) Betriebssysteme: U2 Threadsynchronisation 9 Funktionen für Pthreads (2) void pthread_exit(void* retval); beendet den Thread retval: gibt den Exit-Status an, der zurückgegeben werden soll, wenn der Thread terminiert (optional NULL) Zur Erinnerung: void* stellvertretend für alle möglichen Zeiger. NULL ist gleichbedeutend mit (void*)0 Betriebssysteme: U2 Threadsynchronisation 10
6 Funktionen für Pthreads (3) int pthread_join(pthread_t thread, void **retval); sorgt dafür, dass der Aufrufer warten muss, bis der Thread mit der passenden ID (thread) terminiert retval nimmt den Exit-Status des beendeten Threads entgegen (in unserem Fall: NULL) Rückgabewerte: 0, wenn kein Fehler 0, wenn Fehler Betriebssysteme: U2 Threadsynchronisation 11 Funktionen für Pthreads (4) pthread_t pthread_self(void); Liefert die ID des aufrufenden Threads zurück Bei selbigen Thread entspricht dem Wert des ersten Zeigers der Funktion pthread_create(pthread_t *thread ) Rückgabe ist garantiert Vergleichsfunktion: int pthread_equal(pthread_t t1, pthread_t t2); Rückgabe: 0 bei Gleichheit = 0 bei Ungleichheit Betriebssysteme: U2 Threadsynchronisation 12
7 Was wird passieren? /* globale Variable */ int i = 0; /* Funktion von Thread 1 */ f1(){ i++; pthread_exit(null); /* Funktion von Thread 2 */ f2(){ i++; pthread_exit(null); Betriebssysteme: U2 Threadsynchronisation 13 Was kann passieren? Betriebssysteme: U2 Threadsynchronisation 14
8 Was kann passieren? Benötigen Mittel zur Synchronisation! Betriebssysteme: U2 Threadsynchronisation 15 Mutex Mutual exclusion (gegenseitiger Ausschluss) Atomares Objekt, welches einen gegenseitigen Ausschluss erzwingt Für unsere Übung: pthread_mutex_init(); pthread_mutex_destroy( ); pthread_mutex_lock( ); pthread_mutex_unlock( ); Betriebssysteme: U2 Threadsynchronisation 16
9 Mutex mit Pthreads (1) int pthread_mutex_init(pthread_mutex_t *mutex, *attr); initialisiert den Mutex, attr gibt spezielle Anforderungen für den Mutex an (meistens NULL) Mutex wird nicht sperrend initialisiert! int pthread_mutex_destroy(pthread_mutex_t *mutex); entfernt den Mutex, wenn er nicht weiter verwendet werden soll Rückgabewerte: 0, wenn erfolgreich, 0, Mutex konnte nicht initialisiert/zerstört werden Betriebssysteme: U2 Threadsynchronisation 17 Mutex mit Pthreads (2) int pthread_mutex_lock(pthread_mutex_t *mutex); betritt und sperrt den kritischen Bereich, den der Mutex beschreibt int pthread_mutex_unlock(pthread_mutex_t *mutex); verlässt den kritischen Bereich und gibt ihn wieder frei Mutex kann nur von dem Thread freigegeben werden, der ihn vorher gesperrt hat. Rückgabewerte: wenn 0 erfolgreich, 0 Mutex konnte nicht gelockt/unlockt werden Betriebssysteme: U2 Threadsynchronisation 18
10 Mutex Beispiel #include <pthread.h> int i=0; pthread_mutex_t lock; main() { pthread_mutex_init(&lock, NULL); /* erstelle zwei Threads... */ f1() { /* Thread 1 */ pthread_mutex_lock(&lock); i++; pthread_mutex_unlock(&lock); f2() { /* Thread 2 */ pthread_mutex_lock(&lock); i++; pthread_mutex_unlock(&lock); Betriebssysteme: U2 Threadsynchronisation 19 Condition Variables (1) Bedingungsvariablen an Bedingung gebundene Synchronisation ohne Bedingungsvariable müsste ständig die Bedingung innerhalb des kritischen Abschnitts abgefragt werden kostet unnötig Zeit wird immer zusammen mit Mutex verwendet int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr); initialisiert eine Bedingungsvariable mit cond und optionalen Attributen Rückgabewerte: wenn 0 erfolgreich, 0 Bedingungsvariable konnte nicht initialisiert werden Betriebssysteme: U2 Threadsynchronisation 20
11 Condition Variables (2) int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); blockiert den Zugang zum Mutex solange bis die Bedingung gilt sollte nur aufgerufen werden, wenn der kritische Abschnitt betreten wurde sobald die Bedingung erfüllt ist, bekommt der Thread automatisch den Mutex und sperrt diesen int pthread_cond_signal(pthread_cond_t *cond); weckt einen anderen Thread auf, der auf die Bedingung cond wartet. (welcher Thread aufgeweckt wird, bestimmt eine interne Warteschlange) int pthread_cond_broadcast(pthread_cond_t *cond); weckt alle wartenden Threads auf. Betriebssysteme: U2 Threadsynchronisation 21 Condition Variables Beispiel /* pthread_mutex_t pthread_mutex_t Producer Thread */ lock lock = = PTHREAD_MUTEX_INITIALIZER; PTHREAD_MUTEX_INITIALIZER; /* Consumer Thread */ pthread_cond_t pthread_cond_t canproduce canproduce = = PTHREAD_COND_INITIALIZER; PTHREAD_COND_INITIALIZER; if( pthread_mutex_lock(&lock) pthread_cond_t!=0 ) perror( producer pthread_cond_t canconsume mutex lock canconsume = error ); = PTHREAD_COND_INITIALIZER; PTHREAD_COND_INITIALIZER; perror( consumer mutex lock error ); int int main(void){ main(void){ if( bufferisfull() ) if( bufferisempty() ) pthread_cond_wait(&canproduce,&lock); pthread_t pthread_t threads[2]; threads[2]; pthread_cond_wait(&canconsume,&lock); pthread_create(&threads[0],null,&producer,&prodargs); pthread_create(&threads[0],null,&producer,&prodargs); pthread_create(&threads[1],null,&consumer,&consargs); /* pthread_create(&threads[1],null,&consumer,&consargs); Produce Data */ /* Consume Data */ /* Fill buffer */ /* Empty buffer */ for(int for(int i=2; i=2; i>=0; i>=0; i ){ i ){ if( pthread_mutex_unlock(&lock) pthread_join(threads[i],null); pthread_join(threads[i],null);!=0 ) perror( producer mutex unlock error ); perror( consumer mutex unlock error ); pthread_cond_signal(&canconsume); pthread_cond_signal(&canproduce); Betriebssysteme: U2 Threadsynchronisation 22
12 Condition Variables Beispiel /* Producer Thread */ perror( producer mutex lock error ); /* Consumer Thread */ perror( consumer mutex lock error ); if( bufferisfull() ) pthread_cond_wait(&canproduce,&lock); if( bufferisempty() ) pthread_cond_wait(&canconsume,&lock); /* Produce Data */ /* Fill buffer */ perror( producer mutex unlock error ); pthread_cond_signal(&canconsume); /* Consume Data */ /* Empty buffer */ perror( consumer mutex unlock error ); pthread_cond_signal(&canproduce); Betriebssysteme: U2 Threadsynchronisation 23 Condition Variables Beispiel /* Producer Thread */ perror( producer mutex lock error ); /* Consumer Thread */ perror( consumer mutex lock error ); if( bufferisfull() ) pthread_cond_wait(&canproduce,&lock); if( bufferisempty() ) pthread_cond_wait(&canconsume,&lock); /* Produce Data */ /* Fill buffer */ perror( producer mutex unlock error ); pthread_cond_signal(&canconsume); /* Consume Data */ /* Empty buffer */ perror( consumer mutex unlock error ); pthread_cond_signal(&canproduce); Betriebssysteme: U2 Threadsynchronisation 24
13 Condition Variables Beispiel /* Producer Thread */ perror( producer mutex lock error ); /* Consumer Thread */ perror( consumer mutex lock error ); if( bufferisfull() ) pthread_cond_wait(&canproduce,&lock); if( bufferisempty() ) pthread_cond_wait(&canconsume,&lock); /* Produce Data */ /* Fill buffer */ perror( producer mutex unlock error ); pthread_cond_signal(&canconsume); /* Consume Data */ /* Empty buffer */ perror( consumer mutex unlock error ); pthread_cond_signal(&canproduce); Betriebssysteme: U2 Threadsynchronisation 25 Condition Variables Beispiel /* Producer Thread */ perror( producer mutex lock error ); if( bufferisfull() ) pthread_cond_wait(&canproduce,&lock); /* Consumer Thread */ perror( consumer mutex lock error ); mutex wird if( bufferisempty() ) freigegeben pthread_cond_wait(&canconsume,&lock); /* Produce Data */ /* Fill buffer */ perror( producer mutex unlock error ); pthread_cond_signal(&canconsume); /* Consume Data */ /* Empty buffer */ perror( consumer mutex unlock error ); pthread_cond_signal(&canproduce); Betriebssysteme: U2 Threadsynchronisation 26
14 Condition Variables Beispiel /* Producer Thread */ perror( producer mutex lock error ); /* Consumer Thread */ perror( consumer mutex lock error ); if( bufferisfull() ) pthread_cond_wait(&canproduce,&lock); if( bufferisempty() ) pthread_cond_wait(&canconsume,&lock); /* Produce Data */ /* Fill buffer */ perror( producer mutex unlock error ); pthread_cond_signal(&canconsume); /* Consume Data */ /* Empty buffer */ perror( consumer mutex unlock error ); pthread_cond_signal(&canproduce); Betriebssysteme: U2 Threadsynchronisation 27 Condition Variables Beispiel /* Producer Thread */ perror( producer mutex lock error ); /* Consumer Thread */ perror( consumer mutex lock error ); if( bufferisfull() ) pthread_cond_wait(&canproduce,&lock); if( bufferisempty() ) pthread_cond_wait(&canconsume,&lock); /* Produce Data */ /* Fill buffer */ perror( producer mutex unlock error ); pthread_cond_signal(&canconsume); /* Consume Data */ /* Empty buffer */ perror( consumer mutex unlock error ); pthread_cond_signal(&canproduce); Betriebssysteme: U2 Threadsynchronisation 28
15 Condition Variables Beispiel /* Producer Thread */ perror( producer mutex lock error ); /* Consumer Thread */ perror( consumer mutex lock error ); if( bufferisfull() ) pthread_cond_wait(&canproduce,&lock); if( bufferisempty() ) pthread_cond_wait(&canconsume,&lock); /* Produce Data */ /* Fill buffer */ perror( producer mutex unlock error ); pthread_cond_signal(&canconsume); /* Consume Data */ /* Empty buffer */ perror( consumer mutex unlock error ); pthread_cond_signal(&canproduce); Betriebssysteme: U2 Threadsynchronisation 29 Condition Variables Beispiel /* Producer Thread */ perror( producer mutex lock error ); /* Consumer Thread */ perror( consumer mutex lock error ); if( bufferisfull() ) pthread_cond_wait(&canproduce,&lock); /* Produce Data */ /* Fill buffer */ perror( producer mutex unlock error ); pthread_cond_signal(&canconsume); if( bufferisempty() ) pthread_cond_wait(&canconsume,&lock); mutex wird automatisch /* Consume Data */ gelockt /* Empty buffer */ perror( consumer mutex unlock error ); pthread_cond_signal(&canproduce); Betriebssysteme: U2 Threadsynchronisation 30
16 Condition Variables Beispiel /* Producer Thread */ perror( producer mutex lock error ); /* Consumer Thread */ perror( consumer mutex lock error ); if( bufferisfull() ) pthread_cond_wait(&canproduce,&lock); if( bufferisempty() ) pthread_cond_wait(&canconsume,&lock); /* Produce Data */ /* Fill buffer */ perror( producer mutex unlock error ); pthread_cond_signal(&canconsume); /* Consume Data */ /* Empty buffer */ perror( consumer mutex unlock error ); pthread_cond_signal(&canproduce); Betriebssysteme: U2 Threadsynchronisation 31 Condition Variables Beispiel /* Producer Thread */ perror( producer mutex lock error ); /* Consumer Thread */ perror( consumer mutex lock error ); if( bufferisfull() ) pthread_cond_wait(&canproduce,&lock); if( bufferisempty() ) pthread_cond_wait(&canconsume,&lock); /* Produce Data */ /* Fill buffer */ perror( producer mutex unlock error ); pthread_cond_signal(&canconsume); /* Consume Data */ /* Empty buffer */ perror( consumer mutex unlock error ); pthread_cond_signal(&canproduce); Betriebssysteme: U2 Threadsynchronisation 32
17 Vergleich: exec..() fork() pthread_create() Überlagerung eines Prozesses Keine gemeinsamen Daten schwergewichtig Prozess A STACK DATA, BSS, HEAP /* TEXT Segment prog1 */ exec..( prog2...); Betriebssysteme: U2 Threadsynchronisation 33 Vergleich: exec..() fork() pthread_create() Überlagerung eines Prozesses Keine gemeinsamen Daten schwergewichtig Prozess A STACK DATA,, BSS,, HEAP /* /* TEXT Segment prog2 */ */ int int main(...) Betriebssysteme: U2 Threadsynchronisation 34
18 Vergleich: exec..() fork() pthread_create() Verzweigung eines Prozesses Gemeinsame Daten: shared-memory schwergewichtig Prozess A STACK DATA, BSS, HEAP /* TEXT Segment */ switch(fork()){ case 1: exit(exit_failure); case 0:... break; case default:... break; Betriebssysteme: U2 Threadsynchronisation 35 Vergleich: exec..() fork() pthread_create() Verzweigung eines Prozesses Gemeinsame Daten: shared-memory schwergewichtig Prozess A Prozess B STACK DATA, BSS, HEAP STACK DATA, BSS, HEAP /* TEXT Segment */ switch(fork()){ case 1: exit(exit_failure); case 0:... break; case default:... break; Betriebssysteme: U2 Threadsynchronisation 36
19 Vergleich: exec..() fork() pthread_create() Verzweigung eines Prozesses Gemeinsame Daten: shared-memory schwergewichtig Prozess A Prozess B STACK DATA, BSS, HEAP STACK DATA, BSS, HEAP /* TEXT Segment */ switch(fork()){ case 1: exit(exit_failure); case 0:... break; case default:... break; SHARED MEMORY Betriebssysteme: U2 Threadsynchronisation 37 Vergleich: exec..() fork() pthread_create() Verzweigung eines Prozesses Gemeinsame Daten: shared-memory schwergewichtig Prozess A Prozess B STACK DATA, BSS, HEAP STACK DATA, BSS, HEAP /* TEXT Segment */ switch(fork()){ case 1: exit(exit_failure); case 0: Erzeugung... break; case default:... break; und Anbindung nötig SHARED MEMORY Zugriff muss durch Semaphore synchronisiert werden Betriebssysteme: U2 Threadsynchronisation 38
20 Vergleich: exec..() fork() pthread_create() Aufteilung eines Prozesses Gemeinsame Daten: Data, BSS, Heap, shared-memory leichtgewichtig Prozess A STACK DATA, BSS, HEAP /* TEXT Segment */ int main(void){... pthread_create(,&newthread,(void*)&thargs);... Betriebssysteme: U2 Threadsynchronisation 39 Vergleich: exec..() fork() pthread_create() Aufteilung eines Prozesses Gemeinsame Daten: Data, BSS, Heap, shared-memory leichtgewichtig Prozess A MainThread STACK NEWthread STACK DATA, BSS, HEAP /* TEXT Segment */ int main(void){ new thread void *NEWthread(void *thargs){ pthread_create( ); pthread_exit((void*)0); Betriebssysteme: U2 Threadsynchronisation 40
21 Vergleich: exec..() fork() pthread_create() Aufteilung eines Prozesses Gemeinsame Daten: Data, BSS, Heap, shared-memory leichtgewichtig Prozess A MainThread STACK NEWthread STACK DATA, BSS, HEAP /* TEXT Segment */ Zugriff muss durch Mutexe oder Semaphore synchronisiert werden int main(void){ new thread void *NEWthread(void *thargs){ pthread_create( ); pthread_exit((void*)0); Betriebssysteme: U2 Threadsynchronisation 41 Linux-Systemcalls (hier für x86) Einzige Möglichkeit für Userspace-Programme auf Kernelspace-Funktionen zuzugreifen Jedem Systemcall ist eine eindeutige Nummer zugeordnet arch/x86/kernel/syscall_table_32.s ENTRY(sys_call_table).long sys_restart_syscall /* 0 */.long sys_exit /* 1 */.long sys_fork /* 2 */.long sys_read /* 3 */.long sys_write /* 4 */.long sys_open /* 5 */... Direkter Aufruf von Systemcalls z.b. per syscall(2) #define _GNU_SOURCE #include <unistd.h> #include <sys/syscall.h> /* hier wird SYS_read=3 definiert */ #include <sys/types.h> int main(int argc, char *argv[]) {... syscall(sys_read, fd, &buffer, nbytes); /* read(fd, &buffer, nbytes) */ return 0; Betriebssysteme: U2 Threadsynchronisation 42
22 Systemstruktur Applikation pthread_...() Applikation Applikation... Userspace pthread Lib. fast userspace mutex clone/futex Systemcall Schnittstelle Kernel Subsysteme Kernelspace Gerätetreiber Hardware Betriebssysteme: U2 Threadsynchronisation 43 Ablauf eines Systemcalls 1) Argumente Stack (Konvention: Letztes zuerst) 2) Aufruf der Bibliotheksfunktion (Implizit: push Rücksprungadresse) 3) Argumente in Register laden (Stack für User und Kernel versch.) 4) Interrupt auslösen 5) Interruptnummer Index in Tabelle, hält Adressen der Zielfunktionen 6) Zielfunktion wählt mit eax Funktion aus (Array aus Funktionspointern) 7) Kernel: sys_read() 8) Mode-Wechsel (alter Userstack) 9) Ausführung fährt fort 10) Rücksprungadr. noch auf Stack 11) Stack aufräumen Betriebssysteme: U2 Threadsynchronisation 44
23 Beispiel: _exit(255) per Hand Parameter von Systemcalls: < 6 Parameter: Parameter werden in den Registern ebx, ecx, edx, esi, edi abgelegt >= 6 Parameter: ebx enthält Pointer auf Userspace mit Parametern Aufruf des sys_exit Systemcalls per Assembler void _exit(int status) (beende den aktuellen Prozess mit Statuscode status) sys_exit Systemcall hat die Nr. 0x01 myexit.c int main(void) { asm("mov $0x01, %eax\n" /* syscall # in eax */ "mov $0xff, %ebx\n" /* Parameter 255 in ebx */ "int $0x80\n"); /* Softwareinterrupt an Kernel */ return 0; pohl@host:~$./myexit pohl@host:~$ echo $? 255 pohl@host:~$ Betriebssysteme: U2 Threadsynchronisation 45
Tafelübung zu BS 2. Threadsynchronisation
Tafelübung zu BS 2. Threadsynchronisation Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/
MehrBesprechung Aufgabe 1: Prozesse verwalten Fortsetzung Grundlagen C-Programmierung Aufgabe 2: Threadsynchronisation
Betriebssysteme Tafelübung 2. Thread-Synchronisation http://ess.cs.tu-dortmund.de/de/teaching/ss2016/bs/ Olaf Spinczyk olaf.spinczyk@tu-dortmund.de http://ess.cs.tu-dortmund.de/~os AG Eingebettete Systemsoftware
MehrBetriebssysteme. Tafelübung 2. Thread-Synchronisation. Olaf Spinczyk.
Betriebssysteme Tafelübung 2. Thread-Synchronisation http://ess.cs.tu-dortmund.de/de/teaching/ss2016/bs/ Olaf Spinczyk olaf.spinczyk@tu-dortmund.de http://ess.cs.tu-dortmund.de/~os AG Eingebettete Systemsoftware
MehrTafelübung zu BS 2. Threadsynchronisation
Tafelübung zu BS 2. Threadsynchronisation Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/
MehrTafelübung zu BSRvS 1 4. Speicherverwaltung
Tafelübung zu BSRvS 1 4. Speicherverwaltung Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/
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
MehrTafelübung zu BS 4. Speicherverwaltung
Tafelübung zu BS 4. Speicherverwaltung Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2010/bs/
Mehr4. Speicherverwaltung
Tafelübung zu BSRvS1 4. Speicherverwaltung Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/teaching/ss2008/bsrvs1/exercises/
Mehr4. Speicherverwaltung
Tafelübung zu BSRvS1 4. Speicherverwaltung Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/teaching/ss2008/bsrvs1/exercises/
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
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
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,...)
MehrTafelübung zu BS 5. Dateioperationen
Tafelübung zu BS 5. Dateioperationen Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2012/bs/
MehrTafelübung zu BS 5. Dateioperationen
Tafelübung zu BS 5. Dateioperationen Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2012/bs/
MehrU8 POSIX-Threads U8 POSIX-Threads
U8 POSIX-Threads U8 POSIX-Threads Motivation Thread-Konzepte pthread-api pthread-koordinierung U8.1 U8-1 Motivation von Threads U8-1 Motivation von Threads UNIX-Prozesskonzept: eine Ausführungsumgebung
MehrU8-1 Motivation von Threads. U8-2 Vergleich von Thread-Konzepten. U8-2 Vergleich von Thread-Konzepten (2) Motivation
U8 POSIX-Threads U8 POSIX-Threads U8-1 Motivation von Threads U8-1 Motivation von Threads Motivation Thread-Konzepte UNIX-Prozesskonzept: eine Ausführungsumgebung (virtueller Adressraum, Rechte, Priorität,...)
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
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)
MehrAufgabe 9: recgrep rekursive, parallele Suche (letzte Aufgabe)
U6 6. Übung (Mathematik / Technomathematik) U6 6. Übung (Mathematik / Technomathematik) Besprechung Aufgabe 4 (halde) Besprechung Aufgabe 5 (crawl) Besprechung der Mini-Klausur POSIX-Threads Motivation
MehrÜbungen zu Systemprogrammierung 1
Übungen zu Systemprogrammierung 1 Ü5 Threads und Koordinierung Sommersemester 2018 Christian Eichler, Jürgen Kleinöder Lehrstuhl für Informatik 4 Friedrich-Alexander-Universität Erlangen-Nürnberg Lehrstuhl
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)
MehrTafelübung zu BS 1. Prozesse, Shell
Tafelübung zu BS 1. Prozesse, Shell Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2012/bs/
MehrÜbungen zu Systemprogrammierung 1 (SP1)
Übungen zu Systemprogrammierung 1 (SP1) Ü5 Threads und Koordinierung Andreas Ziegler, Stefan Reif, Jürgen Kleinöder Lehrstuhl für Informatik 4 Verteilte Systeme und Betriebssysteme Friedrich-Alexander-Universität
MehrTafelübung zu BS 1. Prozesse, Shell
Tafelübung zu BS 1. Prozesse, Shell Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2012/bs/
MehrEinführung in POSIX Threads
Einführung in POSIX Threads Radu Prodan Institut für Informatik, Universität Innsbruck Verteilte und Parallele Systeme http://dps.uibk.ac.at 04.05.2012 R. Prodan, Betriebssysteme, Sommersemester 2012 1
MehrBetriebssysteme. Probeklausur. Olaf Spinczyk.
Betriebssysteme Probeklausur https://ess.cs.tu-dortmund.de/de/teaching/ss2018/bs/ Olaf Spinczyk olaf.spinczyk@tu-dortmund.de https://ess.cs.tu-dortmund.de/~os AG Eingebettete Systemsoftware Informatik
MehrInhalt. Übungen zu Systemnahe Programmierung in C (SPiC) Inhalt. Motivation
Übungen zu Systemnahe Programmierung in C (SPiC) Sebastian Maier (Lehrstuhl Informatik 4) Übung 0 Inhalt vs. Prozesse POSIX Stoppuhr Sommersemester 206 Lehrstuhl Informatik 4 Übungen zu SPiC (SS 206) 2
MehrÜbungen zu Systemprogrammierung 1 (SP1)
Übungen zu Systemprogrammierung 1 (SP1) Ü7 Threads und Koordinierung Jens Schedel, Christoph Erhardt, Jürgen Kleinöder Lehrstuhl für Informatik 4 Verteilte Systeme und Betriebssysteme Friedrich-Alexander-Universität
MehrU23 - Shellcode. Twix Chaos Computer Club Cologne. Motivation Einstieg Der erste Shellcode Nullbytes, NOP Slides
Twix e.v. http://koeln.ccc.de 2016-11-28 Überblick 1 Motivation Was ist Shellcode? Beispiel 2 Einstieg Erzeugen, Testen von Shellcode 3 Der erste Shellcode Strings in Shellcode 4 Nullbytes, NOP Slides
MehrTafelübung zu BS 3. Die Bibliothek
Tafelübung zu BS 3. Die Bibliothek Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2010/bs/
MehrÜbungen zu Systemnahe Programmierung in C (SPiC) Sommersemester 2018
Übungen zu Systemnahe Programmierung in C (SPiC) Sommersemester 2018 Übung 10 Benedict Herzog Sebastian Maier Lehrstuhl für Informatik 4 Friedrich-Alexander-Universität Erlangen-Nürnberg Lehrstuhl für
MehrThreads. Netzwerk - Programmierung. Alexander Sczyrba Jan Krüger
Netzwerk - Programmierung Threads Alexander Sczyrba asczyrba@cebitec.uni-bielefeld.de Jan Krüger jkrueger@cebitec.uni-bielefeld.de Übersicht Probleme mit fork Threads Perl threads API Shared Data Mutexes
MehrÜbungen zu Systemnahe Programmierung in C (SPiC)
Übungen zu Systemnahe Programmierung in C (SPiC) Sebastian Maier (Lehrstuhl Informatik 4) Übung 10 Sommersemester 2016 Inhalt Threads Motivation Threads vs. Prozesse Kritische Abschnitte Speedup & Amdahl
MehrÜbungen zu Systemnahe Programmierung in C (SPiC) Inhalt. Sebastian Maier (Lehrstuhl Informatik 4) Übung 10. Sommersemester 2016
Übungen zu Systemnahe Programmierung in C (SPiC) Sebastian Maier (Lehrstuhl Informatik 4) Übung 10 Sommersemester 2016 Inhalt Motivation vs. Prozesse Kritische Abschnitte Speedup & Amdahl s Gesetz POSIX
MehrTafelübung zu BSRvS 1 3. Kreuzung
Tafelübung zu BSRvS 1 3. Kreuzung Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2009/bsrvs1/
MehrTafelübung zu BSRvS 1 1. Prozesse, at
Tafelübung zu BSRvS 1 1. Prozesse, at Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os http://ess.cs.tu-dortmund.de/de/teaching/ss2009/bsrvs1/
MehrPthreads. David Klaftenegger. Seminar: Multicore Programmierung Sommersemester
Seminar: Multicore Programmierung Sommersemester 2009 16.07.2009 Inhaltsverzeichnis 1 Speichermodell 2 3 Implementierungsvielfalt Prioritätsinversion 4 Threads Speichermodell Was sind Threads innerhalb
MehrConcurrency and Processes of Pthreads
Concurrency and Processes of Pthreads Pthreads Pthreads is a POSIX standard for describing a thread model, it specifies the API and the semantics of the calls. POSIX: Portable Operating System Interface
MehrMultithread Programming
Vorlesung Rechnerarchitektur 2 Seite 150 Threads versus Processes Processes execute in separate address spaces (schwergewichtige Prozesse) communicate via IPC mechanisms (sockets, pipes, signals) Thread
MehrTafelübung zu BS 1. Prozesse, ToothBrush
Tafelübung zu BS 1. Prozesse, ToothBrush Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/
MehrLinux Prinzipien und Programmierung
Linux Prinzipien und Programmierung Dr. Klaus Höppner Hochschule Darmstadt Sommersemester 2014 1 / 28 Kritische Bereiche bei Threads Deadlocks Conditions/Semaphore 2 / 28 Beispiel aus der letzten Vorlesung
MehrTafelübung zu BS 1. Prozesse, ToothBrush
Tafelübung zu BS 1. Prozesse, ToothBrush Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/
MehrVorlesung Betriebssysteme I
1 / 22 Vorlesung Betriebssysteme I Thema 8: Threads (Aktivitäten, die zweite) Robert Baumgartl 25. Januar 2018 Threads (Leichtgewichtsprozesse) 2 / 22 Prozess = Container für Ressourcen + (ein) identifizierbarer
MehrÜbungen zu Systemprogrammierung 1 (SP1)
Übungen zu Systemprogrammierung 1 (SP1) Ü5 Threads und Koordinierung Christian Eichler, Andreas Ziegler, Jürgen Kleinöder Lehrstuhl für Informatik 4 Verteilte Systeme und Betriebssysteme Friedrich-Alexander-Universität
MehrTafelübung zu BS 4. Speicherverwaltung
Tafelübung zu BS 4. Speicherverwaltung Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2014/bs/
MehrTafelübung zu BSRvS1. 3. Philosophen. Fortsetzung Grundlagen C-Programmierung
Tafelübung zu BSRvS1 3. Philosophen Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/teaching/ss2008/bsrvs1/exercises/
Mehr3. Philosophen. Tafelübung zu BSRvS1. Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware. Lehrstuhl für Informatik 12 TU Dortmund
Tafelübung zu BSRvS1 3. Philosophen Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/teaching/ss2008/bsrvs1/exercises/
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
MehrBetriebssysteme. Agenda. Tafelübung 3. Deadlock. Olaf Spinczyk.
Betriebssysteme Tafelübung 3. Deadlock http://ess.cs.tu-dortmund.de/de/teaching/ss2016/bs/ Olaf Spinczyk olaf.spinczyk@tu-dortmund.de http://ess.cs.tu-dortmund.de/~os AG Eingebettete Systemsoftware Informatik
MehrUser-Level-Threads (Koroutinen) Realisierung von Threads auf Benutzerebene innerhalb eines Prozesses
52 Überblick über die 12. Übung Überblick über die 12. Übung 54 Vergleich von Prozeß und Thread-Konzepten mehrere UNIX-Prozesse mit gemeinsamen Speicherbereichen POSIX-Threads Bewertung: + echte Parallelität
MehrEchtzeitbetriebssysteme (am Beispiel QNX) Dr. Stefan Enderle HS Esslingen
Echtzeitbetriebssysteme (am Beispiel QNX) Dr. Stefan Enderle HS Esslingen 3. QNX Neutrino Microkernel 3.1 Einführung Der Neutrino-Kernel (Betriebssystemkern) implementiert (nur) die wichtigsten Teile des
MehrBetriebssysteme. Probeklausur. Olaf Spinczyk.
Betriebssysteme https://ess.cs.tu-dortmund.de/de/teaching/ss/bs/ Olaf Spinczyk olaf.spinczyk@tu-dortmund.de https://ess.cs.tu-dortmund.de/~os G Eingebettete Systemsoftware Informatik, TU Dortmund blauf
MehrTafelübung zu BS 4. Speicherverwaltung
Tafelübung zu BS 4. Speicherverwaltung Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2014/bs/
MehrBesprechung Aufgabe 5 (crawl) POSIX-Threads. Problem: UNIX-Prozesskonzept ist für viele heutige Anwendungen unzureichend
U7 6. Übung U7 6. Übung U7-1 Motivation von Threads U7-1 Motivation von Threads Besprechung Aufgabe 5 (crawl) OSIX-Threads Motivation Thread-Konzepte pthread-ai Koordinierung UNIX-rozesskonzept: eine Ausführungsumgebung
MehrTafelübung zu BS 5. Dateioperationen
Tafelübung zu BS 5. Dateioperationen Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2014/bs/
MehrTafelübung zu BS 4. Dateioperationen
Tafelübung zu BS 4. Dateioperationen Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2013/bs/
MehrBetriebssysteme. Einführung C. Olaf Spinczyk.
Betriebssysteme Einführung C http://ess.cs.tu-dortmund.de/de/teaching/ss2016/bs/ Olaf Spinczyk olaf.spinczyk@tu-dortmund.de http://ess.cs.tu-dortmund.de/~os AG Eingebettete Systemsoftware Informatik 12,
MehrTafelübung zu BS 1. Prozesse verwalten
Tafelübung zu BS 1. Prozesse verwalten Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2015/bs/
MehrU6-1 Organisatories. U6-2 Motivation von Threads. U6-3 Vergleich von Thread-Konzepten. Organisatorisches
U6 6. Übung U6 6. Übung U6-1 Organisatories U6-1 Organisatories Organisatorisches Zusätzliche Tafelübung zur S1-Klaurvorbereitung Besprechung Aufgabe 5 (crawl) OSIX-Threads Motivation Thread-Konzepte am
MehrPOSIX Solaris thread management pthread_create thr_create pthread_exit thr_exit pthread_kill thr_kill pthread_self thr_self
Kapitel 5 threads Unter einem thread versteht die Folge von Anweisungen (Adressen im Programmspeicher) die einem Programm entsprechen. Im Normalfall ist dies ein gleichbleibender Strom von Anweisungen.
MehrTafelübung zu BSRvS 1 2. Prozesssynchronisation
Tafelübung zu BSRvS 1 2. Prozesssynchronisation Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/
MehrAlle Fäden in der Hand
Alle Fäden in der Hand Thread Programmierung unter Linux in C und C++ (Teil 1) Wolfgang Schreiner Threads (zu deutsch "Fäden") ermöglichen die gleichzeitige Ausführung von mehreren Programmpfaden innerhalb
MehrSystemnahe Programmierung in C Übungen Jürgen Kleinöder, Michael Stilkerich Universität Erlangen-Nürnberg Informatik 4, 2011 U7.fm
U7 POSIX-Prozesse U7 POSIX-Prozesse Prozesse POSIX-Prozess-Systemfunktionen Aufgabe 7 U7.1 U7-1 Prozesse: Überblick U7-1 Prozesse: Überblick Prozesse sind eine Ausführumgebung für Programme haben eine
MehrMarkus Klußmann, Amjad Saadeh Institut für Informatik. Pthreads. von Markus Klußmann und Amjad Saadeh. Pthreads
Markus Klußmann, Amjad Saadeh Institut für Informatik Pthreads von Markus Klußmann und Amjad Saadeh Pthreads Inhalt - Was sind Threads? - Prozess vs. Thread - Kurzer Überblick POSIX - Threads im Betriebssystem
MehrU7 POSIX-Prozesse U7 POSIX-Prozesse
U7 POSIX-Prozesse U7 POSIX-Prozesse Prozesse POSIX-Prozess-Systemfunktionen Aufgabe 6 U7.1 U7-1 Prozesse: Überblick U7-1 Prozesse: Überblick Prozesse sind eine Ausführumgebung für Programme haben eine
MehrBetriebssysteme. A1- Prozesse. Olaf Spinczyk.
Betriebssysteme A1- Prozesse https://ess.cs.tu-dortmund.de/de/teaching/ss2018/bs/ Olaf Spinczyk olaf.spinczyk@tu-dortmund.de http://ess.cs.tu-dortmund.de/~os AG Eingebettete Systemsoftware Informatik 12,
MehrBetriebssysteme. Tafelübung 4. Speicherverwaltung. Olaf Spinczyk.
Betriebssysteme Tafelübung 4. Speicherverwaltung http://ess.cs.tu-dortmund.de/de/teaching/ss217/bs/ Olaf Spinczyk olaf.spinczyk@tu-dortmund.de http://ess.cs.tu-dortmund.de/~os AG Eingebettete Systemsoftware
MehrBetriebssysteme. Agenda. Tafelübung 4. Speicherverwaltung. Olaf Spinczyk.
Betriebssysteme Tafelübung 4. Speicherverwaltung http://ess.cs.tu-dortmund.de/de/teaching/ss217/bs/ Olaf Spinczyk olaf.spinczyk@tu-dortmund.de http://ess.cs.tu-dortmund.de/~os AG Eingebettete Systemsoftware
Mehre) Welche Aussage zu Speicherzuteilungsverfahren ist falsch?
Aufgabe 1: (1) Bei den Multiple-Choice-Fragen ist jeweils nur eine richtige Antwort eindeutig anzukreuzen. Auf die richtige Antwort gibt es die angegebene Punktzahl. Wollen Sie eine Multiple-Choice-Antwort
MehrTafelübung zu BS 5. Dateioperationen
Tafelübung zu BS 5. Dateioperationen Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2011/bs/
MehrBetriebssysteme. A1- Prozesse. Olaf Spinczyk.
Betriebssysteme A1- Prozesse https://ess.cs.tu-dortmund.de/de/teaching/ss2017/bs/ Olaf Spinczyk olaf.spinczyk@tu-dortmund.de http://ess.cs.tu-dortmund.de/~os AG Eingebettete Systemsoftware Informatik 12,
MehrBetriebssysteme. Tafelübung 4. Speicherverwaltung. Olaf Spinczyk.
Betriebssysteme Tafelübung 4. Speicherverwaltung https://ess.cs.tu-dortmund.de/de/teaching/ss2018/bs/ Olaf Spinczyk olaf.spinczyk@tu-dortmund.de https://ess.cs.tu-dortmund.de/~os AG Eingebettete Systemsoftware
MehrSystemaufrufe. Dr.-Ing. Matthias Sand. Lehrstuhl für Informatik 3 (Rechnerarchitektur) Friedrich-Alexander-Universität Erlangen-Nürnberg WS 2010/2011
Systemaufrufe Dr.-Ing. Matthias Sand Lehrstuhl für Informatik 3 (Rechnerarchitektur) Friedrich-Alexander-Universität Erlangen-Nürnberg WS 2010/2011 Systemaufrufe 1/17 2010-09-13 Motivation Am Beispiel
MehrTafelübung zu BS 1. Prozesse verwalten
Tafelübung zu BS 1. Prozesse verwalten Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2013/bs/
MehrAufgabe 6: palim rekursive, parallele Suche nach einer Zeichenkette
U6 6. Übung U6 6. Übung Besprechung Aufgabe 4 (halde) OSIX-Threads Motivation Thread-Konzepte pthread-ai Koordinierung Aufgabe 6: palim rekursive, parallele Suche nach einer Zeichenkette U6.1 U6-1 Motivation
MehrBetriebssysteme. Tafelübung 3. Deadlock. Olaf Spinczyk.
Betriebssysteme Tafelübung 3. Deadlock http://ess.cs.tu-dortmund.de/de/teaching/ss2017/bs/ Olaf Spinczyk olaf.spinczyk@tu-dortmund.de http://ess.cs.tu-dortmund.de/~os AG Eingebettete Systemsoftware Informatik
MehrFallbeispiel Unix. Betriebssysteme. Hermann Härtig TU Dresden
Fallbeispiel Unix Betriebssysteme Hermann Härtig TU Dresden Wegweiser Geschichte und Struktur von Unix Vom Programm zum Prozess Unix-Grundkonzepte Dateien Prozesse Prozess-Kommunikation Signale Pipes Sockets
MehrAufgabenblatt 5 Musterlösung
Prof. Dr. rer. nat. Roland Wismüller Aufgabenblatt 5 Musterlösung Vorlesung Betriebssysteme I Wintersemester 2017/18 Aufgabe 1: Implementierung von Threads (Bearbeitung zu Hause) Der größte Vorteil ist
MehrBetriebssysteme, Rechnernetze und verteilte Systeme 1. Crashkurs C (2)
Betriebssysteme, Rechnernetze und verteilte Systeme 1 Crashkurs C (2) Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/teaching/ss2008/bsrvs1/
MehrÜbung zu Grundlagen der Betriebssysteme. 10. Übung 18.12.2012
Übung zu Grundlagen der Betriebssysteme 10. Übung 18.12.2012 Aufgabe 1 a) Was versteht man unter einem kritischen Abschnitt oder kritischen Gebiet (critical area)? b) Welche Aufgabe hat ein Semaphor? c)
MehrFallbeispiel Unix. Betriebssysteme. Hermann Härtig TU Dresden
Fallbeispiel Unix Betriebssysteme Hermann Härtig TU Dresden Wegweiser Geschichte und Struktur von Unix Vom Programm zum Prozess Unix-Grundkonzepte Dateien Prozesse Prozess-Kommunikation Signale Pipes Sockets
MehrTafelübung zu BS 1. Prozesse verwalten
Tafelübung zu BS 1. Prozesse verwalten Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund olaf.spinczyk@tu-dortmund.de http://ess.cs.uni-dortmund.de/~os/ http://ess.cs.tu-dortmund.de/de/teaching/ss2014/bs
Mehr2A Basistechniken: Lösungen 2A.1 Wissens- und Verständnisfragen
2A Basistechniken: Lösungen 2A.1 Wissens- und Verständnisfragen 1.a.) Application Programming Interface 1.b.) Multiprogramming 1.c.) Mehreren Prozessoren, die über einen Bus miteinander verbunden sind
Mehr4.4 Prozesse. H. Weber, HS RM SS 2010 Systemprogrammierung Kap. 4.4 Seite 1 von 22
H. Weber, HS RM SS 2010 Systemprogrammierung Kap. 4.4 Seite 1 von 22 getpid Prozeß-Id ermitteln getppid Parent-Prozeß-Id ermitteln fork Duplizieren eines Prozesses exec-familie Prozeß-Überlagerung durch
MehrRechnerarchitektur SS 2012
Rechnerarchitektur SS 2012 Multithreading Michael Engel TU Dortmund, Fakultät für Informatik Teilweise basierend auf Material von Gernot A. Fink und R. Yahyapour 25. Juni 2013 Multithreading: Einleitung
MehrG 5. Übung. G-1 Überblick. Besprechung 3. Aufgabe. Infos zur Aufgabe 5: fork, exec. Rechenzeiterfassung. Ü SoS I G.1
G 5. Übung G 5. Übung G-1 Überblick Besprechung 3. Aufgabe Infos zur Aufgabe 5: fork, exec Rechenzeiterfassung G.1 G-2 Hinweise zur 5. Aufgabe G-2 Hinweise zur 5. Aufgabe Prozesse fork, exec exit wait
MehrKlausur Betriebssysteme I
Prof. Dr. Michael Jäger FB MNI Klausur Betriebssysteme I 18.3.2011 Bitte bearbeiten Sie die Aufgaben auf den Aufgabenblättern. Die Benutzung von Unterlagen oder Hilfsmitteln ist nicht erlaubt. Die Bearbeitungszeit
MehrEntfernungsmesser. für den Raspberry Pi. Tim Riddermann / Nils Wortmann
Entfernungsmesser für den Raspberry Pi Tim Riddermann / Nils Wortmann Inhalt Einleitung Prinzip Hardware MCP3202 Software Anhang Praktikum 2 Einführung Erstellung eines Entfernungsmessers Sobald ein Objekt
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
MehrÜbung zu Betriebssysteme
Übung zu Betriebssysteme Threadumschaltung 6. & 8. Dezember 2017 Andreas Ziegler Bernhard Heinloth Lehrstuhl für Informatik 4 Friedrich-Alexander-Universität Erlangen-Nürnberg Lehrstuhl für Verteilte Systeme
MehrProzesse und Threads. wissen leben WWU Münster
Münster Multi Threading in C++ 1 /19 Prozesse und Threads Ein Unix-Prozess hat IDs (process,user,group) Umgebungsvariablen Verzeichnis Programmcode Register, Stack, Heap Dateideskriptoren, Signale message
MehrExploit-Entwicklung mit Python
Penetration Testing III Bachelor in Computer Science (BCS) 6. Semester Exploit-Entwicklung mit Python von Daniel Baier und Demian Rosenkranz 1 / 20 Gliederung Grundlagen Sicherheitslücken Prozess- und
MehrProgrammiertechnik. Teil 4. C++ Funktionen: Prototypen Overloading Parameter. C++ Funktionen: Eigenschaften
Programmiertechnik Teil 4 C++ Funktionen: Prototypen Overloading Parameter C++ Funktionen: Eigenschaften Funktionen (Unterprogramme, Prozeduren) fassen Folgen von Anweisungen zusammen, die immer wieder
MehrPROGRAMMIEREN MIT UNIX/LINUX-SYSTEMAUFRUFEN
PROGRAMMIEREN MIT UNIX/LINUX-SYSTEMAUFRUFEN 2. UNIX/Linux-Prozessverwaltung und zugehörige Systemaufrufe Wintersemester 2016/17 2. Die UNIX/LINUX-Prozessverwaltung Aufgaben: 1. Erzeugen neuer Prozesse
Mehr