thread_pthreads.h

/*
 *  Copyright (c) 2002-2004    National Research Council
 *
 *  All rights reserved.
 *
 *  This material is confidential and proprietary information of
 *  National Research Council Canada ("Confidential Information").
 *  This Confidential Information may only be used and reproduced
 *  in accordance with the terms of the license agreement.
 *
 */

#ifndef __INCLUDED_SCOPIRA_TOOL_THREAD_PTHREADS_H__
#define __INCLUDED_SCOPIRA_TOOL_THREAD_PTHREADS_H__

#include <scopira/tool/platform.h>
#include <scopira/tool/export.h>

#include <pthread.h>
#include <errno.h>

#include <scopira/tool/object.h>

namespace scopira
{
  namespace tool
  {
    class runnable_i;
    class job_i;

    typedef void* (*runfunc_t)(void*);
    class thread;

    class condition;

    class rwlock;
    class read_locker;
    class write_locker;

    SCOPIRA_EXPORT int num_system_cpus(void);

    template <class T> class shared_area;
    template <class T> class event_area;
    template <class T> class rw_area;

    template <class T> class area_ptr;
    template <class T> class const_area_ptr;
    template <class T> class locker_ptr;
    template <class T> class event_ptr;
    template <class T> class read_locker_ptr;
    template <class T> class write_locker_ptr;
  }
}

class scopira::tool::runnable_i
{
  public:
    SCOPIRA_EXPORT virtual void run(void) = 0;

  protected:
    virtual ~runnable_i() { }
};

class scopira::tool::job_i : public virtual scopira::tool::object
{
  public:
    SCOPIRA_EXPORT virtual void start(void) = 0;

    SCOPIRA_EXPORT virtual void notify_stop(void) = 0;

    SCOPIRA_EXPORT virtual void wait_stop(void) = 0;

    SCOPIRA_EXPORT virtual bool is_running(void) const = 0;
};

class scopira::tool::thread : public virtual scopira::tool::job_i,
  public virtual scopira::tool::runnable_i
{
  public:
    typedef pthread_key_t tlskey_t;

  protected:
    runnable_i *dm_target;
    runfunc_t dm_runfunc;
    void *dm_runfunc_arg;
    volatile bool dm_running;

    pthread_t dm_thread;

  public:
    SCOPIRA_EXPORT thread(runnable_i* target);
    SCOPIRA_EXPORT thread(runfunc_t func, void *arg);

    SCOPIRA_EXPORT virtual ~thread();

    SCOPIRA_EXPORT virtual void run(void);

    SCOPIRA_EXPORT virtual void start(void);
    SCOPIRA_EXPORT virtual void notify_stop(void);
    SCOPIRA_EXPORT virtual void wait_stop(void);
    SCOPIRA_EXPORT virtual bool is_running(void) const { return dm_running; }

    SCOPIRA_EXPORT static void sleep(int msec);

    SCOPIRA_EXPORT static void open_tls(tlskey_t &outkey);
    SCOPIRA_EXPORT static void close_tls(tlskey_t k);

    SCOPIRA_EXPORT static void set_tls(tlskey_t k, const void *val);
    SCOPIRA_EXPORT static void * get_tls(tlskey_t k);

  protected:
    SCOPIRA_EXPORT static void * voidrun(void *arg);
};

class scopira::tool::condition
{
  protected:
    pthread_cond_t dm_con;

  public:
    SCOPIRA_EXPORT condition(void);
    SCOPIRA_EXPORT ~condition();

    SCOPIRA_EXPORT void notify(void);
    SCOPIRA_EXPORT void notify_all(void);
    SCOPIRA_EXPORT void wait(mutex &mut);
    SCOPIRA_EXPORT bool wait(mutex &mut, int msec);
};

class scopira::tool::rwlock
{
  private:
    pthread_rwlock_t dm_rw;

  public:
    SCOPIRA_EXPORT rwlock(void);
    SCOPIRA_EXPORT ~rwlock();

    SCOPIRA_EXPORT void write_lock(void);
    SCOPIRA_EXPORT bool try_write_lock(void);
    SCOPIRA_EXPORT void read_lock(void);
    SCOPIRA_EXPORT bool try_read_lock(void);
    SCOPIRA_EXPORT void unlock(void);
};

