GarbageCollection.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    GarbageCollection.h: Unreal realtime garbage collection helpers
=============================================================================*/
 
#pragma once
 
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Logging/LogMacros.h"
#include "Misc/AssertionMacros.h"
#include "Stats/Stats.h"
#include "UObject/ReferenceToken.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/UnrealNames.h"
 
class UObject;
 
#if WITH_VERSE_VM || defined(__INTELLISENSE__)
namespace Verse
{
struct VNativeStruct;
}
#endif
 
#define GARBAGE_COLLECTION_KEEPFLAGS    (GIsEditor ? RF_Standalone : RF_NoFlags)
 
#ifndef ENABLE_GC_OBJECT_CHECKS
    #define ENABLE_GC_OBJECT_CHECKS (!(UE_BUILD_TEST || UE_BUILD_SHIPPING) || 0)
#endif
 
#define ENABLE_GC_HISTORY (!UE_BUILD_SHIPPING)
 
COREUOBJECT_API DECLARE_LOG_CATEGORY_EXTERN(LogGarbage, Warning, All);
DECLARE_STATS_GROUP(TEXT("Garbage Collection"), STATGROUP_GC, STATCAT_Advanced);
 
#define DO_POINTER_CHECKS_ON_GC 0 
 
 
namespace UE::GC
{
 
enum class EAROFlags
{
    None            = 0,
    Unbalanced      = 1 << 0,       // Some instances are very slow but most are fast. GC can flush these more frequently.
    ExtraSlow       = 2 << 0,       // All instances are slow. GC can work-steal these at finer batch granularity.
};
ENUM_CLASS_FLAGS(EAROFlags);
 
// Reference collection batches up slow AddReferencedObjects calls
COREUOBJECT_API void RegisterSlowImplementation(void (*AddReferencedObjects)(UObject*, FReferenceCollector&), EAROFlags Flags = EAROFlags::None);
 
class FSchemaView;
 
class FSchemaOwner
{
public:
    FSchemaOwner() = default;
    FSchemaOwner(const FSchemaOwner&) = delete;
    FSchemaOwner(FSchemaOwner&& In) : SchemaView(In.SchemaView) { In.SchemaView = 0; }
    COREUOBJECT_API explicit FSchemaOwner(FSchemaView In);
    ~FSchemaOwner() { Reset(); }
    FSchemaOwner& operator=(const FSchemaOwner&) = delete;
    FSchemaOwner& operator=(FSchemaOwner&& In)
    {
        Reset();
        Swap(In.SchemaView, SchemaView);
        return *this;
    }
    
    COREUOBJECT_API void Set(FSchemaView In);
    const FSchemaView& Get() const { return reinterpret_cast<const FSchemaView&>(SchemaView); }
    COREUOBJECT_API void Reset();
private:
    uint64 SchemaView = 0;
};
 
#if WITH_VERSE_VM || defined(__INTELLISENSE__)
COREUOBJECT_API void EnableFrankenGCMode(bool bEnable);
 
COREUOBJECT_API bool ShouldFrankenGCRun();
 
extern COREUOBJECT_API bool GIsFrankenGCCollecting;
 
COREUOBJECT_API void MarkNativeStructAsReachable(::Verse::VNativeStruct* NativeStruct);
#endif
 
} // namespace UE::GC
 
class FGCScopeGuard
{
public:
    COREUOBJECT_API FGCScopeGuard();
    COREUOBJECT_API ~FGCScopeGuard();
};
 
class FGCScopeTryGuard
{
public:
    COREUOBJECT_API FGCScopeTryGuard();
    COREUOBJECT_API ~FGCScopeTryGuard();
 
    bool LockSucceeded() const { return bLockSuccessful;}
 
private:
    bool bLockSuccessful = false;
};
 
class FGCObject;
 
struct FGarbageReferenceInfo
{
    UObject* GarbageObject;
    union FReferencerUnion
    {
        const UObject* Object;
        FGCObject* GCObject;
    } Referencer;
    bool bReferencerUObject;
    FName PropertyName;
 
    FGarbageReferenceInfo(const UObject* InReferencingObject, UObject* InGarbageObject, FName InPropertyName)
        : GarbageObject(InGarbageObject)
        , bReferencerUObject(true)
        , PropertyName(InPropertyName)
    {
        Referencer.Object = InReferencingObject;
    }
    FGarbageReferenceInfo(FGCObject* InReferencingObject, UObject* InGarbageObject)
        : GarbageObject(InGarbageObject)
        , bReferencerUObject(false)
    {
        Referencer.GCObject = InReferencingObject;
    }
 
    FString GetReferencingObjectInfo() const;
};
 
struct FGCDirectReference
{
    explicit FGCDirectReference(FReferenceToken InReference, FName Name = NAME_None) : ReferencerName(Name), Reference(InReference) {}
    explicit FGCDirectReference(const UObject* Obj, FName Name = NAME_None) : ReferencerName(Name), Reference(Obj) {}
    explicit FGCDirectReference(const Verse::VCell* Cell, FName Name = NAME_None) : ReferencerName(Name), Reference(Cell) {}
    FName ReferencerName;
    FReferenceToken Reference;
};
 
extern COREUOBJECT_API TSAN_ATOMIC(bool) GIsGarbageCollecting;
 
COREUOBJECT_API double GetLastGCTime();
 
COREUOBJECT_API double GetLastGCDuration();
 
UE_FORCEINLINE_HINT bool IsGarbageCollecting()
{
    return GIsGarbageCollecting;
}
 
COREUOBJECT_API bool IsGarbageCollectingAndLockingUObjectHashTables();
 
namespace UE::GC::Private
{
    COREUOBJECT_API void SetSkipDestroy(bool bSkip);
}