Übung zu Grundlagen der Betriebssysteme. 8. Übung

Transkript

1 Übung zu Grundlagen der Betriebssysteme 8. Übung

2 Threads Thread (Faden des (Kontrollflusses)): ist ein sequentieller Abarbeitungsablauf (Kontrollfluss) innerhalb eines Prozesses. Umfasst ein Prozess mehr als einen Thread Multithreading ähnlich realisiert wie ein Prozess, aber (konzeptionell) immer in einem Prozess eingebettet, der allein die Betriebsmittel verwaltet Prozess enthält einen oder mehrere Threads Prozess Vorteil: eigenständiges Programm/Anwendung eigener Adressraum eigene Betriebsmittel Nachteil: Umschaltung zwischen Prozessen sehr aufwendig (context switch). aufwendige Kommunikation zwischen Prozessen. Thread Vorteil: Einfache Kommunikation zwischen den Threads eines Prozesses Einfacher Zugriff auf gemeinsame Variablen (gemeinsamer Adressraum). Nachteil: kein eigener Adressraum keine eigenen Betriebsmittel Synchronisation notwendig

3 Aufgabe 1 Erläutern Sie mit wenigen Worten warum der Einsatz von Threads sinnvoll ist! Threads sind leichtgewichtiger als Prozesse. Ein Thread Kontextwechsel innerhalb des laufenden Prozesses kann schneller sein als ein Prozess-Kontextwechsel, weil meist Speicherbereiche des gleichen Prozesses verwendet werden. Ein Austausch von Speicherbereichen ist daher of nicht erforderlich, was den Betriebssystem-Overhead reduziert.

4 Symmetrisches Multiprozessorsystem (SMP) eine Multiprozessor-Architektur, bei der zwei oder mehr identische Prozessoren einen gemeinsamen Adressraumbesitzen. Dies bedeutet, dass jeder Prozessor mit derselben (physikalischen) Adresse dieselbe Speicherzelle oder dasselbe Peripherieregister adressiert. Eine SMP-Architektur erlaubt es, die laufenden Prozesse dynamisch auf alle verfügbaren Prozessoren zu verteilen dagegen muss beim asymmetrischen Multiprocessing jeder CPU eine Aufgabe fest zugewiesen werden.

5 Aufgabe 1 Ein Prozess hat mindestens einen Thread, kann aber aus mehreren Threads bestehen, die praktisch gleichzeitig abgearbeitet werden und sich somit ähnlich wie verschiedene Prozesse verhalten.

6 Aufgabe 1 b) Kann ein Thread unter dem Betriebssystem Windows mehreren Prozessen zugeordnet werden? Begründen Sie! Nein ein Thread wird innerhalb eines Prozesses erzeugt und ist diesem bis zur Terminierung zugeordnet. Nein. Ein Thread befindet sich immer innerhalb eines Prozesses, gegebenenfalls zusammen mit anderen Threads. Alle diese Threads teilen sich den Speicherbereich, der dem Prozess zur Verfügung steht. Sollte also ein Thread zu mehreren Prozessen gehören, dann müsste dieser ja auch auf mehrere Speicherbereiche der einzelnen Prozesse Zugriff haben. Und dies ist weder möglich noch erwünscht. Außerdem ist die Idee eines Threads ja unter anderem, dass die CPU bei der Ausführung eines blockierten Threads nicht den Prozess wechseln muss (kein teurer Kontextwechsel) sondern einfach innerhalb eines Prozesses verbleiben kann und mit einem anderen Thread weiterarbeiten kann.

7 Aufgabe 2 Im letzten Übungsblatt (Blatt 4, Aufgabe 2) haben wir das C-Programm father_son.c kennengelernt. Hier wird ein Programm mittels fork() in mehrere Prozesse aufgeteilt, die die Variable i unabhängig voneinander auf einen bestimmten Wert inkrementieren. Verändern Sie das Programm father_son.c so, dass ein einziger Prozess über 3 zusätzliche Posix-Threads eine (einzige) Integer Variable in einer Schleife bis zu einem bestimmten Wert hoch zählt (immer um Wert 1 inkrementiert). Der Hauptthread (main()) soll beim Hochzählen nicht beteiligt sein, sondern auf die 3 Threads warten (pthread_join(...)). Der maximale Wert der Integer Variable soll beim Programmstart übergeben werden (entweder über Tastatur-Abfrage oder über einen Startparameter des Programms). Über eine printf()-funktion soll jeder Thread auf der Konsole ausgeben, auf welchen Wert er die Integer Variable gerade ändert. Hinweis: Das Hochzählen der Integer Variable muss in dieser Aufgabe nicht synchronisiert werden, d.h. es dürfen z.b. Werte übersprungen werden oder auch doppelt vorkommen.