class scopira::tool::read_locker
{
  private:
    scopira::tool::rwlock &dm_rw;
  public:
    read_locker(rwlock &rw) : dm_rw(rw) { dm_rw.read_lock(); }
    ~read_locker() { dm_rw.unlock(); }
};

class scopira::tool::write_locker
{
  private:
    scopira::tool::rwlock &dm_rw;

  public:
    write_locker(rwlock &rw) : dm_rw(rw) { dm_rw.write_lock(); }
    ~write_locker() { dm_rw.unlock(); }
};

template <class T> class scopira::tool::shared_area
{
  public:
    volatile T pm_data; 
    mutable scopira::tool::mutex      pm_mutex;
};

template <class T> class scopira::tool::event_area : public scopira::tool::shared_area<T>
{
  public:
    mutable scopira::tool::condition  pm_condition;
};

template <class T> class scopira::tool::rw_area
{
  public:
    volatile T pm_data; 
    mutable scopira::tool::rwlock      pm_rwlock;
};

template <class T> class scopira::tool::area_ptr
{
  protected:
    T* dm_ptr;

  public:
    area_ptr(const shared_area<T>& ref) : dm_ptr(const_cast<T*>(&ref.pm_data)) { }
    area_ptr(const rw_area<T>& ref) : dm_ptr(const_cast<T*>(&ref.pm_data)) { }

  protected:
    area_ptr(const volatile T& ref) : dm_ptr(const_cast<T*>(&ref)) { }

  public:
    T* get(void) { return dm_ptr; }
    T& operator*(void) { return *dm_ptr; }
    T* operator->(void) { return dm_ptr; }

    void reset(void) { dm_ptr = const_cast<T*>(const_cast<volatile T*>(dm_ptr)); }  // this is whacky :)
};

template <class T> class scopira::tool::const_area_ptr
{
  protected:
    const T* dm_ptr;

  public:
    const_area_ptr(const shared_area<T>& ref) : dm_ptr(const_cast<const T*>(&ref.pm_data)) { }
    const_area_ptr(const rw_area<T>& ref) : dm_ptr(const_cast<const T*>(&ref.pm_data)) { }

  protected:
    const_area_ptr(const volatile T& ref) : dm_ptr(const_cast<T*>(&ref)) { }

  public:
    const T* get(void) { return dm_ptr; }
    const T& operator*(void) { return *dm_ptr; }
    const T* operator->(void) { return dm_ptr; }

    void reset(void) { dm_ptr = const_cast<const T*>(const_cast<volatile T*>(dm_ptr)); }  // this is whacky :)
};

template <class T> class scopira::tool::locker_ptr : public scopira::tool::area_ptr<T>
{
  protected:
    scopira::tool::mutex & dm_mut;

  public:
    locker_ptr(const shared_area<T>& ref) : area_ptr<T>(ref.pm_data), dm_mut(ref.pm_mutex) { dm_mut.lock(); }

    ~locker_ptr() { dm_mut.unlock(); }
  private:
};

template <class T> class scopira::tool::event_ptr : public scopira::tool::locker_ptr<T>
{
  protected:
    scopira::tool::condition & dm_cond;

  public:
    event_ptr(const event_area<T>& ref) : locker_ptr<T>(ref), dm_cond(ref.pm_condition) { }

    void notify(void) { dm_cond.notify(); }
    void notify_all(void) { dm_cond.notify_all(); }
    void wait(void) { dm_cond.wait(locker_ptr<T>::dm_mut); }
    bool wait(int msec) { return dm_cond.wait(locker_ptr<T>::dm_mut, msec); }
};

template <class T> class scopira::tool::read_locker_ptr : public scopira::tool::const_area_ptr<T>
{
  protected:
    scopira::tool::rwlock & dm_rw;

  public:
    read_locker_ptr(const rw_area<T>& ref) : const_area_ptr<T>(ref.pm_data), dm_rw(ref.pm_rwlock) { dm_rw.read_lock(); }

    ~read_locker_ptr() { dm_rw.unlock(); }
};

template <class T> class scopira::tool::write_locker_ptr : public scopira::tool::area_ptr<T>
{
  protected:
    scopira::tool::rwlock & dm_rw;

  public:
    write_locker_ptr(const rw_area<T>& ref) : area_ptr<T>(ref.pm_data), dm_rw(ref.pm_rwlock) { dm_rw.write_lock(); }

    ~write_locker_ptr() { dm_rw.unlock(); }
};

#endif