ucommon/thread.h

Go to the documentation of this file.

// Copyright (C) 2006-2010 David Sugar, Tycho Softworks.
//
// This file is part of GNU uCommon C++.
//
// GNU uCommon C++ is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published 
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU uCommon C++ is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.

#ifndef _UCOMMON_THREAD_H_
#define _UCOMMON_THREAD_H_

#ifndef _UCOMMON_CONFIG_H_
#include <ucommon/platform.h>
#endif

#ifndef _UCOMMON_ACCESS_H_
#include <ucommon/access.h>
#endif

#ifndef _UCOMMON_TIMERS_H_
#include <ucommon/timers.h>
#endif

#ifndef _UCOMMON_MEMORY_H_
#include <ucommon/memory.h>
#endif

NAMESPACE_UCOMMON

class SharedPointer;

class __EXPORT Conditional 
{
private:
    friend class ConditionalAccess;

#ifdef  _MSWINDOWS_
    enum {SIGNAL = 0, BROADCAST = 1};
    HANDLE events[2];
    unsigned waiting;
    CRITICAL_SECTION mlock;
    CRITICAL_SECTION mutex;
#else
#ifndef __PTH__
    class __LOCAL attribute
    {
    public:
        pthread_condattr_t attr;
        attribute();
    };

    __LOCAL static attribute attr;
#endif

    pthread_cond_t cond;
    pthread_mutex_t mutex;
#endif

protected:
    friend class TimedEvent;

    bool wait(timeout_t timeout);

    bool wait(struct timespec *timeout);

#ifdef  _MSWINDOWS_
    inline void lock(void)
        {EnterCriticalSection(&mutex);};

    inline void unlock(void)
        {LeaveCriticalSection(&mutex);};

    void wait(void);
    void signal(void);
    void broadcast(void);

#else

    inline void lock(void)
        {pthread_mutex_lock(&mutex);};

    inline void unlock(void)
        {pthread_mutex_unlock(&mutex);};

    inline void wait(void)
        {pthread_cond_wait(&cond, &mutex);};

    inline void signal(void)
        {pthread_cond_signal(&cond);};

    inline void broadcast(void)
        {pthread_cond_broadcast(&cond);};
#endif

    Conditional();

    ~Conditional();

public:
#if !defined(_MSWINDOWS_) && !defined(__PTH__)

    static inline pthread_condattr_t *initializer(void)
        {return &attr.attr;};
#endif

    static void gettimeout(timeout_t timeout, struct timespec *hires);
};

class __EXPORT ConditionalAccess : private Conditional
{
private:
#ifndef _MSWINDOWS_
    pthread_cond_t bcast;
#endif

protected:
    unsigned pending, waiting, sharing;

    bool waitSignal(timeout_t timeout);

    bool waitBroadcast(timeout_t timeout);


    bool waitSignal(struct timespec *timeout);

    bool waitBroadcast(struct timespec *timeout);

    inline static void gettimeout(timeout_t timeout, struct timespec *hires)
        {Conditional::gettimeout(timeout, hires);};


#ifdef  _MSWINDOWS_
    inline void lock(void)
        {EnterCriticalSection(&mutex);};

    inline void unlock(void)
        {LeaveCriticalSection(&mutex);};

    void waitSignal(void);
    void waitBroadcast(void);
    
    inline void signal(void)
        {Conditional::signal();};

    inline void broadcast(void)
        {Conditional::broadcast();};

#else

    inline void lock(void)
        {pthread_mutex_lock(&mutex);};

    inline void unlock(void)
        {pthread_mutex_unlock(&mutex);};

    inline void waitSignal(void)
        {pthread_cond_wait(&cond, &mutex);};

    inline void waitBroadcast(void)
        {pthread_cond_wait(&bcast, &mutex);};


    inline void signal(void)
        {pthread_cond_signal(&cond);};

    inline void broadcast(void)
        {pthread_cond_broadcast(&bcast);};
#endif
public:
    ConditionalAccess();

    ~ConditionalAccess();

