// GarbageCollection.cpp
std::atomic<bool> GObjIncrementalPurgeIsInProgress = false;
// GarbageCollection.cpp
bool IsIncrementalPurgePending()
{
  return GObjIncrementalPurgeIsInProgress || GObjPurgeIsRequired;
}

// GarbageCollection.cpp/IncrementalPurgeGarbage()
bTimeLimitReached = UnhashUnreachableObjects(bUseTimeLimit, TimeLimit);

// GarbageCollection.cpp/GatherUnreachableObjects
ParallelFor( TEXT("GC.GatherUnreachable"), ...)

// UnrealEngine.cpp
void UEngine::ForceGarbageCollection(bool bForcePurge/*=false*/)
{
  TimeSinceLastPendingKillPurge = 1.0f + GetTimeBetweenGarbageCollectionPasses();
  bFullPurgeTriggered = bFullPurgeTriggered || bForcePurge;
  //...log
}

// UnrealEngine.cpp
void UEngine::ConditionalCollectGarbage()
{
  ...
  const float TimeBetweenPurgingPendingKillObjects = GetTimeBetweenGarbageCollectionPasses(bHasPlayersConnected);
  ...
  // Perform incremental purge update if it's pending or in progress.
  else if (!IsIncrementalPurgePending()
    // Purge reference to pending kill objects every now and so often.
    && (TimeSinceLastPendingKillPurge > TimeBetweenPurgingPendingKillObjects) && TimeBetweenPurgingPendingKillObjects > 0.f)
  ...
}

// UnrealEngine.cpp
void UEngine::ConditionalCollectGarbage()
{
  if (GFrameCounter != LastGCFrame)

  else if (IsIncrementalReachabilityAnalysisPending())
  {
    PerformIncrementalReachabilityAnalysis(GetReachabilityAnalysisTimeLimit());
  }

  {
    QUICK_SCOPE_CYCLE_COUNTER(STAT_ConditionalCollectGarbage);
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    if (CVarStressTestGCWhileStreaming.GetValueOnGameThread() && IsAsyncLoading())
    {
      CollectGarbage(GARBAGE_COLLECTION_KEEPFLAGS, true);
    }
    else if (CVarForceCollectGarbageEveryFrame.GetValueOnGameThread())
    {
      CollectGarbage(GARBAGE_COLLECTION_KEEPFLAGS, true);
    }
    else
#endif

    {
      EGarbageCollectionType ForceTriggerPurge = ShouldForceGarbageCollection();
#if WITH_VERSE_VM || defined(__INTELLISENSE__)
      if (ForceTriggerPurge == EGarbageCollectionType::None && UE::GC::ShouldFrankenGCRun())
      {
        ForceTriggerPurge = EGarbageCollectionType::Incremental;
      }
#endif
      if (ForceTriggerPurge != EGarbageCollectionType::None)
      {
        ForceGarbageCollection(ForceTriggerPurge == EGarbageCollectionType::Full);
      }

      if (bFullPurgeTriggered)
      {
        if (TryCollectGarbage(GARBAGE_COLLECTION_KEEPFLAGS, true))
        {
          ForEachObjectOfClass(UWorld::StaticClass(),[](UObject* World)
          {
            CastChecked<UWorld>(World)->CleanupActors();
          });
          bFullPurgeTriggered = false;
          bShouldDelayGarbageCollect = false;
          TimeSinceLastPendingKillPurge = 0.0f;
        }
      }

      else
      {
        const bool bTestForPlayers = IsRunningDedicatedServer();
        bool bHasAWorldBegunPlay = false;
        bool bHasPlayersConnected = false;
        // Look for conditions in the worlds that would change the GC frequency
        for (const FWorldContext& Context : WorldList) {
          if (UWorld* World = Context.World()) {
            if (World->HasBegunPlay()) {
              bHasAWorldBegunPlay = true;
            }
            if (bTestForPlayers &&
              World->NetDriver &&
              World->NetDriver->ClientConnections.Num() > 0
            ) {
              bHasPlayersConnected = true;
            }
            // If we found the conditions we wanted, no need to continue iterating
            if (bHasAWorldBegunPlay &&
              (!bTestForPlayers || bHasPlayersConnected)
            ){
              break;
            }
          }
        }

        if (bHasAWorldBegunPlay)
        {
          TimeSinceLastPendingKillPurge += FApp::GetDeltaTime();
          const float TimeBetweenPurgingPendingKillObjects = GetTimeBetweenGarbageCollectionPasses(bHasPlayersConnected);
          // See if we should delay garbage collect for this frame
          if (bShouldDelayGarbageCollect)
          {
            bShouldDelayGarbageCollect = false;
          }
          else if (IsIncrementalReachabilityAnalysisPending())
          {
            SCOPE_CYCLE_COUNTER(STAT_GCMarkTime);
            PerformIncrementalReachabilityAnalysis(GetReachabilityAnalysisTimeLimit());
          }
          // Perform incremental purge update if it's pending or in progress.
          else if (!IsIncrementalPurgePending()
            // Purge reference to pending kill objects every now and so often.
            && (TimeSinceLastPendingKillPurge > TimeBetweenPurgingPendingKillObjects) && TimeBetweenPurgingPendingKillObjects > 0.f)
          {
            SCOPE_CYCLE_COUNTER(STAT_GCMarkTime);
            PerformGarbageCollectionAndCleanupActors();
          }
          else
          {
            SCOPE_CYCLE_COUNTER(STAT_GCSweepTime);
            float IncGCTime = GetIncrementalGCTimePerFrame();
            IncrementalPurgeGarbage(true, IncGCTime);
          }
        }
      }
    }

    if (const int32 Interval = CVarCollectGarbageEveryFrame.GetValueOnGameThread())
    {
      if (0 == (GFrameCounter % Interval))
      {
        ForceGarbageCollection(true);
      }
    }

    else if (CVarContinuousIncrementalGC.GetValueOnGameThread() > 0 &&
        !IsIncrementalReachabilityAnalysisPending() &&
        !IsIncrementalUnhashPending() &&
        !IsIncrementalPurgePending())
    {
      ForceGarbageCollection(false);
    }
    LastGCFrame = GFrameCounter;
  }

  else if (IsIncrementalReachabilityAnalysisPending())
  {
    PerformIncrementalReachabilityAnalysis(GetReachabilityAnalysisTimeLimit());
  }
}

