GCScopeLock.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    Garbage Collection scope lock. 
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "HAL/ThreadSafeCounter.h"
#include "HAL/PlatformProcess.h"
#include "Misc/ScopeLock.h"
#include "HAL/ThreadSafeBool.h"
#include "Async/SharedMutex.h"
#include "Async/SharedLock.h"
#include "Async/UniqueLock.h"
#include "HAL/Event.h"
 
 
class FGCCSyncObject
{
    FThreadSafeCounter AsyncCounter;
    FThreadSafeCounter GCCounter;
    TAtomic<int32> GCWantsToRunCounter {0};
    UE::FSharedMutex SharedMutex;
    FEvent* GCUnlockedEvent;
 
public:
 
    FGCCSyncObject();
    ~FGCCSyncObject();
 
    static void Create();
 
    static FGCCSyncObject& Get();
 
    void LockAsync()
    {
        if (!IsInGameThread())
        {
            // Wait until GC is done if it was running when entering this function
            bool bLocked = false;
            do
            {
                if (GCCounter.GetValue() > 0)
                {
                    GCUnlockedEvent->Wait();
                }
                {
                    // We only need a read lock here since AsyncCounter is already thread-safe
                    // with other threads that want to lock but we need to guard against
                    // the GC trying to take the write lock.
                    UE::TSharedLock SharedLock(SharedMutex);
                    if (GCCounter.GetValue() == 0)
                    {
                        AsyncCounter.Increment();
                        bLocked = true;
                    }
                }
            } while (!bLocked);
        }
    }
 
    bool TryLockAsync(bool bShouldLock = !IsInGameThread())
    {
        bool bLocked = true;
        if (bShouldLock)
        {
            bLocked = false;
            if (GCCounter.GetValue() == 0)
            {
                UE::TSharedLock SharedLock(SharedMutex);
                if (GCCounter.GetValue() == 0)
                {
                    AsyncCounter.Increment();
                    bLocked = true;
                }
            }
        }
 
        return bLocked;
    }
 
    void UnlockAsync(bool bShouldUnlock = !IsInGameThread())
    {
        if (bShouldUnlock)
        {
            AsyncCounter.Decrement();
        }
    }
    void GCLock()
    {
        // Signal other threads that GC wants to run
        SetGCIsWaiting();
 
        // Wait until all other threads are done if they're currently holding the lock
        bool bLocked = false;
        do
        {
            FPlatformProcess::ConditionalSleep([&]()
            {
                return AsyncCounter.GetValue() == 0;
            });
            {
                // Guard against any reader locks owned by other threads.
                UE::TUniqueLock ExclusiveLock(SharedMutex);
                if (AsyncCounter.GetValue() == 0)
                {
                    GCUnlockedEvent->Reset();
                    int32 GCCounterValue = GCCounter.Increment();
                    check(GCCounterValue == 1); // GCLock doesn't support recursive locks
                    // At this point GC can run so remove the signal that it's waiting
                    FPlatformMisc::MemoryBarrier();
                    ResetGCIsWaiting();
                    bLocked = true;
                }
            }
        } while (!bLocked);
    }
    bool IsAsyncLocked() const
    {
        return AsyncCounter.GetValue() != 0;
    }
    bool IsGCLocked() const
    {
        return GCCounter.GetValue() != 0;
    }
    bool TryGCLock()
    {
        bool bSuccess = false;
        if (AsyncCounter.GetValue() != 0)
        {
            return bSuccess;
        }
        // Guard against any reader locks owned by other threads.
        UE::TUniqueLock ExclusiveLock(SharedMutex);
        // If any other thread is currently locking we just exit
        if (AsyncCounter.GetValue() == 0)
        {
            GCUnlockedEvent->Reset();
            int32 GCCounterValue = GCCounter.Increment();
            check(GCCounterValue == 1); // GCLock doesn't support recursive locks
            bSuccess = true;
        }
        return bSuccess;
    }
    void GCUnlock()
    {
        GCUnlockedEvent->Trigger();
        GCCounter.Decrement();
    }
 
    void SetGCIsWaiting()
    {
        GCWantsToRunCounter++;
    }
 
    void ResetGCIsWaiting()
    {
        GCWantsToRunCounter.Store(0);
    }
 
    FORCEINLINE bool IsGCWaiting() const
    {
        return !!GCWantsToRunCounter.Load(EMemoryOrder::Relaxed);
    }
};