8 Threads father_son_thread.c #include <stdio.h> #include <stdlib.h> #include <pthread.h> gcc - o f a t h e r _ s o n _ t h r e a d f a t h e r _ s o n _ t h r e a d. c - l p t h r e a d int i; int rnd; void* thrfunc(void *a); void main(){ pthread_t thr; pthread_create(&thr, NULL, thrfunc, NULL); for (i=0; i<500; i++){ printf("\n Father: %i", i); sleep(1); void* thrfunc(void *a){ for (i=0; i<500;i++){ printf("\n Son: %i", i); rnd=rand(); sleep(rnd%3);

9 Aufgabe 2 #include <stdio.h> #include <stdlib.h> #include <pthread.h> void threadonefunction(int *max); void threadtwofunction(int *max); void threadthreefunction(int *max); int i = 0;int main(int argc, char *argv[]) { int max = atoi(argv[1]); pthread_t threadone; pthread_t threadtwo; pthread_t threadthree; pthread_attr_t threadoneattr; pthread_attr_t threadtwoattr; pthread_attr_t threadthreeattr; pthread_attr_init(&threadoneattr); pthread_attr_init(&threadtwoattr); pthread_attr_init(&threadthreeattr); pthread_create(&threadone, &threadoneattr, threadonefunction, &max); pthread_create(&threadtwo, &threadtwoattr, threadtwofunction, &max); pthread_create(&threadthree, &threadthreeattr, threadthreefunction, &max); pthread_join(threadone, NULL ); pthread_join(threadtwo, NULL ); pthread_join(threadthree, NULL ); return 0; (Gruppe Arrandale)

