GarbageCollectionInternalFlags.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*==============================================================================================
    GarbageCollectionInternalFlags.h: Unreal realtime garbage collection internal flags helpers
===============================================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Stats/Stats.h"
#include "UObject/GarbageCollection.h"
#include "UObject/Object.h"
#include "UObject/UObjectArray.h"
 
namespace UE::GC::Private
{
 
class FGCFlags
{
    static EInternalObjectFlags ReachableObjectFlag;
 
    static EInternalObjectFlags MaybeUnreachableObjectFlag;
 
public:
 
    FORCEINLINE static void SetUnreachable(FUObjectItem* ObjectItem)
    {
        ObjectItem->AtomicallySetFlag_ForGC(EInternalObjectFlags::Unreachable);
    }
 
    FORCEINLINE static void SetReachable_ForGC(FUObjectItem* ObjectItem)
    {
        ObjectItem->AtomicallySetFlag_ForGC(ReachableObjectFlag);
    }
 
    FORCEINLINE static bool IsReachable_ForGC(const FUObjectItem* ObjectItem)
    {
        return !!(ObjectItem->GetFlagsInternal() & int32(ReachableObjectFlag));
    }
 
    FORCEINLINE static void SetMaybeUnreachable_ForGC(FUObjectItem* ObjectItem)
    {
        ObjectItem->AtomicallyClearFlag_ForGC(ReachableObjectFlag);
        ObjectItem->AtomicallySetFlag_ForGC(MaybeUnreachableObjectFlag);
    }
 
    FORCEINLINE static void ClearMaybeUnreachable_ForGC(FUObjectItem* ObjectItem)
    {
        ObjectItem->AtomicallyClearFlag_ForGC(MaybeUnreachableObjectFlag);
        ObjectItem->AtomicallySetFlag_ForGC(ReachableObjectFlag);
    }
 
    FORCEINLINE static bool IsMaybeUnreachable_ForGC(const FUObjectItem* ObjectItem)
    {
        return !!(ObjectItem->GetFlagsInternal() & int32(MaybeUnreachableObjectFlag));
    }
 
    FORCEINLINE static bool IsMaybeUnreachable_ForGC(const UObject* Object)
    {
        const FUObjectItem* ObjectItem = GUObjectArray.IndexToObjectUnsafeForGC(GUObjectArray.ObjectToIndex(Object));
        return IsMaybeUnreachable_ForGC(ObjectItem);
    }
 
    FORCEINLINE static bool ThisThreadAtomicallyClearedRFUnreachable(FUObjectItem* ObjectItem)
    {
        return ObjectItem->AtomicallyClearFlag_ForGC(EInternalObjectFlags::Unreachable);
    }
 
    FORCEINLINE static bool ThisThreadAtomicallySetFlag_ForGC(FUObjectItem* ObjectItem, EInternalObjectFlags Flag)
    {
        return ObjectItem->AtomicallySetFlag_ForGC(Flag);
    }
 
    FORCEINLINE static bool ThisThreadAtomicallyClearedFlag_ForGC(FUObjectItem* ObjectItem, EInternalObjectFlags Flag)
    {
        return ObjectItem->AtomicallyClearFlag_ForGC(Flag);
    }
 
    FORCEINLINE static void FastMarkAsReachableInterlocked_ForGC(FUObjectItem* ObjectItem)
    {
        FPlatformAtomics::InterlockedAnd(&ObjectItem->FlagsAndRefCount, ~(int64(MaybeUnreachableObjectFlag) << 32));
        FPlatformAtomics::InterlockedOr(&ObjectItem->FlagsAndRefCount, int64(ReachableObjectFlag) << 32);
    }
 
    FORCEINLINE static void FastMarkAsReachableAndClearReachableInClusterInterlocked_ForGC(FUObjectItem* ObjectItem)
    {
        FPlatformAtomics::InterlockedAnd(&ObjectItem->FlagsAndRefCount, ~(int64(MaybeUnreachableObjectFlag | EInternalObjectFlags::ReachableInCluster) << 32));
        FPlatformAtomics::InterlockedOr(&ObjectItem->FlagsAndRefCount, int64(ReachableObjectFlag) << 32);
    }
 
    FORCEINLINE static bool MarkAsReachableInterlocked_ForGC(FUObjectItem* ObjectItem)
    {
        const int32 FlagToClear = int32(MaybeUnreachableObjectFlag);
        if (ObjectItem->GetFlagsInternal() & FlagToClear)
        {
            int64 Old = FPlatformAtomics::InterlockedAnd(&ObjectItem->FlagsAndRefCount, ~((int64)FlagToClear << 32));
            FPlatformAtomics::InterlockedOr(&ObjectItem->FlagsAndRefCount, int64(ReachableObjectFlag) << 32);
            return FUObjectItem::GetFlagsInternal(Old) & FlagToClear;
        }
        return false;
    }
 
    FORCEINLINE static constexpr ::size_t OffsetOfFlags_ForGC()
    {
        return offsetof(FUObjectItem, FlagsAndRefCount);
    }
 
    FORCEINLINE static void SwapReachableAndMaybeUnreachable()
    {
        // It's important to lock the global UObjectArray so that the flag swap doesn't occur while a new object is being created
        // as we set the GReachableObjectFlag on all newly created objects
        GUObjectArray.LockInternalArray();
        
        Swap(ReachableObjectFlag, MaybeUnreachableObjectFlag);
 
        // Maintain the old flag variables for backwards compatibility
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        UE::GC::GReachableObjectFlag = ReachableObjectFlag;
        UE::GC::GMaybeUnreachableObjectFlag = MaybeUnreachableObjectFlag;
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
        GUObjectArray.UnlockInternalArray();
    }
 
    FORCEINLINE static EInternalObjectFlags GetReachableFlagValue_ForGC()
    {
        return ReachableObjectFlag;
    }
 
    FORCEINLINE static EInternalObjectFlags GetMaybeUnreachableFlagValue_ForGC()
    {
        return MaybeUnreachableObjectFlag;
    }
 
    FORCEINLINE static bool IsIncrementalGatherUnreachableSupported()
    {
        return false;
    }
};
 
} // namespace UE::GC::Private