int uthread_get_tid()
{
blockTimer();
int tid = (*gRunning).getID();
resumeTimer();
return tid;
}
int uthread_get_quantums(int tid)
{
blockTimer();
if(gThreads.count(tid) == 0)
{
std::cerr << GET_QUANTUMS_ERR << std::endl;
resumeTimer();
return FAILURE;
}
resumeTimer();
return gThreads[tid]->getQuantums();
}
int gtthread_mutex_init(gtthread_mutex_t *mutex){
blockTimer();
if(mutex->mutex_lock == 1){
return -1;
}
mutex->mutex_lock = 0;
mutex->mutex_owner = current_context->thread_id;
unblockTimer();
return 0;
}
int gtthread_mutex_lock(gtthread_mutex_t *mutex){
blockTimer();
// Possibly reentrant lock
if(mutex->mutex_owner == current_context->thread_id && mutex->mutex_lock==1){
unblockTimer();
return 0;
}
// Wait till the lock is free
while(mutex->mutex_lock == 1 && mutex->mutex_owner != current_context->thread_id){
unblockTimer();
gtthread_yield();
blockTimer();
};
mutex->mutex_lock = 1;
mutex->mutex_owner = current_context->thread_id;
unblockTimer();
return 0;
}
int gtthread_mutex_unlock(gtthread_mutex_t *mutex){
blockTimer();
if(mutex->mutex_owner != current_context->thread_id){
unblockTimer();
return -1;
}
// if(mutex->mutex_owner == )
mutex->mutex_lock = 0;
mutex->mutex_owner = -1;
unblockTimer();
return 0;
}
int uthread_spawn(void (*f)(void), Priority pr)
{
blockTimer();
int tid = gAvailableID.top();
if (tid < MAX_THREAD_NUM)
{
Thread *newThread = new Thread(tid, f, pr);
gThreads[tid] = newThread;
gAvailableID.pop();
gReady.push(newThread);
resumeTimer();
return tid;
}
std::cerr<< SPAWN_ERR << std::endl;
resumeTimer();
return FAILURE;
}
int uthread_suspend(int tid)
{
blockTimer();
if(tid == 0)
{
std::cerr<< BLOCK_ERR_MAIN <<std::endl;
resumeTimer();
return FAILURE;
}
if(gThreads.count(tid) == 0)
{
std::cerr << BLOCK_ERR << " Thread does not exist." << std::endl;
resumeTimer();
return FAILURE;
}
Thread* tmp = gThreads[tid];
if(tmp->getState() == BLOCKED )
{
// no effect
resumeTimer();
return SUCCESS;
}
if(tmp->getState() == RUNNING )
{
// make scheduling decision (move to next thread)
switchThreads(BLOCKED);
resumeTimer();
return SUCCESS;
}
if(tmp->getState() == READY )
{
// move to gBlocked + update state in thread
gReady.remove(tid);
gBlocked[tid] = tmp;
tmp->setState(BLOCKED);
resumeTimer();
return SUCCESS;
}
std::cerr << BLOCK_ERR << std::endl;
resumeTimer();
return FAILURE;
}
int uthread_resume(int tid)
{
blockTimer();
if(gThreads.count(tid) == 0)
// thread does not exist -- error
{
std::cerr << RESUME_ERR << std::endl;
resumeTimer();
return FAILURE;
}
Thread* tmp = gThreads[tid];
if (tmp->getState() == READY || tmp->getState() == RUNNING ) //no effect
{
resumeTimer();
return SUCCESS;
}
// otherwise the thread should be in gBlocked (assuming no bugs...)
gBlocked.erase(tid);
gReady.push(tmp);
tmp->setState(READY);
resumeTimer();
return SUCCESS;
}
int gtthread_mutex_destroy(gtthread_mutex_t *mutex){
blockTimer();
mutex->mutex_owner=-1;
mutex->mutex_lock = 0;
return 0;
}
int uthread_terminate(int tid)
{
blockTimer();
if(tid == 0)//if true: exits program
{
// terminate all threads:
std::map<int, Thread*>::iterator threadIt;
for (threadIt = gThreads.begin(); threadIt != gThreads.end(); ++threadIt)
{
Thread* tmp;
switch(threadIt->second->getState() )
{
case(READY) :
gReady.remove(threadIt->second->getID() );
tmp = gThreads[threadIt->second->getID() ];
gThreads.erase(threadIt);
delete tmp;
break;
case(RUNNING) :
gThreads.erase(threadIt);
// gRunning = NULL;
break;
case(BLOCKED) :
gBlocked.erase(threadIt->second->getID() );
tmp = gThreads[threadIt->second->getID() ];
gThreads.erase(threadIt);
delete tmp;
break;
default :
break;
}
}
delete gRunning;
gRunning = NULL;
resumeTimer();
exit(0);
}
if(gThreads.count(tid) == 0) //if true: thread doesn't exist
{
std::cerr<< TERMINATE_ERR << std::endl;
resumeTimer();
return FAILURE;
}
if(gThreads[tid]->getState() == RUNNING)//if true: deletes thread + jumps to next thread
{
switchThreads(TERMINATED);
}
// if in ready or blocked: remove from lists (gReady/gBlocked + gThreads), and delete thread
Thread* tmp = gThreads[tid];
if (tmp->getState() == READY )
{
gReady.remove(tid);
}
if (tmp->getState() == BLOCKED)
{
gBlocked.erase(tid);
}
gThreads.erase(tid);
gAvailableID.push(tid);
delete tmp;
resumeTimer();
return SUCCESS;
}