10 Aufgabe 2 pthread_create(&threadone, &threadoneattr, threadonefunction, &max); void threadonefunction(int *max) { if (i < *max) { i++; printf("thread 1 incremented i to: %d\n", i); threadonefunction(max); pthread_exit(0); void threadtwofunction(int *max) { if (i < *max) { i++; printf("thread 2 incremented i to: %d\n", i); threadtwofunction(max); pthread_exit(0); void threadthreefunction(int *max) { if (i < *max) { i++; printf("thread 3 incremented i to: %d\n", i); threadthreefunction(max); pthread_exit(0); (Gruppe Arrandale)

11 Aufgabe 2./test 30 Thread 3 incremented i to: 1 Thread 3 incremented i to: 3 Thread 3 incremented i to: 4 Thread 3 incremented i to: 5 Thread 3 incremented i to: 7 Thread 3 incremented i to: 8 Thread 3 incremented i to: 9 Thread 3 incremented i to: 10 Thread 3 incremented i to: 11 Thread 3 incremented i to: 12 Thread 3 incremented i to: 13 Thread 3 incremented i to: 14 Thread 3 incremented i to: 15 Thread 3 incremented i to: 16 Thread 3 incremented i to: 17 Thread 3 incremented i to: 18 Thread 3 incremented i to: 19 Thread 3 incremented i to: 20 Thread 2 incremented i to: 2 Thread 1 incremented i to: 6 (Gruppe Arrandale)

12 Aufgabe 2 #include <pthread.h> #include <stdio.h> #include <stdlib.h> int i; long t; void *count(void *threadid){ long* tid; tid=(long*)threadid; while (i<500){ printf("\n Process %d : %d",tid,i); sleep(1); i++; pthread_exit(null); void main(){ pthread_t threads[3]; int out; pthread_create(&threads[1],null,count,(void *)1); pthread_create(&threads[2],null,count,(void *)2); pthread_create(&threads[3],null,count,(void *)3); pthread_join(threads[1],null); pthread_join(threads[2],null); pthread_join(threads[3],null); pthread_exit(null); (Gruppe bekton)

13 Aufgabe 2 #include <stdio.h> #include <stdlib.h> #include <pthread.h> int i; int rnd; int m; void* thrfunc(void *a); int main() { printf("\n Maximaler Wert: "); scanf("%i", &m); pthread_t threads[3]; int thread_arguments[3], p; for (p = 0; p < 3; ++p) { thread_arguments[p] = p; pthread_create(&threads[p], NULL, thrfunc, (void *) &thread_arguments[p]); for (p = 0; p < 3; ++p) { pthread_join(threads[p], NULL); return 0; void* thrfunc(void *a) { int k = *((int*) a); for (i = 0; i <= m; i++) { printf("\n Thread %i: %i", k, i); rnd = rand(); sleep(rnd%3); return NULL;

14 Aufgabe 2 #include <stdio.h> #include <stdlib.h> #include <pthread.h> int maxval; /* Wird inkrementiert */ int i = 0; int rnd; #define NUM_THREADS 3 /* Thread Funktion */ void *runner(void *param) { int tid; tid = *((int *) param); while(i <= maxval) { printf("thread %i: %i\n", tid, i); rnd=rand(); sleep(rnd%3); i++; void main(int argc, const char* argv[] ) { printf("maximalwert eingeben: "); scanf("%i", &maxval); pthread_t threads[num_threads]; int thread_args[num_threads]; int j; /* Alle Threads erstellen */ for (j = 0; j < NUM_THREADS; j++) { thread_args[j] = j; // Thread Nummer als Parameter an die Funktion runner uebergeben pthread_create(&threads[j], NULL, runner, (void *) &thread_args[j]); /* Warten bis alle Threads beendet wurden */ for (j = 0; j < NUM_THREADS; j++) pthread_join(threads[j], NULL);

15 Aufgabe 3 a) Nennen Sie mindestens 4 Vergleichskriterien, nach denen Scheduling- Verfahren verglichen werden können und erläutern Sie diese mit wenigen Worten.

16 Aufgabe 3 a) Nennen Sie mindestens 4 Vergleichskriterien, nach denen Scheduling- Verfahren verglichen werden können und erläutern Sie diese mit wenigen Worten. - Wartezeit: Zeit, die ein Prozess auf die Ausführung warten muss, also die Summe aller Zeiträume, in denen ein Prozess warten muss. - Bedienzeit (Servicezeit): Zeit, in der ein Prozess die CPU hält und arbeiten kann. - Antwortzeit: Zeit, in der ein Anwender auf die Bearbeitung seines Auftrags warten muss. - Durchsatz: Anzahl an Prozessen, die ein System in einer bestimmten Zeit bearbeiten kann. - CPU-Auslastung: Auslastung der CPU während der Bearbeitung von Prozessen in % der Gesamtkapazität - Durchlaufzeit = Verweilzeit: Gesamte Zeit, in der sich ein Prozess im System befindet (Serviczeiten + Wartezeiten)

17 Aufgabe 3 a) Nennen Sie mindestens 4 Vergleichskriterien, nach denen Scheduling-Verfahren verglichen werden können und erläutern Sie diese mit wenigen Worten. Durchsatz: Möglichst viele Prozesse werden in möglichst kurzer Zeit abgearbeitet. Effizienz: Die zur Verfügung stehenden Ressourcen werden möglichst vollständig ausgelastet. Fairness: Die Ressourcen werden den Prozessen gerecht zugeteilt, das heißt kein Prozess wird dauerhaft vernachlässigt. Man sagt auch, das Verfahren vermeide das Verhungern (starvation) von Prozessen. Transparenz: Die einzelnen Schritte der Prozesse werden in ihrem Ablauf und in ihrer Zuordnung zu Ressourcen klar erkannt und getrennt. Termineinhaltung: Prozesse, die zu einem bestimmten Termin beendet sein müssen, werden so geplant, dass der Termin eingehalten wird. Während in der Betriebswirtschaft präzise einzuhaltende Termine Deadlines und ungefähr einzuhaltende Termine Fertigstellungstermine heißen, spricht man in der Informatik nur von Deadlines und unterscheidet stattdessen folgende Arten von Echtzeitanforderungen: Harte Echtzeit hält alle Deadlines präzise ein, weiche Echtzeit hält Deadlines einigermaßen ein und Best Effort ( so gut wie möglich ) sichert keine Einhaltung der Deadlines zu. Einfach und schnell: Für eine Implementierung in Hochgeschwindigkeits-Switchen ist es wichtig die Komplexität zu begrenzen. (

18 Aufgabe 3 b) Ermitteln Sie für folgende fünf Prozesse die gesamte Bearbeitungszeit und die durchschnittliche Bearbeitungszeit unter Berücksichtigung folgender Scheduling- Strategien. (Angaben in ms). Prozess A B C D E Ablaufzeit Priorität ) Reines Priority Scheduling ((A) hat mit 5 die höchste Priorität). 2) First Come First Serve (FCFS) unter Berücksichtigung der Reihenfolge: A, B, D, C, E 3) Shortest Job First (SJF). 4) Round Robin (RR) ohne Prioritäten bei einem Quantum von 2 ms, wobei die Reihenfolge der Abarbeitung A,B,C,D,E sein soll. Die Prozesse werden ungefähr gleichzeitig gestartet. Die Prozesswechselzeit wird nicht betrachtet. Eine Verdrängung (Preemption) wird nur im Fall d) ausgeführt.

