threads.hpp

#ifndef _KERNEL_THREADS_H_
#define _KERNEL_THREADS_H_

#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/interprocess/sync/interprocess_semaphore.hpp>
#include <boost/thread/condition_variable.hpp>
#include <boost/lambda/lambda.hpp>

namespace boost {
  typedef interprocess::interprocess_semaphore semaphore;
}

namespace jafar {
namespace kernel {
  
  class FifoMutex: public boost::noncopyable
  {
    private:
      boost::mutex m;
      typedef std::pair<boost::semaphore*,bool> SemWait;
      typedef std::pair<boost::thread::id, SemWait> SemThread;
      typedef std::map<boost::thread::id, SemWait> SemsMap;
      SemsMap allSems;
      typedef std::list<SemsMap::iterator> SemsList;
      SemsList waitingSems;
      boost::optional<SemsMap::iterator> computingSem;
      
      bool lock_(bool try_);
      
    public:
      
      void lock()
      {
        lock_(false);
      }
      bool try_lock()
      {
        return lock_(true);
      }
      
      void unlock();
      
      bool own_lock()
      {
        boost::thread::id id = boost::this_thread::get_id();
        return (computingSem && (*computingSem)->first == id);
      }

      ~FifoMutex()
      {
        for(SemsMap::iterator it = allSems.begin(); it != allSems.end(); ++it)
          delete it->second.first;
      }

  };
  
  int setThreadPriority(boost::thread &t, int prio);
  
  void setCurrentThreadPriority(int prio, bool warn = true);

  void setCurrentThreadScheduler(int policy, int priority, bool warn = true);

  void setProcessScheduler(int policy, int priority, bool warn = true);

  
  template<typename T>
  class VariableMutex
  {
    public:
      T var; 
      
    protected:
      boost::mutex m;
      
    public:
      VariableMutex(const T &val_init): var(val_init) {}
      
      T get() { boost::unique_lock<boost::mutex> l(m); return var; }
      template<typename Assign> void apply(Assign assign) { boost::unique_lock<boost::mutex> l(m); assign(var); }
      void set(const T &val) { apply(boost::lambda::_1 = val); }
      T operator()() { return get(); }
      void operator()(const T &val) { set(val); }
      
      void lock() { m.lock(); }
      bool try_lock() { return m.try_lock(); }
      void unlock() { m.unlock(); }
  };

  template<typename T>
  class VariableCondition: public VariableMutex<T>
  {
    protected:
      boost::condition_variable c;

    public:
      VariableCondition(const T &val_init): VariableMutex<T>(val_init) {}
      
      template<typename Pred>
      void wait(Pred pred, bool unlock = true)
      {
        boost::unique_lock<boost::mutex> l(VariableMutex<T>::m);
        while(!pred(VariableMutex<T>::var)) c.wait(l);
        if (!unlock) l.release();
      }
      template<typename Pred, typename duration_type>
      bool timed_wait(Pred pred, duration_type const & rel_time, bool unlock = true)
      {
        boost::unique_lock<boost::mutex> l(VariableMutex<T>::m);
        while(!pred(VariableMutex<T>::var))
          if(!c.timed_wait(l, rel_time)) return pred(VariableMutex<T>::var);
        return true;
      }
      void notify() { c.notify_all(); }
      template<typename Assign> void applyAndNotify(Assign assign) { 
        VariableMutex<T>::apply(assign); notify(); 
      }
      void setAndNotify(const T &val) { applyAndNotify(boost::lambda::_1 = val); }
  };

}}

#endif