mtasker.cc

#include "mtasker.hh"
#include <stdio.h>
#include <iostream>



template<class EventKey, class EventVal>int MTasker<EventKey,EventVal>::waitEvent(const EventKey &key, EventVal *val, unsigned int timeout)
{
  Waiter w;
  w.context=new ucontext_t;
  w.ttd= timeout ? time(0)+timeout : 0;
  w.tid=d_tid;
  
  d_waiters[key]=w;
  
  swapcontext(d_waiters[key].context,&d_kernel); // 'A' will return here when 'key' has arrived, hands over control to kernel first
  if(val && d_waitstatus==Answer) 
    *val=d_waitval;
  d_tid=w.tid;
  return d_waitstatus;
}


template<class Key, class Val>void MTasker<Key,Val>::yield()
{
  d_runQueue.push(d_tid);
  swapcontext(d_threads[d_tid],&d_kernel); // give control to the kernel
}


template<class EventKey, class EventVal>int MTasker<EventKey,EventVal>::sendEvent(const EventKey& key, const EventVal* val)
{
  if(!d_waiters.count(key)) {
    return 0;
  }
  
  d_waitstatus=Answer;
  if(val)
    d_waitval=*val;
  
  ucontext_t *userspace=d_waiters[key].context;
  d_tid=d_waiters[key].tid;         // set tid 
  
  d_waiters.erase(key);             // removes the waitpoint 
  swapcontext(&d_kernel,userspace); // swaps back to the above point 'A'
  
  delete userspace;
  return 1;
}


template<class Key, class Val>void MTasker<Key,Val>::makeThread(tfunc_t *start, void* val)
{
  ucontext_t *uc=new ucontext_t;
  getcontext(uc);
  
  uc->uc_link = &d_kernel; // come back to kernel after dying
  uc->uc_stack.ss_sp = new char[d_stacksize];
  
  uc->uc_stack.ss_size = d_stacksize;
#ifdef SOLARIS
  makecontext (uc, (void (*)(...))threadWrapper, 4, this, start, d_maxtid, val);
#else
  makecontext (uc, (void (*)(void))threadWrapper, 4, this, start, d_maxtid, val);
#endif
  d_threads[d_maxtid]=uc;
  d_runQueue.push(d_maxtid++); // will run at next schedule invocation
}



template<class Key, class Val>bool MTasker<Key,Val>::schedule()
{

  if(!d_runQueue.empty()) {
    d_tid=d_runQueue.front();
    swapcontext(&d_kernel, d_threads[d_tid]);
    d_runQueue.pop();
    return true;
  }
  if(!d_zombiesQueue.empty()) {
    delete[] (char *)d_threads[d_zombiesQueue.front()]->uc_stack.ss_sp;
    delete d_threads[d_zombiesQueue.front()];
    d_threads.erase(d_zombiesQueue.front());
    d_zombiesQueue.pop();
    return true;
  }
  if(!d_waiters.empty()) {
    time_t now=time(0);
    for(typename waiters_t::const_iterator i=d_waiters.begin();i!=d_waiters.end();++i) {
      if(i->second.ttd && i->second.ttd<now) {
        d_waitstatus=TimeOut;
        swapcontext(&d_kernel,i->second.context); // swaps back to the above point 'A'
        delete i->second.context;              
        d_waiters.erase(i->first);                  // removes the waitpoint 
      }
    }
  }
  return false;
}


template<class Key, class Val>bool MTasker<Key,Val>::noProcesses()
{
  return d_threads.empty();
}


template<class Key, class Val>unsigned int MTasker<Key,Val>::numProcesses()
{
  return d_threads.size();
}



template<class Key, class Val>void MTasker<Key,Val>::getEvents(std::vector<Key>& events)
{
  events.clear();
  for(typename waiters_t::const_iterator i=d_waiters.begin();i!=d_waiters.end();++i) {
    events.push_back(i->first);
  }
}


template<class Key, class Val>void MTasker<Key,Val>::threadWrapper(MTasker *self, tfunc_t *tf, int tid, void* val)
{
  (*tf)(val);
  self->d_zombiesQueue.push(tid);
  
  // we now jump to &kernel, automatically
}


template<class Key, class Val>int MTasker<Key,Val>::getTid()
{
  return d_tid;
}

---