19 Aufgabe 3 1) Reines Priority Scheduling ((A) hat mit 5 die höchste Priorität). Prozess A B C D E Ablaufzeit Priorität Prozess A B C D E Ablaufzeit Priorität Bearbeitungszeit Die Summe über alle Bearbeitungszeiten ist V all = = 185 ms Durchschnittliche Bearbeitungszeit V avg = 185/5 = 37 ms Wartezeit W all = = 124 ms Durchschnittliche Wartezeit W avg = 124/5 = 24,8 ms

20 Aufgabe 3 2) First Come First Serve (FCFS) unter Berücksichtigung der Reihenfolge: A, B, D, C, E Prozess A B C D E Ablaufzeit Priorität Prozess A B D C E Ablaufzeit Bearbeitungszeit Die Summe über alle Bearbeitungszeiten ist V all = = 181 ms Durchschnittliche Bearbeitungszeit V avg = 181/5 = 36,2 ms Wartezeit W all = = 120 ms Durchschnittliche Wartezeit W avg = 120/5 = 24 ms

21 Aufgabe 3 3) Shortest Job First (SJF). Prozess A B C D E Ablaufzeit Priorität Prozess E A B D C Ablaufzeit Bearbeitungszeit Die Summe über alle Bearbeitungszeiten ist V all = = 145 ms Durchschnittliche Bearbeitungszeit V avg = 145/5= 29 ms Wartezeit W all = = 84 ms Durchschnittliche Wartezeit W avg = 84/5 = 16,8 ms

22 Aufgabe 3 4) Round Robin (RR) ohne Prioritäten bei einem Quantum von 2 ms, wobei die Reihenfolge der Abarbeitung A,B,C,D,E sein soll. Prozess A B C D E Ablaufzeit Priorität Scheduling-Reihenfolge: A B C D E A,B,C,D,E A,B,C,D,E A,B,C,D,E A,B,C,D B,C,D B,C,D C,D C,D C E= E=A+B+C+D+2+A+B+C+D+2+A+B+C+D+1=29ms A= A= =31ms B= B= =31+14=45ms D=45+12 = 57ms C=57+4 = 61ms

23 Aufgabe 3 4) Round Robin (RR) ohne Prioritäten bei einem Quantum von 2 ms, wobei die Reihenfolge der Abarbeitung A,B,C,D,E sein soll. Prozess A B C D E Ablaufzeit Priorität Prozess A B C D E Ablaufzeit Bearbeitungszeit Die Summe über alle Bearbeitungszeiten ist V all = = 223ms Durchschnittliche Bearbeitungszeit V avg = 223/5 = 44,6 ms Wartezeit W all = = 162ms Durchschnittliche Wartezeit W avg = 162/5 = 32,4ms

24 Aufgabe 3 (Gruppe Clarksfield)

