vorlesung betriebssysteme 3. prozesse · unter linux werden alle lauffähigen prozesses in einer...

80
 1 Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt Vorlesung Betriebssysteme 3. Prozesse

Upload: truongkhanh

Post on 05-Jun-2018

213 views

Category:

Documents


0 download

TRANSCRIPT

 1Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

Vorlesung Betriebssysteme3. Prozesse

 2Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

Übersicht

1. Ziel diese Kapitels

2. Prozessmodell

3. Systemaufrufe für Prozesse

4. Threads

5. Scheduling

6. Scheduling mit besonderen Zielen

 3Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

1. Ziel dieses KapitelsEin Prozess kann als die Abstraktion eines Programms, das von einem Prozessor ausgeführt wird, angesehen werden. Hier wird behandelt, was Prozesse sind und wie sie in Betriebssystemen implementiert werden, inklusive Scheduling.

Relevante Abschnitte im Buch [1]● Abschnitte 1.5.1 und 1.6● Abschnitte 2.1, 2.2 und 2.5● Abschnitt 8.1.4

Zusätzlich:● Real-Time Scheduling

Literatur-Hinweise:[2] Albrecht Achilles: Betriebssysteme, Springer

[3] Wolfgang Mauerer: LINUX Kernelarchitektur - Konzepte, Strukturen und Algorithmen von Kernel 2.6, Hanser

 4Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

2. ProzessmodellUm zu verstehen, wie unterschiedliche Aktivitäten scheinbar gleichzeitig ablaufen, braucht man ein Modell eines ablaufenden Programms.Ein (sequentieller) Prozess ist ein sich in Ausführung befindendes (sequentielles) Programm zusammen mit:

● dem aktuellen Wert des Programmzähler,● den Registerinhalten,● den Werten der Variablen, dem Stack und● dem Zustand der geöffneten Dateien und Netzverbindungen.● den Programmdaten● Speicherinformationen

Konzeptionell besitzt jeder Prozess seinen eigenen Prozessor - in der Praxis wird aber immer der reale Prozessor zwischen den Prozessen hin- und hergeschaltet. Da dies die Illusion erweckt, dass die Prozesse gleichzeitig ablaufen, spricht man auch von Quasi-Parallelität.

 5Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

2. ProzessmodellBeim Mehrprogrammbetrieb mit 4 Programmen (A,B,C,D) ergeben sich damit folgende Sichtweisen:

Ein Scheduling-Algorithmus entscheidet, wann die Arbeit eines Prozesses unterbrochen und ein anderer Prozess bedient wird.

real ist zu jedem Zeitpunkt nur ein sequentielles

Programm aktivD

C

B

A

DCA

ein HW Programm-zähler A

C B

Konzeptionell4 Programmzähler:

4 unabhängige Prozesse

B

Arbeitsspeicher mit 4 Programmen

D

 6Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

2. Prozessmodell2.1 Erzeugen & Beenden

Es gibt vier Möglichkeiten, einen Prozess zu erzeugen:1. Beim Systemstart (Initialisierung)

2. Durch einen anderen Prozess (Systemaufruf z.B. fork)

3. Interaktiv durch den Benutzer

4. Per Stapelverarbeitung (Batch Job)

Analog dazu können Prozesse beendet werden durch:5. Normales Beenden (freiwillig)

6. Aufgrund eines Fehlers (freiwillig)

7. Aufgrund eines „schweren“ Fehlers (unfreiwillig)

8. Durch einen anderen Prozess (unfreiwillig)

 7Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

2. ProzessmodellProzess-Hierarchie Durch das Erzeugen von neuen Prozessen (Kindern), ausgehend von einem

Erzeuger-Prozess (Vater), entsteht eine Baumstruktur von Prozessen. Dabei ist es in vielen Fällen nicht erforderlich, dass der Vater auf das Terminieren der Kinder wartet, z.B. wenn eine Suchanfrage über das Internet gestellt wird und die Antwort lange auf sich warten lässt.

Beispiel für einen Baum:

a

b c

d e f g

h i j

 8Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

2. Prozessmodell2.3 ProzesszuständeEine Aufgabe des Betriebssystems ist das Multiplexen des physischen Prozessors. Diese Aufgabe übernimmt der Scheduler zusammen mit dem Dispatcher.

Prozesse können sich in verschiedenen Zuständen befinden. Diese Zustände bilden eine Entscheidungsgrundlage für die Auswahl eines geeigneten Kandidaten bei einem Prozesswechsel:

1. rechnend (running)der Prozessor ist dem Prozess zugeteilt

2. bereit (ready)der Prozess ist ausführbar, aber ein anderer Prozess ist gerade rechnend

3. blockiert (waiting)der Prozess kann nicht ausgeführt werden, da er auf ein externes Ereignis wartet (z.B. liegen bestimmte Eingabedaten noch nicht vor).

 9Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

2. ProzessmodellDabei können folgende Zustandsübergänge auftreten:

rechnend

blockiert bereit

1: Prozess wartet auf externes Ereignis2: Scheduler wählt anderen Prozess aus, da die Zeitscheibe des Prozesses abgelaufen ist3: Scheduler wählt diesen Prozess aus4: externes Ereignis ist eingetreten5: ein neuer Prozess wird erzeugt6: der Prozess terminiert

12

3

4

6

5

 10Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

2. ProzessmodellIn der Praxis jedoch werden die Zustände feiner unterteilt, so dass auch durchaus zwischen mehr Zuständen unterschieden wird (z.B. der theoretische Zustand blockiert (Wartezustand) kann in einem realen Betriebssystem durch zwei Zustände, nämlich warten_auf_ein_Zeitereignis und warten_auf_Ein/Ausgabe abgebildet sein).Linux kennt insgesamt 5 Prozesszustände:1. TASK_RUNNING

Unter Linux werden alle lauffähigen Prozesses in einer runqueue genannten Liste eingehängt. Aus dieser Liste wählt der Scheduler den nächsten aktiven Rechenprozess aus (damit entspricht der Zustand TASK_RUNNING dem oben erwähnten Zustand bereit).

2. TASK_INTERRUPTIBLEIn diesem Wartezustand kann der Prozess durch Signale oder durch das Ablaufen eines Timers unterbrochen und wieder in den Zustand TASK_RUNNING überführt werden.

 11Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

2. Prozessmodell3. TASK_UNINTERRUPTIBLE

Dies ist ebenfalls ein Wartezustand. Im Unterschied zu TASK_INTERRUPTIBLE kann der Task jedoch nur durch ein wake_up wieder in den Zustand TASK_RUNNING überführt werden.

4. TASK_ZOMBIEDer Task mit diesem Zustand gilt zwar als beendet, aber der zugehörige Vater-Prozess hat bisher noch nicht den Prozess-Status abgeholt.

