Vorgabe oostubs Aufgabe 6

meeting/bell.cc

+// vim: set et ts=4 sw=4:
+
+#include "meeting/bell.h"

meeting/bell.h

+// vim: set et ts=4 sw=4:
+
+#pragma once
+
+/*! \file
+ *  \brief Enthält die Klasse Bell.
+ */
+
+#include "meeting/waitingroom.h"
+#include "object/queuelink.h"
+class Bellringer;
+
+/*! \brief Synchronisationsobjekt zum Schlafenlegen für eine bestimmte
+ *  Zeitspanne
+ *  \ingroup ipc
+ *
+ *
+ *  Ein "Wecker" ist ein Synchronisationsobjekt, mit dem ein oder mehrere
+ *  Threads sich für eine bestimmte Zeit schlafen legen können.
+ */
+class Bell
+	: public Waitingroom
+{
+	// Verhindere Kopien und Zuweisungen
+	Bell(const Bell&)            = delete;
+	Bell& operator=(const Bell&) = delete;
+
+private:
+
+	/* Erlaube Klasse Bellringer Zugriff auf die interne Variable counter und
+	 * bellringer_link. */
+	friend class Bellringer;
+
+public:
+	/*! \brief Konstruktor.
+	 *
+	 *  Der Wecker ist zunächst noch abgeschaltet.
+	 *
+	 *  \todo Konstruktor implementieren
+	 *
+	 */
+	Bell()
+	{}
+
+	/*! \brief Läuten der Glocke
+	 *
+	 *  Wird von Bellringer aufgerufen, wenn die Wartezeit abgelaufen ist und
+	 *  weckt den schlafenden Thread.
+	 *
+	 *  \todo Methode implementieren
+	 *
+	 */
+	void ring();
+
+	/*! \brief Temporäres Bell-Objekt erzeugen und Thread schlafen legen, bis
+	 * der Wecker klingelt.
+	 *  \param ms Zeit in Millisekunden, die zur Umrechnung an Bellringer::job()
+	 *  weitergegeben wird.
+	 *
+	 *  \todo Methode implementieren
+	 *
+	 */
+	static void sleep(unsigned int ms);
+};
+

meeting/bellringer.cc

+// vim: set et ts=4 sw=4:
+
+#include "meeting/bellringer.h"

meeting/bellringer.h

+// vim: set et ts=4 sw=4:
+
+/*! \file
+ *  \brief Enthält die Klasse Bellringer.
+ */
+
+#pragma once
+
+#include "meeting/bell.h"
+#include "object/queue.h"
+/*! \brief Verwaltung und Anstoßen von zeitgesteuerten Aktivitäten.
+ *  \ingroup ipc
+ *
+ *
+ *  Der "Glöckner" (Bellringer) wird regelmäßig aktiviert und prüft, ob
+ *  irgendwelche "Glocken" (Bell-Objekte) läuten müssen. Die Glocken befinden
+ *  sich in einer Liste, die der Glöckner verwaltet. Eine geschickte
+ *  Implementierung vermeidet, bei jeder Aktivierung die gesamte Liste
+ *  zu durchlaufen.
+ *
+ *  Auf diese Weise erreicht man eine Komplexität vom O(1) im Timer
+ *  Interrupt, sofern keine Glocke aktiviert werden muss.
+ */
+class Bellringer
+{
+	// Verhindere Kopien und Zuweisungen
+	Bellringer(const Bellringer&)            = delete;
+	Bellringer& operator=(const Bellringer&) = delete;
+public:
+	/*! \brief Konstruktor.
+	 *
+	 */
+	Bellringer() {}
+
+public:
+	/*! \brief Prüft, ob Glocken zu läuten sind und tut es gegebenenfalls.
+	 *
+	 *  Bei jedem Aufruf von check vergeht ein Tick. Wenn das Ticken einer
+	 *  Glocke dazu führt, dass sie ihre Zeit abgelaufen ist, wird sie
+	 *  geläutet.
+	 *
+	 *  \todo Methode implementieren
+	 *
+	 */
+	void check();
+
+	/*! \brief Die Glocke \b bell wird dem Glöckner überantwortet. Sie soll nach
+	 *  \b ms Millisekunden geläutet werden.
+	 *  \param bell Glocke, die nach \b ms Millisekunden geläutet werden
+	 *  soll.
+	 *  \param ms Millisekunden, die abgewartet werden sollen,
+	 *  bevor die Glocke \b bell geläutet wird.
+	 *
+	 *  \todo Methode implementieren
+	 *
+	 */
+	void job(Bell *bell, unsigned int ms);
+
+	/*! \brief Die Glocke \b bell soll nun doch nicht geläutet werden.
+	 *  \param bell Die Glocke, die nicht geläutet werden soll.
+	 *
+	 *  \todo Methode implementieren
+	 *
+	 */
+	void cancel(Bell *bell);
+
+	/*! \brief Ist eine Glocke eingehangen?
+	 *  \return Mindestens eine Glocke ist eingehangen.
+	 *
+	 *  \todo Methode implementieren
+	 *
+	 */
+	bool bell_pending();
+
+};
+

