christoph/lecture-operating-system-development
1
Fork 0
Code Activity

add vorgabe06

Browse Source
This commit is contained in:
Christoph Urlacher
2022-06-02 13:01:43 +02:00
parent 7b7b375c8c
commit 32b1f2391f
15 changed files with 525 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
c_os/kernel/Globals.cc
View File

@ -20,3 +20,4 @@ unsigned int total_mem; // RAM total
// BumpAllocator allocator;
// LinkedListAllocator allocator;
TreeAllocator allocator;
Scheduler scheduler;

2
c_os/kernel/Globals.h
View File

@ -19,6 +19,7 @@
#include "kernel/CPU.h"
#include "kernel/interrupts/IntDispatcher.h"
#include "kernel/interrupts/PIC.h"
#include "kernel/threads/Scheduler.h"
extern CPU cpu; // CPU-spezifische Funktionen
extern PCSPK pcspk; // PC-Lautsprecher
@ -30,6 +31,7 @@ extern unsigned int total_mem; // RAM total
// extern BumpAllocator allocator;
// extern LinkedListAllocator allocator;
extern TreeAllocator allocator;
extern Scheduler scheduler;
constexpr bool DEBUG = true;

48
c_os/kernel/threads/Dispatch.cc Executable file
View File

@ -0,0 +1,48 @@
/*****************************************************************************
* *
* D I S P A T C H E R *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Implementierung des Dispatchers. *
* Der Dispatcher verwaltet den 'active'-Pointer, der den *
* jeweils aktiven Thread angibt. Mit 'start()' wird der *
* 'active' Pointer initialisiert und der erste Thread ge- *
* startet, alle weiteren Kontextwechsel werden mit *
* 'dispatch()' ausgeloest. 'get_active()' liefert den *
* 'active' Pointer zurueck. *
* *
* Autor: Olaf Spinczyk, TU Dortmund *
*****************************************************************************/
#include "kernel/threads/Dispatch.h"
/*****************************************************************************
* Methode: Dispatcher::start *
*---------------------------------------------------------------------------*
* Beschreibung: Thread starten. *
* *
* Parameter: *
* first Zu startender Thread. *
*****************************************************************************/
void Dispatcher::start (Thread& first) {
if (!active) {
active = &first;
active->start ();
}
}
/*****************************************************************************
* Methode: Dispatcher::dispatch *
*---------------------------------------------------------------------------*
* Beschreibung: Auf einen gegebenen Thread wechseln. *
* *
* Parameter: *
* next Thread der die CPU erhalten soll. *
*****************************************************************************/
void Dispatcher::dispatch (Thread& next) {
Thread* current = active;
active = &next;
current->switchTo (next);
}

35
c_os/kernel/threads/Dispatch.h Executable file
View File

@ -0,0 +1,35 @@
/*****************************************************************************
* *
* D I S P A T C H E R *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Implementierung des Dispatchers. *
* Der Dispatcher verwaltet den 'active'-Pointer, der den *
* jeweils aktiven Thread angibt. Mit 'start()' wird der *
* 'active' Pointer initialisiert und der erste Thread ge- *
* startet, alle weiteren Kontextwechsel werden mit *
* 'dispatch()' ausgeloest. 'get_active()' liefert den *
* 'active' Pointer zurueck. *
* *
* Autor: Olaf Spinczyk, TU Dortmund *
*****************************************************************************/
#ifndef __dispatch_include__
#define __dispatch_include__
#include "kernel/threads/Thread.h"
class Dispatcher {
private:
Thread* active; // aktiver Thread
Dispatcher(const Dispatcher &copy); // Verhindere Kopieren
public:
Dispatcher () : active (0) {}
void start (Thread& first);
void dispatch (Thread& next);
Thread* get_active () { return active; }
};
#endif

35
c_os/kernel/threads/IdleThread.h Executable file
View File

@ -0,0 +1,35 @@
/*****************************************************************************
* *
* I D L E T H R E A D *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Wird nur aktiviert, wenn kein Thread arbeiten moechte. *
* *
* Autor: Michael, Schoettner, HHU, 13.8.2016 *
*****************************************************************************/
#ifndef __IdleThread_include__
#define __IdleThread_include__
#include "kernel/threads/Thread.h"
#include "kernel/Globals.h"
class IdleThread : public Thread {
private:
IdleThread(const Thread &copy); // Verhindere Kopieren
public:
IdleThread () : Thread () { }
void run () {
while (1) {
scheduler.yield ();
}
}
};
#endif

95
c_os/kernel/threads/Scheduler.cc Executable file
View File