5. TASK_STOPPEDDer Task wurde angehalten, entweder durch ein entsprechendes Signal oder durch ptrace. Der Systemcall ptrace ermöglicht einem Vater-Prozess das Debugging des Kind-Prozesses.

 12Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

2. ProzessmodellUnter Linux existiert der Zustand rechnend nicht explizit. Der Zustand

● bereit ist unter Linux der Zustand RUNNING, ● der Zustand blockiert wird über INTERRUPTIBLE und

UNINTERRUPTIBLE abgebildet. ● Die Zustände ZOMBIE und STOPPED beschreiben, dass ein Prozess

nicht (mehr) aktiv ist.Folgende Prozessübergänge sind möglich:

running

uninterruptibleinterruptiblestopped zombie

current

fork/clone

exitexit

wait

sleep

sleep

wakeupwakeupsignal

scheduler

 13Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

2. Prozessmodell2.4 Implementierung von Prozessen

Das o.g. Prozessmodell wird in einem Betriebssystem durch eine Prozesstabelle realisiert, die für jeden Prozess einen Eintrag (Process Control Block (PCB)) enthält. Der PCB stellt alle Informationen bereit, die für den Ablauf eines Prozesses notwendig sind.

Je nach Betriebssystem variieren diese Felder. In Unix kann man sich einige der Felder der Prozesstabelle mit dem Shell-Kommando ps ansehen:

$ ps -o "%p %r %c %x %t %G %P %U %z" PID PGID COMMAND TIME ELAPSED GROUP PPID USER VSZ 4334 4334 bash 00:00:00 05:59:24 users 4325 peter 401214103 14103 ps 00:00:00 49710-06:28:08 users 4334 peter 2160$

 14Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

2. ProzessmodellBeispiel: Unter Linux werden Prozesse mithilfe der Struktur task_struct verwaltet (definiert in /usr/src/linux-headers-<version>/include/linux/sched.h). Die ca. 80 Einträge beinhalten Information über [2, 3]:

● Identität (PID), Zeiger auf Eltern und andere verwandte Prozesse● Prioritätskennzahlen, Zeit (z.B. Rechenzeit)● den belegten Speicher● den Prozess-Status● Benutzer- und Gruppenkennzahlen, Ausführungsrechte● verwendete Dateien● anstehende Signale● verwendetes Binärformat● enthaltene Threads● Beschränkung bzgl. Ressourcen-Verbrauch (struct rlimit)

 15Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

2. ProzessmodellBei einem Prozesswechsel (Context Switch) muss vorbereitet werden, einen Prozess später wieder anlaufen lassen zu können, wenn er einmal suspendiert wurde. Dabei werden in der Regel recht komplexe Vorgänge in Gang gesetzt, die dafür zu sorgen haben,

● dass alle benötigten Laufzeit-Daten (Register inkl. PC und Stack) des laufenden Prozesses gesichert werden und

● dass der neue Prozess an exakt an der Stelle weiter machen kann, an der er zuvor unterbrochen wurde (durch das Laden eben dieser Daten).

Beispiel: Unter Linux wird dies in der Quelldatei kernel/sched.c umgesetzt: eine Funktion schedule()ruft eine Funktion context_switch auf.

 16Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für Prozesse3.1 Prozessverwaltung Ein Prozess besitzt einen Adressraum, in dem er abläuft. Der Prozessraum ist

in mehrere Teile (Segmente) aufgeteilt.

Heap

Daten

Text-segment 0000

FFFF Der Programmcode befindet sich im Textsegment.Im Datensegment sind globale Objekte abgelegt, dann folgt der Heap für dynamische Objekte.Der Stack ist zur Speicherung lokaler Objekte und für Rücksprungadressen bei Rekursionen nötig.

Stack

 17Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für Prozesse Ein neuer Prozess wird erzeugt, indem ein Eltern-Prozess durch den

Systemaufruf „fork“ einen Kind-Prozess erzeugt:● Der Aufruf erzeugt eine exakte Kopie des Originalprozesses (Kind=Clone

des Vaters) einschließlich aller Dateideskriptoren, Register usw. ● Nach dem fork werden beide Prozesse unterschiedliche Aktivitäten

übernehmen. ● Zum Zeitpunkt des fork haben alle Variablen die gleichen Werte.● Nach dem fork wirken sich Änderungen der Variablen nur noch im

jeweiligen Prozess aus.

Daten

StackFFFF

0000

...pid=fork()

...

Daten

StackFFFF

0000

...pid=fork()

...

Vater Kind

 18Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für Prozesse Vater- und Kind-Prozess unterscheiden sich allerdings anhand ihrer

Prozessnummer. Außerdem gibt der fork-Aufruf einen Wert zurück, durch den im Programm unterschieden werden kann, ob der Code des Kindes oder des Vaters gemeint ist:

● = 0 ist der Kindprozess, ● > 0 ist die Prozessidentifikation (pid) des Kindprozesses für den Vater-

Prozess. ● < 0 ist, zeigt an, dass kein neuer Prozess erzeugt werden konnte (Fehler).

 19Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

#include <stdio.h>main(){

int childPid;

if ((childPid = fork()) == -1) {fprintf(stderr,"can't fork\n");exit(1);

} else if (childPid == 0) { /* child process */fprintf(stdout, "child: child pid = %d, parent pid = %d\n",

getpid(), getppid());exit(0);

} else { /* parent process */fprintf(stdout, "parent: child pid = %d, parent pid = %d\n",

childPid, getpid());exit(0);

}}

Ausgabe parent: child pid = 28891, parent pid = 28890

Ausgabe child: child pid = 28891, parent pid = 28890

3. Systemaufrufe für Prozesse Beispiel:

● exit beendet die Prozessausführung & gibt Status zurück. ● getpid und getppid liefern die PID von einem Prozess bzw. die PID des eigenen Erzeugers.

 20Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für Prozesse Ein reales Beispiel, bei dem ein Prozess mit fork erzeugt wird, ist die Shell:

● Für jedes Kommando, das aus der Shell heraus ausgeführt wird, wird von der Shell ein eigener Prozess erzeugt.

● Dabei dupliziert sich die Shell, überlagert den eigenen Code mit dem Code des auszuführenden Kommandos und wartet, bis der so erzeugte Prozess terminiert.

● Dazu werden die Systemaufrufe exec und wait, verwendet. (Es existieren mehrere Varianten der exec/wait-Systemaufrufe.)

● Im nachfolgenden Schaubild wird dies anhand des Kommandos echo verdeutlicht.

 21Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für Prozesse

➢ Die Shell erzeugt durch fork einen Prozess und führt den Systemaufruf wait aus.

➢ Dadurch wartet sie, bis sie ein Signal erhält. Dieses Signal wird vom exit-Aufruf des Kindprozesses erzeugt.