25 Aufgabe 4 Erweitern Sie Ihr C-Programm aus Aufgabe 2 um das Round Robin (RR) Scheduling Verfahren und vergeben Sie den einzelnen Threads Prioritäten. Beim Programmstart soll neben dem maximalen Wert für die Integer Variable auch für jeden der 3 Threads eine Priorität übergeben/abgefragt werden. Überprüfen Sie die Funktionsweise ihres Programms anschließend mit ps -elfl

26 Aufgabe 4 #include <stdio.h> #include <stdlib.h> #include <pthread.h> void threadonefunction(int *max); void threadtwofunction(int *max); void threadthreefunction(int *max); int i = 0; int main(int argc, char *argv[]) { int max = atoi(argv[1]); pthread_t threadone; pthread_t threadtwo; pthread_t threadthree; pthread_attr_t threadoneattr; pthread_attr_t threadtwoattr; pthread_attr_t threadthreeattr; int policy = SCHED_RR; struct sched_param threadoneparam; struct sched_param threadtwoparam; struct sched_param threadthreeparam; threadoneparam.sched_priority = atoi(argv[2]); threadtwoparam.sched_priority = atoi(argv[3]); threadthreeparam.sched_priority = atoi(argv[4]); pthread_attr_init(&threadoneattr); pthread_attr_init(&threadtwoattr); pthread_attr_init(&threadthreeattr); pthread_setschedparam(threadone, &policy, &threadoneparam); pthread_setschedparam(threadtwo, &policy, &threadtwoparam); thread_setschedparam(threadthree, &policy, &threadthreeparam); pthread_create(&threadone, &threadoneattr, threadonefunction, &max); pthread_create(&threadtwo, &threadtwoattr, threadtwofunction, &max); pthread_create(&threadthree, &threadthreeattr, threadthreefunction, &max); pthread_join(threadone, NULL ); pthread_join(threadtwo, NULL ); pthread_join(threadthree, NULL ); return 0

27 Aufgabe 4 #include <stdio.h> #include <stdlib.h> #include <pthread.h> void threadonefunction(int *max); void threadtwofunction(int *max); void threadthreefunction(int *max); int i = 0; int main(int argc, char *argv[]) { int max = atoi(argv[1]); pthread_t threadone; pthread_t threadtwo; pthread_t threadthree; pthread_attr_t threadoneattr; pthread_attr_t threadtwoattr; pthread_attr_t threadthreeattr; int policy = SCHED_RR; struct sched_param threadoneparam; struct sched_param threadtwoparam; struct sched_param threadthreeparam; threadoneparam.sched_priority = atoi(argv[2]); threadtwoparam.sched_priority = atoi(argv[3]); threadthreeparam.sched_priority = atoi(argv[4]); pthread_create(&threadone, &threadoneattr, threadonefunction, &max); pthread_create(&threadtwo, &threadtwoattr, threadtwofunction, &max); pthread_create(&threadthree, &threadthreeattr, threadthreefunction, &max); pthread_setschedparam(threadone, policy, &threadoneparam); pthread_setschedparam(threadtwo, policy, &threadtwoparam); thread_setschedparam(threadthree, policy, &threadthreeparam); pthread_join(threadone, NULL ); pthread_join(threadtwo, NULL ); pthread_join(threadthree, NULL ); return 0