    void access(void);

    void modify(void);

    void release(void);

    void commit(void);

    void limit_sharing(unsigned max);
};

class __EXPORT TimedEvent : public Timer
{
private:
#ifdef _MSWINDOWS_
    HANDLE event;
#else
    pthread_cond_t cond;
    bool signalled;
#endif
    pthread_mutex_t mutex;

protected:
    void lock(void);

    void release(void);

    bool sync(void);

public:
    TimedEvent(void);

    TimedEvent(timeout_t timeout);

    TimedEvent(time_t timeout);

    ~TimedEvent();

    void signal(void);

    bool wait(timeout_t timeout);

    void reset(void);

    inline static void signal(TimedEvent& timed)
        {timed.signal();};

    inline static void reset(TimedEvent& timed)
        {timed.reset();};

    inline static bool wait(TimedEvent& timed, timeout_t timeout)
        {return timed.wait(timeout);};
};

class __EXPORT rexlock : private Conditional, public Exclusive
{
private:
    unsigned waiting;
    unsigned lockers;
    pthread_t locker;

    __LOCAL void Exlock(void);
    __LOCAL void Unlock(void);

public:
    rexlock();

    void lock(void);

    void release(void);

    unsigned getLocking(void);

    unsigned getWaiting(void);

    inline static void lock(rexlock& rex)
        {rex.lock();};

    inline static void release(rexlock& rex)
        {rex.release();};
};

class __EXPORT rwlock : private ConditionalAccess, public Exclusive, public Shared
{
private:
    unsigned writers;
    pthread_t writeid;

    __LOCAL void Exlock(void);
    __LOCAL void Shlock(void);
    __LOCAL void Unlock(void);

public:
    class __EXPORT gaurd_reader
    {
    private:
        void *object;
    
    public:
        gaurd_reader();

        gaurd_reader(void *object);

        ~gaurd_reader();
        
        void set(void *object);

        void release(void);

        inline void operator=(void *pointer)
            {set(pointer);};
    };

    class __EXPORT gaurd_writer
    {
    private:
        void *object;
    
    public:
        gaurd_writer();

        gaurd_writer(void *object);

        ~gaurd_writer();
        
        void set(void *object);

        void release(void);

        inline void operator=(void *pointer)
            {set(pointer);};
    };

    rwlock();

    bool modify(timeout_t timeout = Timer::inf);

    bool access(timeout_t timeout = Timer::inf);

    static void indexing(unsigned size);

    static bool writer(void *object, timeout_t timeout = Timer::inf);

    static bool reader(void *object, timeout_t timeout = Timer::inf);

    static void release(void *object);

    void release(void);

    unsigned getAccess(void);

    unsigned getModify(void);

    unsigned getWaiting(void);

    inline static bool modify(rwlock& lock, timeout_t timeout = Timer::inf)
        {return lock.modify(timeout);};

    inline static bool access(rwlock& lock, timeout_t timeout = Timer::inf)
        {return lock.access(timeout);};

    inline static void release(rwlock& lock)
        {lock.release();};
};

class __EXPORT ReusableAllocator : protected Conditional
{
protected:
    ReusableObject *freelist;
    unsigned waiting;

    ReusableAllocator();

    inline ReusableObject *next(ReusableObject *object)
        {return object->getNext();};
    
    void release(ReusableObject *object);
};

class __EXPORT ConditionalLock : protected ConditionalAccess, public Shared
{
private:
    class Context : public LinkedObject
    {
    public:
        inline Context(LinkedObject **root) : LinkedObject(root) {};

        pthread_t thread;
        unsigned count;
    };

    LinkedObject *contexts;

    __LOCAL void Shlock(void);
    __LOCAL void Unlock(void);
    __LOCAL void Exclusive(void);
    __LOCAL void Share(void);
    __LOCAL Context *getContext(void);

public:
    ConditionalLock();

    ~ConditionalLock();

    void modify(void);

    void commit(void);

    void access(void);

    void release(void);