➢ Der Kindprozess benutzt den Systemaufruf exec. Dieser nimmt den Code des ersten Parameters (hier das echo-Kommando) und überlagert den eigenen Code damit.

shell subshell

wait()

shell läuft weiter

exec(echo,..)

exit()

fork()

 22Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für Prozesse Das folgende Programm ist Minishell und funktioniert nach dem o.g. Prinzip. void read_command(char *com, char **par){ fprintf(stdout, "$ "); ..... return; } int main(){

int childPid, status;char command[20];char *parameters[60];

while (1) {read_command(command, parameters);

if ((childPid = fork()) == -1) {fprintf(stderr,"can't fork\n");exit(1);

} else if (childPid == 0) { /* child */execv(command, parameters);

exit(1); /* something wrong */}else

wait(&status); /* parent process */ }

}

 23Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für Prozesse exit hat einen Parameter, den so genannten Exitstatus; dies ist ein Integerwert

zwischen 0 und 255. Konvention in Unix ist, ● dass ein Exitstatus von Null bedeutet, dass die Aktion erfolgreich

ausgeführt werden konnte. ● Jeder andere Wert wird als Fehler angesehen.

Dieser Status wird dem Elternprozess in der Variablen status des wait-Aufrufs mitgegeben. Der Returncode von wait ist die PID des Kindes.

Soll z.B. eine Kommunikation zwischen Kind und Eltern stattfinden, so kann das Kind z.B. durchexit(4);

dem Elternprozess die Nachricht 4 übergeben. Der Elternprozess wird durch n = wait(&status);

dann die Information in der Variablen status sehen.

 24Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für Prozesse3.2 SignaleWenn ein angeschlossenes Gerät eine ihm übertragene Aufgabe erledigt hat, erzeugt es eine Benachrichtigung, die Interrupt genannt wird.Signale sind das Äquivalent im Bereich Software zu Interrupts im Bereich Hardware. Programme, die als Prozess innerhalb des Betriebssystems ablaufen, müssen unterbrechbar sein, damit z.B. ungewollte Aktionen nicht ausgeführt werden.

➢ So kann die Ausgabe (durch das Kommando cat) einer großen Datei mit CTR-C abgebrochen werden. Dadurch wird dem Ausgabeprozess ein Signal gesendet. Als Reaktion beendet der Prozess die Ausgabe.

Wenn ein Signal zu einem Prozess gesendet wird und der Prozess das Signal nicht annimmt, dann wird der Prozess vom Betriebssystem automatisch entfernt. Um sich vor diesem Automatismus schützen zu können, kann sich ein Prozess durch den Systemaufruf signal auf das Eintreffen von Signalen vorbereiten. Dazu muss er eine Signalbehandlungroutine bereitstellen

 25Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für Prozesse

Ein Prozess, der eine Signalbehandlungroutine bereitgestellt hat, ● wird bei Eintreffen eines Signals angehalten, ● der Prozesszustand auf den Stack geschrieben und ● die Signalroutine wird aufgerufen. Diese Routine darf selbst beliebige

Systemaufrufe veranlassen. ● Ist sie beendet, wird der Prozess an der Stelle weiter ablaufen, wo er

vorher unterbrochen wurde (der Zustand wird vom Stack restauriert).

In einem Betriebssystem gibt es mehrere Signalarten. Die meisten Signale werden durch Ereignisse, die von der Hardware ausgelöst werden, erzeugt.

 26Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für ProzesseDie nachfolgende Tabelle listet die wichtigsten Signalarten auf

Nummer Bezeichnung Bedeutung1 SIGHUP Hang up, Modemunterbrechung2 SIGINT DEL Taste3 SIGQUIT Quit Signal von Tastatur4 SIGILL Nicht erlaubte Instruktion5 SIGTRAP Unterbrechung für Testzwecke8 SIGFPE Gleitkommaüberlauf9 SIGKILL Abbruch

10 SIBBUS Busfehler11 SIGSEGV Segmentfehler12 SIGSYS Ungültige Argumente bei Systemaufruf13 SIGPIPE Ausgabe auf Pipe ohne Leser14 SIGALARM Alarm15 SIGTERM Softwareerzeugtes Endesignal16 frei

 27Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für ProzesseDas folgende Beispiel zeigt, wie in C eine Signalbehandlungsroutine realisiert wird. Dabei wird das Programm (eine Endlosschleife) auf das Eintreffen vom Signal SIGINT – ausgelöst durch „CTR-C“ – reagieren, indem es einen Text ausgibt.

$ cat signal.c#include <stdio.h>#include <signal.h>

void handler() {printf("handler\n");return;

}

main() {signal(SIGINT, handler); /* CTR-C handled */while (1) {

printf("main\n");sleep(2);

}}$

 28Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für ProzesseAnstelle eines selbst programmierten Handlers kann man auch vordefinierte Handler verwenden. Sie werden durch die Konstante SIG_IGN (ignoriere Signal) und SIG_DFL (reagiere per Default Aktion) beim Systemaufruf „signal“ verwendet.

In der Implementierung der Shell ist vor dem „fork“ ein Systemaufruf zum Ignorieren des Signals SIGINT, wenn der Prozess im Hintergrund gestartet werden soll: signal(SIGINT, SIG_IGN);

$ cat signal02.c#include <stdio.h>#include <signal.h>main() {

signal(SIGINT, SIG_IGN); /* CTR-C ignored */while (1) {

printf("main\n");sleep(2);

}}$

 29Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für ProzesseIn Unix gibt es das Kommando „kill“ zum Beenden von Prozessen, die im Hintergrund laufen (oder nicht mehr reagieren). Wenn ein Programm so geschrieben ist, dass es alle Signale ignoriert, könnte es nie abgebrochen werden. Deshalb gibt es das Signal SIGKILL. Dieses Signal kann nicht per Signalhandler abgefangen werden.

$ ps2864 pts/1 00:00:18 bash4423 pts/1 00:00:01 signal4525 pts/1 00:00:00 ps $$ kill -9 4423killed signal$

 30Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für ProzesseIm Bereich Echtzeitanwendungen muss ein BS u.a. in der Lage sein, Prozesse nach einer gewissen Zeit zu informieren, dass bestimmte Dinge zu erledigen sind.

Beispiel: In Kernkraftwerken muss die Temperatur des Reaktors regelmässig überprüft werden. Deshalb wird dem Prozess, der die Überwachung bewerkstelligt, regelmäßig ein Signal gesendet, wodurch er die Temperatur prüft.

Der Systemaufruf alarm hat einen Parameter, der die Anzahl Sekunden angibt, nach denen das Signal SIGALARM erzeugt werden soll.

