Commit ce9a34d2 authored by Bernhard Heinloth's avatar Bernhard Heinloth
Browse files

Vorgabe oostubs Aufgabe 6

parent 52b170d4
// vim: set et ts=4 sw=4:
#include "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);
};
// vim: set et ts=4 sw=4:
#include "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();
};
#include "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();
};
// vim: set et ts=4 sw=4:
#include "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);
};
// vim: set et ts=4 sw=4:
#include "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);
};
// vim: set et ts=4 sw=4:
#include "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();
};
// 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() {
}
};
#include "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
{
};
// 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
*
*
*/
};
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment