3 Prozesse und Threads

Transkript

1 Betriebssysteme Folie Prozesse und Threads Programm statische Folge von Anweisungen und Daten befindet sich i.a. als Datei auf einer Festplatte der Dateiinhalt entspricht den Regeln des Betriebssystems für ausführbare Programme (exe-format, elf-format, ) Prozeß dynamische Folge von Aktionen (Zustandsänderungen) führt ein Programm auf einem Prozessor aus wird vom Betriebssystem infolge eines Auftrags erzeugt Eingabe eines Kommandos von einem Benutzer Aufruf einer Systemfunktion von einem Prozeß besitzt zugeordnete Speicherbereiche für den Programmcode, seine statischen und dynamischen Daten sowie seinen Stack

2 Betriebssysteme Folie 3-2 Systemfunktionen zum Erzeugen / Beenden eines Prozesses Windows 95/98/NT/2000/ (Win32-API) CreateProcess () OpenProcess () ExitProcess () TerminateProcess () UNIX fork ( ) execlp (), execvp (), exit () kill () Struktur eines Prozesses Process Virtual Address Space Resources open files locks sockets. main () count () count () Text Identity pid uid gid. prt_result () global_cnt s_time Data Heap Registers PC SP j i p_cnt return address from count () Stack

3 Betriebssysteme Folie 3-3 Thread sequentieller Ausführungsfaden innerhalb eines Prozesses minimaler eigener Kontext CPU-Registersatz Stack Identifikationsnummer, Priorität, alle Threads eines Prozesses benutzen denselben Adreßraum sowie weitere Betriebsmittel des Prozesses gemeinsam jeder Prozeß besitzt mindestens einen (initialen) Thread Systemfunktionen zum Erzeugen / Beenden eines Threads Windows 95/98/NT/2000/ (Win32-API) CreateThread () ExitThread () TerminateThread () POSIX Threads (UNIX, ) pthread_create () pthread_exit () pthread_kill () pthread_cancel ()

4 Betriebssysteme Folie 3-4 Java Threads (plattform-übergreifend) Erweiterung der Klasse Thread Implementierung der Schnittstelle runnable Aufruf der Methode start ( ) der Klasse Thread Aufruf der Methode exit ( ) der Klasse System Aufruf der Methode stop ( ) der Klasse Thread Struktur eines Prozesses mit mehreren Threads (multithreaded process) Process Virtual Address Space Resources open files locks sockets. main () count () Text Identity pid uid gid. prt_result () Data Heap main Thread Specific Data Registers PC SP Thread 1 Registers Stack thread id priority Thread Specific Data thread id priority PC SP Thread 2 Registers PC SP Stack Stack

5 Betriebssysteme Folie 3-5 Prozeßerzeugung unter UNIX 1) Betriebssystemkern muß eine Umgebung bereitstellen, in der das Programm ausgeführt werden kann 2) der Prozeß besteht aus drei Bereichen: instruction segment user data segment system data segment 3) das Programm wird zur Initialisierung des instruction segments und user data segments benutzt 4) nach der Initialisierung besteht zwischen dem Prozeß und dem Programm, das er ausführt, keine weitere Verbindung 5) der Prozeß kann weitere Betriebsmittel (mehr Speicher, neue Dateien, usw.) anfordern, die im Programm nicht vorhanden sind mehrere parallel ablaufende Prozesse können mit demselben Programm initialisiert werden der Betriebssystemkern kann Hauptspeicher sparen, wenn solche Prozesse ein gemeinsames instruction segment verwenden (die beteiligten Prozesse können die gemeinsame Nutzung nicht feststellen, da die Segmente nur Lesezugriffe erlauben)

6 Betriebssysteme Folie 3-6 Prozeßverwaltung Prozesse stellen Verwaltungseinheiten bzw. Objekte dar auf einem Multiprozessorsystem können Prozesse parallel ausgeführt werden auf einem Einprozessorsystem können sie durch eine geeignete zeitliche Verschachtelung quasi-parallel ausgeführt werden das Betriebssystem unterscheidet Anwendungsprozesse / Benutzerprozesse und Systemprozesse Systemprozesse erbringen Betriebssystemleistungen, die aus dem Betriebssystemkern ausgelagert wurden Anwendungs- und Systemprozesse werden im Benutzermodus (user mode) ausgeführt im Benutzermodus sind nur nicht-privilegierte Befehle des Prozessors erlaubt der Betriebssystemkern wird im Systemmodus (system mode, kernel mode) ausgeführt, in dem auch priviligierte Befehle des Prozessors erlaubt sind das Betriebssystem benötigt geeignete Datenstrukturen zur Verwaltung der Prozesse

7 Betriebssysteme Folie 3-7 Prozeßobjekte unter Windows NT Prozeßobjekte werden durch den Objektmanager erzeugt und abgebaut jedes Prozeßobjekt enthält einen Kopf, der unter der Verwaltung des Objektmanagers steht Aufbau des Prozeßobjekts Objekttyp Attribute Dienste Prozeß Prozeß-ID Access Token Basispriorität Prozessorzugehörigkeit Kontingentbeschränkung Ausführungsdauer I/O-Zähler VM-Arbeitszähler Exception / Debugging Ports Beendigungsstatus Prozeß erzeugen Prozeß öffnen Prozeßinformationen einholen Prozeßinformationen einstellen Aktueller Prozeß Prozeß beenden VM reservieren / freigeben VM lesen / schreiben Virtuellen Speicher schützen VM sperren und entsperren VM-Informationen einholen Virtuellen Speicher aktualisieren

8 Betriebssysteme Folie Prozeß- / Thread-Zustände Prozeßzustände und die zugehörigen Zustandsübergänge new ready create dispatch I/O completion, event occurs blocked timeout, yield running I/O wait, event wait terminate resume suspend suspend exit resume suspend suspended ready I/O completion, event occurs suspended blocked Thread-Zustände und -Zustandsübergänge in Java born sleep interval expires notify or notifyall quantum expiration, interrupt, yield ready start dispatch (assign a processor) running I/O completion wait sleep finished issue I/O waiting sleeping dead blocked

9 Betriebssysteme Folie 3-9 Prozeß- / Thread-Verwaltung basiert auf Zustandsmodell Grundzustände, erweiterte Zustände, Pseudozustände Übergänge zwischen den Zuständen Prozeß / Thread kann einige Zustände im Laufe seines Lebens mehrfach durchlaufen typische Grundzustände bereit (Synonyme: rechenwillig, rechenbereit, ausführbar, ready, runable) Prozeß / Thread wartet nur auf Zuteilung eines Prozessors i.a. gibt es verschiedene Prioritätswarteschlangen neue Prozesse werden i.a. am Ende ihrer Prioritätswarteschlange eingefügt aktiv (Synonyme: rechnend, running) Prozeß / Thread hat einen Prozessor zugeteilt bekommen auf einem Einprozessorsystem kann sich nur ein Prozeß / Thread in diesem Zustand befinden