Im Umfeld der Netzprogrammierung wird der Systemaufruf z.B. verwendet, um das ping Kommando zu realisieren. Dabei wird jede Sekunde ein Datenpaket zu einem Rechner gesendet und gewartet, ob es zurück gesendet wird.

 31Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für ProzesseDas folgende Programm timer.c verwendet des Systemaufruf alarm, um einen Timer zu setzen. Wenn innerhalb von 5 Sekunden keine Benutzereingabe erfolgt, wird das Programm beendet.

$ cat timer.c#include <stdio.h>#include <signal.h>void handler() {

printf("Bye\n");exit(0);

}main() {

char str[80];signal(SIGALRM, handler);

while (1) {alarm(5);/* start timer; any previous alarm is cancelled */printf("> ");fgets(str, 80, stdin);printf("%s\n", str);

}}$

$ timer> 1234512345 5 Sekunden warten> Bye$

 32Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für ProzesseWenn Programme ablaufen, bei denen eine gewisse Zeit gewartet werden soll, kann dies realisiert werden, indem man eine Schleife verwendet, die nichts anderes tut, als testet, ob die Zeit schon um ist. Diese Lösung ist CPU intensiv. Besser ist der Systemaufruf pause, welcher den aufrufenden Prozess zum Warten veranlasst, bis er das entsprechende Signal zum Weitermachen erhält.

$ cat pause.c#include <stdio.h>#include <signal.h>

void handler() { printf(" ....wake-up!\n");

return;}

main() {signal(SIGINT, handler); /* CTR-C handled */while (1) {

printf("Going to sleep ....\n"); pause();

}}$

$ ./pauseGoing to sleep .... ....wake-up!Going to sleep ....Getötet$

 33Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für Prozesse3.3 ZeitverwaltungIn Unix ist Datum und Uhrzeit als Anzahl Sekunden, die seit dem "Unix-Urknall" (1.1.1970 00:00:00) vergangen sind, abgelegt. Alle Datumsangaben, werden so gespeichert und erst in der Anzeige in lesbare Form gebracht. Dazu existiert der Systemaufruf time, der die Sekundenanzahl liefert und Routinen, um diese Intergerzahl in ein lesbares Format zu konvertieren.Das folgende C-Programm liefert das aktuelle Datum und die Uhrzeit.$ cat now.c#include <stdio.h>#include <time.h>main() {

time_t now;now = time(NULL); /* now as no. secs since ZERO */printf("%s", ctime(&now));

}$

$ nowThu Nov 15 16:07:55 2001$

 34Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für Prozesse3.4 Pipes Der Systemaufruf pipe erzeugt eine Pipe und gibt zwei Dateideskriptoren

zurück, einen zum Lesen und einen zum Schreiben. int p[2];

pipe(p); /* p[0] zum Lesen (ReadEnd) und

p[1] zum Schreiben (WriteEnd) */

Der Mechanismus wird nun am Beispiel eines Programmes gezeigt, bei dem ein Vaterprozess einem Kind Informationen über eine Pipe sendet, d.h. es wird folgende Kommunikation realisiert:

Kind

Vater erzeugt PipeVater erzeugt SohnVater schließt SchreibendeVater liest von Pipe

Kind schließt LeseendeKind schreibt

p[0]p[1]

Vater

● Kind schließt ReadEnd● Kind schreibt auf Pipe● Kind schließt WriteEnd

● Vater erzeugt Pipe● Vater erzeugt Kind● Vater schließt ReadEnd● Vater liest von Pipe● Vater schließt WriteEnd

 35Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für Prozesse

Als C-Programm sieht die Implementierung wie folgt aus:#include <stdio.h>#include <string.h>#define BUFSIZE 20main() {

int pid, status;int p[2]; /* file descriptor */char buf[BUFSIZE];if (pipe(p) != 0) {

fprintf(stderr, "pipe error\n");exit(1);

}switch (pid = fork()) {

case -1: /* fork failed */fprintf(stderr, "cannot fork\n");exit(2);

case 0: /* child: write into pipe */ ...default: /* father: read from pipe */ ...

} }

 36Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

3. Systemaufrufe für Prozessecase 0: /* Child: Schreibe in Pipe */

int i;close(p[0]); /* ReadEnd wird geschlossen, da C nichts liest *//* create example data */for (i=getpid(); i>0; i--) {

sprintf(buf, "%d\n", i);write(p[1], buf, BUFSIZE); /* schreiben *//* just to have more time to see it with "ps -el" */sleep(2); }

close(p[1]);exit(0);

default: /* Father: Lese aus der Pipe */int length;close(p[1]); /* WriteEnd wird geschlossen, da F nichts schreibt */do { /* lesen */

length = read(p[0], buf, BUFSIZE); fprintf(stdout, "%s", buf);} while (length>0);

close(p[0]);

while (wait(&status) != pid);exit(0);

 37Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

4. Threads

Das bisher betrachtete Prozessmodell basiert darauf, dass jeder Prozess einen eigenen, von einander getrennten Adressraum besitzt.Ein Thread ist ein leichtgewichtiger Prozess. Im Unterschied zu einem Prozess, können sich mehrere Threads denselben Adressraum teilen, d.h. sie arbeiten auf denselben Daten. Mehrere Threads in einem Prozess zu ermöglichen wird auch Multithreading genannt.

 38Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

4. Threads

3 Prozesse mit je einem Thread Ein Prozess mit 3 Threads

Wie bei Prozessen wird auch Multi-Threading schnell so hin und her geschaltet, so das die Illusion entsteht, dass die Threads parallel liefen. Dabei existieren dieselben Zustandsübergänge wie beim Prozessmodell.

 39Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

4. Threads

Threads eines Prozesses teilen sich nicht nur einen Adressraum, sondern zusätzlich wie unten dargestellt den gleichen Satz an geöffneten Dateien, Kindprozessen, Alarmen, Signalen usw.. Folglich würde die Organisation in (a) benutzt, wenn die drei Programme (d.h. Prozesse) völlig eigenständig sind, wohingegen (b) angemessen wäre, wenn die Programme (d.h. Threads) in aktiver, enger Kooperation an derselben Aufgabe arbeiten.

 40Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

4. ThreadsWichtig ist, dass jeder Thread seinen eigenen Stack zur Verwaltung der Prozedur-Aufrufhistorie verwaltet.

 41Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

4. ThreadsEin Beispiel für die Nutzung von Threads ist ein Textverarbeitungsprogramm.

 42Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

Hier bei werden drei Threads mit unterschiedlichen Aufgaben versehen:

1. Interaktion mit dem Benutzer2. Formatierung des Textes3. Regelmäßiges Abspeichern auf der Platte

Da zwangsweise auf denselben Daten gearbeitet werden muss, wäre eine Implementierung über Prozesse nicht möglich. Würde nur ein einzelner Prozess benutzt werden, wäre dies für den Benutzer sehr unkomfortabel, da er solange nicht arbeiten könnte, wie der Text formatiert wird.

