118 lines
4.8 KiB
C++
118 lines
4.8 KiB
C++
/*****************************************************************************
|
|
* *
|
|
* 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/Thread.h"
|
|
#include "lib/SpinLock.h"
|
|
#include "user/lib/Logger.h"
|
|
#include "user/lib/mem/UniquePointer.h"
|
|
#include "user/lib/Vector.h"
|
|
|
|
class Scheduler {
|
|
private:
|
|
Scheduler(const Scheduler& copy) = delete; // Verhindere Kopieren
|
|
|
|
Logger log;
|
|
|
|
// NOTE: Using this instead of the Queue is a side effect, I added the ArrayList for different reasons
|
|
// but my Queue was shit so I replaced it
|
|
// I want to use the queue again to get rid of the Vector overhead (copy + dynamic memory) but
|
|
// this is problematic with the unique_ptr, I guess I would have to wrap the threads in the "Chain"
|
|
// elements instead of a thread being a "Chain"
|
|
bse::Vector<bse::unique_ptr<Thread>> ready_queue;
|
|
bse::Vector<bse::unique_ptr<Thread>> block_queue;
|
|
|
|
// NOTE: It makes sense to keep track of the active thread through this as it makes handling the
|
|
// unique_ptr easier and reduces the copying in the vector when cycling through the threads
|
|
bse::Vector<bse::unique_ptr<Thread>>::Iterator active = ready_queue.begin();
|
|
|
|
// Scheduler wird evt. von einer Unterbrechung vom Zeitgeber gerufen,
|
|
// bevor er initialisiert wurde
|
|
unsigned int idle_tid = 0U;
|
|
|
|
// NOTE: I would have to release the lock when switching threads but I don't know exactly how to do this
|
|
// in the assembly function
|
|
// SpinLock lock; // Use spinlock instead of cpu.disable_int() because it still allows preemption
|
|
// // for threads that don't use the scheduler
|
|
|
|
// Make it easy to switch locking mechanism in the future
|
|
static void lock();
|
|
static void unlock();
|
|
|
|
void start(bse::Vector<bse::unique_ptr<Thread>>::Iterator next); // Switches from prev to current active
|
|
void switch_to(Thread* prev_raw, bse::Vector<bse::unique_ptr<Thread>>::Iterator next); // Switches from prev to current active
|
|
|
|
// Kann nur vom Idle-Thread aufgerufen werden (erster Thread der vom Scheduler gestartet wird)
|
|
void enable_preemption(unsigned int tid) { idle_tid = tid; }
|
|
friend class IdleThread;
|
|
|
|
public:
|
|
Scheduler() : log("SCHED") {}
|
|
|
|
unsigned int get_active() const {
|
|
return (*active)->tid;
|
|
}
|
|
|
|
// Scheduler initialisiert?
|
|
// Zeitgeber-Unterbrechung kommt evt. bevor der Scheduler fertig
|
|
// intiialisiert wurde!
|
|
bool preemption_enabled() const { return idle_tid != 0U; }
|
|
|
|
// Scheduler starten
|
|
void schedule();
|
|
|
|
/*****************************************************************************
|
|
* Methode: Scheduler::ready *
|
|
*---------------------------------------------------------------------------*
|
|
* Beschreibung: Thread in readyQueue eintragen. *
|
|
*****************************************************************************/
|
|
template<typename T, typename... Args>
|
|
unsigned int ready(Args... args) {
|
|
lock();
|
|
|
|
bse::unique_ptr<T> thread = bse::make_unique<T>(std::forward<Args>(args)...);
|
|
|
|
unsigned int tid = thread->tid;
|
|
log << DEBUG << "Adding to ready_queue, ID: " << dec << tid << endl;
|
|
ready_queue.push_back(std::move(thread));
|
|
|
|
unlock();
|
|
|
|
return tid;
|
|
}
|
|
|
|
// Thread terminiert sich selbst
|
|
// NOTE: When a thread exits itself it will disappear...
|
|
// Maybe put exited threads in an exited queue?
|
|
// Then they would have to be acquired from there to exit...
|
|
void exit();
|
|
|
|
// Thread mit 'Gewalt' terminieren
|
|
void kill(unsigned int tid, bse::unique_ptr<Thread>* ptr);
|
|
void kill(unsigned int tid) { kill(tid, nullptr); }
|
|
|
|
// CPU freiwillig abgeben und Auswahl des naechsten Threads
|
|
void yield();
|
|
|
|
// Thread umschalten; wird aus der ISR des PITs gerufen
|
|
void preempt();
|
|
|
|
// Blocks current thread (move to block_queue)
|
|
void block();
|
|
|
|
// Deblock by tid (move to ready_queue)
|
|
void deblock(unsigned int tid);
|
|
};
|
|
|
|
#endif
|