10 Betriebssysteme Folie 3-10 blockiert (Synonyme: wartend, blocked, waiting) Prozeß / Thread wartet auf ein Ereignis, z.b. Ein-/Ausgabe i.a. gibt es für verschiedene Wartebedingungen verschiedene Warteschlangen erweiterte Zustände gibt es z.b. bei vielen UNIX-Systemen suspendiert (Synonyme: ausgelagert, suspended) Prozeß / Thread wurde angehalten und i.a. auf externes Speichermedium ausgelagert häufig über zwei Zustände realisiert: suspendiert blockiert und suspendiert bereit warum wird ein Prozeß / Thread suspendiert? schlechte Systemleistung wegen kurzfristiger Überlast Betriebssystem unterstützt keinen virtuellen Speicher, so daß ganze Prozesse ein- / ausgelagert werden müssen Benutzer will einen Prozeß stoppen, aber noch nicht abbrechen (bei vielen UNIX-Systemen z.b. mit <Ctrl-z> oder <Strg-z>; Fortsetzung z.b. mit "fg" (im Vordergrund) oder "bg" (im Hintergrund))

11 Betriebssysteme Folie 3-11 wer kann einen Prozeß / Thread suspendieren? ein Prozeß / Thread (selbst) über entsprechende Systemfunktionen der Benutzer / das "Betriebssystem" Suspendierung durch Prozeß / Thread kann schwerwiegende Folgen haben Blockierung mehrerer Prozesse / Threads, falls der suspendierte Prozeß / Thread eine Betriebsmittelsperre hält u.u. sogar Deadlock, falls die Funktion zur Fortsetzung des Prozesses / Threads dieselbe Betriebsmittelsperre benötigt Zombie Zwischenzustand bevor ein Prozeß das System verläßt Prozeß hat seine Aufgabe erledigt und muß nur noch einen Status an seinen Vaterprozeß liefern Zombie-Prozesse belegen nur noch einen Eintrag in der Prozeßtabelle des Betriebssystems

12 Betriebssysteme Folie 3-12 Pseudozustände Beginn (Synonyme: nicht existent, new, born) "notwendiger" Zustand, um einen Prozeß / Thread in das System zu bringen wichtig ist nur der Zustandsübergang Ende (Synonyme: nicht existent, exit, exited, dead) "notwendiger" Zustand, um einen Prozeß / Thread aus dem System zu entfernen wichtig ist nur der Zustandsübergang Zustandsübergänge Beginn bereit neuer Prozeß / Thread wird erzeugt Speicherbereiche und Datenstrukturen für neuen Prozeß anlegen und initialisieren (z.b. Codesegment, Datensegment, Prozeßkontrollblock, ) Prozeß / Thread in Warteschlange "bereit" einketten

13 Betriebssysteme Folie 3-13 bereit aktiv Prozeß / Thread wird einem freien Prozessor zugeteilt letzten Prozeß- / Thread-Kontext wiederherstellen Prozeß- / Thread-Zustand auf aktiv setzen Prozeß / Thread starten aktiv bereit Prozessor wird dem Prozeß / Thread entzogen Zeitscheibe des Prozesses / Threads ist abgelaufen Prozeß / Thread höherer Priorität wurde rechenwillig Prozeß- / Thread-Kontext retten Prozeß- / Thread-Zustand auf "bereit" setzen und Prozeß / Thread in Warteschlange "bereit" einketten aktiv blockiert Prozeß / Thread muß auf ein Ereignis warten Beendigung einer Ein- / Ausgabeoperation Beendigung eines erzeugten Prozesses / Threads Prozeß- / Thread-Kontext retten Prozeß- / Thread-Zustand auf "blockiert" setzen und Prozeß/ Thread in Warteschlange "blockiert" einketten

14 Betriebssysteme Folie 3-14 aktiv Ende Prozeß / Thread verläßt das System Aufräumarbeiten durchführen (i.a. nur bei Prozessen) ggf. offene Dateien des Prozesses schließen ggf. andere Betriebsmittel des Prozesses freigeben alle Datenstrukturen und Speicherbereiche freigeben (i.a. nur bei Prozessen) blockiert bereit Ereignis ist eingetreten Prozeß- / Thread-Zustand auf "bereit" setzen und Prozeß / Thread in Warteschlange "bereit" einketten blockiert suspendiert blockiert, bereit suspendiert bereit, suspendiert blockiert blockiert, suspendiert bereit bereit (i.a. nur bei Prozessen; suspendierte Threads werden i.a. über Zustand "blockiert" des Prozesses verwaltet) nur in Ausnahmefällen (siehe Zustand "suspendiert") Prozeß- / Thread-Zustand ändern und Prozeß / Thread in entsprechende Warteschlange einketten aufwendig, da Datentransport zwischen Haupt- und Hintergrundspeicher erforderlich

15 Betriebssysteme Folie 3-15 suspendiert blockiert suspendiert bereit (i.a. nur bei Prozessen) Ereignis ist eingetreten Prozeß kann ausgeführt werden, sobald er in Hauptspeicher geladen worden ist Prozeßzustand ändern und Prozeß in Warteschlange "suspendiert bereit" einketten aktiv suspendiert bereit (nur bei Prozessen) kommt eigentlich nicht (mehr) vor könnte benutzt werden, wenn ein Prozeß der Warteschlange "suspendiert blockiert" mit hoher Priorität rechenwillig wird, der sehr viel Hauptspeicher benötigt und der aktuelle Prozeß viel Hauptspeicher belegt Prozeßkontext retten Prozeßzustand ändern und Prozeß in Warteschlange "suspendiert bereit" einketten

16 Betriebssysteme Folie 3-16 Prioritätsklassen in den Zuständen können über verkettete Listen realisiert werden, z.b. einfach verkettete Listen n first last count process 0 first last count process process process ringförmig doppelt verkettete Listen priority priority n current count process 0 current process process process count Vor- / Nachteile?

17 Betriebssysteme Folie 3-17 Warteschlangenmodelle für Prozeßzustände Modell mit mehreren "blockiert"-warteschlangen swap in, resume new process partially executed swapped-out processes (in disk swap area) ready queue dispatch CPU CPU swap out, suspend terminated process time slice expired I/O I/O queue I/O request event occurs wait for termination wait for interrupt fork a child call sleep () blocked queues Modell kann durch "bereit"-warteschlangen erweitert werden real-time processes ready queues system processes interactive processes dispatch CPU CPU terminated process batch processes process with higher priority is ready, time slice expired, I/O finished,

18 Betriebssysteme Folie Prozeßkontrollblock das Betriebssystem verwaltet für jeden Prozeß einen Prozeßkontrollblock, der alle relevanten Informationen über den Prozeß enthält (Synonyme: Prozeßkontext, process control block, task control block Abkürzungen: PCB, TCB) typische Komponenten eines Prozeßkontrollblocks Identifikatoren Prozeßnummer / -name Nummer / Name des Benutzers, der den Prozeß gestartet hat Gruppennummer Stellung in der Prozeßhierarchie Prozeßnummer des Vaterprozesses Prozeßnummern der Sohnprozesse Prozessor-Zustandsinformation Register der Programmierumgebung (Datenregister, Adreßregister, Segmentregister, Indexregister, ) Kontroll-, Steuer-, Statusregister (System-/Benutzer-Stack-Register, Programmzähler, Prozessorstatuswort, )