void UEngine::PerformGarbageCollectionAndCleanupActors()
{
  // We don't collect garbage while there are outstanding async load requests as we would need
  // to block on loading the remaining data.
  if (GPerformGCWhileAsyncLoading || !IsAsyncLoading())
  {
    bool bForcePurge = true;
    for (FWorldContext& Context : WorldList)
    {
      UWorld* World = Context.World();
      if (World != nullptr && World->IsGameWorld())
      {
        bForcePurge = false;
        break;
      }
    }

    // Perform housekeeping.
    if (TryCollectGarbage(GARBAGE_COLLECTION_KEEPFLAGS, bForcePurge))
    {
      ForEachObjectOfClass(UWorld::StaticClass(), [](UObject* World)
      {
        CastChecked<UWorld>(World)->CleanupActors();
      });
      // Reset counter.
      TimeSinceLastPendingKillPurge = 0.0f;
      bFullPurgeTriggered = false;
      LastGCFrame = GFrameCounter;
    }
  }
}

// if(bFullPurgeTriggered)
if (TryCollectGarbage(GARBAGE_COLLECTION_KEEPFLAGS, true))
{
  ForEachObjectOfClass(UWorld::StaticClass(),[](UObject* World)
  {
    CastChecked<UWorld>(World)->CleanupActors();
  });
  TimeSinceLastPendingKillPurge = 0.0f;
  bFullPurgeTriggered = false;
  bShouldDelayGarbageCollect = false;
}
// UEngine::PerformGarbageCollectionAndCleanupActors
if (TryCollectGarbage(GARBAGE_COLLECTION_KEEPFLAGS, bForcePurge))
{
  ForEachObjectOfClass(UWorld::StaticClass(), [](UObject* World)
  {
    CastChecked<UWorld>(World)->CleanupActors();
  });
  TimeSinceLastPendingKillPurge = 0.0f;
  bFullPurgeTriggered = false;
  LastGCFrame = GFrameCounter;
}

