Kap. 2 Prozesse Version vom 21.03.2007

Scheduling bei Echtzeitsystemen Beispiele Kap. 2 - Inhalt Definition Prozeßzustände Threads Scheduling Scheduling bei Echtzeitsystemen Beispiele Prozesse

Definition I - Woraus bestehen Prozesse ? Prozeß ist ein Programm in seiner Ausführung, d.h. besteht aus Programmdaten und Prozeßkontext Prozeß Prozeßkontext Daten CPU MMU Register Register Pro- Dateiinfo, gramm Zugriffs- Kernel- rechte stack Stack Prozesse

Definition II - Prozeßmodell Prozesse

Definition III - Prozeßerzeugung Ein Auftrag  mehrere Prozesse z.B. UNIX shell (Elternprozeß) cat Text1 Text2 | pr | lpr Kindprozess1 Kindprozess3 Kindprozess2 Prozesse

Definition IV - Prozeßerzeugung Prinzipielle Ereignisse, die die Erzeugung eines Prozesses auslösen System-Initialisierung Systemaufruf zum Erzeugen eines Prozesses durch einen anderen Prozeß Benutzeranfrage, einen neuen Prozeß zu erzeugen Initialisierung eines Batch-Jobs Prozesse

Definition IV - Prozeßtermination Bedingungen, die Prozesse terminieren Normales Beenden (freiwillig) Beenden aufgrund eines Fehlers (freiwillig) Beenden aufgrund eines schwerwiegenden Fehlers (unfreiwillig) Beenden durch einen anderen Prozeß (unfreiwillig) Prozesse

Definition V - Prozeßhierarchie Vaterprozess kreiert einen Kindprozess, Kindprozesse können ihre eigenen Prozeß kreieren Sie bilden eine Hierarchie UNIX nennt dies eine “Prozeßgruppe" Windows hat kein Konzept der Prozeßhierarchie All Prozesse sind gleich Prozesse

auf den Prozessor (bereit) auf eine Nachricht (blockiert) Prozeßzustände I blockiert erwarte Signal i term niert nicht-ex erhalte Signal erzeugt bereit nicht-ex. aktiv running Zuteilung Prozesse warten ... auf den Prozessor (bereit) auf eine Nachricht (blockiert) auf ein Timersignal (blockiert) auf Daten des I/O-Geräts (blockiert) Prozesse

Prozeßzustände II - Unix blockiert erzeugt nicht-ex . idle bereit aktiv zombie stop erhalte Signal Zuteilung warte auf Ereignis warte auf Eltern weitermachen terminiert für Tracing und Debugging Prozesse

Prozeß-Zustände III - Unix (genauer) fork Created Preempted return to user enough memory not enough memory (swapping system only) User Running preempt swap out return reschedule process Ready to Run in Memory Ready to Run Swapped swap in system call, interrupt Kernel Running sleep wakeup wakeup interrupt, interrupt return exit Asleep in Memory swap out Sleep, Swapped Zombie

Prozeßzustände IV – Unix: Prozeßerzeugung Eltern PID = fork() /* PID  0 */ if (PID==0) { ... }; waitpid(PID) Kind if (PID==0) { exec („program“) ... }; /* PID = = 0 */ . . . exit () }; Prozesse

Prozeßzustände V – Unix: Prozeßmanipulation pid_t fork(void) Erzeugen einer Kopie des Prozesses (Sohn), Vater erhält pid des Sohnes zurück oder -1 bei Fehler, Sohn erhält 0 als Ergebnis. int execve(char* name, char* argv[], char* envp[]) Überlagern des ausgeführten Programms eines Prozesses (Code, Daten, Stack) durch neues Programm name, Übergabe von Argumenten und Environment-Variablen über NULL-terminierten Vektor. Andere Varianten mit unterschiedlicher Übergabe von Argumenten und Environment: execl(), execle(), execlp(), execv(), execvp() Prozesse

Prozeßzustände VI – Unix: Prozeßmanipulation pid_t getpid(void) Rückgabe der eigenen Process Id. pid_t getppid(void) Rückgabe der Process Id des Vaters. exit(status) Beende den laufenden Prozeß und stelle dem Vater den Exit-Status zur Verfügung. pid_t wait(int* status) Warten auf die Beendigung eines Sohn-Prozesses. Dessen Id wird uber den Ruckgabewert, sein Status über status zurückgegeben. pid_t waitpid(pid_t pid, int* status, int opts) Warten auf das Ende eines bestimmten Sohnes, dessen Id über den Parameter pid ubergeben wird. Prozesse

