condition.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_CONDITION_H_
#define _UCOMMON_CONDITION_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 __EXPORT ConditionMutex
{
private:
    friend class ConditionVar;
    friend class autolock;
 
    __DELETE_COPY(ConditionMutex);
 
protected:
#if defined(_MSTHREADS_)
    mutable CRITICAL_SECTION mutex;
#else
    mutable pthread_mutex_t mutex;
#endif
 
public:
    ConditionMutex();
 
    ~ConditionMutex();
 
#ifdef  _MSTHREADS_
    inline void lock(void) {
        EnterCriticalSection(&mutex);
    }
 
    inline void unlock(void) {
        LeaveCriticalSection(&mutex);
    }
 
#else
 
    inline void lock(void) {
        pthread_mutex_lock(&mutex);
    }
 
    inline void unlock(void) {
        pthread_mutex_unlock(&mutex);
    }
#endif
 
    class __EXPORT autolock
    {
    private:
#ifdef  _MSTHREADS_
        CRITICAL_SECTION *mutex;
#else
        pthread_mutex_t *mutex;
#endif
        __DELETE_COPY(autolock);
 
    public:
        inline autolock(const ConditionMutex* object) {
            mutex = &object->mutex;
#ifdef _MSTHREADS_
            EnterCriticalSection(mutex);
#else
            pthread_mutex_lock(mutex);
#endif
        }
 
        inline ~autolock() {
#ifdef  _MSTHREADS_
            LeaveCriticalSection(mutex);
#else
            pthread_mutex_unlock(mutex);
#endif
        }
    };
};
 
class __EXPORT ConditionVar
{
private:
    __DELETE_DEFAULTS(ConditionVar);
 
protected:
    friend class ConditionList;
 
#if defined(_MSTHREADS_)
    mutable CONDITION_VARIABLE cond;
#else
    mutable pthread_cond_t cond;
#endif
    ConditionMutex *shared;
 
public:
    ConditionVar(ConditionMutex *mutex);
 
    ~ConditionVar();
 
    bool wait(timeout_t timeout);
 
    bool wait(struct timespec *timeout);
 
#ifdef  _MSTHREADS_
    void wait(void);
    void signal(void);
    void broadcast(void);
 
#else
 
    inline void wait(void) {
        pthread_cond_wait(&cond, &shared->mutex);
    }
 
    inline void signal(void) {
        pthread_cond_signal(&cond);
    }
 
    inline void broadcast(void) {
        pthread_cond_broadcast(&cond);
    }
#endif
};
 
class __EXPORT Conditional : protected ConditionMutex
{
private:
    __DELETE_COPY(Conditional);
 
protected:
    friend class ConditionalAccess;
    friend class ConditionVar;
 
#if defined(_MSTHREADS_)
    mutable CONDITION_VARIABLE cond;
#else
#ifndef __PTH__
    class __LOCAL attribute
    {
    public:
        pthread_condattr_t attr;
        attribute();
    };
 
    __LOCAL static attribute attr;
#endif
 
    mutable pthread_cond_t cond;
#endif
 
    friend class TimedEvent;
 
    bool wait(timeout_t timeout);
 
    bool wait(struct timespec *timeout);
 
#ifdef  _MSTHREADS_
    void wait(void);
    void signal(void);
    void broadcast(void);
 
#else
 
    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();
 
    friend class autolock;
 
public:
#if !defined(_MSTHREADS_) && !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
{
private:
    __DELETE_COPY(ConditionalAccess);
 
protected:
#if defined _MSTHREADS_
    CONDITION_VARIABLE bcast;
#else
    mutable pthread_cond_t bcast;
#endif
 
    static unsigned max_sharing;
 
    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  _MSTHREADS_
    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 ConditionalLock : protected ConditionalAccess, public __PROTOCOL SharedProtocol
{
private:
    __DELETE_COPY(ConditionalLock);
 
protected:
    class Context : public LinkedObject
    {
    private:
        __DELETE_COPY(Context);
 
    public:
        inline Context(LinkedObject **root) : LinkedObject(root) {}
 
        pthread_t thread;
        unsigned count;
    };
 
    LinkedObject *contexts;
 
    virtual void _share(void) __OVERRIDE;
    virtual void _unshare(void) __OVERRIDE;
 
    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;
 
    __DELETE_DEFAULTS(Barrier);
 
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 __PROTOCOL SharedProtocol, protected Conditional
{
protected:
    unsigned count, waits, used;
 
    virtual void _share(void) __OVERRIDE;
    virtual void _unshare(void) __OVERRIDE;
 
    __DELETE_COPY(Semaphore);
 
public:
    typedef autoshared<Semaphore> autosync;
        
    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();
    }
};
 
typedef ConditionalLock condlock_t;
 
typedef ConditionalAccess accesslock_t;
 
typedef Semaphore semaphore_t;
 
typedef Barrier barrier_t;
 
} // namespace ucommon
 
#endif