// GarbageColleciton.cpp
void PerformReachabilityAnalysis(EObjectFlags KeepFlags, const EGCOptions Options) {
  LLM_SCOPE(ELLMTag::GC);
  const bool bIsGarbageTracking = !GReachabilityState.IsSuspended() && Stats.bFoundGarbageRef;
  if (!GReachabilityState.IsSuspended()) {
    StartReachabilityAnalysis(KeepFlags, Options);
    // We start verse GC here so that the objects are unmarked prior to verse marking them
    StartVerseGC();
  }
  {
    const double StartTime = FPlatformTime::Seconds();
    while (true) {
      PerformReachabilityAnalysisPass(Options);
      if (GReachabilityState.IsSuspended()) {
// We may have suspended either via incremental timeout, or because verse GC is still marking.
// If we are not incremental, keep going while verse GC adds to GReachableObjects.
        if (EnumHasAnyFlags(Options, EGCOptions::IncrementalReachability)) {
          break;
        }
      }
      else if (Private::GReachableObjects.IsEmpty() && Private::GReachableClusters.IsEmpty()) {
// We terminate verse GC here now that both sides have nothing left to mark.
// This check must happen only when !IsSuspended, so verse GC can no longer add to GReachableObjects.
        StopVerseGC();
        break;
      }
    }
    // ... time tracing
  }

PRAGMA_DISABLE_DEPRECATION_WARNINGS
  // Allowing external systems to add object roots. This can't be done through AddReferencedObjects
  // because it may require tracing objects (via FGarbageCollectionTracer) multiple times
  if (!GReachabilityState.IsSuspended())
  {
    const double StartTime = FPlatformTime::Seconds();
    FCoreUObjectDelegates::TraceExternalRootsForReachabilityAnalysis.Broadcast(*this, KeepFlags, !(Options & EGCOptions::Parallel));
    GGCStats.TraceExternalRootsTime += FPlatformTime::Seconds() - StartTime;
  }
PRAGMA_ENABLE_DEPRECATION_WARNINGS
}

// GarbageCollection.cpp
void PerformReachabilityAnalysisPass(const EGCOptions Options)
{
  FContextPoolScope Pool;
  FWorkerContext* Context = nullptr;
  if (!GReachabilityState.IsSuspended())
  {
    Context = Pool.AllocateFromPool();
  }
  else
  {
    Context = GReachabilityState.GetContextArray()[0];
    Context->bDidWork = false;
    InitialObjects.Reset();
  }

  if (!Private::GReachableObjects.IsEmpty())
  {
    // Add objects marked with the GC barrier to the inital set of objects for the next iteration of incremental reachability
    Private::GReachableObjects.PopAllAndEmpty(InitialObjects);
    GGCStats.NumBarrierObjects += InitialObjects.Num();
    UE_LOG(LogGarbage, Verbose, TEXT("Adding %d object(s) marker by GC barrier to the list of objects to process"), InitialObjects.Num());
    ConditionallyAddBarrierReferencesToHistory(*Context);
  }

  else if (GReachabilityState.GetNumIterations() == 0 || (Stats.bFoundGarbageRef && !GReachabilityState.IsSuspended()))
  {
    Context->InitialNativeReferences = GetInitialReferences(Options);
  }

  if (!Private::GReachableClusters.IsEmpty())
  {
    // Process cluster roots that were marked as reachable by the GC barrier
    TArray<FUObjectItem*> KeepClusterRefs;
    Private::GReachableClusters.PopAllAndEmpty(KeepClusterRefs);
    for (FUObjectItem* ObjectItem : KeepClusterRefs)
    {
      // Mark referenced clusters and mutable objects as reachable
      MarkReferencedClustersAsReachable<EGCOptions::None>(ObjectItem->GetClusterIndex(), InitialObjects);
    }
  }

  Context->SetInitialObjectsUnpadded(InitialObjects);

  PerformReachabilityAnalysisOnObjects(Context, Options);

  if (!GReachabilityState.IsSuspended())
  {
    GReachabilityState.ResetWorkers();
    Stats.AddStats(Context->Stats);
    GReachabilityState.UpdateStats(Context->Stats);
    Pool.ReturnToPool(Context);
  }
}

