虚幻4垃圾回收剖析

/**
* Deletes all unreferenced objects, keeping objects that have any of the passed in KeepFlags set. Will wait for other threads to unlock GC.
*
* @param    KeepFlags            objects with those flags will be kept regardless of being referenced or not
* @param    bPerformFullPurge    if true, perform a full purge after the mark pass
*/
COREUOBJECT_API void CollectGarbage(EObjectFlags KeepFlags, bool bPerformFullPurge = true);

void CollectGarbage(EObjectFlags KeepFlags, bool bPerformFullPurge)
{
    // No other thread may be performing UOBject operations while we're running
    GGarbageCollectionGuardCritical.GCLock();
    // Perform actual garbage collection
    CollectGarbageInternal(KeepFlags, bPerformFullPurge);
    // Other threads are free to use UObjects
    GGarbageCollectionGuardCritical.GCUnlock();
}

/**
 * Performs reachability analysis.
 *
 * @param KeepFlags        Objects with these flags will be kept regardless of being referenced or not
*/

void PerformReachabilityAnalysis(EObjectFlags KeepFlags, bool bForceSingleThreaded = false)
{        
    /** Growing array of objects that require serialization */
    TArray<UObject*>& ObjectsToSerialize = *FGCArrayPool::Get().GetArrayFromPool();

    // Reset object count.
    GObjectCountDuringLastMarkPhase = 0;


    // Presize array and add a bit of extra slack for prefetching.
    ObjectsToSerialize.Reset( GUObjectArray.GetObjectArrayNumMinusPermanent() + 3 );
    // Make sure GC referencer object is checked for references to other objects even if it resides in permanent object pool
    if (FPlatformProperties::RequiresCookedData() && FGCObject::GGCObjectReferencer && GUObjectArray.IsDisregardForGC(FGCObject::GGCObjectReferencer))
    {
        ObjectsToSerialize.Add(FGCObject::GGCObjectReferencer);
    }

    MarkObjectsAsUnreachable(ObjectsToSerialize, KeepFlags);

    {
        FGCReferenceProcessor ReferenceProcessor;
        TFastReferenceCollector<FGCReferenceProcessor, FGCCollector, FGCArrayPool> ReferenceCollector(ReferenceProcessor, FGCArrayPool::Get());
        ReferenceCollector.CollectReferences(ObjectsToSerialize, bForceSingleThreaded);
    }

    FGCArrayPool::Get().ReturnToPool(&ObjectsToSerialize);
}

{
    FGCReferenceProcessor ReferenceProcessor;
    TFastReferenceCollector<FGCReferenceProcessor, FGCCollector, FGCArrayPool> ReferenceCollector(ReferenceProcessor, FGCArrayPool::Get());
    ReferenceCollector.CollectReferences(ObjectsToSerialize, bForceSingleThreaded);
}

// Make sure that token stream has been assembled at this point as the below code relies on it.
if (bAutoGenerateTokenStream && !ReferenceProcessor.IsRunningMultithreaded())
{
    UClass* ObjectClass = CurrentObject->GetClass();
    if (!ObjectClass->HasAnyClassFlags(CLASS_TokenStreamAssembled))
    {
        ObjectClass->AssembleReferenceTokenStream();
    }
}
 

TokenStreamIndex++;
FGCReferenceInfo ReferenceInfo = TokenStream->AccessReferenceInfo(ReferenceTokenStreamIndex);
if (ReferenceInfo.Type == GCRT_Object)
{
    // We're dealing with an object reference.
    UObject**    ObjectPtr = (UObject**)(StackEntryData + ReferenceInfo.Offset);
    UObject*&    Object = *ObjectPtr;
    TokenReturnCount = ReferenceInfo.ReturnCount;
    ReferenceProcessor.HandleTokenStreamObjectReference(NewObjectsToSerialize, CurrentObject, Object, ReferenceTokenStreamIndex, true);
}
else if (ReferenceInfo.Type == GCRT_ArrayObject)
{
    // We're dealing with an array of object references.
    TArray<UObject*>& ObjectArray = *((TArray<UObject*>*)(StackEntryData + ReferenceInfo.Offset));
    TokenReturnCount = ReferenceInfo.ReturnCount;
    for (int32 ObjectIndex = 0, ObjectNum = ObjectArray.Num(); ObjectIndex < ObjectNum; ++ObjectIndex)
    {
        ReferenceProcessor.HandleTokenStreamObjectReference(NewObjectsToSerialize, CurrentObject, ObjectArray[ObjectIndex], ReferenceTokenStreamIndex, true);
    }
}
...

