UT_Condition.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_Condition.h ( UT Library, C++)
 *
 * COMMENTS:
 *      A condition class the implements pthread-like condition variables.
 */

#ifndef __UT_Condition_h__
#define __UT_Condition_h__

#include "UT_API.h"
#include "UT_Assert.h"
#include "UT_Lock.h"

#ifdef USE_PTHREADS
    #include <pthread.h>
#endif


/// Condition synchronization primitive
class UT_API UT_Condition
{
public:
    UT_Condition();
    ~UT_Condition();

    /// Block until we're triggered.
    ///
    /// The lock must be held when this method is called.  Will return when
    /// the predicate evaluates to true, with the lock acquired.  Internally
    /// will release the lock and wait for triggers before retesting the
    /// predicate.
    template<typename Predicate>
    void wait(UT_Lock &lock, const Predicate& pred)
    {
        while (!pred())
            waitForTrigger(lock);
    }

    /// The lock must be held when this method is called it will be released
    /// when waiting for the trigger and re-acquired when this method returns.
    void waitForTrigger(UT_Lock &lock);

    /// Wait with a timeout, returns true if the lock was re-acquired.
    /// False means a timeout occurred.
    bool waitForTriggerMS(UT_Lock &lock, int64 timeout_msec);

    /// Trigger all waiting threads.
    ///
    /// @note The caller should hold the same lock that was passed to
    /// waitForTrigger() if precise scheduling of events is desired.
    void triggerAll();

    /// Trigger one waiting thread.
    ///
    /// @note The caller should hold the same lock that was passed to
    /// waitForTrigger() if precise scheduling of events is desired.
    void triggerOne();

    // Prevent users from calling the copy constructor or assignment operator
    // by declaring them as private.  They are not implemented.
    UT_Condition(const UT_Condition &copy) = delete;
    UT_Condition &operator=(const UT_Condition &copy) = delete;

private:

#if defined(USE_PTHREADS)
    pthread_cond_t myCond;
#elif defined(_WIN32)
    void *myCond;
#else
    #error Missing implementation
#endif
};

//////////////////////////////////////////////////////////////////////////////
//
// PThreads Implementation
//

#ifdef USE_PTHREADS

inline
UT_Condition::UT_Condition()
{
    UT_VERIFY(pthread_cond_init(&myCond, 0) == 0);
}

inline
UT_Condition::~UT_Condition()
{
    // You should not destroy a condition upon which other threads are
    // currently blocked.  I suppose we trigger them here to try and detect
    // errors more easily.
    triggerAll();

    UT_VERIFY(pthread_cond_destroy(&myCond) == 0);
}

// inline for speed
inline void
UT_Condition::waitForTrigger(UT_Lock &lock)
{
    UT_VERIFY(pthread_cond_wait(&myCond, &lock.myLock) == 0);
}

// inline for speed
inline void
UT_Condition::triggerAll()
{
    UT_VERIFY(pthread_cond_broadcast(&myCond) == 0);
}

// inline for speed
inline void
UT_Condition::triggerOne()
{
    UT_VERIFY(pthread_cond_signal(&myCond) == 0);
}

#endif // USE_PTHREADS

//////////////////////////////////////////////////////////////////////////////
//
// Windows Implementation
//

#ifdef _WIN32

extern "C"
{
    struct _RTL_CONDITION_VARIABLE;
    using CONDITION_VARIABLE = _RTL_CONDITION_VARIABLE;

    __declspec(dllimport) void __stdcall
        WakeConditionVariable(CONDITION_VARIABLE *ConditionVariable);
    __declspec(dllimport) void __stdcall
        WakeAllConditionVariable(CONDITION_VARIABLE *ConditionVariable);
}

inline
UT_Condition::UT_Condition()
    : myCond{nullptr}
{
}

inline
UT_Condition::~UT_Condition()
{
    // You should not destroy a condition upon which other threads are
    // currently blocked.  I suppose we trigger them here to try and detect
    // errors more easily.
    triggerAll();
}

// inline for speed
inline void
UT_Condition::waitForTrigger(UT_Lock &lock)
{
    lock.sleep(this);
}

inline bool
UT_Condition::waitForTriggerMS(UT_Lock &lock, int64 timeout_ms)
{
    return lock.sleepMS(this, timeout_ms);
}

// inline for speed
inline void
UT_Condition::triggerAll()
{
    WakeAllConditionVariable((CONDITION_VARIABLE*) &myCond);
}

// inline for speed
inline void
UT_Condition::triggerOne()
{
    WakeConditionVariable((CONDITION_VARIABLE*) &myCond);
}

#endif // _WIN32

#endif // __UT_Condition_h__