    void exclusive(void);

    void share(void);

    unsigned getReaders(void);

    unsigned getWaiters(void);

    inline static void modify(ConditionalLock& lock)
        {lock.modify();};

    inline static void commit(ConditionalLock& lock)
        {lock.commit();};

    inline static void release(ConditionalLock& lock)
        {lock.release();};

    inline static void access(ConditionalLock& lock)
        {lock.access();};

    inline static void exclusive(ConditionalLock& lock)
        {lock.exclusive();};

    inline static void share(ConditionalLock& lock)
        {lock.share();};
};  

class __EXPORT barrier : private Conditional 
{
private:
    unsigned count;
    unsigned waits;

public:
    barrier(unsigned count);

    ~barrier();

    void set(unsigned count);

    void wait(void);

    bool wait(timeout_t timeout);

    inline static void wait(barrier& sync)
        {sync.wait();};

    inline static bool wait(barrier& sync, timeout_t timeout)
        {return sync.wait(timeout);};


    inline static void set(barrier& sync, unsigned count)
        {sync.set(count);};
};

class __EXPORT semaphore : public Shared, private Conditional
{
private:
    unsigned count, waits, used;

    __LOCAL void Shlock(void);
    __LOCAL void Unlock(void);

public:
    semaphore(unsigned count = 0);

    void wait(void);

    bool wait(timeout_t timeout);

    unsigned getCount(void);

    unsigned getUsed(void);

    void set(unsigned count);

    void release(void);

    inline void operator++(void)
        {wait();};

    inline void operator--(void)
        {release();};

    inline static void wait(semaphore& sync)
        {sync.wait();};

    inline static bool wait(semaphore& sync, timeout_t timeout)
        {return sync.wait(timeout);};

    inline static void release(semaphore& sync)
        {sync.release();};
};

class __EXPORT mutex : public Exclusive
{
private:
    pthread_mutex_t mlock;

    __LOCAL void Exlock(void);
    __LOCAL void Unlock(void);
        
public:
    class __EXPORT gaurd 
    {
    private:
        void *object;
    
    public:
        gaurd();

        gaurd(void *object);

        ~gaurd();
        
        void set(void *object);

        void release(void);

        inline void operator=(void *pointer)
            {set(pointer);};
    };


    mutex();

    ~mutex();

    inline void acquire(void)
        {pthread_mutex_lock(&mlock);};

    inline void lock(void)
        {pthread_mutex_lock(&mlock);};

    inline void unlock(void)
        {pthread_mutex_unlock(&mlock);};

    inline void release(void)
        {pthread_mutex_unlock(&mlock);};

    inline static void acquire(mutex& lock)
        {pthread_mutex_lock(&lock.mlock);};

    inline static void lock(mutex& lock)
        {pthread_mutex_lock(&lock.mlock);};

    inline static void unlock(mutex& lock)
        {pthread_mutex_unlock(&lock.mlock);};

    inline static void release(mutex& lock)
        {pthread_mutex_unlock(&lock.mlock);};

    inline static void acquire(pthread_mutex_t *lock)
        {pthread_mutex_lock(lock);};

    inline static void lock(pthread_mutex_t *lock)
        {pthread_mutex_lock(lock);};

    inline static void unlock(pthread_mutex_t *lock)
        {pthread_mutex_unlock(lock);};

    inline static void release(pthread_mutex_t *lock)
        {pthread_mutex_unlock(lock);};

    static void indexing(unsigned size);

    static void protect(void *pointer);

    static void release(void *pointer);
};

class __EXPORT auto_protect
{
private:
    // cannot copy...
    inline auto_protect(const auto_pointer &pointer) {};

protected:
    void *object;
    
    auto_protect();

public:
    auto_protect(void *object);
    
    ~auto_protect();

    void release(void);

    inline bool operator!() const
        {return object == NULL;};

    inline operator bool() const
        {return object != NULL;};

    void operator=(void *object);
};  