19 Betriebssysteme Folie 3-19 Informationen zur Prozeßsteuerung Prozeßzustand Priorität Alarmzustand Zeiger auf Vorgänger und / oder Nachfolger Zeiger auf Threads des Prozesses Informationen zur Interprozeßkommunikation Rechte Zugriffsrechte auf Speicherbereiche, Dateien, Art der erlaubten Prozessorbefehle (priviligiert / nicht priviligiert) Speicherverwaltung Zeiger auf Segment- und / oder Seitentabellen Zeiger auf Tabelle mit offenen Dateien Betriebsmittelkonten Maximalwerte für erlaubte Betriebsmittel noch verfügbare Kontingente Abrechnungsdaten (CPU-Zeiten im System- / Benutzermodus, Anzahl Seitenfehler, ) sonstiges (Uhren, Sperren, )

20 Betriebssysteme Folie 3-20 Prozeßkontext wird manchmal aufgeteilt in Hardware-Kontext (i.w. Abbild der Prozessorregister) Benutzer-Kontext (i.w. Speicherabbild des Prozesses) System-Kontext (betriebssysteminterne Verwaltungsdaten) Prozeßtabelle enthält Verweise auf Prozeßkontrollblöcke process table process control block process identification process state process priority pointer to parent process pointer to child processes CPU register save area pointers to locate process's memory pointers to allocated resources NULL

21 Betriebssysteme Folie 3-21 Beipiele Linux Prozeßtabelle bis Version 2.2.x (linux/kernel/sched.c) struct task_struct *task [NR_TASKS] = &init_task, ; "Prozeßtabelle" ab Version 2.4.x struct task_struct *init_tasks [NR_CPUS] = &init_task, ; Prozeßtabelle wurde in Prozeßliste je CPU überführt Prozeßkontrollblock (/usr/include/linux/sched.h) struct task_struct volatile long state; unsigned long flags; long priority; int has_cpu; int processor; int last_processor; struct task_struct *next_task, *prev_task; struct task_struct *next_run, *prev_run; pid_t pid; pid_t pgrp; struct wait_queue *wait_chldexit; /* for wait4() */ struct sem_queue *sem_sleeping; struct files_struct *files; /* open file table */ struct mm_struct *mm; /* memory management info */ ; Solaris 8 struct proc (/usr/include/sys/proc.h) struct _klwp (/usr/include/sys/klwp.h) struct _kthread (/usr/include/sys/thread.h)

22 Betriebssysteme Folie 3-22 Verweisstrukturen zur Verwaltung der Sohnprozesse Linux p_cptr struct task_struct parent p_pptr p_pptr p_pptr youngest child p_osptr p_ysptr child p_osptr p_ysptr oldest child jeder Prozeß wird zusätzlich in der Prozeßtabelle geführt (bis Linux Version 2.2.x) jeder Prozeß befindet sich zusätzlich in der Prozeßliste (auch bei Linux bis Version 2.2.x) Solaris struct proc parent p_child p_parent p_parent p_parent youngest child p_psibling p_sibling child p_psibling p_sibling oldest child

23 Betriebssysteme Folie 3-23 Verweisstrukturen zur Verwaltung von Threads Linux Threads werden im Betriebssystemkern nicht unterstützt (zumindest nicht bis Version 2.4.x) Betriebssystemkern enthält keine Verweisstrukturen für Threads Threads werden mit clone ( ) erzeugt und wie Prozesse verwaltet es gibt immer einen Master-Thread, der z.b. für die Signalbehandlung zuständig ist jeder Thread hat eine eigene Prozeßnummer (PID) (unter Solaris würde "getpid ( )" bei jedem Thread dieselbe PID des umfassenden Prozesses liefern) das Kommando "ps" zeigt jeden Thread als eigenen Prozeß an Threads eines Prozesses können unterschiedliche Benutzer- und Gruppennummern haben (ist bei Solaris nicht möglich, da Threads keine Prozesse sind) Threads haben Vater-Sohn-Beziehungen (bei Solaris sind alle Threads gleichwertig)

24 Betriebssysteme Folie 3-24 einige Ressourcen sind auf einige Threads beschränkt (ist bei Solaris nicht möglich, da Threads innerhalb eines Prozesses laufen) auf einen durch fork ( ) erzeugten Sohnprozeß kann nur der Thread warten, der den Aufruf enthält mit rlimit ( ) gesetzte Begrenzungen für Ressourcen gelten nicht für alle Threads clock ( ) liefert nur Zeit für aktuellen Thread und nicht für gesamten Prozeß inklusive aller Threads usw. Threads werden in der Thread-Bibliothek verwaltet Thread-Kontrollblock (/internals.h) typedef struct _pthread_descr_struct *pthread_descr; struct _pthread_descr_struct union struct pthread_descr self; /* Pointer to this structure */ data; void * padding[16]; p_header; pthread_descr p_nextlive, p_prevlive; pthread_descr p_nextwaiting; pthread_descr p_nextlock; pthread_t p_tid; /* Thread identifier */ int p_pid; /* PID of Unix process */ int p_priority; /* (== 0 if not realtime) */ attribute ((aligned(32))); Threads verhalten sich wie Kernel-level Threads, da für jeden Thread ein Prozeß erzeugt wird

25 Betriebssysteme Folie 3-25 Beispielprogramm zur Beschränkung der Ressource fork ( ) pid_t fork_pid; /* ID of child process */ int main (void) ThrID_t thr_id [2]; /* ID's of created threads */ thr_id [0] = parallel ((PtrFunc_t) thr_fork, 0); thr_id [1] = parallel ((PtrFunc_t) thr_wait, 1); join_all (thr_id, 2); return 0; void thr_fork (void) printf ("Thread thr_fork: forking a child process.\n"); fork_pid = fork (); switch (fork_pid) case -1: /* error: no process created */ perror ("fork failed"); errno = 0; break; case 0: /* child process */ printf ("Child process: I'm sleeping for 2 seconds.\n"); sleep (2); printf ("Child process: terminating.\n"); exit (0); break; default: /* parent process */ printf ("Thread thr_fork: sleeping for 10 seconds.\n"); sleep (10); printf ("Thread thr_fork: try to wait for my child.\n"); if (waitpid (fork_pid, NULL, WNOHANG) == -1) perror ("Thread thr_fork"); errno = 0; else printf ("Thread thr_fork: child terminated.\n"); ; ; void thr_wait (void) printf ("Thread thr_wait: sleeping for 5 seconds.\n"); sleep (5); printf ("Thread thr_wait: try to wait for child process.\n"); if (waitpid (fork_pid, NULL, WNOHANG) == -1) perror ("Thread thr_wait"); errno = 0; else printf ("Thread thr_wait: child terminated.\n"); ;

26 Betriebssysteme Folie 3-26 Ausgabe unter Linux Thread thr_fork: forking a child process. Thread thr_fork: sleeping for 10 seconds. Child process: I'm sleeping for 2 seconds. Thread thr_wait: sleeping for 5 seconds. Child process: terminating. Thread thr_wait: try to wait for child process. Thread thr_wait: No child processes Thread thr_fork: try to wait for my child. Thread thr_fork: child terminated. Ausgabe unter Solaris Thread thr_fork: forking a child process. Child process: I'm sleeping for 2 seconds. Thread thr_wait: sleeping for 5 seconds. Thread thr_fork: sleeping for 10 seconds. Child process: terminating. Thread thr_wait: try to wait for child process. Thread thr_wait: child terminated. Thread thr_fork: try to wait for my child. Thread thr_fork: No child processes Aufgabe 3-1: Erstellen Sie ein Programm, das die Beschränkung der Funktion clock ( ) unter Linux aufzeigt.

