ConditionVariable.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Commons/Threading/Mutex.hpp"
#include "Arp/System/Commons/Chrono/TimePoint.hpp"
 
// forwards
namespace Arp::System::Ve
{
class ICondVariableService;
}
 
namespace Arp::System::Commons::Threading
{
 
using namespace Arp::System::Commons::Chrono;
 
class ConditionVariable
{
public: // construction/destruction
    ConditionVariable(void);
 
    ~ConditionVariable(void);
 
public: // operations
 
    template<class Predicate>
    void Wait(Mutex& mutex, Predicate predicate);
 
    template<class Predicate>
    bool WaitFor(Mutex& mutex, uint64 timeoutMs, Predicate predicate);
 
    template<class Predicate>
    bool WaitUntil(Mutex& mutex, TimePointClockSteady timePoint, Predicate predicate);
 
    void NotifyOne(void);
 
    void NotifyAll(void);
 
private: // methods
    void WaitInternal(Mutex& mutex);
    bool WaitUntilInternal(Mutex& mutex, TimePointClockSteady timePoint);
 
    static SteadyTimePoint CalculateWaitForTimepoint(uint64 timeoutMs);
    static TimePointClockSteady RoundUpToMultipleOf(const TimePointClockSteady& timePoint, const ClockSteady::duration& intervalRounding);
    static ClockSteady::duration RoundUpToMultipleOf(const ClockSteady::duration& duration, const ClockSteady::duration& intervalRounding);
    static ClockSteady::duration RoundDownToMultipleOf(const ClockSteady::duration& duration, const Arp::uint64& intervalRounding);
 
private: // deleted methods
    ConditionVariable(const ConditionVariable& arg) = delete;
 
    ConditionVariable& operator=(const ConditionVariable& arg) = delete;
 
private: // fields
    Arp::System::Ve::ICondVariableService *pCondVariableService;
};
 
// inline methods of class ConditionVariable
template<class Predicate>
void ConditionVariable::Wait(Mutex& mutex, Predicate predicate)
{
    while (!predicate())
    {
        WaitInternal(mutex);
    }
}
 
template<class Predicate>
bool ConditionVariable::WaitFor(Mutex& mutex, uint64 timeoutMs, Predicate predicate)
{
    SteadyTimePoint timePoint = CalculateWaitForTimepoint(timeoutMs);
    return WaitUntil(mutex, timePoint, predicate);
}
 
template<class Predicate>
bool ConditionVariable::WaitUntil(Mutex& mutex, TimePointClockSteady timePoint, Predicate predicate)
{
    bool result = true;
    while ((!predicate()) && result)
    {
        result = WaitUntilInternal(mutex, timePoint);
    }
 
    // https://www.man7.org/linux/man-pages/man3/pthread_cond_timedwait.3p.html
    // Condition Wait Semantics
    //    Similarly, when
    //    pthread_cond_timedwait() returns with the timeout error, the
    //    associated predicate may be true due to an unavoidable race
    //    between the expiration of the timeout and the predicate state
    //    change.
    return predicate();
}
 
} // end of namespace Arp::System::Commons::Threading