class __EXPORT LockedPointer
{
private:
    friend class locked_release;
    pthread_mutex_t mutex;
    Object *pointer;

protected:
    LockedPointer();

    void replace(Object *object);

    Object *dup(void);

    inline void operator=(Object *object)
        {replace(object);};
};

class __EXPORT SharedObject
{
protected:
    friend class SharedPointer;

    virtual void commit(SharedPointer *pointer);

public:
    virtual ~SharedObject();
};

class __EXPORT SharedPointer : protected ConditionalAccess
{
private:
    friend class shared_release;
    SharedObject *pointer;

protected:
    SharedPointer();
    
    ~SharedPointer();

    void replace(SharedObject *object);

    SharedObject *share(void);
};

class __EXPORT Thread
{
protected:
    pthread_t tid;
    size_t stack;
    int priority;

    Thread(size_t stack = 0);

public:
    void setPriority(void);

    static void yield(void);

    static void sleep(timeout_t timeout);

    virtual void run(void) = 0;
    
    virtual ~Thread();

    virtual void exit(void);

    static void init(void);

    static void policy(int polid);

    static void concurrency(int level);

    static bool equal(pthread_t thread1, pthread_t thread2);

#ifdef  __PTH__
    inline static pthread_t self(void)
        {return pth_self();};
#else
    inline static pthread_t self(void)
        {return pthread_self();};
#endif
};

class __EXPORT JoinableThread : protected Thread
{
private:
#ifdef  _MSWINDOWS_
    HANDLE joining;
#else
    volatile bool running;
#endif

protected:
    JoinableThread(size_t size = 0);

    virtual ~JoinableThread();

    void join(void);

public:
#ifdef  _MSWINDOWS_
    inline bool isRunning(void)
        {return (joining != INVALID_HANDLE_VALUE);};
#else

    inline bool isRunning(void)
        {return running;};
#endif

    void start(int priority = 0);

    inline void background(void)
        {start(-1);};
};

class __EXPORT DetachedThread : protected Thread
{
protected:
    DetachedThread(size_t size = 0);

    ~DetachedThread();

    void exit(void);

public:
    void start(int priority = 0);
};
    
class __EXPORT queue : protected OrderedIndex, protected Conditional
{
private:
    mempager *pager;
    LinkedObject *freelist;
    size_t used;

    class __LOCAL member : public OrderedObject
    {
    public:
        member(queue *q, Object *obj);
        Object *object;
    };

    friend class member;

protected:
    size_t limit;

public:
    queue(mempager *pager = NULL, size_t number = 0);

    ~queue();

    bool remove(Object *object);

    bool post(Object *object, timeout_t timeout = 0);

    Object *fifo(timeout_t timeout = 0);

    Object *lifo(timeout_t timeout = 0);

    size_t getCount(void);

    static bool remove(queue& queue, Object *object)
        {return queue.remove(object);};

    static bool post(queue& queue, Object *object, timeout_t timeout = 0)
        {return queue.post(object, timeout);};

    static Object *fifo(queue& queue, timeout_t timeout = 0)
        {return queue.fifo(timeout);};

    static Object *lifo(queue& queue, timeout_t timeout = 0)
        {return queue.lifo(timeout);};

    static size_t count(queue& queue)
        {return queue.getCount();};
};

class __EXPORT stack : protected Conditional
{
private:
    LinkedObject *freelist, *usedlist;
    mempager *pager;
    size_t used;

    class __LOCAL member : public LinkedObject
    {
    public:
        member(stack *s, Object *obj);
        Object *object;
    };

    friend class member;

protected:
    size_t limit;

public:
    stack(mempager *pager = NULL, size_t number = 0);

    ~stack();

    bool remove(Object *object);

    bool push(Object *object, timeout_t timeout = 0);

    Object *pull(timeout_t timeout = 0);

    size_t getCount(void);

    static inline bool remove(stack& stack, Object *object)
        {return stack.remove(object);};

    static inline bool push(stack& stack, Object *object, timeout_t timeout = 0)
        {return stack.push(object, timeout);};

