thread.hpp

Go to the documentation of this file.

/*
 * Copyright (C) Sergey P. Derevyago, 2008-2009.
 *
 * Permission to copy, use, modify, sell and distribute this software is granted
 * provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied warranty, and
 * with no claim as to its suitability for any purpose.
 *
 */

#ifndef __DERS__THREAD_HPP__
#define __DERS__THREAD_HPP__

#include <ders/config.hpp>
#include <ders/sh_ptr.hpp>

namespace ders {  // ::ders

class thread : virtual public destroyable {
 public:
      virtual bool is_running()=0;
      virtual void join()=0;
};

typedef sh_ptr<thread> sh_thread;

sh_thread new_thread(mem_pool& mp, void (*start)(void*), void* arg);

class mutex : virtual public destroyable {
 public:
      virtual void lock()=0;
      virtual void unlock()=0;
};

typedef sh_ptr<mutex> sh_mutex;

sh_mutex new_mutex(mem_pool& mp);

sh_mutex new_long_mutex(mem_pool& mp);

class auto_mutex {
      mutex& mtx;

      auto_mutex(const auto_mutex&);
      auto_mutex& operator=(const auto_mutex&);

 public:
      auto_mutex(mutex& m) : mtx(m) { mtx.lock(); }
      ~auto_mutex() { mtx.unlock(); }
};

class cond_var : virtual public destroyable {
 public:
      static const long infinite=-1;

      void wait() { wait(infinite); }
      virtual void wait(long timeout)=0;
      virtual void notify()=0;
      virtual void notify_all()=0;
};

typedef sh_ptr<cond_var> sh_cond_var;

sh_cond_var new_cond_var(mem_pool& mp, mutex& mtx);

class barrier;

class barrier_listener : virtual public destroyable {
 public:
      enum action { release_one_false, release_all_false, release_all_true };

      virtual action on_release(barrier& bar)=0;
};

class barrier {
      sh_mutex mtx;
      sh_cond_var cv1, cv2;
      int maxCnt, wtCnt, relCnt;
      bool ret;
      barrier_listener* blnr;

 public:
      barrier(mem_pool& mp, int cnt);
      ~barrier();

      int inc_count();
      int dec_count();
      int get_count();

      bool wait();
      void release_one();
      void release_all();

      barrier_listener* set_listener(barrier_listener* bl);
};

typedef sh_ptr<barrier> sh_barrier;

sh_barrier new_barrier(mem_pool& mp, int cnt);

namespace detail {  // ::ders::detail

struct thr_core {
       void (*strt)(void*);
       void* arg;

       mem_pool ownmp;
       sh_mutex mtx;
       sh_cond_var cv;
       int refs;
       bool rng;

       thr_core(void (*st)(void*), void* ar);

       void inc_refs();
       void dec_refs(bool parent);
       void clear_rng();
       void start();

       bool is_running();
       void join();
};

struct tc_ptr {
       bool parent;
       thr_core* ptr;

       tc_ptr(bool pr, thr_core* pt) : parent(pr), ptr(pt) { ptr->inc_refs(); }
       ~tc_ptr() { ptr->dec_refs(parent); }

       thr_core* operator->() { return ptr; }
};

}  // namespace ::ders::detail

}  // namespace ::ders

#endif  // __DERS__THREAD_HPP__

---