Die Tatsache, dass Threads miteinander kommunizieren und auf denselben Daten arbeiten, ist nicht unproblematisch, da es ungewollt zu Blockierungen und Inkonsistenzen kommen kann.Dieses wird im Kapitel „Prozessinteraktion“ näher betrachtet werden.

4. Threads

 43Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. Scheduling

Der Teil des Betriebssystems, der entscheidet, welcher der Prozesse, die im Zustand „bereit“ sind, ausgewählt wird und dann den Prozessor zugeteilt bekommt, heißt Scheduler. Das Verfahren, wie ausgewählt wird, nennt man Scheduling-Algorithmus. Je nach Anwendungsfeld ergeben sich dabei sehr unterschiedliche Anforderungen, so dass es keinen Algorithmus gibt, der für jeden Einsatz geeignet ist.

Folgende Kriterien sind beim Scheduling zu berücksichtigen:● Fairness:

Jeder Prozess wird gleichermaßen berücksichtigt; es gibt keine privilegierten Prozesse.

● Effizienz:Der Prozessor wird stets vollständig ausgelastet.

● Antwortzeit:Die Antwortzeit für die interaktiv arbeitenden Benutzer wird minimiert

 44Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. Scheduling● Verweilzeit:

Die Zeit, die auf Ausgabe von Stapelaufträge gewartet werden muss, ist minimal

● Durchsatz:Die Anzahl der Jobs, die in einem gegebenen Zeitintervall ausgeführt werden, wird maximiert.

● Ressourcenbedarf:Der für die Implementierung benötigte Ressourcenbedarf ist minimal.

Nicht alle Kriterien sind gleichzeitig zu erfüllen, da sie teilweise widersprüchlich sind (z.B. Antwortzeit – Verweilzeit).

 45Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. SchedulingJe nach Anwendungsfeld ergeben sich dabei folgende Anforderungen:

 46Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. Scheduling

Ein Betriebssystem nutzt den Unterbrechungsmechanismus moderner CPU's, um sicher zu stellen, dass kein Prozess zu lange ausgeführt wird:

Wenn die Hardware einen Interrupt (etwa 100 mal pro Sekunde) ausgelöst hat, erhält das Betriebssystem die Kontrolle und der Scheduler wählt u.U. einen neuen Prozess aus.

Je nachdem, wie der Scheduler die Auswahl der Prozesse vornimmt, werden Scheduling-Algorithmen unterschieden in:

● preemptive Schedulingrechnende Prozesse können unterbrochen werden.

● run to completion (non-preemptive) Schedulingder rechnende Prozess wird nicht unterbrochen.

 47Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. Scheduling5.1 Shortest-Job-First

Ein Verfahren, bei denen die Ausführungszeiten der einzelnen Prozesse im Voraus bekannt sind, benutzt eine Warteschlange für die gleichgewichtigen Prozesse. Der Scheduler wählt den Prozess mit der kürzesten Ausführungszeit zuerst.

Dieser Algorithmus ist besser als FIFO (FCFS), bei dem die Prozesse in der Reihenfolge ihres Eintreffens behandelt werden, denn es wird die durchschnittliche Verweilzeit (Zeit, die der Prozess im System verweilt) von Prozessen minimiert.

 48Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. SchedulingGegeben seien 4 Prozesse mit folgenden Ausführungszeiten:

A: 8 SekundenB: 6 SekundenC: 4 SekundenD: 6 Sekunden

Ausführungsreihenfolge FIFO: A, B, C, D

durchschnittliche Verweilzeit (8+14+18+24)/4 = 16

Ausführungsreihenfolge SJF: C, B, D, A:

durchschnittliche Verweilzeit (4+10+16+24)/4 = 13,5

VerweilzeitC 4B 4+6=10D 4+6+6=16A 4+6+6+8=24

VerweilzeitA 8B 8+6=14C 8+6+4=18D 8+6+4+6=24

 49Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. SchedulingBehauptung:Den Prozess mit der kürzesten Ausführungszeit zu wählen, ist optimal bzgl. der mittleren Verweilzeit.Beweis:

Gegeben seien 4 Prozesse A-D mit den jeweiligen Verweilzeiten a, b, c, d, die in der Reihenfolge A,B,C,D ausgeführt werden.Verweilzeit A = aVerweilzeit B = a+bVerweilzeit C = a+b+cVerweilzeit D = a+b+c+ddurchschnittliche Verweilzeit = (4a+3b+2c+d)/4

d.h. a beeinflusst die durchschnittliche Verweilzeit am meisten, gefolgt von b und c. Daraus folgt: die durchschnittliche Verweilzeit ist minimal, wenn zuerst A der Prozess mit der kleinsten Ausführungszeit ist, B der Prozess mit der zweit-kleinsten Ausführungszeit, etc.

 50Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. Scheduling

Das Problem bei interaktiven Betriebssystemen ist es, die Ausführungszeitder Prozesse zu bestimmen.Idee: Schätze die Ausführungszeit auf Basis der gemessenen Zeit derVergangenheit. Der Scheduler wählt dann den Prozess mit der kürzestengeschätzten Zeit.

Der neue geschätzte Wert zum Zeitpunkt n+1 wird aus dem gewichtetenDurchschnitt des aktuellen und des vorherigen Wertes gebildet.

α (mit 0 ≤ α ≤ 1) ist dabei der Faktor, der den Einfluss derzurückliegenden Periode auf die Schätzung angibt; Werte nahe 1ordnen der geschätzten Vergangenheit wenig Stellenwert zu.

neuer Schätzwert

alter Schätzwert

Messwert

Sn1=α∗Mn1−α∗Sn

 51Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. Scheduling

Hörsaalübung:Gegeben seien 5 Prozesse mit folgenden Ausführungszeiten:

A: 6 SekundenB: 6 SekundenC: 8 SekundenD: 2 SekundenE: 4 Sekunden

Welche Ausführungsreihenfolge führt zur optimalen durchschnittlichenVerweilzeit?

Prozess Verweilzeit

durchschnittliche Verweilzeit =

 52Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. Scheduling5.2 Round-Robin Scheduling

Ein einfaches und häufig angewendetes Verfahren für interaktive Systeme ist das Round-Robin Verfahren:

Jeder Prozess erhält eine Zeitscheibe (Quantum), die er maximal für die Ausführung zugeteilt bekommt. Ist diese Zeit abgelaufen, wird ihm der Prozessor entzogen und ein anderer Prozess wird ausgewählt (bei Blockierung wg. E/A wird dem Prozess der Prozessor entzogen, auch wenn sein Quantum noch nicht abgelaufen ist).

 53Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. Scheduling

c Scheduler reiht suspendierten Prozess a hinten in Liste ein und wählt Nachfolger b der Liste aus. Neue Prozesse werden ebenfalls hinten angehängt.