27 Betriebssysteme Folie 3-27 Solaris Threads werden im Betriebssystemkern unterstützt Betriebssystemkern enthält Verweisstrukturen für Threads Prozeßkontrollblock verweist auf ringförmig verkette Liste seiner Kernel-level Threads Kernel Thread verweist auf seinen Lightweight Process (im Prinzip nur eine Datenstruktur) struct proc process p_tlist t_procp must remain in memory lwp_procp struct _klwp lwp_thread lightweight process t_lwp lwp_ thread lightweight process t_lwp lwp_ thread lightweight process t_lwp can be swapped or paged out t_next t_prev kernel thread struct _kthread t_next t_prev t_forw t_back kernel thread t_next t_prev t_forw t_back kernel thread t_next t_prev must remain in memory Aufgabe 3-2: Untersuchen Sie, wie die Daten auf die Strukturen struct proc, struct _klwp und struct _kthread unter Solaris aufgeteilt werden.

28 Betriebssysteme Folie Dispatcher / Scheduler Scheduler (Ablaufplaner) ist für die zeitliche Ablaufplanung der Prozesse zuständig erledigt seine Arbeit aufgrund einer gewählten Strategie setzt Anfangspriorität der Prozesse fest kann die Priorität aufgrund des Prozeßverhaltens ändern wird z.b. aktiviert, wenn Prozesse erzeugt / beendet werden Prozeßeigenschaften (z.b. Priorität) geändert werden eine Zeit abgelaufen ist oder bestimmte Systemfunktionen aufgerufen werden, die indirekt in die Prozeßverwaltung eingreifen (z.b. zur Koordinierung / Synchronisation von Prozesssen) Dispatcher (Prozeßumschalter, low-level scheduler) ist für den Prozeßwechsel (task switch, context switch) zuständig muß sehr effizient implementiert werden, da Prozeßwechsel im 10 bis 100 Millisekundenbereich vorkommen wird z.b. aktiviert, wenn der aktive Prozeß unterbrochen wird (z.b. Ablauf der Zeitscheibe) auf ein Ereignis warten muß (z.b. Ende einer Ein-/Ausgabeoperation) freiwillig auf den Prozessor verzichtet (spezielle Systemfunktion) endet

29 Betriebssysteme Folie 3-29 Aufgaben des Dispatchers sichert den (gesamten) Hardware-Kontext des bisher aktiven Prozesses in dessen Prozeßkontrollblock (VAX/VMS (1982) hat hierfür den Befehl SVPCTX (save process context). Die Intel Pentium Familie führt diese Aktion automatisch bei einem Prozeßwechsel durch. Ein Prozeßwechsel wird hier z.b. durchgeführt, wenn ein "CALL"-Befehl auf einen TSS- Deskriptor (task state segment) in der globalen Deskriptortabelle ausgeführt wird.) ändert den Zustand des Prozesses ("bereit", "blockiert", ) kettet den Prozeß in die entsprechende Warteschlange ein (VAX/VMS hat hierfür den Befehl INSQUE (insert into queue). Die Intel Pentium Familie hat keinen entsprechenden Befehl.) "sucht" den nächsten zu aktivierenden Prozeß (VAX/VMS unterstützt 32 Prioritätsklassen, in denen Prozesse derselben Priorität in einer verketteten Liste gespeichert sind. Das "Compute Queue Status Longword" enthält für jede nicht leere Warteschlange ein auf "1" gesetztes Bit. Der Bit-Suchbefehl "FFS" (find first set bit) liefert die nicht leere Warteschlange höchster Priorität und der Befehl "REMQUE" (remove from queue) kettet den ersten Prozeßkontrollblock aus der Warteschlange aus. Der neue Prozeß kann also mit zwei Befehlen gefunden werden. Die Intel Pentium Familie hat u.a. die Befehle "BSF" (bit scan forward) und "BSR" (bit scan reverse), die dem Befehl "FFS" entsprechen. Sie hat keinen Befehl, der dem Befehl "REMQUE" entspricht.) ändert den Zustand des Prozesses von "bereit" auf "aktiv" restauriert den (gesicherten) Hardware-Kontext des Prozesses (VAX/VMS hat hierfür den Befehl LDPCTX (load process context). Die Intel Pentium Familie führt diese Aktion automatisch bei einem Prozeßwechsel durch.) "startet" den Prozeß (Erfolgt i.a. automatisch durch die Rückkehr aus der Dispatcher-Routine, da die Prozessorregister nach dem Kontextwechsel den früher unterbrochenen Zustand des restaurierten Prozesses enthalten.)

30 Betriebssysteme Folie 3-30 Aufgaben des Schedulers Minimierung der Gesamtkosten des Systems möglichst hoher Durchsatz (Stapelbetrieb) Verwaltungsaufwand reduzieren (wenig Prozeßwechsel) möglichst kurze Antwortzeiten (Dialogbetrieb) häufige Prozeßwechsel garantierte Antwortzeiten (Echtzeitbetrieb) widersprüchliche Anforderungen Verhältnis Stapelbetrieb zu Dialogbetrieb wird voreingestellt Scheduler kann Stapel- und Dialogbetrieb unabhängig voneinander optimieren sollte die bisherigen Verläufe der Prozesse bei seinen Entscheidungen berücksichtigen ordnet die Prozesse / Threads verschiedenen "bereit"- Warteschlangen zu (z.b. aufgrund von Prozeßklassen oder Warte- und Rechenzeiten)

31 Betriebssysteme Folie 3-31 "bereit"-warteschlangen unter Solaris scheduling order class-specific priorities scheduler classes global priorities process queues first last RT max 0 + TS max 0 - TS max interrupts real-time class (RT) system class (SYS) timesharing class (TS) highest lowest der Scheduler konvertiert klassen-spezifische Prioritäten in globale Prioritäten die globale Priorität ist für den Dispatcher maßgebend ein Prozeß behält die CPU bis seine Zeitscheibe abgelaufen ist er sich selbst blockiert oder endet ein Prozeß höherer Priorität rechenwillig wird Prozesse derselben Priorität benutzen die Round-Robin-Strategie für alle Prozesse gilt i.a. eine Standard-Zeitscheibe Echtzeitprozesse können prozeß-spezifische Zeitscheiben haben Prioritäten von Echtzeitprozessen werden durch das System nicht geändert (können nur vom Benutzer geändert werden)

32 Betriebssysteme Folie 3-32 Prioritäten von Systemprozessen werden nur vom Betriebssystem verwaltet (können vom Benutzer nicht beeinflußt werden) Prioritäten von Time-sharing-Prozessen haben benutzer- und system-orientierte Komponente system-orientierte Komponente wird dynamisch geändert Priorität wird erhöht, wenn der Prozeß nur einen kleinen Teil seiner Zeitscheibe nutzt Priorität wird erniedrigt bei rechenintensiven Prozessen die Länge der Zeitscheibe wird größer je kleiner die Priorität ist (wenn Prozesse geringer Priorität aktiv werden, dürfen sie länger arbeiten, wenn sie nicht durch einen Prozeß höherer Priorität unterbrochen werden) benutzer-orientierte Komponente kann vom Benutzer zwischen "-TS max" und "TS max" geändert werden (i.a. -20 bis 20; siehe Kommando "nice") Standardpriorität: 0 Sohnprozesse erben die benutzer-orientierte Priorität globale Priorität ergibt sich aus den beiden Komponenten

