Echtzeitbetriebssysteme Übungen M.Sc. Alexander Nitsch, M.Sc. Michael Rethfeldt (mit freundlicher Unterstützung von Dr.-Ing. Guido Moritz)

Übungsfahrplan Nr. Beschreibung Inhalte 1 Erzeugen und Starten von Prozessen I Von Threads und Prozessen 2 Erzeugen und Starten von Prozessen II 3 Pipes & Signale Inter-Prozess-Kommunikation (IPC) 4 Messagequeues, Shared Memory 5 POSIX & Threads Inter-Prozess-Synchronisation (IPS) 6 Mutexe, Conditions & Semaphore unter POSIX 7 Synchronisationsprotokolle & Deadlocks Schedulinganalysen 8 Schedulinganalyse Sensornetzwerke: -> Was ist Ubiquitous Computing , Sensorknoten, Sensornetzwerk, Beispiele Herausforderungen: -> Probleme bei der Umsetzung

Übung 1 – Hello World ////////////////////////////////////////////////////////// // Veranstaltung: Echtzeitbetriebssysteme // Dozent: Dr.-Ing. Frank Golatowski // Übungsleiter: Dipl.-Ing. Guido Moritz // Übung: 1 // Aufgabe: 1 // Name: aufgabe1.c // Beschreibung: Hello World Ausgabe #include <stdio.h> int main(int argc, char *argv[]) { printf("Hello world!\n"); }

Übung 1 – fork() fork() fork_pid = fork_pid = fork_pid!=0 fork_pid==0 #include <stdio.h> #include <stdlib.h> int main(void) { int status; int fork_pid; fork_pid=fork() ; if ( fork_pid == 0 ) printf("* Ich bin der Sohn. *\n"); exit(3); } else if (fork_pid == -1) printf("Aufruf von fork() gescheitert!\n"); exit(2); wait(&status); // warten auf Ende des Sohnes printf("wait-Status: 0x%x | 0x%x | 0x%x |\n", status, (status>>8) & 0xff, status & 0xff); return 0; fork() fork_pid = fork_pid = fork_pid!=0 fork_pid==0 printf() exit() fork_pid!=-1 wait() printf()

Übung 1 – Starten von Prozessen

Übung 1 – Speicherbelegung Code beider Prozesse Code Code Daten Daten Vater Daten des Vaters Daten Daten des Sohnes