    static inline Object *pull(stack& stack, timeout_t timeout = 0)
        {return stack.pull(timeout);};  

    static inline size_t count(stack& stack)
        {return stack.getCount();};
};

class __EXPORT Buffer : protected Conditional
{
private:
    size_t size, objsize;
    caddr_t buf, head, tail;
    unsigned count, limit;

public:
    Buffer(size_t size, size_t count);

    virtual ~Buffer();

    unsigned getSize(void);

    unsigned getCount(void);

    void *get(timeout_t timeout);

    void *get(void);

    void put(void *data);

    bool put(void *data, timeout_t timeout);

    void release(void);

    void copy(void *data);

    bool copy(void *data, timeout_t timeout);

    operator bool();

    bool operator!();
};

class __EXPORT locked_release
{
protected:
    Object *object; 
    locked_release();

    locked_release(const locked_release &object);

public:
    locked_release(LockedPointer &pointer);

    ~locked_release();

    void release(void);

    locked_release &operator=(LockedPointer &pointer);
};

class __EXPORT shared_release
{
protected:
    SharedPointer *ptr; 
    shared_release();

    shared_release(const shared_release &object);

public:
    shared_release(SharedPointer &pointer);

    ~shared_release();

    void release(void);

    SharedObject *get(void);

    shared_release &operator=(SharedPointer &pointer);
};

template<class T>
class queueof : public queue
{
public:
    inline queueof(mempager *memory, size_t size = 0) : queue(memory, size) {};

    inline bool remove(T *object)
        {return queue::remove(object);};    

    inline bool post(T *object, timeout_t timeout = 0)
        {return queue::post(object);};

    inline T *fifo(timeout_t timeout = 0)
        {return static_cast<T *>(queue::fifo(timeout));};

    inline T *lifo(timeout_t timeout = 0)
        {return static_cast<T *>(queue::lifo(timeout));};
};

template<class T>
class stackof : public stack
{
public:
    inline stackof(mempager *memory, size_t size = 0) : stack(memory, size) {};

    inline bool remove(T *object)
        {return stack::remove(object);};    

    inline bool push(T *object, timeout_t timeout = 0)
        {return stack::push(object);};

    inline T *pull(timeout_t timeout = 0)
        {return static_cast<T *>(stack::pull(timeout));};
};

template<class T>
class bufferof : public Buffer
{
public:
    inline bufferof(unsigned count) :
        Buffer(sizeof(T), count) {};

    inline T *get(void)
        {return static_cast<T*>(get());};

    inline T *get(timeout_t timeout)
        {return static_cast<T*>(get(timeout));};

    inline void put(T *object)
        {put(object);};

    inline bool put(T *object, timeout_t timeout)
        {return put(object, timeout);};

    inline void copy(T *object)
        {copy(object);};

    inline bool get(T *object, timeout_t timeout)
        {return copy(object, timeout);};
};

template<class T>
class shared_pointer : public SharedPointer
{
public:
    inline shared_pointer() : SharedPointer() {};

    inline const T *dup(void)
        {return static_cast<const T*>(SharedPointer::share());};

    inline void replace(T *object)
        {SharedPointer::replace(object);};
    
    inline void operator=(T *object)
        {replace(object);};

    inline T *operator*()
        {return dup();};
};  

template<class T>
class locked_pointer : public LockedPointer
{
public:
    inline locked_pointer() : LockedPointer() {};

    inline T* dup(void)
        {return static_cast<T *>(LockedPointer::dup());};

    inline void replace(T *object)
        {LockedPointer::replace(object);};

    inline void operator=(T *object)
        {replace(object);};

    inline T *operator*()
        {return dup();};
};

template<class T>
class locked_instance : public locked_release
{
public:
    inline locked_instance() : locked_release() {};

    inline locked_instance(locked_pointer<T> &pointer) : locked_release(pointer) {};

    inline T& operator*() const
        {return *(static_cast<T *>(object));};

    inline T* operator->() const
        {return static_cast<T*>(object);};