33 Betriebssysteme Folie 3-33 "bereit"-warteschlangen unter Windows NT scheduling order dispatcher ready queues priorities process queues first last real-time variable priorities system 0 highest lowest für "variable priorities" Priorität eines Prozesses / Threads wird jedesmal erniedrigt, wenn er seine Zeitscheibe ausgenutzt hat Priorität eines blockierten Prozesses / Threads wird erhöht großer Wert, falls auf Tastatureingabe gewartet wurde kleiner Wert, falls auf andere Ein- / Ausgabe gewartet wurde Verfahren führt mittelfristig zu einer "Dreiteilung" hohe Priorität für interaktive Prozesse / Threads mittlere Priorität für E/A-orientierte Prozesse / Threads geringe Priorität für rechenintensive Prozesse / Threads Auswahl eines Prozesses / Threads aufgrund seiner Priorität und Prozessorzugehörigkeit falls ein ausgewählter Prozeß / Thread aufgrund der Prozessorzugehörigkeit nicht auf einem freien Prozessor ausgeführt werden kann, wird der Prozeß / Thread mit der nächst geringeren Priorität ausgewählt geringste Priorität hat der "idle"-prozeß ("system")

34 Betriebssysteme Folie 3-34 "bereit"-warteschlangen für Java-Threads high priority Priority 10 Priority 9 thr1 normal priority Priority 6 Priority 5 thr2 thr6 thr n Priority 4 Priority 3 thr3 thr5 Priority 2 low priority Priority 1 thr4 alle Threads starten mit normaler Priorität 5 Threads erben die Priorität ihres Erzeugers es gibt Implementierungen mit Zeitscheibenverfahren und rein prioritätsgesteuerten Scheduling-Verfahren (Threads derselben Prioritätsklasse werden im ersten Fall im Round-Robin-Verfahren bearbeitet. Im zweiten Fall können sie solange arbeiten bis sie fertig werden, sich selbst blockieren oder durch einen Thread höherer Priorität verdrängt werden) Aufgabe 3-3: a) Welchen Prioritätsklassen gehören die folgenden Prozesse unter Solaris an: sched, pageout, init, Xsession, dtlogin b) Wie funktioniert das Scheduling unter Linux (siehe linux/kernel/sched.c)?

35 Betriebssysteme Folie 3-35 Einteilung der Scheduling-Strategien nicht unterbrechende Verfahren (Prozeß bleibt solange aktiv, bis er sich selbst in den Zustand blockiert versetzt) unterbrechende Verfahren (dem Prozeß kann der Prozessor entzogen werden; notwendig bei Echtzeit-Betriebssystemen) Prozeß kann nur dann unterbrochen werden, wenn der Prozessor im Benutzermodus arbeitet (Standard bei älteren UNIX-Systemen) Prozeß kann auch dann unterbrochen werden, wenn der Prozessor im Systemmodus arbeitet (notwendig bei Echtzeit-Betriebssystemen) Ausnutzung der Prozessoren bei Multiprozessorsystemen alle Prozessoren werden genutzt, wenn Arbeit vorhanden ist einzelne Prozessoren dürfen ungenutzt bleiben, obwohl noch Arbeit vorhanden ist

36 Betriebssysteme Folie 3-36 Bewertung von Scheduling-Verfahren CPU-Auslastung (utilization) Maß für die Auslastung eines Prozessors durch Prozesse sollte zwischen 40 und 90 Prozent liegen Durchsatz (throughput) Anzahl der pro Zeiteinheit fertiggestellten Aufträge schwankt zwischen vielen Aufträgen pro Sekunde und wenigen pro Tag, Woche oder Monat (abhängig von der erforderlichen Rechenleistung der Aufträge) Durchlaufzeit (turnaround time) Zeit zwischen Betreten und Verlassen des Systems für einen Auftrag Summe aus Rechenzeit und verschiedenen Wartezeiten (warten auf CPU in der "bereit"-warteschlange, auf E/A-Ende in der "blockiert"- Warteschlange, usw.) Wartezeit (waiting time) Wartezeit in der "bereit"-warteschlange nur diese Zeit kann vom Scheduler direkt beeinflußt werden Antwortzeit (response time) wichtige Zeitspanne für interaktive Prozesse Zeit zwischen Eingabe und Reaktion auf Eingabe

37 Betriebssysteme Folie 3-37 mögliche Scheduling-Verfahren 1) First-Come-First-Served (FCFS), First-In-First-Out (FIFO) (Prozesse werden in der Reihenfolge ihrer Ankunft ohne Unterbrechung bis zu ihrem Ende bzw. ihrer Blockierung bedient) das einfachste Verfahren Implementierung über FIFO-Warteschlange u.u. große Wartezeiten und damit schlechte Antwortzeiten i.a. gute Auslastung der CPU kann zu langen Warteschlangen mit E/A-intensiven Prozessen führen, wenn ein rechenintensiver Prozeß mit wenig E/A-Operationen immer wieder die CPU blockiert Beispiel: Zum Zeitpunkt 0 treffen die Prozesse P 1, P 2 und P 3 ein. Die Ausführungszeiten der Prozesse betragen t 1 = 24, t 2 = 8 und t 3 = 3 Zeiteinheiten resp.. Die folgenden Gantt-Diagramme geben die zeitliche Zuordnung der Prozesse auf einen Prozessor an, wenn sie in der Reihenfolge (P 1, P 2, P 3 ) bzw. (P 3, P 2, P 1 ) ankommen S 1 P 1 P 2 P S 2 P 3 P 2 P 1 Im Vergabeplan S 1 wartet P 1 gar nicht, während P 2 und P 3 24 bzw. 32 Zeiteinheiten warten. Im Mittel warten die Prozesse im Plan S 1 ( )/3 = 56/3 Zeiteinheiten, während sie im Vergabeplan S 2 nur 14/3 Zeiteinheiten warten.

38 Betriebssysteme Folie ) FCFS mit Prioritätswarteschlangen (Regel: rechenintensive Prozesse erhalten eine geringe Priorität und E/A-intensive eine hohe Priorität. Prozesse derselben Prioritätsklasse werden in der Reihenfolge ihrer Ankunft ohne Unterbrechung bis zu ihrem Ende bzw. ihrer Blockierung bedient. Prozesse können durch Prozesse höherer Priorität unterbrochen werden. Der Scheduler kann die Prioritäten der Prozesse ändern.) 3) Shortest-Job-First (SJF), Shortest-Processing-Time (SPT) (der Prozeß mit der kürzesten Rechenzeit wird als nächster ohne Unterbrechung bedient; Kenntnis der Rechenzeit ist erforderlich; Prozesse mit gleicher Rechenzeit werden nach FCFS bedient) Verfahren ist optimal bezogen auf die mittlere Wartezeit für eine vorgegebene Menge von Prozessen (Beweis siehe Literatur) nicht geeignet für kurzfristiges Scheduling, da die Rechenzeiten i.a. nicht bekannt sind wird häufig eingesetzt für langfristiges Scheduling im Stapelbetrieb (in diesem Fall wird das vom Benutzer vorgegebene Zeitlimit benutzt) kann auch als "FCFS mit Prioritätswarteschlangen" implementiert werden (die Priorität eines Prozesses könnte über den Kehrwert der geschätzten Rechenzeit bestimmt werden je mehr Rechenzeit desto niedriger die Priorität) 4) Shortest-Remaining-Time (SRT), Shortest-Remaining- Processing-Time (SRPT) (im Prinzip SPT mit Unterbrechung, d.h. falls ein neuer Prozeß eintrifft, dessen Rechenzeit geringer ist als die verbleibende Rechenzeit des gerade aktiven Prozesses, dann wird ein Prozeßwechsel durchgeführt)