Übung 1 – Wieviele Söhne werden erzeugt? int main(int argc, char *argv[]) { fork(); } int main(int argc, char *argv[]) { switch ( fork() ) { case 0: printf(„Sohn erzeugt\n“); break; default: switch ( fork() ) { case 0: printf(„Sohn erzeugt\n“); default: printf(„Vater\n“); }

Übung 1 – Wieviele Söhne werden erzeugt? Vater Vater Sohn1 Sohn1 1. fork() 1. fork() printf() Sohn2 Sohn3 2. fork() 2. fork() Sohn2 2. fork() printf() printf() ENDE

Übung 2 Sohn 3 Sohn 1 PID: 2 Sohn 4 PID: 4 Vater PID=1 Sohn 5 Sohn 2 Frage: Kann es sein, dass PID=3 und PID=4 zweimal vergeben werden?

Typischer Prozessbaum 3774 ? Ss 0:00 /usr/sbin/privoxy --user privoxy privoxy --pidfile 3779 ? Ss 0:00 /usr/sbin/sshd -o PidFile=/var/run/sshd.init.pid 10341 ? Ss 0:00 \_ sshd: bj [priv] 10343 ? S 0:00 | \_ sshd: bj@pts/3 10344 pts/3 Ss+ 0:00 | \_ -bash 27959 ? Ss 0:00 \_ sshd: bj [priv] 27961 ? S 0:00 \_ sshd: bj@pts/4 27962 pts/4 Ss 0:00 \_ -bash 28213 pts/4 R+ 0:00 \_ ps -fax 3834 ? S 0:00 /bin/sh /usr/bin/mysqld_safe --user=mysql 4016 ? S 0:00 \_ /usr/sbin/mysqld --basedir=/usr -- 4682 ? S 0:00 /usr/lib/AntiVir/antivir --updater-daemon 4770 ? Ss 0:00 /usr/sbin/cupsd 4815 ? Ss 0:01 /usr/sbin/nscd 4835 ? Ss 0:00 /usr/sbin/smbd -D -s /etc/samba/smb.conf 4842 ? S 0:00 \_ /usr/sbin/smbd -D -s /etc/samba/smb.conf 7378 ? S 0:04 \_ /usr/sbin/smbd -D -s /etc/samba/smb.conf 27995 ? S 0:00 \_ /usr/sbin/smbd -D -s /etc/samba/smb.conf

Übung 2 #include <stdio.h> int main(void) { int var; printf(“PID(Father)=%d, var=%d\n", getpid(), var); if ( fork() == -1 ) fprintf( stderr, "Aufruf fork() gescheitert!\n" ); } else var++; printf(“PID=%d, var=%d\n", getpid(), var); fprintf( stderr, "Fehler beim 2. fork()!\n"); return 0;

Übung 2 Typische Ausgaben nach stdout PID(Father): 5179, var=0 PID=5180, var=1 PID=5181, var=2 PID=5180, var=2 PID=5179, var=1 PID=5182, var=2 PID=5179, var=2

Übung 2: Execl() Vater fork() Vater Sohn fork() Vater Externes Programm

Übung 2: Execl Fork() dient der Prozessverzweigung Execl() dient dem Starten des externen Programmes Nebeneffekt: Alle Daten des Vaters werden gelöscht Alle Filedescriptoren des Vaters werden freigegeben Anwendung: Starten von Programmen, z.B. init

Execl()-Parametermapping int execl(const char *path, const char *arg, ...); Execl-Parameter Argument der Main-Funktion Anzahl der Parameter-1 argn const char *arg argv[0] …. argv[1] Ausführbare Datei int execl(“/bin/ls”, “ls”, “-lias”, NULL); Argument der Main-Funktion Argumente argn 2 argv[0] ls argv[1] -lias

Übung 3 Prozess A Prozess B Betriebssystem Fork() erzeugt Kopie aller Daten des Prozesses A Direkter Datenaustausch zwischen Prozessen nicht möglich Ausweg: Pipe des Betriebssystems

Übung 3 Prozess A Prozess B Betriebssystem write(fd[1]); read(fd[0]); Array aus zwei File-Descriptoren: int fd[2] Erzeugen der Pipe mit pipe() Vererbung von fd[2] durch fork() an Sohn Lesen: fd[0] Schreiben: fd[1] Schließen der korrespondierenden File-Descriptoren Writer schließt fd[0] Reader schließt fd[1]

Übung 3 Prozess A Prozess B Initialisieren einer Pipe fd[2], File-Zähler=2 pipe(fd) Erzeugen des Sohn-Prozesses, File-Zähler=4 fork() Schließen des Lesedescriptors (fd[0]) und des Schreibdescriptors (fd[1]), File-Zähler=2 close(fd[0]) close(fd[1]) write(fd[1]) read(fd[0]) Datenaustausch über Pipe

Idealer Programmverlauf Unterbrochener Programmverlauf Übung 3 Idealer Programmverlauf Unterbrochener Programmverlauf Signale können jederzeit auftreten Nebenläufige Fehlerbehandlung erfolgt in Signal-Handlern Behandlung des Signals, sodass Hauptprogramm fehlerfrei weiterläuft ! Signal Signal-behandlung

Übung 4 Prozess A Prozess B Prozess C Betriebssystem ftok(…,1) msgget() msgrcv(); ftok(…,1) ftok(…,2) msgget() msgsnd() Proj_id=1 Proj_id=2 Prozess C ftok(…,2) msgget() msgrcv(); Systemweiten eindeutigen Key erzeugen Öffnen der Nachrichtenwarteschlange (Messagequeue) Projektidentifier proj_id kennzeichnet Nummer der Pipe

Übung 4 Was ist an welcher Schreibweise günstiger? void main(void) { pid_t p=getpid(); switch ( fork() ) case 0: printf(„The son!\n“); break; default: printf(„The father!\n“); printf(„pid: %d\n“,p); } default: {

Übung 5 – Casting von Funktionszeigern Casting notwendig: Kein Casting notwendig: int main(int argc, char *argv[]) { … pthread_create( &thread, &attr, (void*)&thread_start, 0); } void thread_start(void *ptr) return; thread_start, 0); void* thread_start(void *ptr) return 0; Linke Variante ist inkorrekt, da Rückgabetyp von thread_start falsch ist!

Übung 5 – Typen von Funktionszeigern Zeigerübergabe von Funktionen ohne typedef Zeigerübergabe von Funktionen mit typedef #include <stdio.h> int printme(const char *msg); void thread1(int (*function)(const char *ptr) ); void thread2(int (*)(const char *ptr) ); int main(int argc, char *argv[]) { thread1(printme); thread2(printme); return 0; } void thread1(int (*function)(const char *ptr) ) { function("Hans im Glück\n"); void thread2(int (*function)(const char *ptr) ) { function("Der Wolf im Schafspelz\n"); int printme(const char *msg) { printf(msg); typedef int (*CALLBACK)(const char *ptr); void thread1(CALLBACK function); void thread2(CALLBACK); void thread1(CALLBACK function) void thread2(CALLBACK function)

Übung 6 – Condition Variablen Aktives Warten Warten mit Conditionvariablen void* reader_function(void *ptr) { char a=0; while( a!= 'q' ) { pthread_mutex_lock( &mutex ); if ( buffer_has_item == 1) { a=buffer; if ( a != 'q' ) consume_item(a,count); buffer_has_item = 0; } pthread_mutex_unlock( &mutex ); return 0; while ( buffer_has_item != 1) pthread_cond_wait( &cond_buffer_full, &mutex); a=buffer; pthread_cond_signal( &cond_buffer_empty);

Übung 7 – Deadlock Zwei Prozesse betreten in unterschiedlicher Reihenfolge zwei kritische Abschnitte Kritischer Punkt: Threadumschaltung, wenn einer der Threads in einem kritischen Abschnitt ist  DEADLOCK

Übung 7 – Prioritäteninversion Ein höher priorisierter Thread wird durch einen niedriger priorisierten Thread unterbrochen. Bezeichnung: Direct Blocking

Übung 7 – Pass Through Blocking Prozess Priorität Periode Offset Deadline Rechenzeit Auslastung PH 3 (hoch) 120 20 30 0,25 PM 2 (mittel) 40 PL 1 (niedrig) 50 0,42

Übung 7 – Priority Inheritance Protocol PL wird auf Priorität von PH angehoben, wenn PH das Mutex anfordert PM kommt nicht zum Zuge Zeit im kritischen Abschnitt wird verringert Keine Kenntnis der nutzenden Threads nötig

Übung 7 – Priority Ceiling Protocol (PCP) Der Grundgedanke bei PCP ist, sicherzustellen, dass ein Prozess, der andere Prozesse in kritischen Abschnitten unterbricht und einen eigenen betritt, eine höhere Priorität in diesem Abschnitt garantieren muss als die Prioritäten aller unterbrochenen kritischen Abschnitte. Kann diese Bedingung nicht erfüllt werden, wird der Prozess blockiert. Vermeidung von Deadlocks und Mehrfachvererbungen (Chained Blocking) [Raj91] Einführung einer Ceiling-Konstanten c(Sj) pro Semaphor Sj c(Sj) = Priorität des höchst-prioren Prozesses, der das Semaphor nutzen wird Prozess P kann ein Semaphor S nur setzen, wenn seine Priorität größer als die der Ceiling-Konstanten aller nicht von P zur Zeit belegten Semaphoren ist (außer er besitzt bereits das höchst-priore Semaphor) Kann ein Prozess ein Semaphor nicht setzen, wird die Priorität des unterbrochenen Prozesses auf die des unterbrechenden Prozesses erhöht Einführung einer System-Ceiling-Konstanten S* zur einfacheren Berechnung  Maximum aller Semaphor-Ceiling-Konstanten, die gerade genutzt werden

Übung 7 – Beispiel PCP P0 P1 P2 3 Prozesse (P0, P1 & P2) konkurrieren über 3 Semaphoren (S0, S1 & S2) Prozess Priorität Periode Offset Deadline Rechenzeit Auslastung P0 3 (hoch) 150 50 40 0,27 P1 2 (mittel) 20 30 0,2 P2 1 (niedrig) 70 0,47  Statische Prio S*=2 S*=0 S*=0 S*=0 Prio 3 2 1 S*=3 Prio-Vererbung P1P2 S*=2 Da alle Semaphore anfangs noch komplett frei sind, ist die Ceiling des Systems S* noch 0  P2 bekommt in jedem Fall S2  danach ist S* = S2 = 2 (S2 ‚begründet‘ S*)

Übung 7 – Deadlockvermeidung Prio(P1) = Prio(P2) = 1 C(S1) = C(S2) = 1