template<bool bPerformFullPurge>
void PostCollectGarbageImpl(EObjectFlags KeepFlags)
{
  const double PostCollectStartTime = FPlatformTime::Seconds();
  using namespace UE::GC;
  using namespace UE::GC::Private;
  if (!GIsIncrementalReachabilityPending)
  {
    FContextPoolScope ContextPool;
    TConstArrayView<TUniquePtr<FWorkerContext>> AllContexts = ContextPool.PeekFree();
    // This needs to happen before clusters get dissolved otherwisise cluster information will be missing from history
    UpdateGCHistory(AllContexts);
    // Reconstruct clusters if needed
    if (GUObjectClusters.ClustersNeedDissolving())
    {
      const double StartTime = FPlatformTime::Seconds();
      GUObjectClusters.DissolveClusters();
      UE_LOG(LogGarbage, Log, TEXT("%f ms for dissolving GC clusters"), (FPlatformTime::Seconds() - StartTime) * 1000);
    }
    DumpGarbageReferencers(AllContexts);
    const EGatherOptions GatherOptions = GetObjectGatherOptions();
    DissolveUnreachableClusters(GatherOptions);

    // This needs to happen after DissolveUnreachableClusters since it can mark more objects as unreachable
    if (GReachabilityState.GetNumIterations() > 1){
      ClearWeakReferences<true>(AllContexts);
    } else {
      ClearWeakReferences<false>(AllContexts);
    }
    if (bPerformFullPurge) {
      ContextPool.Cleanup();
    }
    GGatherUnreachableObjectsState.Init();
    if (bPerformFullPurge || !GAllowIncrementalGather || !FGCFlags::IsIncrementalGatherUnreachableSupported()) {
      GatherUnreachableObjects(GatherOptions, /*TimeLimit =*/ 0.0);
    }
  }

  GIsGarbageCollectingAndLockingUObjectHashTables = false;
  UnlockUObjectHashTables();
  GIsGarbageCollecting = false;
  // The hash tables lock was released when reachability analysis was done.
  // BeginDestroy, FinishDestroy, destructors and callbacks are allowed to call functions like StaticAllocateObject and StaticFindObject.
  // Now release the GC lock to allow async loading and other threads to perform UObject operations under the FGCScopeGuard.
  ReleaseGCLock();

  if (!GIsIncrementalReachabilityPending)
  {
    ...
    // Perform a full purge by not using a time limit for the incremental purge.
    if (bPerformFullPurge)
    {
      IncrementalPurgeGarbage(false);
    }
    ...
  }
  //... log and trace
}

while (Iterator.Index <= Iterator.LastIndex)
{
  FUObjectItem* ObjectItem = &GUObjectArray.GetObjectItemArrayUnsafe()[Iterator.Index++];
  if (FGCFlags::IsMaybeUnreachable_ForGC(ObjectItem))
  {
    checkf(!ObjectItem->HasAnyFlags(EInternalObjectFlags::ClusterRoot), TEXT("Unreachable cluster root found. Unreachable clusters should have been dissolved in DissolveUnreachableClusters!"));
    FGCFlags::SetUnreachable(ObjectItem);
    Iterator.Payload.Add({ ObjectItem });
  }
  if (Timer.IsTimeLimitExceeded())
  {
    return;
  }
}

    if (IsIncrementalUnhashPending())
    {
      bTimeLimitReached = UnhashUnreachableObjects(bUseTimeLimit, TimeLimit);
      if (GUnrechableObjectIndex >= GUnreachableObjects.Num())
      {
        FScopedCBDProfile::DumpProfile();
      }
    }
    if (!bTimeLimitReached)
    {
      bCompleted = IncrementalDestroyGarbage(bUseTimeLimit, TimeLimit);
    }

