ManualResetEvent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/ParkingLot.h"
#include <atomic>
 
namespace UE
{
 
class FManualResetEvent
{
public:
    constexpr FManualResetEvent() = default;
 
    FManualResetEvent(const FManualResetEvent&) = delete;
    FManualResetEvent& operator=(const FManualResetEvent&) = delete;
 
    inline bool IsNotified() const
    {
        return !!(State.load(std::memory_order_acquire) & IsNotifiedFlag);
    }
 
    inline void Wait()
    {
        WaitUntil(FMonotonicTimePoint::Infinity());
    }
 
    inline bool WaitFor(FMonotonicTimeSpan WaitTime)
    {
        return WaitTime.IsZero() ? IsNotified() : WaitUntil(FMonotonicTimePoint::Now() + WaitTime);
    }
 
    inline bool WaitUntil(FMonotonicTimePoint WaitTime)
    {
        for (;;)
        {
            uint8 CurrentState = State.load(std::memory_order_acquire);
            if (CurrentState & IsNotifiedFlag)
            {
                return true;
            }
            if (!WaitTime.IsInfinity() && WaitTime <= FMonotonicTimePoint::Now())
            {
                return false;
            }
            if ((CurrentState & MaybeWaitingFlag) ||
                State.compare_exchange_weak(CurrentState, MaybeWaitingFlag, std::memory_order_acq_rel))
            {
                ParkingLot::WaitUntil(&State, [this]
                {
                    uint8 NewState = State.load(std::memory_order_relaxed);
                    return !(NewState & IsNotifiedFlag) && (NewState & MaybeWaitingFlag);
                }, nullptr, WaitTime);
            }
        }
    }
 
    inline void Notify()
    {
        const uint8 CurrentState = State.exchange(IsNotifiedFlag, std::memory_order_release);
        if (!(CurrentState & IsNotifiedFlag) && (CurrentState & MaybeWaitingFlag))
        {
            ParkingLot::WakeAll(&State);
        }
    }
 
    inline void Reset()
    {
        State.fetch_and(~IsNotifiedFlag, std::memory_order_release);
    }
 
private:
    static constexpr uint8 IsNotifiedFlag = 1 << 0;
    static constexpr uint8 MaybeWaitingFlag = 1 << 1;
 
    std::atomic<uint8> State = 0;
};
 
} // UE