meeting/semaphore.cc

+#include "meeting/semaphore.h"
+

meeting/semaphore.h

+// vim: set et ts=4 sw=4:
+
+#pragma once
+
+/*! \file
+ *  \brief Enthält die Klasse Semaphore.
+ */
+
+#include "meeting/waitingroom.h"
+
+/*! \brief Semaphore werden zur Synchronisation von Threads verwendet.
+ *  \ingroup ipc
+ *
+ *
+ *  Die Klasse Semaphore implementiert das Synchronisationskonzept des zählenden
+ *  Semaphors. Die benötigte Warteliste erbt sie dabei von ihrer Basisklasse
+ *  Waitingroom.
+ */
+class Semaphore
+	: public Waitingroom
+{
+	// Verhindere Kopien und Zuweisungen
+	Semaphore(const Semaphore&)            = delete;
+	Semaphore& operator=(const Semaphore&) = delete;
+public:
+	/*! \brief Der Konstruktor initialisiert den Semaphorzähler mit dem
+	 *  angegebenen Wert \b c
+	 *  \param c Initialer Zählerwert des Semaphors
+	 *
+	 *  \todo Konstruktor implementieren
+	 */
+	Semaphore(int c = 0)
+	{}
+
+	/*! \brief Warten auf das Freiwerden eines kritischen Abschnitts.
+	 *
+	 *  Warteoperation: Sofern der Semaphorzähler größer als Null ist, wird er
+	 *  nur um eins erniedrigt. Anderenfalls wird der aktuell laufende Thread
+	 *  an die Warteliste angefügt und blockiert.
+	 *
+	 *  \todo Methode implementieren
+	 *
+	 */
+	void p();
+
+	/*! \brief Freigeben des kritischen Abschnitts.
+	 *
+	 *  Freigabeoperation: Wenn auf der Warteliste mindestens ein Thread
+	 *  eingetragen ist, wird der erste davon aufgeweckt. Anderenfalls wird der
+	 *  Semaphorzähler um eins erhöht.
+	 *
+	 *  \todo Methode implementieren
+	 *
+	 */
+	void v();
+};
+

meeting/waitingroom.cc

+// vim: set et ts=4 sw=4:
+
+#include "meeting/waitingroom.h"

meeting/waitingroom.h