bool IncrementalDestroyGarbage(bool bUseTimeLimit, double TimeLimit)
{
  ...
      while (GObjCurrentPurgeObjectIndex < GUnreachableObjects.Num())
      {
        FUObjectItem* ObjectItem = GUnreachableObjects[GObjCurrentPurgeObjectIndex].ObjectItem;
        checkSlow(ObjectItem);
        check(!FGCFlags::IsReachable_ForGC(ObjectItem) && FGCFlags::IsMaybeUnreachable_ForGC(ObjectItem));
        if (ObjectItem->IsUnreachable())
        {
          UObject* Object = static_cast<UObject*>(ObjectItem->Object);
          // Object should always have had BeginDestroy called on it and never already be destroyed
          check( Object->HasAnyFlags( RF_BeginDestroyed ) && !Object->HasAnyFlags( RF_FinishDestroyed ) );
          // Only proceed with destroying the object if the asynchronous cleanup started by BeginDestroy has finished.
          if(Object->IsReadyForFinishDestroy())
          {
            UE::GC::GDetailedStats.IncPurgeCount(Object);
            // Send FinishDestroy message.
            Object->ConditionalFinishDestroy();
          }
          else
          {
            GGCObjectsPendingDestruction.Add(Object);
            GGCObjectsPendingDestructionCount++;
          }
        }

        ++GObjCurrentPurgeObjectIndex;
        // Only check time limit every so often to avoid calling FPlatformTime::Seconds too often.
        const bool bPollTimeLimit = ((TimeLimitTimePollCounter++) % TimeLimitEnforcementGranularityForDestroy == 0);
        if( bUseTimeLimit && bPollTimeLimit && ((FPlatformTime::Seconds() - GCStartTime) > TimeLimit) )
        {
          bTimeLimitReached = true;
          break;
        }
      }
    }

    // Have we finished the first round of attempting to call FinishDestroy on unreachable objects?
    if (GObjCurrentPurgeObjectIndex >= GUnreachableObjects.Num())
    {
      ...
      while( GGCObjectsPendingDestructionCount > 0 )
      {
        int32 CurPendingObjIndex = 0;
        while( CurPendingObjIndex < GGCObjectsPendingDestructionCount )
        {
          ...
        }

        if( bUseTimeLimit )
        {
          break;
        }

        else if( GGCObjectsPendingDestructionCount > 0 ) {
          if (FPlatformProperties::RequiresCookedData()) {...}
// Sleep before the next pass to give the render thread some time to release fences.
          FPlatformProcess::Sleep( 0 );
        }
        LastLoopObjectsPendingDestructionCount = GGCObjectsPendingDestructionCount;
      }

      // Have all objects been destroyed now?
      if( GGCObjectsPendingDestructionCount == 0 )
      {
        ...
// Release memory we used for objects pending destruction, leaving some slack space
        GGCObjectsPendingDestruction.Empty( 256 );
// Destroy has been routed to all objects so it's safe to delete objects now.
        GObjFinishDestroyHasBeenRoutedToAllObjects = true;
        GObjCurrentPurgeObjectIndexNeedsReset = true;
        GWarningTimeOutHasBeenDisplayedGC = false;
      }
    }
  }

  if (GObjFinishDestroyHasBeenRoutedToAllObjects && !bTimeLimitReached)
  {
    ...
    GUObjectPurge.DestroyObjects(bUseTimeLimit, TimeLimit, GCStartTime);
    ...
    if (GUObjectPurge.IsFinished())
    {
      bCompleted = true;
      ...
    }
  }
  //...log

  return bCompleted;
}