a

c

b

Queue ausführbarer

Prozesse

aktueller Prozess

a

b

Zur Implementierung verwaltet der Scheduler eine Queue mit rechenbereiten Prozessen, wobei ein aktiver Prozess nach Ablauf des Quantums wieder hinten in die Liste eingereiht wird:

 54Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. SchedulingEine Implementierung dieses Verfahrens muss eine vernünftige Wahl für die Dauer des Quantums finden:

Angenommen, ein Kontextwechsel dauert 5 Millisekunden. ● Quantum=20 Millisekunden

5/20*100=25% Verwaltungsaufwand ist zu viel.● Quantum=500 Millisekunden

5/500*100=1% Verwaltungsaufwand bedeutet, dass u.U. ein Benutzer zu lange warten (5 Sekunden, wenn 10 Benutzer gleichzeitig arbeiten) muss, bevor seine Anfrage (Tastendruck während Editorsitzung) bearbeitet wird.

Folgerung:● Quantum zu klein wegen häufiger Kontextwechsel sinkt

Prozessorausnutzung● Quantum zu groß schlechte Antwortzeiten bei vielen kurzen Anfragen● Erfahrungswert: Quantum=100 Millisekunden ist guter Kompromiss

 55Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. Scheduling5.3 Scheduling mit Prioritäten

Die Grundidee des Prioritäts-Scheduling ist es, jedem Prozess eine Priorität zuzuweisen. Es wird immer der rechenbereite Prozess mit der höchsten Priorität ausgeführt.

Wird kein weiterer Mechanismus realisiert, so kommt es vor, dass Prozesse mit hoher Priorität verhindern, dass ein Prozess mit niedriger Priorität je den Prozessor bekommen (d.h. sie verhungern).

Um dies zu verhindern, können Gegenmaßnahmen ergriffen werden: z.B:● Der Scheduler verringert fortlaufend die Priorität des rechnenden

Prozesses (mit jedem Interrupt der Prozessor-Uhr). Damit fällt dessen Priorität irgendwann unter die eines anderen rechenbereiten Prozesses, welcher dann die CPU bekommt.

● In Kombination mit Round-Robin-Scheduling bekommt jeder Prozess ein Quantum. Ist das abgelaufen, müssen erst andere Prozesse bedient werden.

 56Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. SchedulingPrioritäten können statisch vergeben werden (z.B. Batchprozesse < Systemprozesse < Interaktive Prozesse < ...),d.h. sie ändern sich nicht mehr.Dynamische Vergabe von Prioritäten wird häufig realisiert, um bestimmte Systemziele zu erreichen:

● z.B. Optimierung des I/O-Verhaltens: ein Prozess, der bei einem E/A Ereignis rechenbereit wird, bekommt hohe Priorität, damit das E/A Ereignis behandelt werden kann.

In modernen Betriebssystemen werden Prozesse in Klassen eingeteilt, wobei zwischen den Klassen Prioritäts-Scheduling und innerhalb der Klasse Round-Robin Scheduling verwendet wird:

Priorität 4

Priorität 3

Priorität 2

Priorität 1

Warteschlangen rechenbereite Prozesse

Wenn keine Prozesse mehr in einer Schlange für Priorität i enthalten sind, wird ein Prozess aus der Schlange für Priorität i-1 genommen.

 57Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. Scheduling5.4 Multiprozessor SchedulingBei modernen Computer setzen sich zunehmend Multicore-Architekturen durch, bei denen Prozesse auf mehreren CPUs parallel laufen können. Dabei teilen sich die Prozesse wie bei Ein-Prozessor-Systemen einen gemeinsamen Speicher.

[Systeme, die jeder CPU einen eigenen Speicher zuordnen, werden Multicomputer genannt, sind aber nicht Gegenstand dieser Vorlesung.]

Das Ziel eines Multiprozessor-Systems ist mit n CPUs n-mal so schnell zu sein wie mit einem Einprozessor-System – also einen linearen Speedup zu erzielen.

Das Scheduling-Problem ist dabei zweidimensional: Der Scheduler muss aus der Menge von rechen-bereiten Prozessen einen auszuwählen und ihn zusätzlich einer bestimmten CPU zuzuordnen.

Das Ziel es linearen Speedups ist äußerst schwierig zu erreichen, da die Prozesse bzw. Threads i.d.R. voneinander abhängig sind.

 58Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. SchedulingDas es auf Betriebssystem-Ebene keine algorithmische Information über einzelne Threads oder Prozesse gibt, können nur relativ einfache Strategien beim Multiprozessor-Scheduling verfolgt werden.Die einfachste besteht daraus, eine System-weite Liste aller bereiten Prozesse zu verwalten. Daraus wird wie bei einem Einprozessor-System ausgewählt und der Prozess einer freien CPU zugeteilt. Beispiel:

 59Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. SchedulingEs kommt also immer dann zu einer Zuteilung, wenn eine CPU frei wird, z.B. weil der bislang dort laufende Prozess suspendiert wurde.

Vorteil:● Man erzielt i.A. eine recht gute d.h. faire Lastverteilung: Es kann nie

vorkommen, dass eine CPU im Leerlauf und eine andere überlastet ist.

Nachteile:● Es kommt zu häufigen, konkurrierenden Zugriffen auf der zentrale Liste.● Voneinander abhängige Threads, welche auf verschiedenen CPUs laufen,

können sich gegenseitig blockieren, und damit gleichzeitig auf mehrere CPUs Kontextwechsel verursachen.

 60Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. Scheduling5.5 Scheduling in Linux [2,3]Unter Linux wird eine Mischung aus Prioritäts- und Round-Robin-Scheduling verwendet. Es wird auf Basis von Threads (=Task) gearbeitet:

● Alle lauffähigen Tasks befinden sich in einer Active Runqueue, die nach Prioritäten sortiert ist. Es wird jeweils die Task mit der höchsten Priorität ausgewählt. Jede Prioritätsstufe besitzt einen Listenkopf, der auf eine Liste rechenbereiter Tasks dieser Priorität weist.

 61Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. Scheduling● Ist die Zeitscheibe abgelaufen, so wird die Task unterbrochen und in die

Expired Runqueue verschoben. Wird die Task aus eine anderen Grund unterbrochen, wird sie zurück in die Active Runqueue gebracht, sofern vom Quantum (also die verbleibende Zeit, die eine Task die CPU noch benutzen darf) noch etwas übrig ist. Andernfalls wird die Task nicht mehr berücksichtigt, bis auch alle anderen Tasks ihr Quantum aufgebraucht haben.

● Die Priorität wird in bestimmten Momenten ebenso wie das Quantum dynamisch angepasst: Grundlage ist dabei zunächst ein nice value (aus dem Bereich -20 bis 19), der die statische Priorität angibt: je kleiner der Wert, um so höher die Priorität). Neue Tasks haben per Default die statische Priorität 0.

