Friedrich-Alexander-Universität UnivisSuche FAU-Logo
Techn. Fakultńt Willkommen am Department Informatik FAU-Logo
Logo I4
Lehrstuhl für Informatik 4
Betriebssysteme
 
  Vorlesung
    - UnivIS-Infos
    - Inhalt
    - Folien
 
  Übungen
    - UnivIS-Infos
    - Inhalt
    - Mailingliste
    - Ergänzendes Material
    - Terminübersicht
    - Aufgaben
       * Umgebung
       * Typische Fehler
       * Aufgabe 1
          Dokumentation
       * Aufgabe 2
          Dokumentation
       * Aufgabe 3
          Dokumentation
       * Aufgabe 4
          Dokumentation
       * Aufgabe 5
          Dokumentation
       * Aufgabe 6
          Dokumentation
       * Aufgabe 7
          Dokumentation
 
  Evaluation
Department Informatik  >  Informatik 4  >  Lehre  >  WS 2010/11  >  Betriebssysteme  >  ├ťbungen  >  Aufgaben  >  Aufgabe 6

Aufgabe 6: Ereignisbearbeitung und Synchronisation

Lernziel

  • Synchronisation mit Hilfe von Semaphoren und anderen Kernobjekten

Aufgabenbeschreibung

OOStuBS/MPStuBS soll nun um Synchronisationsobjekte erweitert werden, mit denen Threads sich gegenseitig ├╝ber verschiedene Ereignisse informieren bzw. auf Ereignisse warten k├Ânnen. Folgende Synchronisationsobjekte sollen in dieser Aufgabe erstellt werden:

  • Mit Hilfe von Semaphoren besteht die M├Âglichkeit, Anwendungsprozesse miteinander zu synchronisieren. Dar├╝berhinaus sollen sie dazu verwendet werden, Anwendungsprozesse bei der Tastaturabfrage zu blockieren, bis eine Taste gedr├╝ckt wurde.
  • Durch Buzzer (Wecker) k├Ânnen Threads sich f├╝r eine bestimmte Zeit schlafen legen.

Hierzu m├╝ssen die Klassen Waitingroom, Semaphore, Customer, Organizer, Bell, Bellringer, Buzzer, Guarded_Buzzer, Guarded_Organizer, Guarded_Semaphore und Guarded_Keyboard implementiert, die Klasse Keyboard erweitert und die Klassen Thread sowie Watch angepasst werden.

Die Klasse Guarded_Scheduler wird nicht l├Ąnger ben├Âtigt, da Guarded_Organizer ihre Aufgabe ├╝bernimmt. Ebenso soll das globale Guarded_Scheduler-Objekt scheduler durch ein globales Guarded_Organizer-Objekt organizer ersetzt werden.

Abschliessend soll dann noch eine M├Âglichkeit geschaffen werden, den Prozessor schlafen zu lassen, wenn keine Benutzerprozesse vorhanden sind.

In OOStuBS empfiehlt es sich dazu in einer Schleife den Idle-Befehl der CPU auszuf├╝hren. Neue Prozesse k├Ânnen lediglich durch Interruptbehandlungsroutinen aktiviert werden. Wenn nach einem Interrupt wieder neue Prozesse in der Bereitliste vorhanden sind, soll die Ausf├╝hrung fortgef├╝hrt werden.

In MPStuBS ist die Idle-Problematik jedoch etwas komplexer, da sich hier eine Teilmenge der CPUs im Idle-Zustand befinden k├Ânnen k├Ânnen w├Ąhrend andere CPUs noch Prozesse ausf├╝hren. Darum ist es hier sinnvoll mit dedizierten, pro Prozessor allokierten Idle-Threads (Instanzen der Klasse IdleThread) zu arbeiten, die eingeplant werden, sobald keine anderen Prozesse vorhanden sind. Die Idle-Threads f├╝hren dann ein Idle-Loop analog zu dem aus OOStuBS aus. Dar├╝berhinaus ist es notwendig schlafende Prozessoren immer dann zu wecken, wenn ein Prozess durch Aufruf von Scheduler::ready() auf die Bereitliste gesetzt wird. Dazu soll ein eigener Interprozessorinterrupt (IPI) analog zur Implementierung von Scheduler::kill(Entrant& that) in Aufgabe 5 verwendet werden.

a6.dot

Klassen├╝bersicht f├╝r Aufgabe 6

Bearbeitung

Teil A

Beginnt am besten mit der Implementierung der Semaphoren. Dazu m├╝ssen zun├Ąchst die Klassen Waitingroom, Semaphore, Customer, Organizer, Guarded_Organizer und Guarded_Semaphore implementiert werden. Mit Hilfe von Semaphorvariablen solltet ihr nun verhindern k├Ânnen, dass sich eure Anwendungsprozesse bei der Bildschirmausgabe gegenseitig behindern.

Teil B

Im n├Ąchsten Schritt k├Ânnt ihr dann die Klasse Keyboard um die getkey()-Methode erweitern, durch die Prozesse nun mit Hilfe einer Semaphore beim Lesen von der Tastatur blockieren, falls keine Taste gedr├╝ckt wurde. Erweitert euer Programm dahingehend, dass einer der Prozesse Tastaturabfragen vornimmt (und in irgendeiner sichtbaren Weise darauf reagiert).

Teil C

Anschlie├čend k├Ânnen die Klassen Bell und Bellringer implementiert und getestet werden. Von Bellringer sollte eine globale Instanz bellringer angelegt werden. Wenn klar ist, dass insbesondere der Bellringer funktioniert, wie er sollte, k├Ânnt ihr die Klassen Buzzer und Guarded_Buzzer erstellen. Damit lassen sich nun sehr einfach periodische Prozesse erstellen, indem ein Prozess sich immer wieder f├╝r ein paar Millisekunden schlafen legt und dann z. B. eine Ausgabe macht. Auch daf├╝r sollt ihr ein geeignetes Beispiel vorbereiten.

Teil D

Wenn alle vorhergenden Klassen implementiert und getestet wurden, kann man nun die Idle-Problematik angehen und den entsprechnden Ansatz implementieren. Dies sollte auch getestet werden, indem man in der Testapplikation regelm├Ą├čig daf├╝r sorgt, dass zuwenig (in MPStuBS) oder gar keine Prozesse zum Ausf├╝hren vorhanden sind.

Vorgaben

Die Implementierung der Klasse List haben wir bereits f├╝r euch erledigt.
  Impressum Stand: 2011-01-16 21:32   BO, DL