void UWorld::CleanupActors()
{
  // 遍历所有世界
  for (ULevel* Level : Levels)
  {
    if(ensure(Level != nullptr) && (CurrentLevelPendingVisibility != Level))
    {
      const int32 FirstDynamicIndex = 2;
      int32 NumActorsToRemove = 0;
      // 反向遍历 Actors，因为会发生删除 Actor
      for(int32 ActorIndex=Level->Actors.Num()-1;
        ActorIndex>=FirstDynamicIndex;
        ActorIndex-- )
      {
        // 为了减少内存操作次数，在遇到空 Actor 时，
        // 引擎会增加一个连续空 Actor 计数，即上面的 NumActorsToRemove
        // 在遇到非空对象的时候，才会把之前遇到的一系列连续的空 Actor 删除
        if (Level->Actors[ActorIndex] == nullptr)
        {
          ++NumActorsToRemove;
        }
        else if (NumActorsToRemove > 0)
        {
          Level->Actors.RemoveAt(ActorIndex+1, NumActorsToRemove, EAllowShrinking::No);
          NumActorsToRemove = 0;
        }
      }
      if (NumActorsToRemove > 0)
      {
        Level->Actors.RemoveAt(FirstDynamicIndex, NumActorsToRemove, EAllowShrinking::No);
      }
    }
  }
}

  typedef void(FRealtimeGC::*ReachabilityAnalysisFn)(FWorkerContext&);
  /** Pointers to functions used for Reachability Analysis */
  ReachabilityAnalysisFn ReachabilityAnalysisFunctions[8];

FRealtimeGC()
{
  ReachabilityAnalysisFunctions[GetGCFunctionIndex(EGCOptions::None)] = &FRealtimeGC::PerformReachabilityAnalysisOnObjectsInternal<EGCOptions::None | EGCOptions::None>;
  ...
}

  template <EGCOptions Options>
  void PerformReachabilityAnalysisOnObjectsInternal(FWorkerContext& Context)
  {
    TRACE_CPUPROFILER_EVENT_SCOPE(PerformReachabilityAnalysisOnObjectsInternal);
    //... Editor Only
    TReachabilityProcessor<Options> Processor;
    CollectReferencesForGC<TReachabilityCollector<Options>>(Processor, Context);
  }

template<class CollectorType, class ProcessorType>
FORCEINLINE void CollectReferencesForGC(ProcessorType& Processor, UE::GC::FWorkerContext& Context)
{
    using FastReferenceCollector = TFastReferenceCollector<ProcessorType, CollectorType>;
    if constexpr (IsParallel(ProcessorType::Options))
    {       ProcessAsync([](void* P, FWorkerContext& C) { FastReferenceCollector(*reinterpret_cast<ProcessorType*>(P)).ProcessObjectArray(C); }, &Processor, Context);
    }    else
    {
       if (!GReachabilityState.IsSuspended())
       {          GReachabilityState.SetupWorkers(1);
          GReachabilityState.GetContextArray()[0] = &Context;
       }
       FastReferenceCollector(Processor).ProcessObjectArray(Context);
       Context.ResetInitialObjects();
       Context.InitialNativeReferences = TConstArrayView<UObject**>();
       GReachabilityState.CheckIfAnyContextIsSuspended();
    }}