28 Aufgabe 4 void threadonefunction(int *max) { if (i < *max) { i++; printf("thread 1 incremented i to: %d\n", i); threadonefunction(max); pthread_exit(0); void threadtwofunction(int *max) { if (i < *max) { i++; printf("thread 2 incremented i to: %d\n", i); threadtwofunction(max); pthread_exit(0); void threadthreefunction(int *max) { if (i < *max) { i++; printf("thread 3 incremented i to: %d\n", i); threadthreefunction(max); pthread_exit(0);

29 Threads

30 Scheduling Scheduling im Einprozessorsystem Scheduling Planung der zeitlichen Zuteilung von Ressourcen Arten des Prozess-Scheduling: Langfristiges Scheduling: Die Entscheidung, einen Prozess in den Pool der auszuführenden Prozesse aufzunehmen Mittelfristiges Scheduling: Die Entscheidung, einen Prozess zu den Prozessen hinzuzufügen, die sich teilweise oder ganz im Hauptspeicher befinden Kurzfristiges Scheduling: Die Entscheidung, welcher Prozess durch den Prozessor bearbeitet wird. Zuteilung der E/A Ressourcen: Die Entscheidung, welche E/A-Anforderung eines Prozesses von einem verfügbaren E/A-Gerät bearbeitet werden soll.

31 Scheduling Scheduling im Einprozessorsystem Scheduling Zuteilung der Prozessoren zu lauffähigen Prozessen Grundmuster für Prozesse CPU-lastig: Prozess nutzt viel Rechenzeit, wartet selten auf I/O I/O-lastig: Prozess nutzt Peripherie und wartet auf I/O Prozessklassen Batch Jobs: Prozesse ohne Benutzerdialog Interaktive Prozesse: Ablauf gesteuert durch Benutzer Real-Time Prozesse: Einhalten vorgegebener Zeitlimits

32 Scheduling

33 Scheduling

34 Scheduling Optimierungsziele: Durchlaufzeit: Gesamtzeit von Prozessstart bis Beendigung Antwortzeit: Zeit zwischen Eingabe und Reaktion Endtermin: Zeitpunkt, zu dem Aktion erfolgt sein muss Vorhersagbarkeit: Ausführungszeit eines bestimmten Prozesses vorhersagbar Prozessorauslastung: Prozentualer Anteil der Zeit, zu der der Prozessor beschäftigt ist Durchsatz: Maximierung der Anzahl Prozesse pro Zeiteinheit Prozess-basiertes Scheduling (ohne Threads) vs Thread-basiertes Scheduling

35 Scheduling Kurzfristiges Scheduling: verdrängende Strategien (mit Preemption) / unterbrechendes Scheduling: Ein Prozess läuft so lange, bis er die Kontrolle abgibt oder durch Anforderung einer Resource zum Anhalten gebracht wird. nicht verdrängende Strategien (ohne Preemption) / nicht unterbrechendes Scheduling: Ein Prozess läuft so lange, bis er die Kontrolle abgibt oder durch Anforderung einer Resource zum Anhalten gebracht wird.

36 Scheduling probalistisches Scheduling Der Scheduler beobachtet das Prozessverhalten und ermittelt charakteristische Parameter (z. B. E/A- und Prozessor-Intensität), um dann Prozesse zu bevorzugen oder zu benachteiligen. deterministisches Scheduling Alle Prozesse und deren charakteristischen Merkmale (Ausführungszeit, Bedarf an Betriebsmitteln, Anhängigkeiten von anderen Prozessen) sind bekannt. Zu erstellen ist ein Zeitplan, der die Zielsetzungen des Scheduling verwirklicht.

37 Scheduling Das deterministische Scheduling arbeitet mit festen, bekannten Eigenschaften. Beispiele sind Ausführungszeit oder benutzte Betriebsmittel. Aufgrund dieser Informationen wird ein Zeitplan erstellt. Probalistisches Scheduling hat keine festen Informationen. Der Scheduler beobachtet die Prozesse während der Ausführung (Anzahl der Ein- und Ausgabe Operationen und/oder Rechenintensität) und priorisiert aufgrund der gesammelten Informationen einzelne Prozesse. Somit werden andere Prozesse vernachlässigt.

38 Scheduling Verschiedene Scheduling Verfahren: FCFS (First Come First Served): Es wird der Prozess gewählt, der bereits am längsten darauf wartet, bearbeitet zu werden. Round Robin: Mit Hilfe von Zeitscheiben wird die aktiven Prozessen zur Verfügung stehende Zeit beschränkt. Sämtlichen bereiten Prozessen wird der Reihe nach eine Zeitscheibe zugeteilt. SPN (Shortest Process Next): Es wird jeweils der Prozess ausgewählt, dessen erwartete Bearbeitungszeit am kürzesten ist. Dieser Prozess wird nicht aufgrund vorrangiger Prozesse unterbrochen. SRT (Shortest Remaining Next): Es wird jeweils der Prozess ausgewählt, dessen erwartete, noch verbleibende Bearbeitungszeit am kürzesten ist. Ein Prozess kann unterbrochen und aus der CPU verdrängt werden, wenn ein anderer Prozess bereit wird.

39 Scheduling Verschiedene Scheduling Verfahren: HRRN (Highest Response Ratio Next): Die Zuteilungsentscheidung beruht auf einer Schätzung der normalisierten Durchlaufzeit. Feedback: Es werden Warteschlangen eingerichtet, denen Prozesse aufgrund ihrer Ausführungsgeschichte und anderer Kriterien zugeteilt werden.

40 Scheduling Round Robin Beim Round Robin werden Prozesse, die wartend auf den Prozessor sind, nach dem FIFO-Prinzip in eine Warteschlange rechenbereit eingereiht. Wenn die Zeitscheibe abläuft wird der aktuell aktive Prozess aus dem Prozessor entnommen, hinten in die Warteschlange eingereiht und der nächste Prozess (erster in rechenbereit ) wird den Prozessor betreten. Dies passiert nicht nur wenn die Zeitscheibe abläuft, sondern auch wenn (gerade aktive) Prozesse terminiert werden.

41 Scheduling Nachteil Round Robin: Zwar arbeitet Round Robin in gewöhnlichem Timesharing-System effektiv aber: CPU- und E/A-lastige Prozesse werden unterschiedlich behandelt. E/A-lastiger Prozess belegt CPU nur für kurze Zeitdauer und wird dann wegen E/A-Zugriff blockiert wartet bis E/A-Operation abgeschlossen kehrt dann zurück zu den rechenbereiten Prozessen CPU-lastiger Prozess nutzt komplettes Zeitquantum aus und kehrt direkt in die Warteschlange der rechenbereiten Prozesse zurück. CPU-lastige Prozesse werden bevorzugt erhalten insgesamt mehr CPU-Zeit höhere Durchlaufzeit bei E/A-lastigen Prozessen

42 Scheduling Dynamic Priority Round Robin (DPRR) Das DPRR Verfahren besteht aus 2 Warteschlangen. Die Erste für anstehende Prozesse, es gilt die First Come First Served (FCFS) Strategie die Zweite für rechenbereite Prozesse. es gilt Round Robin

43 Scheduling

44 Scheduling

45 Scheduling

46 Scheduling

47 Scheduling Starvation: Ist ein Problem bei Priortäts-basiertem Scheduling: Threads mit niedriger Priorität verhungern. Lösungen: Aging (Unix): Priorität von CPU-lastigen Prozessen wird verringert Priorität lange wartender Prozesse erhöht Exponentielles Mitteln der CPU-Nutzung, um die Priorität blockierter Prozesse zu ehöhen Priority Elevation (Windows): Erhöhung der Priorität der Prozesse nach Erledigung von I/O System gibt verhungernden Threads einen extra Schub (burst) Quantum Stretching: Bevorzugung der GUI-aktiven Threads oder Bevorzugung I/O-lastiger Threads

48 Scheduling Prioritäten: Die Systeme unterhalten verschiedene Prioritätsgruppen: Echtzeitprioritäten, Variable Prioritäten, Background/Batch Prioritäten Prioritäten werden bei der Prozesserzeugung eingestellt(statische Priorität) und können während der Ausführung variieren (dynamische Priorität) Dynamische Prioritäten können durch explizite Aufforderung variieren (Linux: nice) und/oder Aufgrund von Messwerten im System geändert werden. Windows: Priority Boosting nach I/O Beendigung, nach Wartebedingungen, nach CPU Starvation Linux: bonus Werte nach durchschnittlicher Wartezeit und statischer Pirorität

49 Scheduling Quantum: Wird ein Thread zur Ausführung ausgewählt, läuft er für eine gewisse Zeit: Quantum Quantum Werte können von System zu System und von Prozess zu Prozess variieren Die Ausführung des Prozesses kann vor Ablauf des Quantums unterbrochen werden (z.b. Prozess höherer Priorität betritt das System) Die Länge des Quantums richtet sich nach der statischen Priorität eines Prozesses (Linux), sie kann dynamisch verändert werden (Quantum Boosting, Windows)

50 Scheduling Quantum: Ein Zeitquantum ist die Dauer, die der Prozess die CPU benutzen darf. Bei hoher Priorität (z.b. viele Ein- und Ausgabe Operationen) kann dieser Zeitraum verlängert werden. Der Prozess erhält eine längere Rechenzeit als sonst, man spricht von Quantum- Stretching.

51 Scheduling