GenericPlatformManualResetEvent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/Fundamental/Oversubscription.h"
#include "HAL/PlatformMath.h"
#include "Misc/MonotonicTime.h"
 
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <mutex>
 
namespace UE::HAL::Private
{
 
class FGenericPlatformManualResetEvent
{
public:
    FGenericPlatformManualResetEvent() = default;
    FGenericPlatformManualResetEvent(const FGenericPlatformManualResetEvent&) = delete;
    FGenericPlatformManualResetEvent& operator=(const FGenericPlatformManualResetEvent&) = delete;
 
    void Reset()
    {
        std::unique_lock SelfLock(Lock);
        bWait = true;
    }
 
    bool Poll()
    {
        std::unique_lock SelfLock(Lock);
        return !bWait;
    }
 
    void Wait()
    {
        LowLevelTasks::FOversubscriptionScope _;
        std::unique_lock SelfLock(Lock);
        Condition.wait(SelfLock, [this] { return !bWait; });
    }
 
    bool WaitFor(FMonotonicTimeSpan WaitTime)
    {
        if (WaitTime.IsInfinity())
        {
            Wait();
            return true;
        }
 
        if (WaitTime <= FMonotonicTimeSpan::Zero())
        {
            std::unique_lock SelfLock(Lock);
            return !bWait;
        }
 
        LowLevelTasks::FOversubscriptionScope _;
        std::unique_lock SelfLock(Lock);
        const int64 WaitMs = FPlatformMath::CeilToInt64(WaitTime.ToMilliseconds());
        return Condition.wait_for(SelfLock, std::chrono::milliseconds(WaitMs), [this] { return !bWait; });
    }
 
    bool WaitUntil(FMonotonicTimePoint WaitTime)
    {
        return WaitFor(WaitTime - FMonotonicTimePoint::Now());
    }
 
    void Notify()
    {
        // The lock must be held by Notify() until it is finished accessing its members, otherwise a waiting thread
        // may destroy the event after its wait but before Notify() has finished.
        std::unique_lock SelfLock(Lock);
        bWait = false;
        Condition.notify_one();
    }
 
private:
    std::mutex Lock;
    std::condition_variable Condition;
    bool bWait = true;
};
 
} // UE::HAL::Private