● Grundlage für das Scheduling ist aber die dynamische Priorität, die sich zunächst aus der statischen Priorität der Task errechnet und zwischen 100 und 139 liegen kann. Die Blockiert-Zeiten einer Task können die Priorität um bis zu fünf Einheiten verändern. Interaktive Tasks werden in ihrer Reaktionzeit (wg. einer höheren Priorität) bevorzugt.

 62Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. Scheduling

● Das Quantum ergibt sich aus der statischen Priorität. Interaktive Tasks werden also nicht mit einer höheren Rechenzeit versehen. Außerdem gilt: je höher die Priorität umso länger die Zeitscheibe.

● Das Quantum einer laufenden Task wird in jedem Durchlauf einen „Tick“ (= 10ms) verringert. Wenn das Quantum 0 erreicht hat, wird die Task verdrängt, d.h. in die Expired Runqueue gesteckt. Das Quantum wird dabei neu aufgefüllt. Stark interaktive Task kommen ggf. direkt zurück in die Active Runqueue.

● Wird eine neue Task bereit, wird sie in die Active Runqueue gesteckt und verdrängt dann ggf. eine andere Task von der CPU. Ist die Active Runqueue leer, wird sie mit der Expired Runqueue getauscht (= Round Robin).

● Ist keine Task aktiv, wird die Idle-Task ausgeführt.

 63Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. SchedulingDas folgende Programm zeigt, wie der nice value eines Prozesses gesetzt und abgefragt werden kann:$ cat getPriority.c#include <stdio.h>#include <sched.h>#include <sys/resource.h>#include <errno.h>extern int errno;main() {

printf("%d\n", getpriority(PRIO_PROCESS, 0));

if (setpriority(PRIO_PROCESS, 0, 10) != 0) { /* 0 == calling process */

fprintf(stderr, "Error setpriority: %s\n", strerror(errno));exit(1);

}

printf("%d\n", getpriority(PRIO_PROCESS, 0));exit(0);

}$

 64Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. SchedulingAlternativ kann die statische Priorität mit folgendem Shell-Kommando beeinflusst werden:$ nice --helpAufruf: nice [OPTION] [BEFEHL [ARGUMENT]...]Run COMMAND with an adjusted niceness, which affects processscheduling. With no COMMAND, print the current niceness. Nicenessesrange from -20 (most favorable scheduling) to 19 (least favorable).

-n, --adjustment=N add integer N to the niceness (default 10) --help diese Hilfe anzeigen und beenden --version Versionsinformation anzeigen und beenden

$

 65Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

5. SchedulingZusammenfassung:

Aufgabe: Sie starten 2 Batch-Jobs (ohne Ein-/Ausgabe) mit nice -3 A und nice -19 B.(a) Wie wird die CPU vergeben, d.h. welche Zeitscheiben ergeben sich?

(b) Welche CPU-Zeiten kann man folgern (Angabe in Prozent), wenn dies die beiden einzigen Tasks im System sind?

statische Priorität (nice) 19 18 0 -19 -20dynamische Priorität (initial) 139 138 120 101 100Quantum (ms) 10 15 105 200 205PR bei top 39 38 20 1 0

 66Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

6. Scheduling mit besonderen Zielen6.1 Garantiertes SchedulingBeim garantierten Scheduling wird einem Prozess eine gewisse Performance versprochen und die Einhaltung garantiert.

Mögliche Versprechen:Bei interaktiven Systemen mit n Benutzern, erhält jeder 1/n der verfügbaren Prozessorzeit

Implementierung:● Zu jeder Benutzersitzung sei die insgesamt erhaltene Prozessorzeit seit

Sitzungsbeginn e. ● Der Scheduler berechnet die dem Benutzer zustehende Zeit z und

ermittelt das Verhältnis von erhaltener Zeit e und zustehender Zeit z. ● Das Verhältnis 0,5 bedeutet, dass der Prozess halb so viel Zeit verbraucht

hat, wie ihm garantiert wurde. ● Der Scheduler wählt immer den Prozess, mit dem berechneten kleinsten

Verhältnis e/z.

 67Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

6. Scheduling mit besonderen Zielen

Beispiel:

rechenbereiterProzess

erhalteneZeit e

versprocheneZeit z

e/z ausgewählterProzess

A14

(14+11+20)/3=15

14/15=0,93

B 11 15 11/15=0,73 XC 20 15 20/15=1,33

 68Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

6. Scheduling mit besonderen ZielenHörsaalübung

Ein interaktives System sei gegeben durch:

rechenbereiterProzess

erhalteneZeit e

versprocheneZeit z

e/z ausgewählterProzess

A 6B 2C 4D 4

Welcher Prozess wird ausgewählt?

 69Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

6. Scheduling mit besonderen Zielen6.2 Real-Time Scheduling

Im Folgenden werden Real-Time-Scheduling-Verfahren vorgestellt und analysiert. Es wird nicht zwischen Prozessen und Threads unterschieden, sondern der Begriff Task verwendet. In den seltensten Fällen wird nur eine Task allein den Prozessor benutzen. Deshalb ist es notwendig, das Scheduling so zu gestalten, dass potenziell alle vorhandenen Tasks rechtzeitig vor dem Ablauf eine Deadline fertig werden.

Alle Verfahren basieren auf der Kenntnis der voraussichtlichen maximalen Laufzeit einer Task (Worst-Case Execution Time – WCET). Diese zu bestimmen ist zwar schwierig aber möglich, jedoch nicht Gegenstand dieser Vorlesung.

Dabei liegt zugrunde, dass solche Tasks entweder Teil eines Regelungs- und Steuerungsverfahrens oder einer Multimedia-Anwendung ist. In beiden Fällen wird die Task daher mit einer festen Periode immer wieder neu gestartet.

 70Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

6. Scheduling mit besonderen ZielenDie wesentlichen Parameter des Schedulings (und dessen Analyse) umfassen somit:

• period T: Länge des Kreislaufs, z.B. TA=3

• computation time C: längste zu erwartende Berechnungszeit, z.B. CA=1

• deadline D: Zeitpunkt (relativ zum Beginn), bis zu dem die Berechnung jeweils erfolgt sein muss

Beispiel: Tragen Sie die Zeiträume ein, in denen Task A die CPU bekommt (es existieren keine weiteren Tasks):

A

0 4 82 6 10

 71Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

6. Scheduling mit besonderen Zielen6.2.1 Rate-Monotonic Scheduling (RMS) RMS ist das bekannteste (weil älteste) RT-Scheduling-Verfahren

[Lui/Layland73]. Hierbei gilt:• D = T; je kleiner D, desto höher die Priorität• Statisch: die Priorität ändert sich nicht mehr• Preemptiv: höher-priorisierte Tasks verdrängen niedrigere