void UClass::AssembleReferenceTokenStream(bool bForce)
{
    if (!HasAnyClassFlags(CLASS_TokenStreamAssembled) || bForce)
    {
        if (bForce)
        {
            ReferenceTokenStream.Empty();
            ClassFlags &= ~CLASS_TokenStreamAssembled;
        }
        TArray<const UStructProperty*> EncounteredStructProps;
        // Iterate over properties defined in this class
        for( TFieldIterator<UProperty> It(this,EFieldIteratorFlags::ExcludeSuper); It; ++It)
        {
            UProperty* Property = *It;
            Property->EmitReferenceInfo(*this, 0, EncounteredStructProps);
        }
        if (GetSuperClass())
        {
            GetSuperClass()->AssembleReferenceTokenStream();
            if (!GetSuperClass()->ReferenceTokenStream.IsEmpty())
                PrependStreamWithSuperClass(*GetSuperClass());
        }
        else
            UObjectBase::EmitBaseReferences(this);
        static const FName EOSDebugName("EOS");
        EmitObjectReference(0, EOSDebugName, GCRT_EndOfStream);
        ReferenceTokenStream.Shrink();
        ClassFlags |= CLASS_TokenStreamAssembled;
    }
}

/**
* Emits tokens used by realtime garbage collection code to passed in OwnerClass' ReferenceTokenStream. The offset emitted is relative
* to the passed in BaseOffset which is used by e.g. arrays of structs.
*/
void UObjectProperty::EmitReferenceInfo(UClass& OwnerClass, int32 BaseOffset, TArray<const UStructProperty*>& EncounteredStructProps)
{
    FGCReferenceFixedArrayTokenHelper FixedArrayHelper(OwnerClass, BaseOffset + GetOffset_ForGC(), ArrayDim, sizeof(UObject*), *this);
    OwnerClass.EmitObjectReference(BaseOffset + GetOffset_ForGC(), GetFName(), GCRT_Object);
}

/** Looks through objects loaded with a package and creates clusters from them */
void CreateClustersFromPackage(FLinkerLoad* PackageLinker)
{    
    if (FPlatformProperties::RequiresCookedData() && !GIsInitialLoad && GCreateGCClusters && !GUObjectArray.IsOpenForDisregardForGC())
    {
        check(PackageLinker);

        for (FObjectExport& Export : PackageLinker->ExportMap)
        {
            if (Export.Object && Export.Object->CanBeClusterRoot())
            {
                Export.Object->CreateCluster();
            }
        }
    }
}

void UObjectBaseUtility::CreateCluster()
{
    FUObjectItem* RootItem = GUObjectArray.IndexToObject(InternalIndex);
    if (RootItem->GetOwnerIndex() != 0 || RootItem->HasAnyFlags(EInternalObjectFlags::ClusterRoot))
    {
        return;
    }
    // If we haven't finished loading, we can't be sure we know all the references
    check(!HasAnyFlags(RF_NeedLoad | RF_NeedPostLoad));
    // Create a new cluster, reserve an arbitrary amount of memory for it.
    FUObjectCluster* Cluster = new FUObjectCluster;
    Cluster->Objects.Reserve(64);
 
    // Collect all objects referenced by cluster root and by all objects it's referencing
    FClusterReferenceProcessor Processor(InternalIndex, *Cluster);
    TFastReferenceCollector<FClusterReferenceProcessor, TClusterCollector<FClusterReferenceProcessor>, FClusterArrayPool, true> ReferenceCollector(Processor, FClusterArrayPool::Get());
    TArray<UObject*> ObjectsToProcess;
    ObjectsToProcess.Add(static_cast<UObject*>(this));
    ReferenceCollector.CollectReferences(ObjectsToProcess, true);
    if (Cluster->Objects.Num())
    {
        // Add new cluster to the global cluster map.
        GUObjectClusters.Add(InternalIndex, Cluster);
        check(RootItem->GetOwnerIndex() == 0);
        RootItem->SetFlags(EInternalObjectFlags::ClusterRoot);
    }
    else
    {
        delete Cluster;
    }
}

for (FRawObjectIterator It(true); It; ++It)
{
    FUObjectItem* ObjectItem = *It;
    if (ObjectItem->IsUnreachable())
    {
        if ((ObjectItem->GetFlags() & EInternalObjectFlags::ClusterRoot) == EInternalObjectFlags::ClusterRoot)// Nuke the entire cluster
        {
            ObjectItem->ClearFlags(EInternalObjectFlags::ClusterRoot | EInternalObjectFlags::NoStrongReference);
            const int32 ClusterRootIndex = It.GetIndex();
            FUObjectCluster* Cluster = GUObjectClusters.FindChecked(ClusterRootIndex);
            for (int32 ClusterObjectIndex : Cluster->Objects)
            {
                FUObjectItem* ClusterObjectItem = GUObjectArray.IndexToObjectUnsafeForGC(ClusterObjectIndex);
                ClusterObjectItem->ClearFlags(EInternalObjectFlags::NoStrongReference);
                ClusterObjectItem->SetOwnerIndex(0);
                if (!ClusterObjectItem->HasAnyFlags(EInternalObjectFlags::ReachableInCluster))
                {
                    ClusterObjectItem->SetFlags(EInternalObjectFlags::Unreachable);
                    if (ClusterObjectIndex < ClusterRootIndex)
                    {
                        UObject* ClusterObject = (UObject*)ClusterObjectItem->Object;
                        ClusterObject->ConditionalBeginDestroy();
                    }
                }
            }
            delete Cluster;
            GUObjectClusters.Remove(ClusterRootIndex);
        }
    }
}