/home/andref/projetos/epos--/include/thread.h

// EPOS-- Thread Abstraction Declarations

// This work is licensed under the Creative Commons
// Attribution-NonCommercial-NoDerivs License. To view a copy of this license,
// visit http://creativecommons.org/licenses/by-nc-nd/2.0/ or send a letter to
// Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.

#ifndef __thread_h
#define __thread_h

#include <system/config.h>
#include <utility/queue.h>
#include <cpu.h>
#include <mmu.h>
#include <scheduler.h>
#include "ep_cvec.h"

__BEGIN_SYS

const unsigned int NULL = 0;

class Thread {
private:
//      typedef Traits<Thread> Traits;
        static const Type_Id TYPE = Type<Thread>::TYPE;

        typedef Queue<Thread> Queue;

        static const unsigned int STACK_SIZE =
                __SYS(Traits)<Machine>::APPLICATION_STACK_SIZE;

        typedef CPU::Log_Addr Log_Addr;
        typedef CPU::Context Context;

public:
        friend class Scheduler;
        typedef short State;

        typedef short Priority;
        enum {
                HIGH = 1,
                NORMAL = 15,
                LOW = 63,
                IDLE = 127
        };

        enum ThreadState {
                RUNNING,
                READY,
                SUSPENDED,
                FINISHING,
                DESTROYED
        };

        enum ThreadType {
                JOINABLE,
                DETACHED
        };

        Thread(int (* entry)(),
                        const State & state = READY,
                        const Priority & priority = NORMAL,
                        unsigned int stack_size = STACK_SIZE)
                : _stack(Scheduler::getInstance().getThreadStack(STACK_SIZE)),
                _context(new (_stack + stack_size
                                        - sizeof(int) - sizeof(Context))
                                Context(entry)),
                _state(state),
                _priority(priority),
                _link(this),
                _waitingThread(NULL)
        {
                header(entry, stack_size);
                Log_Addr sp = _stack + stack_size;
                sp -= sizeof(int); *static_cast<unsigned int *>(sp) =
                        reinterpret_cast<unsigned int>(&exit);
                body();
        }

        template<class T1>
                Thread(int (* entry)(T1 a1), T1 a1,
                                const State & state = READY,
                                const Priority & priority = NORMAL,
                                unsigned int stack_size = STACK_SIZE)
                : _stack(Scheduler::getInstance().getThreadStack(STACK_SIZE)),
                _context(new (_stack + stack_size - sizeof(T1)
                                        - sizeof(int) - sizeof(Context))
                                Context(entry)),
                _state(state),
                _priority(priority),
                _link(this),
                _waitingThread(NULL)
        {
                header(entry, stack_size);
                Log_Addr sp = _stack + stack_size;
                sp -= sizeof(T1); *static_cast<T1 *>(sp) = a1;
                sp -= sizeof(int); *static_cast<unsigned int *>(sp) =
                        reinterpret_cast<unsigned int>(&exit);
                body();
        }

        template<class T1, class T2>
                Thread(int (* entry)(T1 a1, T2 a2), T1 a1, T2 a2,
                                const State & state = READY,
                                const Priority & priority = NORMAL,
                                unsigned int stack_size = STACK_SIZE)
                : _stack(Scheduler::getInstance().getThreadStack(STACK_SIZE)),
                _context(new (_stack + stack_size - sizeof(T2) - sizeof(T1)
                                        - sizeof(int) - sizeof(Context))
                                Context(entry)),
                _state(state),
                _priority(priority),
                _link(this),
                _waitingThread(NULL)
        {
                header(entry, stack_size);
                Log_Addr sp = _stack + stack_size;
                sp -= sizeof(T2); *static_cast<T2 *>(sp) = a2;
                sp -= sizeof(T1); *static_cast<T1 *>(sp) = a1;
                sp -= sizeof(int); *static_cast<unsigned int *>(sp) =
                        reinterpret_cast<unsigned int>(&exit);
                body();
        }

        template<class T1, class T2, class T3>
                Thread(int (* entry)(T1 a1, T2 a2, T3 a3), T1 a1, T2 a2, T3 a3,
                                const State & state = READY,
                                const Priority & priority = NORMAL,
                                unsigned int stack_size = STACK_SIZE)
                : _stack(Scheduler::getInstance().getThreadStack(STACK_SIZE)),
                _context(new (_stack + stack_size - sizeof(T3) - sizeof(T2)
                                        - sizeof(T1) - sizeof(int) - sizeof(Context))
                                Context(entry)),
                _state(state),
                _priority(priority),
                _link(this),
                _waitingThread(NULL)
        {
                header(entry, stack_size);
                Log_Addr sp = _stack + stack_size;
                sp -= sizeof(T3); *static_cast<T3 *>(sp) = a3;
                sp -= sizeof(T2); *static_cast<T2 *>(sp) = a2;
                sp -= sizeof(T1); *static_cast<T1 *>(sp) = a1;
                sp -= sizeof(int); *static_cast<unsigned int *>(sp) =
                        reinterpret_cast<unsigned int>(&implicit_exit);
                body();
        }

        ~Thread();

        volatile const State & state() const { return _state; }
        volatile const Priority & priority() const { return _priority; }
        void priority(const Priority & priority);

        int join();

        //This could result in serious thrashing
        inline void pass() {
                Scheduler::getInstance().pass(this);
        }

        inline void suspend() {
                Scheduler::getInstance().suspend(this);
        }

        inline void resume() {
                Scheduler::getInstance().resume(this);
        }

        inline static void yield() {
                Scheduler::getInstance().yield();
        }

        static void exit(int status = 0) {
                Scheduler::getInstance().exit(status);
        }

        inline static Thread* volatile running() { return &Scheduler::getInstance().getRunning(); }

        inline void addSemaphore(Semaphore *semaphore) { _semaphores.pushBack(semaphore); }

        inline void removeSemaphore(Semaphore *semaphore) { _semaphores.remove(semaphore); }

        static int init(System_Info * si);

        static void idle();
private:
        void header(Log_Addr entry, unsigned int stack_size);
        void body();
        void releaseSemaphores();
        static void implicit_exit() { exit(CPU::fr()); }

        Log_Addr _stack;
        Context * volatile _context;
        volatile State _state;
        volatile Priority _priority;
        Queue::Element _link;

        CircularVector<Semaphore *> _semaphores;
        Thread* _waitingThread;

};

__END_SYS

#endif

---