FastReferenceCollector(Processor).ProcessObjectArray(Context);

  void ProcessObjectArray(FWorkerContext& Context)
  {
    Context.bDidWork = true;
    Context.bIsSuspended = false;
    static_assert(!EnumHasAllFlags(Options, EGCOptions::Parallel | EGCOptions::AutogenerateSchemas), "Can't assemble token streams in parallel");
    CollectorType Collector(Processor, Context);
    // Either TDirectDispatcher living on the stack or TBatchDispatcher reference owned by Collector
    decltype(GetDispatcher(Collector, Processor, Context)) Dispatcher = GetDispatcher(Collector, Processor, Context);

StoleContext:
    // Process initial references first
    Context.ReferencingObject = FGCObject::GGCObjectReferencer;
    for (UObject** InitialReference : Context.InitialNativeReferences)
    {
      Dispatcher.HandleKillableReference(*InitialReference, EMemberlessId::InitialReference, EOrigin::Other);
    }
    TConstArrayView<UObject*> CurrentObjects = Context.InitialObjects;

    while (true)
    {
      Context.Stats.AddObjects(CurrentObjects.Num());
      ProcessObjects(Dispatcher, CurrentObjects);

      // Free finished work block
      if (CurrentObjects.GetData() != Context.InitialObjects.GetData())
      {
        Context.ObjectsToSerialize.FreeOwningBlock(CurrentObjects.GetData());
      }

      if (Processor.IsTimeLimitExceeded())
      {
        FlushWork(Dispatcher);
        Dispatcher.Suspend();
        SuspendWork(Context);
        return;
      }

      int32 BlockSize = FWorkBlock::ObjectCapacity;
      FWorkBlockifier& RemainingObjects = Context.ObjectsToSerialize;
      FWorkBlock* Block = RemainingObjects.PopFullBlock<Options>();

      if (!Block)
      {
        if constexpr (bIsParallel)
        {
          FSlowARO::ProcessUnbalancedCalls(Context, Collector);
        }
StoleARO:
        FlushWork(Dispatcher);

        if (Block = RemainingObjects.PopFullBlock<Options>(); Block);
        else if (Block = RemainingObjects.PopPartialBlock(/* out if successful */ BlockSize); Block);

        else if (bIsParallel) // if constexpr yields MSVC unreferenced label warning
        {
          switch (StealWork(/* in-out */ Context, Collector, /* out */ Block, Options))
          {
            case ELoot::Nothing:  break;        // Done, stop working
            case ELoot::Block: break;        // Stole full block, process it
            case ELoot::ARO:  goto StoleARO;    // Stole and made ARO calls that feed into Dispatcher queues and RemainingObjects
            case ELoot::Context:  goto StoleContext;  // Stole initial references and initial objects worker that hasn't started working
          }
        }

        if (!Block)
        {
          break;
        }
      }

      CurrentObjects = MakeArrayView(Block->Objects, BlockSize);
    } // while (true)

    Processor.LogDetailedStatsSummary();
  }

FORCEINLINE_DEBUGGABLE void ProcessObjects(DispatcherType& Dispatcher, TConstArrayView<UObject*> CurrentObjects)
{
  for (FPrefetchingObjectIterator It(CurrentObjects); It.HasMore(); It.Advance())
  {
    UObject* CurrentObject = It.GetCurrentObject();
    UClass* Class = CurrentObject->GetClass();
    UObject* Outer = CurrentObject->GetOuter();

    if (!!(Options & EGCOptions::AutogenerateSchemas) && !Class->HasAnyClassFlags(CLASS_TokenStreamAssembled))
    {
      Class->AssembleReferenceTokenStream();
    }
    FSchemaView Schema = Class->ReferenceSchema.Get();
    Dispatcher.Context.ReferencingObject = CurrentObject;

    // Emit base references
    Dispatcher.HandleImmutableReference(Class, EMemberlessId::Class, EOrigin::Other);
    Dispatcher.HandleImmutableReference(Outer, EMemberlessId::Outer, EOrigin::Other);
#if WITH_EDITOR
    UObject* Package = CurrentObject->GetExternalPackageInternal();
    Package = Package != CurrentObject ? Package : nullptr;
    Dispatcher.HandleImmutableReference(Package, EMemberlessId::ExternalPackage, EOrigin::Other);
#endif

    if (!Schema.IsEmpty())
    {
      typename DispatcherType::SchemaStackScopeType SchemaStack(Dispatcher.Context, Schema);
      Processor.BeginTimingObject(CurrentObject);
      Private::VisitMembers(Dispatcher, Schema, CurrentObject);
      Processor.UpdateDetailedStats(CurrentObject);
    }}}