/home/andref/projetos/epos--/src/abstraction/scheduler.cc

#include "scheduler.h"
#include "thread.h"
#include "system/config.h"
#include "utility/queue.h"
#include "utility/malloc.h"
#include "cpu.h"
#include "mmu.h"
#include "alarm.h"
#include "system/kmalloc.h"
#include "scheduler_disabler.h"

__BEGIN_SYS

#define DEBUG_CONTEXT(__old) do { db<Thread>(INF) << "old={" << (__old) << "," \
                << *(__old)->_context << "}\n";\
                db<Thread>(INF) << "new={" << _running << "," \
                << *_running->_context << "}\n"; } while(0)


Scheduler Scheduler::_instance;

struct ThreadComparator {
        inline ThreadComparator() {}

        inline int operator()(const Thread* t1, const Thread* t2) const {
                int comparison = 0;
                comparison -= (t1->priority() < t2 ->priority());
                comparison += (t1->priority() > t2 ->priority());

                return comparison;
        }
};

inline void Scheduler::insertOnReady(Thread* thread) {
        thread->_state = Thread::READY;


        _readyP->pushBack(thread, ThreadComparator());
        db<Thread>(TRC) << "inserted thread address: " << thread << "\n";
        //_ready.insert(&thread->_link);
}

static int dummyhalt() {
        while (true) Thread::idle();
        return 0;
}

int Scheduler::init(System_Info * si) {
    db<Init>(TRC) << "Thread::init(entry="
                  << (void *)si->lmm.app_entry << ")\n";

        Scheduler::getInstance()._readyP = new ThreadCircVec();
    if(Traits<Thread>::active_scheduler)
                Alarm::master(Traits<Thread>::quantum, &Scheduler::schedule);

    Scheduler::getInstance()._main = new(malloc(sizeof(Thread)))
                Thread(reinterpret_cast<int (*)()>(si->lmm.app_entry), Thread::RUNNING);
    Scheduler::getInstance()._running = Scheduler::getInstance()._main;

        db<Thread>(TRC) << "IdleThread creation\n";
        new Thread(dummyhalt, Thread::READY, Thread::IDLE);
        
        db<Thread>(TRC) << "AlarmThread creation\n";
        new Thread(&Alarm::alarmLoop);
        
        db<Thread>(TRC) << "IdleThread created\n";
    Scheduler::getInstance()._running->_context->load();

    return 0;//never get here actually, but avoids dummy warnings
}

void Scheduler::pass(Thread* thread) {
        db<Thread>(TRC) << "Thread::pass(this=" << thread << ")\n";

        DISABLE_SCHED {
                Thread * old = &getRunning();
                insertOnReady(old);

                thread->_state = Thread::RUNNING;
                _running = thread;

                DEBUG_CONTEXT(old);

                if (old != _running)
                        CPU::switch_context(&old->_context, thread->_context);
        }
}

void Scheduler::cacheThreadStack(CPU::Log_Addr stack) {
        db<Thread>(TRC) << "Thread::cachedThreadStack " << stack << "\n";
        DISABLE_SCHED {
                _stackCache.cache(stack);
        }
        db<Thread>(TRC) << "cache size " << _stackCache.size() << "\n";

}

CPU::Log_Addr Scheduler::getThreadStack(unsigned int size) {
        CPU::Log_Addr result;

        db<Thread>(TRC) << "Thread::getThreadStack() ThreadStack size " << _stackCache.size() << "\n";
        DISABLE_SCHED {
                result = (_stackCache.size()) ? _stackCache.uncache() : CPU::Log_Addr(malloc(size));
        }

        return result;
}

inline Thread* Scheduler::getNext() {
        Thread* result = NULL;

        if (!_readyP->isEmpty()) {
                result = _readyP->front();
                _readyP->popFront();
        }

        db<Thread>(TRC) << "result: " << result << "\n";

        return result;
}

void Scheduler::yield() {
        db<Thread>(TRC) << "Thread::yield()\n";

        DISABLE_SCHED {
                Thread* old = _running;
                Thread* next = getNext();

                if (next == NULL) return;

                insertOnReady(old);

                _running = next;
                _running->_state = Thread::RUNNING;

                db<Thread>(TRC) << "Threads priority [" << old->priority() << ", " << _running->priority() << "]\n";

                DEBUG_CONTEXT(old);

                CPU::switch_context(&old->_context, _running->_context);
        }
}

void Scheduler::resume(Thread* thread) {
        db<Thread>(TRC) << "Thread::resume(this=" << thread << ")\n";

        DISABLE_SCHED {
                if (thread->_state == Thread::SUSPENDED) {
                        _suspended.remove(thread);
                        insertOnReady(thread);
                }
        }
}

void Scheduler::addThread(Thread* thread) {
        DISABLE_SCHED {
                switch(thread->state()) {
                        case Thread::RUNNING:
                                break;
                        case Thread::SUSPENDED:
                                _suspended.insert(&thread->_link);
                                break;
                        default:
                                insertOnReady(thread);
                }
        }
}

void Scheduler::exit(int status) {
        db<Thread>(TRC) << "Thread::exit(status=" << status << ")\n";
        if (_running == Scheduler::getInstance()._main) {
                DISABLE_SCHED {
                        kout << "EPOS shutting down..." << "\n";
                        CPU::shutdown();
                }
        }

        // wakeup the threads waiting this thread finish
        if(_running->_waitingThread) _running->_waitingThread->resume();
        _running->_state = Thread::FINISHING;
        _suspended.remove(_running);


        DISABLE_SCHED {
                Thread* old = _running;
                Thread* next = getNext();

                if (next == NULL || (next->priority() > _running->priority())) return;

                _running = next;
                _running->_state = Thread::RUNNING;

                db<Thread>(TRC) << "Threads priority [" << old->priority() << ", " << _running->priority() << "]\n";

                DEBUG_CONTEXT(old);

                CPU::switch_context(&old->_context, _running->_context);
        }
}

void Scheduler::exit(Thread* thread, int status) {
        DISABLE_SCHED {
                if (thread == &getRunning()) {
                        exit(status);
                }
                else {
                        thread->_state = Thread::FINISHING;
                        _suspended.remove(thread);
                        _readyP->remove(thread);
                        if (thread->_waitingThread) thread->_waitingThread->resume();
                }
        }
}

void Scheduler::suspend(Thread* thread) {
        db<Thread>(TRC) << "Thread::suspend(this=" << thread << ")\n";

        DISABLE_SCHED {
                if (_running != thread)
                        _readyP->remove(thread);
                thread->_state = Thread::SUSPENDED;
                _suspended.insert(&thread->_link);

                if (thread == _running) {
                        DISABLE_SCHED {
                                Thread* old = _running;
                                Thread* next = getNext();

                                if (next == NULL) return;

                                _running = next;
                                _running->_state = Thread::RUNNING;

                                db<Thread>(TRC) << "Threads priority [" << old->priority() << ", " << _running->priority() << "]\n";

                                DEBUG_CONTEXT(old);

                                CPU::switch_context(&old->_context, _running->_context);
                        }
                }
        }
}



__END_SYS

---