39 Betriebssysteme Folie ) Round-Robin (RR) (der Prozeß darf den Prozessor für eine Zeitscheibe benutzen; falls er in dieser Zeit nicht fertig wird, wird er unterbrochen und am Ende der Warteschlange eingereiht; es handelt sich hier um ein zyklisches Verfahren ohne Prioritäten) weit verbreitetes Verfahren für die meisten Multitasking- Betriebssysteme gleichmäßige Aufteilung der CPU-Zeit auf die Prozesse Größe der Zeitscheibe bestimmt die Leistung zu kleine Zeitscheibe hoher Verwaltungsaufwand durch Prozeßwechsel nominale Systemleistung wird u.u. nicht erreicht, da Kontextwechsel durchgeführt wird, bevor Cache- Speicher ihre "Warmlaufphase" überwunden haben zu große Zeitscheibe nähert sich dem FCFS-Verfahren, da mit zunehmender Zeitscheibe blockierende Systemaufrufe wahrscheinlicher werden mittlere Wartezeiten und Antwortzeiten werden größer 6) Shortest-Elapsed-Time (SET), Multilevel Feedback Queue Scheduling (im Prinzip RR mit Prioritätswarteschlangen; neuer Prozeß wird in die Warteschlange höchster Priorität eingereiht und erhält hier eine Zeitscheibe; nutzt er die Zeitscheibe aus, wird er in die Warteschlange nächst niedriger Priorität eingereiht; andernfalls wird er blockiert und kommt irgendwann wieder in die Eingangswarteschlange; rechenintensive Prozesse sinken schnell in der Priorität)

40 Betriebssysteme Folie 3-40 Fallbeispiel: Solaris benutzt ein 2-layer scheduling (nur bis Solaris 8) process process user level thread user level thread user level thread user level thread unbounded user threads are scheduled within the threads library software context, software context, open files, credentials, address space, process group, lightweight process machine state, lightweight process machine state, lightweight process machine state, kernel level scheduler and dispatcher CPU CPU kernel thread kernel thread kernel thread Bounded Threads werden fest mit einem Lightweight Process (LWP) und damit mit einem Kernel Thread verknüpft dieser LWP steht für andere Threads nicht zur Verfügung Scheduling erfolgt nur durch den Dispatcher im Betriebssystemkern verbraucht Betriebssystemressourcen (z.b. Kernel-Stack)

41 Betriebssysteme Folie 3-41 Unbounded Threads werden auf einem freien LWP ausgeführt Unbounded Threads werden in verschiedenen Prioritätswarteschlangen der Thread-Bibliothek verwaltet das Betriebssystem verwaltet Warteschlangen für LWPs der Thread wird durch den Scheduler der Thread-Bibliothek einem LWP zugeordnet der Dispatcher ordnet den LWP einer CPU zu nicht für jeden Unbounded Thread wird ein LWP erzeugt ein LWP kann im Laufe der Zeit verschiedene Unbounded Threads eines Prozesses ausführen falls ein Prozeß viele rechenwillige Unbounded Threads hat, erzeugt das Betriebssystem für den Prozeß weitere LWPs Kernel Threads bilden den unterbrechbaren Echtzeitkern im Betriebssystemkern (sie bearbeiten auch Unterbrechungen) Lightweight Prozesse sind Kernel Threads mit zusätzlichen Kontrollstrukturen zur Unterstützung der User-level Threads (Kernel Threads sind keine LWPs, aber LWPs sind immer Kernel Threads) LWPs werden innerhalb des Prozesses erzeugt und teilen sich alle Betriebsmittel mit dem Prozeß (mit dem Kommando "ps -elc" werden alle LWPs eines Prozesses angezeigt)

42 Betriebssysteme Folie 3-42 Aufgabe 3-4: Gegeben seien die folgenden Prozesse: Prozeß Rechenzeit (in Zeiteinheiten) Priorität P P P P P Die Prozesse sind in der Reihenfolge (P 1, P 2, P 3, P 4, P 5 ) zum Zeitpunkt 0 angekommen. a) Zeichnen Sie die Gantt-Diagramme, falls der Scheduler die Prozesse nach dem FCFS-, SJF- bzw. RR-Verfahren (eine Zeitscheibe entspricht einer Zeiteinheit) auf einen Prozessor zuteilt. Wie sieht das Gantt-Diagramm aus, wenn er ein nicht unterbrechendes Verfahren mit Prioritätswarteschlangen (kleine Prioritätsnummer entspricht hoher Priorität) benutzt? b) Geben Sie die Durchlaufzeit für jeden Prozeß und die mittlere Durchlaufzeit der Prozesse für jeden Vergabeplan an. c) Geben Sie die Wartezeit für jeden Prozeß und die mittlere Wartezeit der Prozesse für jeden Vergabeplan an.

43 Betriebssysteme Folie Prozeßsynchronisation Prozesse können folgendermaßen ausgeführt werden zeitlich verschachtelt (quasi-parallel) auf einem Einprozessorsystem zeitlich überlappt (parallel) auf einem Multiprozessorsystem zeitlich verschachtelt und überlappt (heutiger Standard auf einem Multiprozessorsystem) Beispiel: modifizierender Zugriff auf eine gemeinsame Variable 1. Ausführungsreihenfolge Prozeß / Thread 1 liest Wert der Variablen i erhöht Wert um 1 speichert neuen Wert in i Prozeß / Thread 2 liest Wert der Variablen i erhöht Wert um 1 speichert neuen Wert in i 2. Ausführungsreihenfolge Prozeß / Thread 1 liest Wert der Variablen i erhöht Wert um 1 speichert neuen Wert in i Prozeß / Thread 2 liest Wert der Variablen i erhöht Wert um 1 speichert neuen Wert in i

44 Betriebssysteme Folie 3-44 Problem des obigen Beispiels Fehler kann auftreten, muß aber nicht auftreten Fehler ist schwer reproduzierbar, da abhängig von Nebenbedingungen (z.b. Systemlast) typischer Synchronisationsfehler, wenn ein Prozeß einen anderen im Ablauf überholt (als race condition bekannt) Programmbereiche, in denen solche Fehler entstehen können, dürfen nicht unterbrochen werden (kritischer Abschnitt, critical section) Arbeitsweise der Prozesse muß koordiniert werden Koordinierung Beeinflussung der Abläufe paralleler Prozesse / Threads Steuerung von Wechselwirkungen (Konkurrenz / Kooperation) Mittel: Synchronisation / Kommunikation Ziel: deterministischer Ablauf (globale Ergebnisse sind unabhängig von der Ablaufreihenfolge der Prozesse) Synchronisation Ablauf wird in zeitliche Reihenfolge gebracht Reihenfolge kann zufällig oder vorbestimmt sein Sperrsynchronisation / wechselseitiger Ausschluß (mutual exclusion) Menge von konkurrierenden Prozessen / Threads um ein Betriebsmittel einer wird ausgewählt und alle anderen werden gesperrt