    inline T* get(void) const
        {return static_cast<T*>(object);};
};

template<class T>
class shared_instance : public shared_release
{
public:
    inline shared_instance() : shared_release() {};

    inline shared_instance(shared_pointer<T> &pointer) : shared_release(pointer) {};

    inline const T& operator*() const
        {return *(static_cast<const T *>(ptr->pointer));};

    inline const T* operator->() const
        {return static_cast<const T*>(ptr->pointer);};

    inline const T* get(void) const
        {return static_cast<const T*>(ptr->pointer);};
};

template <class T>
class mutex_pointer : public auto_protect
{
public:
    inline mutex_pointer() : auto_protect() {};

    inline mutex_pointer(T* object) : auto_protect(object) {};

    inline T& operator*() const
        {return *(static_cast<T*>(auto_protect::object));};

    inline T* operator->() const
        {return static_cast<T*>(auto_protect::object);};

    inline T* get(void) const
        {return static_cast<T*>(auto_protect::object);};
};

inline void start(JoinableThread *thread, int priority = 0)
    {thread->start(priority);}

inline void start(DetachedThread *thread, int priority = 0)
    {thread->start(priority);}

typedef ConditionalLock condlock_t;

typedef ConditionalAccess accesslock_t;

typedef TimedEvent timedevent_t;

typedef mutex mutex_t;

typedef mutex Mutex;

typedef rwlock rwlock_t;

typedef rexlock rexlock_t;

typedef semaphore semaphore_t;

typedef barrier barrier_t;

typedef stack stack_t;

typedef queue fifo_t;

inline void wait(barrier_t &barrier)
    {barrier.wait();}

inline void wait(semaphore_t &semaphore, timeout_t timeout = Timer::inf)
    {semaphore.wait(timeout);}

inline void release(semaphore_t &semaphore)
    {semaphore.release();}

inline void acquire(mutex_t &mutex)
    {mutex.lock();}

inline void release(mutex_t &mutex)
    {mutex.release();}

inline void modify(accesslock_t &lock)
    {lock.modify();}

inline void access(accesslock_t &lock)
    {lock.access();}

inline void release(accesslock_t &lock)
    {lock.release();}

inline void commit(accesslock_t &lock)
    {lock.commit();}

inline void exclusive(condlock_t &lock)
    {lock.exclusive();}

inline void share(condlock_t &lock)
    {lock.share();}

inline void modify(condlock_t &lock)
    {lock.modify();}

inline void commit(condlock_t &lock)
    {lock.commit();}

inline void access(condlock_t &lock)
    {lock.access();}

inline void release(condlock_t &lock)
    {lock.release();}

inline bool exclusive(rwlock_t &lock, timeout_t timeout = Timer::inf)
    {return lock.modify(timeout);}

inline bool share(rwlock_t &lock, timeout_t timeout = Timer::inf)
    {return lock.access(timeout);}

inline void release(rwlock_t &lock)
    {lock.release();}

inline void lock(rexlock_t &lock)
    {lock.lock();}

inline void release(rexlock_t &lock)
    {lock.release();}

inline void push(stack_t &stack, Object *object)
    {stack.push(object);}

inline Object *pull(stack_t &stack, timeout_t timeout = Timer::inf)
    {return stack.pull(timeout);}

inline void remove(stack_t &stack, Object *object)
    {stack.remove(object);}

inline void push(fifo_t &fifo, Object *object)
    {fifo.post(object);}

inline Object *pull(fifo_t &fifo, timeout_t timeout = Timer::inf)
    {return fifo.fifo(timeout);}

inline void remove(fifo_t &fifo, Object *object)
    {fifo.remove(object);}

END_NAMESPACE

#define ENTER_EXCLUSIVE \
    do { static pthread_mutex_t __sync__ = PTHREAD_MUTEX_INITIALIZER; \
        pthread_mutex_lock(&__sync__);

#define LEAVE_EXCLUSIVE \
    pthread_mutex_unlock(&__sync__);} while(0);

#endif

---