+// vim: set et ts=4 sw=4:
+
+#pragma once
+
+/*! \file
+ *  \brief Enthält die Klasse Waitingroom.
+ */
+
+/*! \defgroup ipc IPC Subsystem
+ *
+ * Das IPC Subsystem stellt der Fadenabstraktion eine Schnittstelle
+ * bereit um Synchronisation durchzuführen. Diese Synchronisation
+ * beinhaltet sowohl die Synchronisation zwischen Threads
+ * (Semaphoren), als auch die Synchronisation mit der Umwelt (Bell).
+ */
+
+#include "object/queue.h"
+class Thread;
+
+/*! \brief Liste von Threads, die auf ein Ereignis warten.
+ *  \ingroup ipc
+ *
+ *
+ *  Die Klasse Waitingroom implementiert eine Liste von Threads, die alle auf
+ *  ein bestimmtes Ereignis warten.
+ *  \note
+ *  Die Methode remove(Thread*) muss virtuell sein, damit der Scheduler einen
+ *  Thread aus dem Wartezimmer entfernen kann, ohne wissen zu müssen, welcher
+ *  Art dieses Wartezimmer ist. Sofern es erforderlich ist, kann eine von
+ *  Waitingroom abgeleitete Klasse die Methode auch noch neu definieren.
+ *
+ *  Der Destruktor sollte wie bei allen Klassen, die virtuelle Methoden
+ *  definieren, ebenfalls virtuell sein.
+ */
+class Waitingroom
+	: public Queue<Thread>
+{
+	// Verhindere Kopien und Zuweisungen
+	Waitingroom(const Waitingroom&)            = delete;
+	Waitingroom& operator=(const Waitingroom&) = delete;
+
+public:
+	Waitingroom() {}
+
+	/*! \brief Destruktor
+	 *
+	 *  Der Destruktor entfernt alle noch wartenden Threads von der Liste und
+	 *  weckt sie zudem auf.
+	 *
+	 *  \todo Destruktor implementieren
+	 *
+	 */
+	virtual ~Waitingroom();
+
+	/*! \brief Mit dieser Methode kann der angegebene Thread customer vorzeitig
+	 *  aus dem Wartezimmer entfernt werden.
+	 *
+	 *
+	 *  \todo Methode implementieren
+	 *
+	 */
+	virtual void remove(Thread *customer);
+};
+

syscall/guarded_bell.cc

+// vim: set et ts=4 sw=4:
+
+#include "syscall/guarded_bell.h"

syscall/guarded_bell.h

+// vim: set et ts=4 sw=4:
+
+#pragma once
+
+/*! \file
+ *  \brief Enthält die Klasse Guarded_Bell
+ */
+
+#include "meeting/bell.h"
+
+/*! \brief Schnittstelle von Anwendungsthreads zu Bell-Objekten.
+ *
+ *  Die Klasse Guarded_Bell implementiert die Systemaufrufschnittstelle zur
+ *  Bell Klasse. Die von Guarded_Bell angebotenen Methoden werden direkt auf
+ *  die Methoden der Basisklasse abgebildet, nur dass ihre Ausführung jeweils
+ *  mit Hilfe eines Objekts der Klasse Secure geschützt wird.
+ */
+class Guarded_Bell
+	: public Bell
+{
+	// Verhindere Kopien und Zuweisungen
+	Guarded_Bell(const Guarded_Bell&)            = delete;
+	Guarded_Bell& operator=(const Guarded_Bell&) = delete;
+
+public:
+	Guarded_Bell() {}
+
+	/*! \brief Diese Methode entspricht der gleichnamigen Methode der
+	 *  Basisklasse Bell, nur dass sie mit Hilfe eines Secure Objekts
+	 *  geschützt wird.
+	 *
+	 *  \todo Methode implementieren
+	 *
+	 *
+	 */
+	static void sleep(unsigned int ms);
+};
+

syscall/guarded_keyboard.cc

+// vim: set et ts=4 sw=4:
+
+#include "syscall/guarded_keyboard.h"

syscall/guarded_keyboard.h

+// vim: set et ts=4 sw=4:
+
+#pragma once
+
+/*! \file
+ *  \brief Enthält die Klasse Guarded_Keyboard
+ */
+
+#include "device/keyboard.h"
+
+/*! \brief Systemaufrufschnittstelle zur Tastatur
+ *
+ */
+class Guarded_Keyboard
+	: public Keyboard
+{
+	// Verhindere Kopien und Zuweisungen
+	Guarded_Keyboard(const Guarded_Keyboard&)            = delete;
+	Guarded_Keyboard& operator=(const Guarded_Keyboard&) = delete;
+public:
+	Guarded_Keyboard() {}
+
+	/*! \brief Diese Methode entspricht der gleichnamigen Methode der
+	 *  Basisklasse Keyboard, nur dass sie mit Hilfe eines Secure Objekts
+	 *  geschützt wird.
+	 *
+	 *  \todo Methode implementieren
+	 *
+	 *
+	 */
+	Key getkey();
+};
+