45 Betriebssysteme Folie 3-45 wechselseitiger Ausschluß wird i.a. durch Protokolle realisiert Vorprotokoll sorgt für Auswahl eines Prozesses / Threads Nachprotokoll sorgt für Freigabe des kritischen Bereichs Process / Thread 1 acquire lock access data release lock Process / Thread 2 acquire lock access data release lock shared data acquire lock access data release lock Process / Thread 3 Regeln für die Benutzung eines kritischen Abschnitts 1) Sicherheit: zu jeder Zeit darf sich höchstens ein Prozeß innerhalb des kritischen Abschnitts befinden 2) Lebendigkeit: wenn ein Prozeß in einen kritischen Abschnitt eintreten will, wird ihm dies nach endlicher Zeit gestattet jeder Prozeß verbringt nur eine endliche Zeit im kritischen Abschnitt (keine Programmierfehler durch Endlosschleifen, ) das Protokoll garantiert Fairneß

46 Betriebssysteme Folie 3-46 Realisierungsmöglichkeiten für wechselseitigen Ausschluß kurzfristige Deaktivierung des Unterbrechungssystems (verhindert Unterbrechungen und damit Prozeßwechsel; sehr harte Methode, die nur in Ausnahmefällen benutzt werden sollte) Sperrvariablen (spin locks) (ihr Wert gibt an, ob der kritische Bereich belegt oder frei ist; sie funktionieren nur dann effizient und allgemeingültig, wenn sie über einen speziellen, unteilbaren Befehl der Maschinensprache (z.b. "BSET" (test a bit and set, Motorola MC68x00 Familie), "BST" (bit test and set, Intel Pentium Familie)) realisiert werden; Variablen werden im Vorprotokoll abgefragt und im Nachprotokoll freigegeben; ggf. muß der Wert im Vorprotokoll zyklisch abgefragt werden, bis der kritische Abschnitt frei ist (aktives Warten, busy waiting), so daß Prozessorzeit verschwendet wird; es müssen aufwendige Algorithmen implementiert werden, wenn solche Maschinenbefehle nicht benutzt werden können) Semaphore (integrieren eine Variable (eine Art "Ampel") und eine Warteschlange für Prozesse / Threads, so daß aktives Warten vermieden wird; die Variable kann vom Typ boolean bzw. bit sein (binäre Semaphore, mutex) oder vom Typ integer (allgemeine / zählende Semaphore); Semaphore und die zugehörigen Protokolloperationen sind im Betriebssystem implementiert; die Operationen werden aus der Sicht der Prozesse atomar ausgeführt) Monitore (sind Bestandteil einer höheren Programmiersprache, so daß der Einsatz vom Compiler überwacht werden kann; stehen nur in wenigen Sprachen zur Verfügung)

47 Betriebssysteme Folie Globale Variablen Synchronisation der Prozesse / Threads ohne Betriebssystem- / Compiler-Unterstützung (in Zukunft wird nur noch der Begriff Prozeß benutzt, obwohl die verschiedenen Algorithmen in den Beispielprogrammen tatsächlich über Threads realisiert werden, da sie auf einfache Weise globale Variablen unterstützen) Zugriff auf ein Betriebsmittel erfolgt in zwei Schritten: 1) Variable auf den Wert Betriebsmittel frei überprüfen 2) a) frei: Variable auf den Wert Betriebsmittel belegt ändern und das Betriebsmittel nutzen b) belegt: warten, bis das Betriebsmittel frei wird zugehöriger Programmausschnitt /* normales Programm */ while (BetriebsmittelZustand == belegt) ; /* warten */ BetriebsmittelZustand = belegt; /* Betriebsmittel nutzen */ BetriebsmittelZustand = frei; /* normales Programm */ leider kann das Problem auf diese einfache Weise nicht gelöst werden (siehe auch einführendes Beispiel am Anfang des Kapitels 3.4)

48 Betriebssysteme Folie 3-48 möglicher Ablauf das Betriebsmittel sei frei und Programm A sei aktiv nachdem Programm A die while-schleife erfolgreich durchlaufen hat, wird ein Prozeßwechsel durchgeführt als nächstes wird Programm B aktiviert und durchläuft die while-schleife ebenfalls erfolgreich, da Programm A das Betriebsmittel nicht mehr sperren konnte Programm B sperrt das Betriebsmittel und benutzt es innerhalb der Nutzungsphase wird auch Programm B der Prozessor entzogen und Programm A wird aktiviert da Programm A die while-schleife bereits erfolgreich durchlaufen hat und nicht weiß, daß ihm zwischenzeitlich der Prozessor entzogen worden ist, belegt und benutzt es das Betriebsmittel ebenfalls die Sperrsynchronisation durch eine globale Variable hat versagt

49 Betriebssysteme Folie 3-49 Lösung 1 für den wechselseitigen Ausschluß /* Solution 1 for the synchronization of two concurrent workers * with global variables. * * For Windows 98/NT/2000 only "/W3" should be used because "/W4" * results in lots of warnings in Microsoft's header files. * * UNIX: * (g)cc [-DSunOS] [-DLinux] [-DIRIX] [-DCygwin] * -o glvar_1a glvar_1a.c parallel.c -lpthread * Windows 98/NT/2000: * cl /DWin32 /W3 glvar_1a.c parallel.c (Microsoft) * bcc32 /DWin32 glvar_1a.c parallel.c (Borland) * * * File: glvar_1a.c Author: S. Gross * Date: * */ #include <stdio.h> #include <stdlib.h> #include <time.h> #include <assert.h> #include "parallel.h" #define NUM_THR 2 /* must (!) be 2 */ #define NUM_CYCLES 30 /* # of normal/critical cycles */ #define MAX_NTIME 4 /* max. time for normal work */ #define MAX_CTIME 2 /* max. time for critical work */ void worker1 (int nr); void worker2 (int nr); /* turn: number of the worker which is allowed to enter the critical * section next */ int turn; int main (void) ThrID_t thr_id [NUM_THR]; /* ID's of concurrent workers */ assert (NUM_THR == 2); srand ((unsigned int) time ((time_t) NULL)); /* worker 1 is allowed to enter the critical section first */ turn = 1; /* start concurrent workers */ thr_id [0] = parallel ((PtrFunc_t) worker1, 0); thr_id [1] = parallel ((PtrFunc_t) worker2, 1); /* wait until all concurrent workers have terminated */ join_all (thr_id, NUM_THR); return 0;

50 Betriebssysteme Folie 3-50 /* Worker processes doing critical and non-critical work. * * input parameter: nr "name" of the worker * output parameter: none * return value: none * side effects: none * */ void worker1 (int nr) int i; /* loop variable */ for (i = 0; i < NUM_CYCLES; ++i) printf ("Worker %d: doing normal work in cycle %d.\n", nr, i); /* simulate some normal work */ SLEEP ((unsigned int) rand () % MAX_NTIME); printf ("Worker %d: try to enter critical section in cycle %d.\n", nr, i); while (turn == 2) printf ("Worker %d: waiting in cycle %d.\n", nr, i); SLEEP (1); ; printf ("Worker %d: doing critical work in cycle %d.\n", nr, i); /* simulate some critical work */ SLEEP ((unsigned int) rand () % MAX_CTIME); turn = 2; /* release critical region */ ; void worker2 (int nr) int i; /* loop variable */ for (i = 0; i < NUM_CYCLES; ++i) printf ("Worker %d: doing normal work in cycle %d.\n", nr, i); /* simulate some normal work */ SLEEP ((unsigned int) rand () % MAX_NTIME); printf ("Worker %d: try to enter critical section in cycle %d.\n", nr, i); while (turn == 1) printf ("Worker %d: waiting in cycle %d.\n", nr, i); SLEEP (1); ; printf ("Worker %d: doing critical work in cycle %d.\n", nr, i); /* simulate some critical work */ SLEEP ((unsigned int) rand () % MAX_CTIME); turn = 1; /* release critical region */ ;

