thread.h

Go to the documentation of this file.

// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
// Copyright (C) 2015 Cherokees of Idaho.
//
// 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
 
#ifndef _UCOMMON_CONDITION_H_
#include <ucommon/condition.h>
#endif
 
namespace ucommon {
 
class __EXPORT RWLock : private ConditionalAccess, public __PROTOCOL ExclusiveProtocol, public __PROTOCOL SharedProtocol
{
private:
    __DELETE_COPY(RWLock);
 
protected:
    unsigned writers;
    pthread_t writeid;
 
    virtual void _share(void) __OVERRIDE;
    
    virtual void _lock(void) __OVERRIDE;
 
    virtual void _unlock(void) __OVERRIDE;
 
    virtual void _unshare(void) __OVERRIDE;
 
public:
    typedef autoshared<RWLock> autoreader;
 
    typedef autoexclusive<RWLock> autowriter;
 
    class __EXPORT reader
    {
    private:
        const void *object;
 
        __DELETE_COPY(reader);
 
    public:
        reader();
 
        reader(const void *object);
 
        ~reader();
 
        void set(const void *object);
 
        void release(void);
 
        inline void operator=(const void *pointer) {
            set(pointer);
        }
 
        static bool lock(const void *object, timeout_t timeout = Timer::inf);
    };
 
    class __EXPORT writer
    {
    private:
        const void *object;
 
        __DELETE_COPY(writer);
 
    public:
        writer();
 
        writer(const void *object);
 
        ~writer();
 
        void set(const void *object);
 
        void release(void);
 
        inline void operator=(const void *pointer) {
            set(pointer);
        }
 
        static bool lock(const void *object, timeout_t timeout = Timer::inf);
    };
 
    RWLock();
 
    bool modify(timeout_t timeout = Timer::inf);
 
    bool access(timeout_t timeout = Timer::inf);
 
    static void indexing(unsigned size);
 
    static bool release(const void *object);
 
    void release(void);
};
 
class __EXPORT TimedEvent : public Timer
{
private:
#ifdef _MSTHREADS_
    HANDLE event;
#else
    mutable pthread_cond_t cond;
    bool signalled;
#endif
    mutable pthread_mutex_t mutex;
 
    __DELETE_COPY(TimedEvent);
 
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 __PROTOCOL ExclusiveProtocol
{
private:
    __DELETE_COPY(RecursiveMutex);
 
protected:
    unsigned waiting;
    unsigned lockers;
    pthread_t locker;
 
    virtual void _lock(void) __OVERRIDE;
    virtual void _unlock(void) __OVERRIDE;
 
public:
    typedef autoexclusive<RecursiveMutex> autolock;
 
    RecursiveMutex();
 
    void lock(void);
 
    bool lock(timeout_t timeout);
 
    void release(void);
};
 
class __EXPORT ReusableAllocator : protected Conditional
{
private:
    __DELETE_COPY(ReusableAllocator);
 
protected:
    ReusableObject *freelist;
    unsigned waiting;
 
    ReusableAllocator();
 
    inline ReusableObject *next(ReusableObject *object) {
        return object->getNext();
    }
 
    void release(ReusableObject *object);
};
 
class __EXPORT Mutex : public __PROTOCOL ExclusiveProtocol
{
private:
    __DELETE_COPY(Mutex);
 
protected:
    mutable pthread_mutex_t mlock;
 
    virtual void _lock(void) __OVERRIDE;
    virtual void _unlock(void) __OVERRIDE;
 
public:
    typedef autoexclusive<Mutex> autolock;
 
    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 bool protect(const void *pointer);
 
    static bool release(const void *pointer);
};
 
class __EXPORT AutoProtect
{
private:
 
    __DELETE_COPY(AutoProtect);
 
protected:
    const void *object;
 
    AutoProtect();
 
    void set(const void *object);
 
    void release(void);
 
public:
    AutoProtect(const void *object);
 
    ~AutoProtect();
 
    inline operator bool() const {
        return object != NULL;
    }
 
    inline bool operator!() const {
        return object == NULL;
    }    
};
 
template<typename T>
class autoprotect : public AutoProtect
{
public:
    inline autoprotect() : AutoProtect() {};
 
    inline autoprotect(const T *object) : AutoProtect(object) {};
 
    inline void set(const T *object) {
        AutoProtect::set(object);
    }
 
    inline void release() {
        AutoProtect::release();
    }
 
    inline autoprotect& operator=(const T* object) {
        AutoProtect::set(object);
        return *this;
    }
 
    inline T* operator->() const {
        return static_cast<T*>(object);
    }
 
    inline T& operator*() const {
        __THROW_DEREF(object);
        return *(static_cast<T*>(object));
    }
};
 
class __EXPORT Thread
{
private:
    __DELETE_COPY(Thread);
 
protected:
// may be used in future if we need cancelable threads...
#ifdef  _MSTHREADS_
    HANDLE cancellor;
#else
    void *cancellor;
#endif
 
    enum {R_UNUSED} reserved;   // cancel mode?
    pthread_t tid;
    stacksize_t stack;
    int priority;
 
    Thread(size_t stack = 0);
 
    void map(void);
 
    virtual bool is_active(void) const;
 
public:
    class __EXPORT Local : public LinkedObject
    {
    private:
        friend class Thread;
 
        pthread_key_t key;
        static LinkedObject *list;
 
        __DELETE_COPY(Local);
 
    protected:
        Local();
 
        virtual void release(void *instance) = 0;
 
        virtual void *allocate();
 
    public:
        ~Local();
 
        void *operator*();
 
        void set(void *instance);
 
        void *get(void);
 
        inline void clear() {
            set(nullptr);
        }
    };
 
    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 size_t cache(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() const {
        return is_active();
    }
 
    inline bool operator!() const {
        return !is_active();
    }
 
    inline bool isRunning(void) const {
        return is_active();
    }
 
    static void release(void);
};
 
class __EXPORT JoinableThread : public Thread
{
private:
    __DELETE_COPY(JoinableThread);
 
protected:
#ifdef  _MSTHREADS_
    HANDLE running;
#else
    volatile bool running;
#endif
    volatile bool joining;
 
    JoinableThread(size_t size = 0);
 
    virtual ~JoinableThread();
 
    void join(void);
 
    bool is_active(void) const __OVERRIDE;
 
    virtual void run(void) __OVERRIDE = 0;
 
public:
 
    void start(int priority = 0);
 
    inline void background(void) {
        start(-1);
    }
};
 
class __EXPORT DetachedThread : public Thread
{
private:
    __DELETE_COPY(DetachedThread);
 
protected:
    bool active;
 
    DetachedThread(size_t size = 0);
 
    ~DetachedThread();
 
    void exit(void) __OVERRIDE;
 
    bool is_active(void) const __OVERRIDE;
 
    virtual void run(void) __OVERRIDE = 0;
 
public:
    void start(int priority = 0);
};
 
typedef TimedEvent timedevent_t;
 
typedef Mutex mutex_t;
 
typedef RWLock rwlock_t;
 
typedef RecursiveMutex rexlock_t;
 
#define __AUTOLOCK(x)       autolock __autolock__(x)
#define __AUTOPROTECT(x)    AutoProtect __autolock__(x)
#define __SYNC(x) for(bool _sync_flag_ = Mutex::protect(x); _sync_flag_; _sync_flag_ = !Mutex::release(x))
 
} // namespace ucommon
 
#endif