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

// EPOS-- Thread Abstraction Implementation

// 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.

#include <thread.h>
#include <scheduler_disabler.h>
#include <semaphore.h>

__BEGIN_SYS

// Class attributes
Thread::~Thread() {
        DISABLE_SCHED {
                if (state() != FINISHING) {
                        if (!_waitingThread) Scheduler::getInstance().cacheThreadStack(_stack);
                        releaseSemaphores();
                        Scheduler::getInstance().exit(this, 0);
                }
        }
}


void Thread::releaseSemaphores() {
        db<Thread>(TRC) << "Thread::releaseSemaphores()\n";
  for (CircularVector<Semaphore *>::Iterator it = _semaphores.begin(); it != _semaphores.end(); ++it) {
                db<Thread>(TRC) << "Thread::releaseSemaphores [Semaphore=" << *it << "]\n";
                (*it)->v();
        }
}


void Thread::header(Log_Addr entry, unsigned int stack_size) {
        db<Thread>(TRC) << "Thread(this=" << this
                << ",entry=" << (void *)entry
                << ",state=" << _state
                << ",priority=" << _priority
                << ",stack={b=" << _stack
                << ",s=" << stack_size
                << ",context={b=" << _context
                << "," << *_context << "})\n";
}

void Thread::body() {
        db<Thread>(TRC) << "Inserted thread: " << this << "\n";
        Scheduler::getInstance().addThread(this);
}

int Thread::join() {
        db<Thread>(TRC) << "Thread::join(this=" << this
                << ",state=" << _state << ")\n";

        int value = -1;

        //TODO -- assert(!_waitingThread);
        DISABLE_SCHED {
                bool isFinished = state() == FINISHING;
                if (!isFinished) {
                        _waitingThread = &Scheduler::getInstance().getRunning();
                        Scheduler::getInstance().suspend(&Scheduler::getInstance().getRunning());
                }

                value = (state() == Thread::DESTROYED) ? 0 : *((int *)_stack);

                if (!isFinished) Scheduler::getInstance().cacheThreadStack(this->_stack);
        }

        return value;
}

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

        db<Thread>(WRN) << "There are no runnable threads at the moment!\n";
        db<Thread>(WRN) << "Halting the CPU ...\n";

        CPU::int_enable();
        CPU::halt();
}

__END_SYS

---