ucommon/thread.h

Go to the documentation of this file.

// Copyright (C) 2006-2014 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_CPR_H_
#include <ucommon/cpr.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;

#if defined(_MSCONDITIONAL_)
    CRITICAL_SECTION mutex;
    CONDITION_VARIABLE cond;
#elif defined(_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 set(struct timespec *hires, timeout_t timeout);
};

class __EXPORT ConditionalAccess : private Conditional
{
protected:
#if defined _MSCONDITIONAL_
    CONDITION_VARIABLE bcast;
#elif !defined(_MSWINDOWS_)
    pthread_cond_t bcast;
#endif

    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 set(struct timespec *hires, timeout_t timeout)
        {Conditional::set(hires, timeout);};


#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 wait(void);

    void reset(void);
};

class __EXPORT RecursiveMutex : private Conditional, public ExclusiveAccess
{
protected:
    unsigned waiting;
    unsigned lockers;
    pthread_t locker;

    virtual void _lock(void);
    virtual void _unlock(void);

public:
    RecursiveMutex();

    void lock(void);

    bool lock(timeout_t timeout);

    void release(void);
};

class __EXPORT ThreadLock : private ConditionalAccess, public ExclusiveAccess, public SharedAccess
{
protected:
    unsigned writers;
    pthread_t writeid;

    virtual void _lock(void);
    virtual void _share(void);
    virtual void _unlock(void);

public:
    class __EXPORT guard_reader
    {
    private:
        const void *object;

    public:
        guard_reader();

        guard_reader(const void *object);

        ~guard_reader();

        void set(const void *object);

        void release(void);

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

    class __EXPORT guard_writer
    {
    private:
        const void *object;

    public:
        guard_writer();

        guard_writer(const void *object);

        ~guard_writer();

        void set(const void *object);

        void release(void);

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

    ThreadLock();

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

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

    static void indexing(unsigned size);

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

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

    static void release(const void *object);

    void release(void);
};

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 SharedAccess
{
protected:
    class Context : public LinkedObject
    {
    public:
        inline Context(LinkedObject **root) : LinkedObject(root) {};

        pthread_t thread;
        unsigned count;
    };

    LinkedObject *contexts;

    virtual void _share(void);
    virtual void _unlock(void);

    Context *getContext(void);

public:
    ConditionalLock();

    ~ConditionalLock();

    void modify(void);

    void commit(void);

    void access(void);

    void release(void);

    virtual void exclusive(void);

    virtual void share(void);
};

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

public:
    barrier(unsigned count);

    ~barrier();

    void set(unsigned count);

    void inc(void);

    void dec(void);

    unsigned operator++(void);

    unsigned operator--(void);

    void wait(void);

    bool wait(timeout_t timeout);
};

class __EXPORT Semaphore : public SharedAccess, protected Conditional
{
protected:
    unsigned count, waits, used;

    virtual void _share(void);
    virtual void _unlock(void);

public:
    Semaphore(unsigned count = 0);

    Semaphore(unsigned count, unsigned avail);

    void wait(void);

    bool wait(timeout_t timeout);

    void set(unsigned count);

    void release(void);

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

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

class __EXPORT Mutex : public ExclusiveAccess
{
protected:
    pthread_mutex_t mlock;

    virtual void _lock(void);
    virtual void _unlock(void);

public:
    class __EXPORT guard
    {
    private:
        const void *object;

    public:
        guard();

        guard(const void *object);

        ~guard();

        void set(const 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(pthread_mutex_t *lock)
        {pthread_mutex_lock(lock);};

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

    static void indexing(unsigned size);

    static void protect(const void *pointer);

    static void release(const void *pointer);
};

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

protected:
    const void *object;

    auto_protect();

public:
    auto_protect(const void *object);

    ~auto_protect();

    void release(void);

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

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

    void operator=(const void *object);
};

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

protected:
    LockedPointer();

    void replace(ObjectProtocol *object);

    ObjectProtocol *dup(void);

    inline void operator=(ObjectProtocol *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:
// may be used in future if we need cancelable threads...
#ifdef  _MSWINDOWS_
    HANDLE cancellor;
#else
    void *cancellor;
#endif

    enum {} reserved;   // cancel mode?
    pthread_t tid;
    size_t stack;
    int priority;

    Thread(size_t stack = 0);

    void map(void);

    virtual bool is_active(void);

public:
    void setPriority(void);

    static void yield(void);

    static void sleep(timeout_t timeout);

    static Thread *get(void);

    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);

    static pthread_t self(void);

    inline operator bool()
        {return is_active();}

    inline bool operator!()
        {return !is_active();}

    inline bool isRunning(void)
        {return is_active();}
};

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

    JoinableThread(size_t size = 0);

    virtual ~JoinableThread();

    void join(void);

    bool is_active(void);

    virtual void run(void) = 0;

public:

    void start(int priority = 0);

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

class __EXPORT DetachedThread : public Thread
{
protected:
    bool active;

    DetachedThread(size_t size = 0);

    ~DetachedThread();

    void exit(void);

    bool is_active(void);

    virtual void run(void) = 0;

public:
    void start(int priority = 0);
};

class __EXPORT locked_release
{
protected:
    ObjectProtocol *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 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 ThreadLock rwlock_t;

typedef RecursiveMutex rexlock_t;

typedef Semaphore semaphore_t;

typedef barrier barrier_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 bool _sync_protect_(const void *obj)
{
    Mutex::protect(obj);
    return true;
}

inline bool _sync_release_(const void *obj)
{
    Mutex::release(obj);
    return false;
}

inline bool _rw_reader_(const void *obj)
{
    ThreadLock::reader(obj);
    return true;
}

inline bool _rw_writer_(const void *obj)
{
    ThreadLock::writer(obj);
    return true;
}

inline bool _rw_release_(const void *obj)
{
    ThreadLock::release(obj);
    return false;
}

#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);

#define SYNC(obj) for(bool _sync_flag_ = _sync_protect_(obj); _sync_flag_; _sync_flag_ = _sync_release_(obj))

#define SHARED(obj) for(bool _sync_flag_ = _rw_reader_(obj); _sync_flag_; _sync_flag_ = _rw_release_(obj))

#define EXCLUSIVE(obj) for(bool _sync_flag_ = _rw_writer_(obj); _sync_flag_; _sync_flag_ = _rw_release_(obj))

END_NAMESPACE

#endif

---