syscall/guarded_semaphore.h

+// vim: set et ts=4 sw=4:
+
+#pragma once
+
+/*! \file
+ *  \brief Enthält die Klasse Guarded_Semaphore
+ */
+
+#include "meeting/semaphore.h"
+#include "guard/secure.h"
+
+/*! \brief Systemaufrufschnittstelle zum Semaphor
+ *
+ *  Die Klasse Guarded_Semaphore implementiert die Systemaufrufschnittstelle zur
+ *  Semaphore Klasse. Die von Guarded_Semaphore angebotenen Methoden werden
+ *  direkt auf die Methoden der Basisklasse abgebildet, nur dass ihre Ausführung
+ *  jeweils mit Hilfe eines Objekts der Klasse Secure geschützt wird.
+ */
+class Guarded_Semaphore
+	: public Semaphore
+{
+	// Verhindere Kopien und Zuweisungen
+	Guarded_Semaphore(const Guarded_Semaphore&)            = delete;
+	Guarded_Semaphore& operator=(const Guarded_Semaphore&) = delete;
+public:
+	/*! \brief Der Konstruktor reicht nur den Parameter c an den Konstruktor
+	 *  der Basisklasse weiter.
+	 *
+	 *
+	 *  \todo Konstruktor implementieren
+	 *
+	 */
+	Guarded_Semaphore(int c)
+	{}
+
+	/*! \brief Diese Methode entspricht der gleichnamigen Methode der
+	 *  Basisklasse Semaphore, nur dass sie mit Hilfe eines Secure Objekts
+	 *  geschützt wird.
+	 *
+	 *  \todo Methode implementieren
+	 *
+	 *
+	 */
+	void p() {
+	}
+
+	/// \copydoc p()
+	void v() {
+	}
+};
+

thread/idlethread.cc

+#include "thread/idlethread.h"
+

thread/idlethread.h

+// vim: set et ts=4 sw=4:
+
+#pragma once
+
+/*! \file
+ *  \brief Enthält die Klasse IdleThread
+ */
+
+#include "thread/thread.h"
+
+/*! \brief Thread, der immer dann läuft, wenn eine CPU nichts zu tun hat.
+ *  \ingroup thread
+ *
+ *
+ *  Die Verwendung von IdleThread vereinfacht die
+ *  Behandlung von "däumchendrehenden" Prozessoren.
+ *  \note
+ *  Instanzen von IdleThread sollten nie in der Bereitliste des Schedulers
+ *  auftauchen, sondern immer getrennt gehalten werden, da sie ja nur dann
+ *  ausgeführt werden sollen, wenn kein normaler Thread mehr bereit ist.
+ *
+ */
+class IdleThread
+{
+};
+

thread/wakeup.h

+// vim: set et ts=4 sw=4:
+
+#pragma once
+
+/*! \file
+ *  \brief Enthält die Klasse WakeUp
+ */
+
+#include "guard/gate.h"
+#include "machine/plugbox.h"
+
+extern Plugbox plugbox;
+
+/*! \brief Interruptbehandlungsobjekt, um in MPStuBS schlafende Prozessoren
+ *  mit einem IPI zu wecken, falls neue Threads aktiv wurden. Diese Interruptbehandlung
+ *  soll explizit keinen Epilog nach sich ziehen.
+ *
+ *  Nur in MPStuBS benötigt.
+ */
+class WakeUp
+	: public Gate
+{
+public:
+	/*! \brief Interruptbehandlung registrieren.
+	 *
+	 *
+	 *  \todo Methode implementieren
+	 *
+	 */
+
+	/*! \brief Interrupt soll Prozessor nur aufwecken und signalisieren, dass
+	 *  neue Threads in der Bereitliste vorhanden sind.
+	 *
+	 *  \todo Methode implementieren
+	 *
+	 *
+	 */
+};
+