@fluidframework/container-runtime 2.0.0-internal.4.3.0 → 2.0.0-internal.4.4.0

package/lib/gc/garbageCollection.js

@@ -91,8 +91,7 @@ export class GarbageCollector {
                 // in the snapshot cannot be interpreted correctly. Set everything to undefined except for
                 // deletedNodes because irrespective of GC versions, these nodes have been deleted and cannot be
                 // brought back. The deletedNodes info is needed to identify when these nodes are used.
-                if (this.configs.gcVersionInBaseSnapshot !==
-                    this.summaryStateTracker.currentGCVersion) {
+                if (this.configs.gcVersionInEffect !== this.configs.gcVersionInBaseSnapshot) {
                     return {
                         gcState: undefined,
                         tombstones: undefined,
@@ -181,6 +180,10 @@ export class GarbageCollector {
     get summaryStateNeedsReset() {
         return this.summaryStateTracker.doesSummaryStateNeedReset;
     }
+    /** Returns the count of data stores whose GC state updated since the last summary. */
+    get updatedDSCountSinceLastSummary() {
+        return this.summaryStateTracker.updatedDSCountSinceLastSummary;
+    }
     /**
      * Called during container initialization. Initialize from the tombstone state in the base snapshot. This is done
      * during initialization so that deleted or tombstoned objects are marked as such before they are loaded or used.
@@ -302,6 +305,13 @@ export class GarbageCollector {
             this.initializeGCStateFromBaseSnapshotP.catch((error) => { });
         }
     }
+    /**
+     * Returns a the GC details generated from the base summary. This is used to initialize the GC state of the nodes
+     * in the container.
+     */
+    async getBaseGCDetails() {
+        return this.baseGCDetailsP;
+    }
     /**
      * Runs garbage collection and updates the reference / used state of the nodes in the container.
      * @returns stats of the GC run or undefined if GC did not run.
@@ -337,53 +347,224 @@ export class GarbageCollector {
             return undefined;
         }
         return PerformanceEvent.timedExecAsync(logger, { eventName: "GarbageCollection" }, async (event) => {
-            await this.runPreGCSteps();
-            // Get the runtime's GC data and run GC on the reference graph in it.
-            const gcData = await this.runtime.getGCData(fullGC);
-            const gcResult = runGarbageCollection(gcData.gcNodes, ["/"]);
-            const gcStats = await this.runPostGCSteps(gcData, gcResult, logger, currentReferenceTimestampMs);
+            /** Pre-GC steps */
+            // Ensure that state has been initialized from the base snapshot data.
+            await this.initializeGCStateFromBaseSnapshotP;
+            // Let the runtime update its pending state before GC runs.
+            await this.runtime.updateStateBeforeGC();
+            /** GC step */
+            const gcStats = await this.runGC(fullGC, currentReferenceTimestampMs, logger);
             event.end(Object.assign(Object.assign({}, gcStats), { timestamp: currentReferenceTimestampMs }));
+            /** Post-GC steps */
+            // Log pending unreferenced events such as a node being used after inactive. This is done after GC runs and
+            // updates its state so that we don't send false positives based on intermediate state. For example, we may get
+            // reference to an unreferenced node from another unreferenced node which means the node wasn't revived.
+            await this.telemetryTracker.logPendingEvents(logger);
+            // Update the state of summary state tracker from this run's stats.
+            this.summaryStateTracker.updateStateFromGCRunStats(gcStats);
+            this.newReferencesSinceLastRun.clear();
             this.completedRuns++;
             return gcStats;
         }, { end: true, cancel: "error" });
     }
-    async runPreGCSteps() {
-        // Ensure that state has been initialized from the base snapshot data.
-        await this.initializeGCStateFromBaseSnapshotP;
-        // Let the runtime update its pending state before GC runs.
-        await this.runtime.updateStateBeforeGC();
-    }
-    async runPostGCSteps(gcData, gcResult, logger, currentReferenceTimestampMs) {
-        // Generate statistics from the current run. This is done before updating the current state because it
-        // generates some of its data based on previous state of the system.
+    /**
+     * Runs garbage collection. It does the following:
+     * 1. It generates / analyzes the runtime's reference graph.
+     * 2. Generates stats for the GC run based on previous / current GC state.
+     * 3. Runs Mark phase.
+     * 4. Runs Sweep phase.
+     */
+    async runGC(fullGC, currentReferenceTimestampMs, logger) {
+        var _a;
+        // 1. Generate / analyze the runtime's reference graph.
+        // Get the reference graph (gcData) and run GC algorithm to get referenced / unreferenced nodes.
+        const gcData = await this.runtime.getGCData(fullGC);
+        const gcResult = runGarbageCollection(gcData.gcNodes, ["/"]);
+        // Get all referenced nodes - References in this run + references between the previous and current runs.
+        const allReferencedNodeIds = (_a = this.findAllNodesReferencedBetweenGCs(gcData, this.gcDataFromLastRun, logger)) !== null && _a !== void 0 ? _a : gcResult.referencedNodeIds;
+        // 2. Generate stats based on the previous / current GC state.
+        // Must happen before running Mark / Sweep phase because previous GC state will be updated in these stages.
         const gcStats = this.generateStats(gcResult);
-        // Update the current mark state and update the runtime of all used routes or ids that used as per the GC run.
-        const sweepReadyNodes = this.updateMarkPhase(gcData, gcResult, currentReferenceTimestampMs, logger);
+        // 3. Run the Mark phase.
+        // It will mark nodes as referenced / unreferenced and return a list of node ids that are ready to be swept.
+        const sweepReadyNodeIds = this.runMarkPhase(gcResult, allReferencedNodeIds, currentReferenceTimestampMs);
+        // 4. Run the Sweep phase.
+        // It will delete sweep ready nodes and return a list of deleted node ids.
+        const deletedNodeIds = this.runSweepPhase(gcResult, sweepReadyNodeIds, currentReferenceTimestampMs, logger);
+        this.gcDataFromLastRun = cloneGCData(gcData, (id) => deletedNodeIds.includes(id) /* filter out deleted nodes */);
+        return gcStats;
+    }
+    /**
+     * Runs the GC Mark phase. It does the following:
+     * 1. Marks all referenced nodes in this run by clearing tracking for them.
+     * 2. Marks unreferenced nodes in this run by starting tracking for them.
+     * 3. Calls the runtime to update nodes that were marked referenced.
+     *
+     * @param gcResult - The result of the GC run on the gcData.
+     * @param allReferencedNodeIds - Nodes referenced in this GC run + referenced between previous and current GC run.
+     * @param currentReferenceTimestampMs - The timestamp to be used for unreferenced nodes' timestamp.
+     * @returns - A list of sweep ready nodes, i.e., nodes that ready to be deleted.
+     */
+    runMarkPhase(gcResult, allReferencedNodeIds, currentReferenceTimestampMs) {
+        // 1. Marks all referenced nodes by clearing their unreferenced tracker, if any.
+        for (const nodeId of allReferencedNodeIds) {
+            const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
+            if (nodeStateTracker !== undefined) {
+                // Stop tracking so as to clear out any running timers.
+                nodeStateTracker.stopTracking();
+                // Delete the node as we don't need to track it any more.
+                this.unreferencedNodesState.delete(nodeId);
+            }
+        }
+        // 2. Mark unreferenced nodes in this run by starting unreferenced tracking for them.
+        const sweepReadyNodeIds = [];
+        for (const nodeId of gcResult.deletedNodeIds) {
+            const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
+            if (nodeStateTracker === undefined) {
+                this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(currentReferenceTimestampMs, this.configs.inactiveTimeoutMs, currentReferenceTimestampMs, this.configs.sweepTimeoutMs));
+            }
+            else {
+                // If a node was already unreferenced, update its tracking information. Since the current reference time
+                // is from the ops seen, this will ensure that we keep updating unreferenced state as time moves forward.
+                nodeStateTracker.updateTracking(currentReferenceTimestampMs);
+                // If a node is sweep ready, store it so it can be returned.
+                if (nodeStateTracker.state === UnreferencedState.SweepReady) {
+                    sweepReadyNodeIds.push(nodeId);
+                }
+            }
+        }
+        // 3. Call the runtime to update referenced nodes in this run.
         this.runtime.updateUsedRoutes(gcResult.referencedNodeIds);
-        // Log events for objects that are ready to be deleted by sweep.
+        return sweepReadyNodeIds;
+    }
+    /**
+     * Runs the GC Sweep phase. It does the following:
+     * 1. Calls the runtime to delete nodes that are sweep ready.
+     * 2. Clears tracking for deleted nodes.
+     *
+     * @param gcResult - The result of the GC run on the gcData.
+     * @param sweepReadyNodes - List of nodes that are sweep ready.
+     * @param currentReferenceTimestampMs - The timestamp to be used for unreferenced nodes' timestamp.
+     * @param logger - The logger to be used to log any telemetry.
+     * @returns - A list of nodes that have been deleted.
+     */
+    runSweepPhase(gcResult, sweepReadyNodes, currentReferenceTimestampMs, logger) {
+        // Log events for objects that are ready to be deleted by sweep. This will give us data on sweep when
+        // its not enabled.
         this.telemetryTracker.logSweepEvents(logger, currentReferenceTimestampMs, this.unreferencedNodesState, this.completedRuns, this.getLastSummaryTimestampMs());
-        let updatedGCData = gcData;
-        if (this.configs.shouldRunSweep) {
-            updatedGCData = this.runSweepPhase(sweepReadyNodes, gcData);
-        }
-        else if (this.configs.testMode) {
-            // If we are running in GC test mode, delete objects for unused routes. This enables testing scenarios
-            // involving access to deleted data.
+        /**
+         * Currently, there are 3 modes for sweep:
+         * Test mode - Unreferenced nodes are immediately deleted without waiting for them to be sweep ready.
+         * Tombstone mode - Sweep ready modes are marked as tombstones instead of being deleted.
+         * Sweep mode - Sweep ready modes are deleted.
+         *
+         * These modes serve as staging for applications that want to enable sweep by providing an incremental
+         * way to test and validate sweep works as expected.
+         */
+        if (this.configs.testMode) {
+            // If we are running in GC test mode, unreferenced nodes (gcResult.deletedNodeIds) are deleted.
             this.runtime.updateUnusedRoutes(gcResult.deletedNodeIds);
+            return [];
         }
-        else if (this.configs.tombstoneMode) {
+        if (this.configs.tombstoneMode) {
             this.tombstones = sweepReadyNodes;
             // If we are running in GC tombstone mode, update tombstoned routes. This enables testing scenarios
             // involving access to "deleted" data without actually deleting the data from summaries.
-            // Note: we will not tombstone in test mode.
             this.runtime.updateTombstonedRoutes(this.tombstones);
+            return [];
         }
-        this.gcDataFromLastRun = cloneGCData(updatedGCData);
-        // Log pending unreferenced events such as a node being used after inactive. This is done after GC runs and
-        // updates its state so that we don't send false positives based on intermediate state. For example, we may get
-        // reference to an unreferenced node from another unreferenced node which means the node wasn't revived.
-        await this.telemetryTracker.logPendingEvents(logger);
-        return gcStats;
+        if (!this.configs.shouldRunSweep) {
+            return [];
+        }
+        // 1. Call the runtime to delete sweep ready nodes. The runtime returns a list of nodes it deleted.
+        // TODO: GC:Validation - validate that removed routes are not double delete and that the child routes of
+        // removed routes are deleted as well.
+        const deletedNodeIds = this.runtime.deleteSweepReadyNodes(sweepReadyNodes);
+        // 2. Clear unreferenced state tracking for deleted nodes.
+        for (const nodeId of deletedNodeIds) {
+            const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
+            // TODO: GC:Validation - assert that the nodeStateTracker is defined
+            if (nodeStateTracker !== undefined) {
+                // Stop tracking so as to clear out any running timers.
+                nodeStateTracker.stopTracking();
+                // Delete the node as we don't need to track it any more.
+                this.unreferencedNodesState.delete(nodeId);
+            }
+            // TODO: GC:Validation - assert that the deleted node is not a duplicate
+            this.deletedNodes.add(nodeId);
+        }
+        return deletedNodeIds;
+    }
+    /**
+     * Since GC runs periodically, the GC data that is generated only tells us the state of the world at that point in
+     * time. There can be nodes that were referenced in between two runs and their unreferenced state needs to be
+     * updated. For example, in the following scenarios not updating the unreferenced timestamp can lead to deletion of
+     * these objects while there can be in-memory referenced to it:
+     * 1. A node transitions from `unreferenced -> referenced -> unreferenced` between two runs. When the reference is
+     * added, the object may have been accessed and in-memory reference to it added.
+     * 2. A reference is added from one unreferenced node to one or more unreferenced nodes. Even though the node[s] were
+     * unreferenced, they could have been accessed and in-memory reference to them added.
+     *
+     * This function identifies nodes that were referenced since the last run.
+     * If these nodes are currently unreferenced, they will be assigned new unreferenced state by the current run.
+     *
+     * @returns - a list of all nodes referenced from the last local summary until now.
+     */
+    findAllNodesReferencedBetweenGCs(currentGCData, previousGCData, logger) {
+        // If we haven't run GC before there is nothing to do.
+        // No previousGCData, means nothing is unreferenced, and there are no reference state trackers to clear
+        if (previousGCData === undefined) {
+            return undefined;
+        }
+        /**
+         * If there are references that were not explicitly notified to GC, log an error because this should never happen.
+         * If it does, this may result in the unreferenced timestamps of these nodes not updated when they were referenced.
+         */
+        this.telemetryTracker.logIfMissingExplicitReferences(currentGCData, previousGCData, this.newReferencesSinceLastRun, logger);
+        // No references were added since the last run so we don't have to update reference states of any unreferenced
+        // nodes. There is no in between state at this point.
+        if (this.newReferencesSinceLastRun.size === 0) {
+            return undefined;
+        }
+        /**
+         * Generate a super set of the GC data that contains the nodes and edges from last run, plus any new node and
+         * edges that have been added since then. To do this, combine the GC data from the last run and the current
+         * run, and then add the references since last run.
+         *
+         * Note on why we need to combine the data from previous run, current run and all references in between -
+         * 1. We need data from last run because some of its references may have been deleted since then. If those
+         * references added new outbound references before they were deleted, we need to detect them.
+         *
+         * 2. We need new outbound references since last run because some of them may have been deleted later. If those
+         * references added new outbound references before they were deleted, we need to detect them.
+         *
+         * 3. We need data from the current run because currently we may not detect when DDSes are referenced:
+         * - We don't require DDSes handles to be stored in a referenced DDS.
+         * - A new data store may have "root" DDSes already created and we don't detect them today.
+         */
+        const gcDataSuperSet = concatGarbageCollectionData(previousGCData, currentGCData);
+        const newOutboundRoutesSinceLastRun = [];
+        this.newReferencesSinceLastRun.forEach((outboundRoutes, sourceNodeId) => {
+            if (gcDataSuperSet.gcNodes[sourceNodeId] === undefined) {
+                gcDataSuperSet.gcNodes[sourceNodeId] = outboundRoutes;
+            }
+            else {
+                gcDataSuperSet.gcNodes[sourceNodeId].push(...outboundRoutes);
+            }
+            newOutboundRoutesSinceLastRun.push(...outboundRoutes);
+        });
+        /**
+         * Run GC on the above reference graph starting with root and all new outbound routes. This will generate a
+         * list of all nodes that could have been referenced since the last run. If any of these nodes are unreferenced,
+         * unreferenced, stop tracking them and remove from unreferenced list.
+         * Note that some of these nodes may be unreferenced now and if so, the current run will mark them as
+         * unreferenced and add unreferenced state.
+         */
+        const gcResult = runGarbageCollection(gcDataSuperSet.gcNodes, [
+            "/",
+            ...newOutboundRoutesSinceLastRun,
+        ]);
+        return gcResult.referencedNodeIds;
     }
     /**
      * Summarizes the GC data and returns it as a summary tree.
@@ -407,23 +588,16 @@ export class GarbageCollector {
     getMetadata() {
         return {
             /**
-             * If GC is enabled, the GC data is written using the current GC version and that is the gcFeature that goes
+             * If GC is enabled, the GC data is written using the GC version in effect and that is the gcFeature that goes
              * into the metadata blob. If GC is disabled, the gcFeature is 0.
              */
-            gcFeature: this.configs.gcEnabled ? this.summaryStateTracker.currentGCVersion : 0,
+            gcFeature: this.configs.gcEnabled ? this.configs.gcVersionInEffect : 0,
             gcFeatureMatrix: this.configs.persistedGcFeatureMatrix,
             sessionExpiryTimeoutMs: this.configs.sessionExpiryTimeoutMs,
             sweepEnabled: false,
             sweepTimeoutMs: this.configs.sweepTimeoutMs,
         };
     }
-    /**
-     * Returns a the GC details generated from the base summary. This is used to initialize the GC state of the nodes
-     * in the container.
-     */
-    async getBaseGCDetails() {
-        return this.baseGCDetailsP;
-    }
     /**
      * Called to refresh the latest summary state. This happens when either a pending summary is acked or a snapshot
      * is downloaded and should be used to update the state.
@@ -459,7 +633,7 @@ export class GarbageCollector {
             return;
         }
         this.telemetryTracker.nodeUsed({
-            nodeId: nodePath,
+            id: nodePath,
             usageType: reason,
             currentReferenceTimestampMs: timestampMs !== null && timestampMs !== void 0 ? timestampMs : this.runtime.getCurrentReferenceTimestampMs(),
             packagePath,
@@ -485,7 +659,7 @@ export class GarbageCollector {
         outboundRoutes.push(toNodePath);
         this.newReferencesSinceLastRun.set(fromNodePath, outboundRoutes);
         this.telemetryTracker.nodeUsed({
-            nodeId: toNodePath,
+            id: toNodePath,
             usageType: "Revived",
             currentReferenceTimestampMs: this.runtime.getCurrentReferenceTimestampMs(),
             packagePath: undefined,
@@ -507,164 +681,6 @@ export class GarbageCollector {
         (_a = this.sessionExpiryTimer) === null || _a === void 0 ? void 0 : _a.clear();
         this.sessionExpiryTimer = undefined;
     }
-    /**
-     * Updates the state of the system as per the current GC run. It does the following:
-     * 1. Sets up the current GC state as per the gcData.
-     * 2. Starts tracking for nodes that have become unreferenced in this run.
-     * 3. Clears tracking for nodes that were unreferenced but became referenced in this run.
-     * @param gcData - The data representing the reference graph on which GC is run.
-     * @param gcResult - The result of the GC run on the gcData.
-     * @param currentReferenceTimestampMs - The timestamp to be used for unreferenced nodes' timestamp.
-     * @returns - A list of sweep ready nodes. (Nodes ready to be deleted)
-     */
-    updateMarkPhase(gcData, gcResult, currentReferenceTimestampMs, logger) {
-        var _a;
-        // Get references from the current GC run + references between previous and current run and then update each
-        // node's state
-        const allNodesReferencedBetweenGCs = (_a = this.findAllNodesReferencedBetweenGCs(gcData, this.gcDataFromLastRun, logger)) !== null && _a !== void 0 ? _a : gcResult.referencedNodeIds;
-        this.newReferencesSinceLastRun.clear();
-        // Iterate through the referenced nodes and stop tracking if they were unreferenced before.
-        for (const nodeId of allNodesReferencedBetweenGCs) {
-            const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
-            if (nodeStateTracker !== undefined) {
-                // Stop tracking so as to clear out any running timers.
-                nodeStateTracker.stopTracking();
-                // Delete the node as we don't need to track it any more.
-                this.unreferencedNodesState.delete(nodeId);
-            }
-        }
-        /**
-         * If a node became unreferenced in this run, start tracking it.
-         * If a node was already unreferenced, update its tracking information. Since the current reference time is
-         * from the ops seen, this will ensure that we keep updating the unreferenced state as time moves forward.
-         *
-         * If a node is sweep ready, store and then return it.
-         */
-        const sweepReadyNodes = [];
-        for (const nodeId of gcResult.deletedNodeIds) {
-            const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
-            if (nodeStateTracker === undefined) {
-                this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(currentReferenceTimestampMs, this.configs.inactiveTimeoutMs, currentReferenceTimestampMs, this.configs.sweepTimeoutMs));
-            }
-            else {
-                nodeStateTracker.updateTracking(currentReferenceTimestampMs);
-                if (nodeStateTracker.state === UnreferencedState.SweepReady) {
-                    sweepReadyNodes.push(nodeId);
-                }
-            }
-        }
-        return sweepReadyNodes;
-    }
-    /**
-     * Deletes nodes from both the runtime and garbage collection
-     * @param sweepReadyNodes - nodes that are ready to be deleted
-     */
-    runSweepPhase(sweepReadyNodes, gcData) {
-        // TODO: GC:Validation - validate that removed routes are not double deleted
-        // TODO: GC:Validation - validate that the child routes of removed routes are deleted as well
-        const sweptRoutes = this.runtime.deleteSweepReadyNodes(sweepReadyNodes);
-        const updatedGCData = this.deleteSweptRoutes(sweptRoutes, gcData);
-        for (const nodeId of sweptRoutes) {
-            const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
-            // TODO: GC:Validation - assert that the nodeStateTracker is defined
-            if (nodeStateTracker !== undefined) {
-                // Stop tracking so as to clear out any running timers.
-                nodeStateTracker.stopTracking();
-                // Delete the node as we don't need to track it any more.
-                this.unreferencedNodesState.delete(nodeId);
-            }
-            // TODO: GC:Validation - assert that the deleted node is not a duplicate
-            this.deletedNodes.add(nodeId);
-        }
-        return updatedGCData;
-    }
-    /**
-     * @returns IGarbageCollectionData after deleting the sweptRoutes from the gcData
-     */
-    deleteSweptRoutes(sweptRoutes, gcData) {
-        const sweptRoutesSet = new Set(sweptRoutes);
-        const gcNodes = {};
-        for (const [id, outboundRoutes] of Object.entries(gcData.gcNodes)) {
-            if (!sweptRoutesSet.has(id)) {
-                gcNodes[id] = Array.from(outboundRoutes);
-            }
-        }
-        // TODO: GC:Validation - assert that the nodeId is in gcData
-        return {
-            gcNodes,
-        };
-    }
-    /**
-     * Since GC runs periodically, the GC data that is generated only tells us the state of the world at that point in
-     * time. There can be nodes that were referenced in between two runs and their unreferenced state needs to be
-     * updated. For example, in the following scenarios not updating the unreferenced timestamp can lead to deletion of
-     * these objects while there can be in-memory referenced to it:
-     * 1. A node transitions from `unreferenced -> referenced -> unreferenced` between two runs. When the reference is
-     * added, the object may have been accessed and in-memory reference to it added.
-     * 2. A reference is added from one unreferenced node to one or more unreferenced nodes. Even though the node[s] were
-     * unreferenced, they could have been accessed and in-memory reference to them added.
-     *
-     * This function identifies nodes that were referenced since the last run.
-     * If these nodes are currently unreferenced, they will be assigned new unreferenced state by the current run.
-     *
-     * @returns - a list of all nodes referenced from the last local summary until now.
-     */
-    findAllNodesReferencedBetweenGCs(currentGCData, previousGCData, logger) {
-        // If we haven't run GC before there is nothing to do.
-        // No previousGCData, means nothing is unreferenced, and there are no reference state trackers to clear
-        if (previousGCData === undefined) {
-            return undefined;
-        }
-        /**
-         * If there are references that were not explicitly notified to GC, log an error because this should never happen.
-         * If it does, this may result in the unreferenced timestamps of these nodes not updated when they were referenced.
-         */
-        this.telemetryTracker.logIfMissingExplicitReferences(currentGCData, previousGCData, this.newReferencesSinceLastRun, logger);
-        // No references were added since the last run so we don't have to update reference states of any unreferenced
-        // nodes. There is no in between state at this point.
-        if (this.newReferencesSinceLastRun.size === 0) {
-            return undefined;
-        }
-        /**
-         * Generate a super set of the GC data that contains the nodes and edges from last run, plus any new node and
-         * edges that have been added since then. To do this, combine the GC data from the last run and the current
-         * run, and then add the references since last run.
-         *
-         * Note on why we need to combine the data from previous run, current run and all references in between -
-         * 1. We need data from last run because some of its references may have been deleted since then. If those
-         * references added new outbound references before they were deleted, we need to detect them.
-         *
-         * 2. We need new outbound references since last run because some of them may have been deleted later. If those
-         * references added new outbound references before they were deleted, we need to detect them.
-         *
-         * 3. We need data from the current run because currently we may not detect when DDSes are referenced:
-         * - We don't require DDSes handles to be stored in a referenced DDS.
-         * - A new data store may have "root" DDSes already created and we don't detect them today.
-         */
-        const gcDataSuperSet = concatGarbageCollectionData(previousGCData, currentGCData);
-        const newOutboundRoutesSinceLastRun = [];
-        this.newReferencesSinceLastRun.forEach((outboundRoutes, sourceNodeId) => {
-            if (gcDataSuperSet.gcNodes[sourceNodeId] === undefined) {
-                gcDataSuperSet.gcNodes[sourceNodeId] = outboundRoutes;
-            }
-            else {
-                gcDataSuperSet.gcNodes[sourceNodeId].push(...outboundRoutes);
-            }
-            newOutboundRoutesSinceLastRun.push(...outboundRoutes);
-        });
-        /**
-         * Run GC on the above reference graph starting with root and all new outbound routes. This will generate a
-         * list of all nodes that could have been referenced since the last run. If any of these nodes are unreferenced,
-         * unreferenced, stop tracking them and remove from unreferenced list.
-         * Note that some of these nodes may be unreferenced now and if so, the current run will mark them as
-         * unreferenced and add unreferenced state.
-         */
-        const gcResult = runGarbageCollection(gcDataSuperSet.gcNodes, [
-            "/",
-            ...newOutboundRoutesSinceLastRun,
-        ]);
-        return gcResult.referencedNodeIds;
-    }
     /**
      * Generates the stats of a garbage collection run from the given results of the run.
      * @param gcResult - The result of a GC run.