Beispiel: Tragen Sie die Zeiträume ein, in denen die Tasks A und X jeweils die CPU bekommen (beide sind zum Zeitpunkt 0 bereit):

A

0 4 82 6 10

310X

1

C

3A

TTask

X

 72Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

6. Scheduling mit besonderen Zielen Bei der Analyse des RT-Schedulings geht es darum, zu bestimmen, ob alle

Tasks unter dem gegebenen Scheduling-Verfahren ihre Deadlines einhalten werden. Je nach benutztem Verfahren existieren unterschiedliche Techniken, die i.A. ohne eine komplette Betrachtung des KgVs auskommen und somit effizient arbeiten. Solche Analyse-Techniken werden Schedulability-Tests genannt.

Ein Schedulability-Test für Rate-Monotonic Scheduling ist gegeben durch [Lui/Layland73]:

Der Test sagt aus, dass man auf der sicheren Seite ist, wenn die Auslastung der CPU nicht 69% Prozent überschreitet.

i i

i ≤ 0.69TC∑

 73Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

6. Scheduling mit besonderen ZielenBeispiel: Wenden Sie den Lui-Layland Test auf folgendes Beispiel an und

zeichnen Sie zur Kontrolle die aktiven Zeiträume über der Zeitachse ein:

412B

4

C

6A

TTask

 74Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

6. Scheduling mit besonderen Zielen6.2.2 Earliest-Deadline First (EDF) Scheduling Bislang wurden nur Scheduling-Algorithmen mit statischer Prioritätsvergabe

betrachtet. Nun wenden wir uns dynamischen Verfahren zu, bei denen zur Laufzeit immer wieder neu die Prioritäten vergeben werden.

Bei EDF hat (wie bei Deadline Monotonic) immer die Task mit der nächsten Deadline die höchste Priorität. Wir betrachten einen preemptiven Ansatz.

i i

i ≤ 1.0TC∑

Ein Schedulability Test für EDF ist sehr einfach und effizient, sofern T=D gilt:

  Für alle Tasks muss zusätzlich gelten: C ≤ T

 75Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

6. Scheduling mit besonderen Zielen

Beispiel: Wenden Sie den EDF-Test auf folgendes Beispiel an und zeichnen Sie zur Kontrolle die aktiven Zeiträume über der Zeitachse ein:

Task T C DA 3 1 3B 6 1 6C 5 1 5D 10 2 10

 76Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

6. Scheduling mit besonderen Zielen6.2.3 RT Scheduling in Linux Das oben beschriebene Standard-Scheduling für Linux hat i.W. das Ziel, alle Prozesse möglichst fair zu behandeln. Dies ist für Echtzeitsysteme nicht adäquat. Daher ist Linux-Scheduling gemäß POSIX wie folgt erweitert worden [2]:

● Es gibt Scheduling-Klassen mit statischen Prioritäten von 0 (niedrigste) bis 99 (höchste). Prozesse mit hoher Priorität verdrängen die mit niedriger.

● Das Standard-Scheduling (SCHED_OTHER) läuft in Klasse 0.● Zusammenhang:

19 0 -20139 120 100 1 10 98 99

Quantum (ms) 10 105 20539 20 0 -2 -11 -99 RT

Normales Scheduling Real-Time Schedulingstatische Priorität (nice)dynamische Priorität (initial) Prioritätsklasse

PR bei top PR bei top

 77Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

6. Scheduling mit besonderen Zielen● In Prioritätsklassen sind Tasks vom Typ

➢ SCHED_FIFO d.h. nicht unterbrechbar (außer durch höhere Priorität) oder

➢ SCHED_RR d.h. nach Ablauf eine Zeitscheibe wird die Task ans Ende der Schlange in der jeweiligen Klasse gehängt.

Besonders SCHED_FIFO ist dabei mit äußerster Vorsicht zu benutzen.

Durch den Systemaufruf sched_setscheduler() kann ein Prozess (per Root-Berechtigung) in eine andere Scheduling-Klasse verschoben werden, wie folgendes Beispiel zeigt:

 78Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

6. Scheduling mit besonderen Zielen#include <stdio.h>#include <sched.h>#include <errno.h>#include <stdlib.h>#include <limits.h> // wg. UINT_MAX

main(int argc, char **argv) {int rc;struct sched_param param;

param.sched_priority = 1;

rc = sched_setscheduler(0 /* calling process */, SCHED_FIFO /* SCHED_RR */, &param);

if (rc < 0) {switch (errno) {case EINVAL:

printf(" Falsche Policy oder falsche Parameter!\n"); break;case EPERM:

printf(" Keine Erlaubnis!\n"); break;case ESRCH:

printf(" Keine gültige PID!\n"); break;default:

printf(" Komischer Fehler!\n"); break;}exit(2);

}

unsigned long i;for(i = 0; i < UINT_MAX/4; i++ )/* printf("%d\r", i) */;

}

 79Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

6. Scheduling mit besonderen ZielenIn Linux kann das Quantum eines in SCHED_OTHER oder SCHED_RR laufenden Prozesses wie folgt ermittelt werden:

$ cat getQuantum.c#include <stdio.h>#include <unistd.h>#include <sched.h>/* struct timespec { time_t tv_sec; long tv_nsec; // Nanosekunden=10**-9 Sekunden };*/main(int argc, char **argv) { struct timespec t;

if (argc != 2) { fprintf(stderr, "usage %s pid\n", argv[0]); exit(1); }

if (sched_rr_get_interval(atoi(argv[1]),&t)==0) printf("sec: %d millisec: %ld\n", t.tv_sec, t.tv_nsec/1000000); else printf("pid %d not existing\n", atoi(argv[1]));}

$ ./getQuantum 1sec: 0 millisec: 100$ ./getQuantum 2sec: 0 millisec: 4$

 80Peter Altenbernd – Prozesse – Betriebssysteme – WS 2010/11 – Hochschule Darmstadt

6. Scheduling mit besonderen Zielen6.3 Energie-effizientes Scheduling Moderne Prozessoren verbrauchen dann den meisten Strom, wenn sie die meiste Arbeit zu erledigen haben, d.h. ihre Taktrate wird dynamisch angepasst.

Ähnlich zum Real-Time Scheduling ist es daher naheliegend, einen Prozess so langsam wie gerade noch möglich auszuführen, indem der Prozessor herunter getaktet wird, denn das senkt den Stromverbrauch.

Daher steht der Scheduler in Verbindung mit der Geräteverwaltung, um die Geschwindigkeit des Prozessors zu steuern. Dabei kann der Prozessor bei Bedarf sogar „schlafen“ gelegt werden (dormant mode), sofern abzusehen ist, dass in einem überschaubaren Zeitintervall nichts zu erledigen ist.