51 Betriebssysteme Folie 3-51 Diskussion der Lösung 1 Lösung garantiert wechselseitigen Ausschluß, da Prozeß i nur dann in seinen kritischen Abschnitt eintritt, wenn turn == i ist Lösung ist verklemmungsfrei, da der Prozeß, dessen Nummer in turn gespeichert ist, immer weiterarbeiten kann Lösung stellt sicher, daß kein Prozeß am Betreten des kritischen Abschnitts gehindert wird, falls der unkritische Abschnitt normale Arbeit nur eine endliche Zeit dauert Lösung erfüllt Regeln zur Benutzung eines kritischen Abschnitts aus den folgenden Gründen ist sie trotzdem nicht als Lösung des Problems geeignet 1) die beiden Prozesse müssen ihre kritischen Abschnitte abwechselnd betreten, d.h. ein langsamer Prozeß kann einen schnellen behindern 2) falls Prozeß worker1 den kritischen Abschnitt durchlaufen und für Prozeß worker2 freigegeben hat, kann er ihn nie mehr betreten, wenn Prozeß worker2 inzwischen z.b. aufgrund eines Fehlers im unkritischen Bereich beendet wurde

52 Betriebssysteme Folie 3-52 Lösung 2 für den wechselseitigen Ausschluß anstelle der gemeinsamen Variablen turn wird jedem der beiden Prozesse worker_i eine globale Variable c i zugeordnet /* c[i] state variable for worker i. * 0: worker uses critical section or wants to use it * 1: worker performs normal work */ int c [NUM_THR]; int main (void) for (i = 0; i < NUM_THR; ++i) c [i] = 1; /* workers doing norm. work 1st */ ; /* start concurrent workers */ return 0; void worker (int nr) int other_nr, /* number of other worker */ i; /* loop variable */ int ntime; /* normal work time */ other_nr = (nr + 1) % 2; for (i = 0; i < NUM_CYCLES; ++i) prt_msg ("Worker", nr, "doing normal work in cycle", i); /* simulate some normal work */ SLEEP ((unsigned int) rand () % ntime); prt_msg ("Worker", nr, "try to enter critical section in cycle", i); c [nr] = 0; while (c [other_nr] == 0) prt_msg ("Worker", nr, "waiting in cycle", i); SLEEP (1); ; prt_msg ("Worker", nr, "doing critical work in cycle", i); /* simulate some critical work */ SLEEP ((unsigned int) rand () % MAX_CTIME); c [nr] = 1; /* release critical region */ ; prt_msg ("Worker", nr, "#################### finished after " "cycle", i - 1); diskutieren Sie die Lösung

53 Betriebssysteme Folie 3-53 Lösung 3 für den wechselseitigen Ausschluß Problem von Lösung 2 soll dadurch behoben werden, daß der Prozeß kurzfristig darauf verzichtet, den kritischen Abschnitt zu betreten, wenn die globale Variable des anderen Prozesses anzeigt, daß er im kritischen Abschnitt ist bzw. ihn betreten will Code zwischen COBEGIN und COEND wird parallel ausgeführt int c1, c2; /* ci = 0: P. ist im krit. Abschn. oder */ /* will ihn betreten */ /* ci = 1: P. ist im "normalen" Progr. */ int main (void) /* ========= Hauptprogramm ========== */ c1 = 1; c2 = 1; COBEGIN worker1 (1); /* beide Prozesse starten */ worker2 (2); COEND; void worker1 (int nr) /* =========== Prozess 1 ============ */ for (;;) normale Arbeit; c1 = 0; /* Vorprotokoll */ while (c2 == 0) /* */ /* */ c1 = 1; /* Verzicht auf krit. Abschnitt */ /* einen Augenblick warten */ c1 = 0; /* neuer Versuch */ ; /* */ kritischer Abschnitt; c1 = 1; /* Nachprotokoll */ ; void worker2 (int nr) /* =========== Prozess 2 ============ */ /* analog worker1 */

54 Betriebssysteme Folie 3-54 Implementierung des obigen Programms /* c[i] state variable for worker i. * 0: worker uses critical section or wants to use it * 1: worker performs normal work */ int c [NUM_THR]; int main (void) for (i = 0; i < NUM_THR; ++i) c [i] = 1; /* workers doing norm. work 1st */ ; /* start concurrent workers */ return 0; void worker (int nr) int other_nr, /* number of other worker */ i; /* loop variable */ int ntime; /* normal work time */ other_nr = (nr + 1) % 2; for (i = 0; i < NUM_CYCLES; ++i) prt_msg ("Worker", nr, "doing normal work in cycle", i); /* simulate some normal work */ SLEEP ((unsigned int) rand () % ntime); prt_msg ("Worker", nr, "try to enter critical section in cycle", i); c [nr] = 0; while (c [other_nr] == 0) prt_msg ("Worker", nr, "!!!!!!!!!!!!!!! Critical section is " "busy. Drop my request for cycle", i); c [nr] = 1; SLEEP (1); prt_msg ("Worker", nr, "try again to enter critical section " "in cycle", i); c [nr] = 0; ; prt_msg ("Worker", nr, "doing critical work in cycle", i); /* simulate some critical work */ SLEEP ((unsigned int) rand () % MAX_CTIME); c [nr] = 1; /* release critical region */ ; prt_msg ("Worker", nr, "#################### finished after " "cycle", i - 1); diskutieren Sie die Lösung

55 Betriebssysteme Folie 3-55 Lösung 4: Algorithmus von Dekker Kombination der ersten und dritten Lösung zum wechselseitigen Ausschluß int turn, /* Nr. des Prozesses, der als nächster */ /* den krit. Abschnitt betreten darf */ c1, c2; /* ci = 0: P. ist im krit. Abschn. o. */ /* will ihn betreten */ /* ci = 1: P. ist im "normalen" Progr. */ int main (void) /* ========= Hauptprogramm ========= */ turn = 1; c1 = 1; c2 = 1; COBEGIN worker1 (1); /* beide Prozesse starten */ worker2 (2); COEND; void worker1 (int nr) /* =========== Prozess 1 =========== */ for (;;) sonstige Arbeit; c1 = 0; /* Vorprotokoll */ while (c2 == 0) /* */ /* */ if (turn == 2) /* Prozess 2 hat Prioritaet */ /* -> "hoeflich" sein */ c1 = 1; /* Verzicht auf krit. Abschnitt */ while (turn == 2) /* */ /* */ ; /* warten */ ; /* */ c1 = 0; /* neuer Versuch */ ; /* */ ; /* */ kritischer Abschnitt; turn = 2; /* Nachprotokoll */ c1 = 1; /* */ ; void worker2 (int nr) /* =========== Prozess 2 =========== */ /* analog worker1 */