@ -0,0 +1,95 @@
/*****************************************************************************
* *
* S C H E D U L E R *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Implementierung eines einfachen Zeitscheiben-Schedulers. *
* Rechenbereite Threads werden in 'readQueue' verwaltet. *
* *
* Autor: Michael, Schoettner, HHU, 23.11.2018 *
*****************************************************************************/
#include "kernel/threads/Scheduler.h"
#include "kernel/threads/IdleThread.h"
/*****************************************************************************
* Methode: Scheduler::schedule *
*---------------------------------------------------------------------------*
* Beschreibung: Scheduler starten. Wird nur einmalig aus main.cc gerufen.*
*****************************************************************************/
void Scheduler::schedule () {
/* hier muss Code eingefuegt werden */
/* Bevor diese Methode anufgerufen wird, muss zumindest der Idle-Thread
* in der Queue eingefuegt worden sein.
*/
}
/*****************************************************************************
* Methode: Scheduler::ready *
*---------------------------------------------------------------------------*
* Beschreibung: Thread in readyQueue eintragen. *
* *
* Parameter: *
* that Einzutragender Thread *
*****************************************************************************/
void Scheduler::ready (Thread * that) {
/* hier muss Code eingefuegt werden */
}
/*****************************************************************************
* Methode: Scheduler::exit *
*---------------------------------------------------------------------------*
* Beschreibung: Thread ist fertig und terminiert sich selbst. Hier muss *
* nur auf den naechsten Thread mithilfe des Dispatchers *
* umgeschaltet werden. Der aktuell laufende Thread ist *
* nicht in der readyQueue. *
*****************************************************************************/
void Scheduler::exit () {
/* hier muss Code eingefuegt werden */
}
/*****************************************************************************
* Methode: Scheduler::kill *
*---------------------------------------------------------------------------*
* Beschreibung: Thread mit 'Gewalt' terminieren. Er wird aus der *
* readyQueue ausgetragen und wird dann nicht mehr aufge- *
* rufen. Der Aufrufer dieser Methode muss ein anderer *
* Thread sein. *
* *
* Parameter: *
* that Zu terminierender Thread *
*****************************************************************************/
void Scheduler::kill (Thread * that) {
/* hier muss Code eingefuegt werden */
}
/*****************************************************************************
* Methode: Scheduler::yield *
*---------------------------------------------------------------------------*
* Beschreibung: CPU freiwillig abgeben und Auswahl des naechsten Threads.*
* Naechsten Thread aus der readyQueue holen, den aktuellen *
* in die readyQueue wieder eintragen. Das Umschalten soll *
* mithilfe des Dispatchers erfolgen. *
* *
* Achtung: Falls nur der Idle-Thread läuft, so ist die *
* readyQueue leer. *
*****************************************************************************/
void Scheduler::yield () {
/* hier muss Code eingefuegt werden */
}

46
c_os/kernel/threads/Scheduler.h Executable file
View File

@ -0,0 +1,46 @@
/*****************************************************************************
* *
* S C H E D U L E R *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Implementierung eines einfachen Zeitscheiben-Schedulers. *
* Rechenbereite Threads werden in 'readQueue' verwaltet. *
* *
* Autor: Michael, Schoettner, HHU, 22.8.2016 *
*****************************************************************************/
#ifndef __Scheduler_include__
#define __Scheduler_include__
#include "kernel/threads/Dispatch.h"
#include "kernel/threads/Thread.h"
#include "lib/Queue.h"
class Scheduler : public Dispatcher {
private:
Scheduler (const Scheduler &copy); // Verhindere Kopieren
private:
Queue readyQueue; // auf die CPU wartende Threads
public:
Scheduler () {}
// Scheduler starten
void schedule ();
// Thread in readyQueue eintragen
void ready (Thread * that);
// Thread terminiert sich selbst
void exit ();
// Thread mit 'Gewalt' terminieren
void kill (Thread * that);
// CPU freiwillig abgeben und Auswahl des naechsten Threads
void yield ();
};
#endif

54
c_os/kernel/threads/Thread.h Executable file
View File

@ -0,0 +1,54 @@
/*****************************************************************************
* *
* T H R E A D *
* *
*---------------------------------------------------------------------------*
* Beschreibung: Implementierung eines kooperativen Thread-Konzepts. *
* Thread-Objekte werden vom Scheduler in einer verketteten *
* Liste 'readylist' verwaltet. *
* *
* Im Konstruktor wird der initialie Kontext des Threads *
* eingerichtet. Mit 'start' wird ein Thread aktiviert. *
* Die CPU sollte mit 'yield' freiwillig abgegeben werden. *
* Um bei einem Threadwechsel den Kontext sichern zu *
* koennen, enthaelt jedes Threadobjekt eine Struktur *
* ThreadState, in dem die Werte der nicht-fluechtigen *
* Register gesichert werden koennen. *
* *
* Autor: Michael, Schoettner, HHU, 16.12.2016 *
*****************************************************************************/
#ifndef __Thread_include__
#define __Thread_include__
#include "kernel/threads/ThreadState.h"
#include "lib/Chain.h"
class Thread : public Chain {
private:
Thread(const Thread &copy); // Verhindere Kopieren
private:
struct ThreadState regs;
unsigned int *stack;
public:
unsigned int tid; // Thread-ID (wird im Konstruktor vergeben)
Thread () { }
// Thread aktivieren
void start ();
// Umschalten auf Thread 'next'
void switchTo (Thread& next);
// Methode des Threads, muss in Sub-Klasse implementiert werden
virtual void run () = 0;
~Thread ();
};
#endif