Prozeßzustände VII - Unix: Shell while (TRUE) { /* repeat forever */ type_prompt( ); /* display prompt */ read_command (command, parameters) /* input from terminal */ if (fork() != 0) { /* fork off child process */ /* Parent code */ waitpid( -1, &status, 0); /* wait for child to exit */ } else { /* Child code */ execve (command, parameters, 0); /* execute command */ } Prozesse

Prozeßzustände VIII - Unix Prozeßkontext Speicherresidente Prozeßkontrollblöcke PCB der Prozeßtabelle Scheduling-Parameter Speicherreferenzen: Code-, Daten-, Stackadressen im Haupt- bzw. Massenspeicher Signaldaten: Masken, Zustände Verschiedenes: Prozeßzustand, erwartetes Ereignis, Timerzustand, PID, PID der Eltern, User/Group-IDs Auslagerbarer Benutzerkontext (swappable user structure) Prozessorzustand: Register, FPU-Register,  Systemaufruf: Parameter, bisherige Ergebnisse,  Datei-Info-Tabelle (file descriptor table) Benutzungsinfo: CPU-Zeit, max. Stackgröße,  Kernel-stack: Platz für Systemaufrufe des Prozesses Prozesse

Prozeßzustände IX – Wann kommt Wechsel? Interrupts Timer (Zeitscheibe abgelaufen) I/O Speicherfehler Speicheradresse ist im virtuellen Speicher, also muss sie in den Arbeitsspeicher gebracht werden Trap Fehler trat auf Kann den Prozess in den Exit-Status bringen Systemaufruf Wie z.B. File open

Prozeß-Zustände X - Zustandswechsel Prozessor-Kontext inklusive Programmzähler und anderer Register sichern Prozeßkontrollblock updaten mit neuem Zustand und Accounting Informationen Prozeßkontrollblock in geeignete Queue bringen - Bereit-Queue, Blockiert-Queue Einen anderen Prozeß zur Ausführung auswählen Prozeßkontrollblock des gewählten Prozesses updaten Memory-Management Datebstrukturen updaten Prozessor-Kontext des gewählten Prozesses restaurieren

Prozeßzustände XI - Windows NT trans. erhalte warte auf Ereignis erzeugt Signal terminiert nicht-ex. init ready running termin. nicht-ex. Abbruch ausgewählt, dispatch abgebrochen standby Prozesse

Prozeßzustände XII – Windows NT Subsystem-Prozeßerzeugung Programm: NewPID = fork() LPC-message POSIX: NewPIDhandle := NtCreateProcess (Eltern=CurrentPID) SystemCall Einheitliches Prozeßmodell: Alle Subsystem-spezifischen Mechanismen werden auf Basismechanismen von NT abgebildet. Win32: NtCreateProcess( ) Prozesse

Threads I - Motivation Motivation Prozeßerzeugung, Prozeßumschaltung und Prozeßkommunikation sind teuer (= rechenzeitaufwendig zur Laufzeit). Wie nutzt man mehrere Prozessoren eines Multiprozessors fur eine Applikation? Wie strukturiert man einen Server-Prozeß, der Anforderungen von mehreren Klienten bedienen kann? Mehrere Kind-Prozesse (Parallelität, Blockierungen erlaubt, gute Performance, hoher Aufwand für fork()) Prozeß mit einem Kontrollfluß (keine Parallelität, Blockierungen erlaubt, schlechte Performance) endlicher Automat (keine Parallelitat, keine Blockierungen, gute Performance, Multiplexing von Hand = komplexe Programmierung) Prozesse

Threads II - Motivation Lösung Einführung von billiger Nebenläufigkeit in einem Prozeßadreßraum durch "Mini-Prozesse", sogenannte Threads. => Parallelität, Blockierungen erlaubt, gute Performance, einfache Programmierung Prozesse

Threads III - Eigenschaften Asynchroner, paralleler, unterschiedlicher Programmverlauf (eigener stack) gemeinsamer Prozeßkontext (Speicher-Addreßbereich, Dateien (file handles) Gemeinsamer Prozeßkontext Prozesse

Threads IV - Eigenschaften (a) Drei Prozesse - jeder mit einem Thread (b) Ein Prozess mit drei Threads Prozesse

kontrolliert vom Benutzerprogramm (Unix-Bibliothek) Threads V - Typen kontrolliert vom Benutzerprogramm (Unix-Bibliothek) lightweight threads (ULT) Vorteil: sehr schneller Thread-Wechsel Nachteil: Blockieren aller Threads bei I/O-Warten von einem Thread. kontrolliert vom Betriebssystem (Windows NT) heavyweight threads (KLT) Vorteil: Unabhängiger I/O aller Threads Nachteil: langsamer System Call nötig  fibers Prozesse

Threads VI – Mischformen zwischen ULT und KLT Solaris Multithreading Architektur mit Leichtgewichtsprozessen Prozesse

Threads VII – Mischformen zwischen ULT und KLT Prozesse

Threads VIII - Benutzung Ein Textverarbeitungssystem mit drei Threads Prozesse

Ein Webserver mit mehreren Threads Threads IX - Benutzung Ein Webserver mit mehreren Threads Prozesse

Threads X - Programmierung Leider nicht einheitlich! Unterschiedliche Bibliotheksfunktionen bzw. Systemaufrufe : Java-Threads Threads in Windows-NT Unix-KLTs Pthreads-Bibliothek (Unix ULTs) Solaris LWPs Prozesse

Threads XI – Pthreads-Beispiel pthread_t thread1, thread2; if (pthread_create(&thread1, NULL, (void *) do_one_thing, (void *) &r1) != 0) perror("pthread_create"), exit(1); if (pthread_create(&thread2, NULL, (void *) do_another_thing, (void *) &r2) != 0) if (pthread_join(thread1, NULL) != 0) perror("pthread_join"), exit(1); if (pthread_join(thread2, NULL) != 0) perror("pthread_join"), exit(1); do_wrap_up(r1, r2); Prozesse

Threads XII – Pthread-Funktionen Prozesse

Scheduling I Neben dem Speicher ist der Prozessor (sind die Prozessoren) eines Rechners das wichtigste Betriebsmittel. Mit der zeitlichen Zuordnung des Prozessors (bzw. der Prozessoren) an die verschiedenen Prozesse im System beschäftigt sich das Scheduling, manchmal auch Dispatching genannt. Prozesse

Vorplanung in verschiedenen Zeitmaßstäben Scheduling II Vorplanung in verschiedenen Zeitmaßstäben Hier: Nur Kurzzeitschedul ! Ankunft Warteschlange Abgang Prozessor Prozesse

Durchsatz (throughput) Faire Behandlung (fairness) Scheduling III - Ziele Auslastung der CPU Ziel ist die 100%ige Auslastung der CPU, normal 40%–90%. Durchsatz (throughput) # Jobs pro Zeiteinheit sollte maximal sein. Faire Behandlung (fairness) Jeder Benutzer sollte im Mittel den gleichen CPU-Zeitanteil erhalten. Ausführungszeit (turn­around time) Die Zeitspanne vom Jobbeginn bis zum Jobende sollte sie minimal sein. Sie enthält alle Zeiten in Warteschlangen, der Ausführung (Bedienzeit) und der Ein- und Ausgabe. Wartezeit (waiting time) Wartezeit in der bereit-Liste minimieren (einziger Scheduling-parameter) Antwortzeit (response time) Die Zeit zwischen einer Eingabe und der Übergabe der Antwortdaten an die Ausgabegeräte sollte minimal werden (interaktive Systeme!). Prozesse

Scheduling IV - Konflikte Problem: Ziele sind weder vollständig noch konsistent Prozeßumschaltung (context switch) kostet Zeit. Wenn viele kurze Prozesse bevorzugt  Durchsatz, Ausführungszeit, Antwortzeit werden gut, aber die Umschaltzeit verkürzt rel. Zeitanteil für lange Prozesse (fairness!) Erhöhen der Auslastung  Erhöhen der Antwortzeit; Beispiel Autovermietung Werden bestimmte Kunden bevorzugt, müssen andere warten. Sind alle Wagen gut ausgelastet, müssen neue Kunden warten. Es gibt keinen idealen Schedulingalgorithmus ! Prozesse

Scheduling V - Nicht-präemptives Scheduling Jeder Prozeß läuft so lange, wie er will. First Come First Serve (FCFS). Einsortieren in der Ankunftsreihenfolge (FIFO-Warteschlange). Ausführungszeit: Job1=10, Job2=14, Job3=17; Mittelwert=41/3=13.67. Job1=10 Job2=4 Job3=3 Job 1 Job 2 Job 3 10 14 17 Shortest Job First (SJF) Job mit kürzester Bedienzeit zuerst (min. mittl. Wartezeit). Ausführungszeit: Job1=17, Job2=7, Job3=3; Mittelwert=27/3=9. Job 3 Job 2 Job 1 0 3 7 17 Prozesse

Scheduling VI - Nicht-präemptives Scheduling Priority Scheduling (PS) Prio Prozeß; Bevorzugung von hoher Prio. Problem SJF und PS erlauben Verhungern (starvation) von benachteiligten Prozessen Prozesse

Scheduling VII - Präemptives Scheduling Rücksichtslose Prozesse (Benutzer!)  Einführung von „Zeitscheiben“: Prozeß2 Prozeß1 Prozeß3 Zeitscheibe Jeder Prozeß läuft nur so lange, wie er darf. Ankunft Warteschlange Abgang Prozessor Abbruch Prozesse

Scheduling VIII - Präemptives Scheduling Jeder Prozeß läuft nur so lange, wie er darf. Round Robin (RR) Einsortieren in der Ankunftsreihenfolge (FIFO-Warteschlange) + Zeitscheibe Zeitscheibengröße T von Umschaltzeit des Kontextes abhängig! Richtwert: T > mittlerer CPU-Bedarf zwischen zwei I/O-Vorgängen (CPU burst) von 80% der Jobs: Dynamic Priority Round Robin (DPRR) RR + wachsende Prio-Vorstufe Shortest Remaining Time First Job mit kürzester verbleibender Bedienzeit zuerst . Prozesse

Scheduling IX - Adaption der Parameter Beispiel: Parameter a eines Prozesses = gewichteter Mittelwert aus dem aktuellen Wert bt und dem früheren Wert a(t) a(t) = (1–) a(t-1) +  bt Es ergibt sich hier die Reihe a(0)  b0 a(1) = (1–) b0 + b1 a(2) = (1–)2b0 + (1–) b1 + b2 a(3) = (1–)3b0 + (1–)2b1 + (1–) b2 + b3 ... a(n) = (1–)n b0 + (1–)n–1b1 +...+ (1–)n–i bi +...+ bn Mit <1 schwindet der Einfluß der frühen Messungen exponentiell, der Parameter altert (zeitabhängig). Prozesse

Scheduling X - Multiple Warteschlangen und Scheduler Multiple Warteschlangen für I/O multi level scheduling Prozesse

Scheduling bei Echtzeitbetriebssystemen I Echtzeitbetriebssysteme (real time systems) = ? Soft-Echtzeitsysteme: gewünschte Zeitschranken „Verzögerung ärgerlich, aber Zeitschranke nicht bindend“: Texteingabesysteme, Banken, Behörden ,... Hard-Echtzeitsysteme: verbindliche Zeitschranken Konsequenzen bei Nichterfüllung der Spezifikation: Kontrolle von Kernkraftwerken, Flugzeugen, Fahrzeugen, Produktionsstraßen,... Typisch: periodisch wiederkehrende, gleiche tasks Prozesse

Scheduling bei Echtzeitbetriebssystemen II Beispiel Tasks für flight-by-wire (Airbus) Flugdatenverarbeitung Beschleunigung (x,y,z) 5 ms Drehungswinkel 40 ms Monitordisplay 100 ms Temperatur 1 s GPS-Position 10 s Scheduling-Strategien = ? Prozesse

Scheduling bei Echtzeitbetriebssystemen III Polled Loop Dauerwarten aber: andere Anforderungen Interruptgesteuerte Systeme Prio-gesteuerte ISR aber: Interrupt geringer Prio kann verloren gehen Minimal Deadline First nächste Zeitschranke TD zuerst aber: gleiche Zeitschranken? Prio? Minimal Processing Time First SJF-Strategie aber: Prio unbeachtet Rate-Monotonic Scheduling (RMS) Task-Frequenz ~ Prio aber: Prioritätsinversion für wichtige Tasks mit geringer Frequenz Foreground-Background Scheduling nützlich vs. notwendig Hintergrundprozesse: Selbsttests, RAM scrabbing, Alarm-Monitore Prozesse

Scheduling bei Echtzeitbetriebssystemen IV Notwendige, kritische Tasks (z.B. RMS) Nützliche, unkritische Tasks (z.B. Hintergrund) Notwendige, aber unkritische Tasks: Zeitpunkt TS wenn notw. Ressourcen frei, Zeitschranke TD, restl. Bedienzeit TC, Wichtigkeit w Minimum Earliest Start min. TS Minimum Laxity First min. TD - (TS+TC) Kombin. Kriterium 1 min. TD + wTC Kombin. Kriterium 2 min. TD + wTS Simulationsergebnis: Kombin. Kriterium 2 ist am besten! Prozesse

Beispiele für Scheduling I - Unix Round-Robin, ersetzbar durch anderes. dyn. Prio, jeweils eine FCFS-Warteschlange pro prio Benutzer: nice-Kommando Umhängen in andere Schlangen bei prio-Erhöhung HP-UX: Prio 0-255 Multi level-Warteschlangen 0 = hohe prio Prozesse

Beispiele für Scheduling II - Windows NT Round-Robin für Threads getrenntes dispatching Dyn. Prio, abhängig von Zeit und Liste Prozessoraffinitäten Symmetrisches multiprocessing 0 = kleinste prio Prozesse