Retain the empty potentialUnreachable collection to reduce potential allocation

Author: Lifeng Lu

src/Microsoft.VisualStudio.Threading/JoinableTask.cs

@@ -389,6 +389,12 @@ internal WeakReference<JoinableTask> WeakSelf
         [DebuggerBrowsable(DebuggerBrowsableState.Never)]
         internal HashSet<IJoinableTaskDependent>? PotentialUnreachableDependents { get; set; }
 
+        /// <summary>
+        /// Gets a value indicating whether PotentialUnreachableDependents is empty.
+        /// </summary>
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        internal bool HasPotentialUnreachableDependents => this.PotentialUnreachableDependents is object && this.PotentialUnreachableDependents.Count != 0;
+
         /// <summary>
         /// Gets the flags set on this task.
         /// </summary>
@@ -711,7 +717,7 @@ internal void Post(SendOrPostCallback d, object? state, bool mainThreadAffinitiz
                                 eventsNeedNotify = new List<AsyncManualResetEvent>(tasksNeedNotify.Count);
                                 foreach (JoinableTask? taskToNotify in tasksNeedNotify)
                                 {
-                                    if (mainThreadQueueUpdated && taskToNotify != this && taskToNotify.pendingEventCount == 0 && taskToNotify.PotentialUnreachableDependents != null)
+                                    if (mainThreadQueueUpdated && taskToNotify != this && taskToNotify.pendingEventCount == 0 && taskToNotify.HasPotentialUnreachableDependents)
                                     {
                                         // It is not essential to clean up potential unreachable dependent items before triggering the UI thread,
                                         // because dependencies may change, and invalidate this work. However, we try to do this work in the background thread to make it less likely
@@ -1101,7 +1107,7 @@ private bool TryDequeueSelfOrDependencies(bool onMainThread, ref HashSet<IJoinab
                         {
                             if (this.pendingEventSource.TryGetTarget(out JoinableTask? pendingSource) &&
                                 (pendingSource == this ||
-                                 (this.PotentialUnreachableDependents == null && JoinableTaskDependencyGraph.IsDependingSynchronousTask(pendingSource, this))))
+                                 (!this.HasPotentialUnreachableDependents && JoinableTaskDependencyGraph.IsDependingSynchronousTask(pendingSource, this))))
                             {
                                 ExecutionQueue? queue = onMainThread ? pendingSource.mainThreadQueue : pendingSource.threadPoolQueue;
                                 if (queue is object && !queue.IsCompleted && queue.TryDequeue(out work))
@@ -1131,19 +1137,15 @@ private bool TryDequeueSelfOrDependencies(bool onMainThread, ref HashSet<IJoinab
                         bool foundWork = TryDequeueSelfOrDependencies(this, onMainThread, visited, out work);
 
                         HashSet<IJoinableTaskDependent>? visitedNodes = visited;
-                        if (visitedNodes != null && this.PotentialUnreachableDependents != null)
+                        if (visitedNodes != null && this.HasPotentialUnreachableDependents)
                         {
                             // We walked the dependencies tree and use this information to update the PotentialUnreachableDependents list.
-                            this.PotentialUnreachableDependents.RemoveWhere(n => visitedNodes.Contains(n));
-                            if (this.PotentialUnreachableDependents.Count == 0)
-                            {
-                                this.PotentialUnreachableDependents = null;
-                            }
+                            this.PotentialUnreachableDependents!.RemoveWhere(n => visitedNodes.Contains(n));
 
-                            if (!foundWork && this.PotentialUnreachableDependents != null)
+                            if (!foundWork && this.PotentialUnreachableDependents.Count > 0)
                             {
                                 JoinableTaskDependencyGraph.RemoveUnreachableDependentItems(this, this.PotentialUnreachableDependents, visitedNodes);
-                                this.PotentialUnreachableDependents = null;
+                                this.PotentialUnreachableDependents.Clear();
                             }
                         }
 

src/Microsoft.VisualStudio.Threading/JoinableTaskDependencyGraph.cs

@@ -236,20 +236,20 @@ internal static bool CleanUpPotentialUnreachableDependentItems(JoinableTask sync
             // the reference count, we will calculate the entire reachable tree from the root.  That will
             // tell us the exactly tasks which need track the synchronous task, and we will clean up the rest.
             HashSet<IJoinableTaskDependent>? possibleUnreachableItems = syncTask.PotentialUnreachableDependents;
-            if (possibleUnreachableItems is object)
+            if (possibleUnreachableItems is object && possibleUnreachableItems.Count > 0)
             {
                 var reachableNodes = new HashSet<IJoinableTaskDependent>();
                 var syncTaskItem = (IJoinableTaskDependent)syncTask;
 
                 JoinableTaskDependentData.ComputeSelfAndDescendentOrJoinedJobsAndRemainTasks(syncTaskItem, reachableNodes, possibleUnreachableItems);
 
-                syncTask.PotentialUnreachableDependents = null;
                 allReachableNodes = reachableNodes;
 
                 // force to remove all invalid items
                 if (possibleUnreachableItems.Count > 0)
                 {
                     JoinableTaskDependentData.RemoveUnreachableDependentItems(syncTask, possibleUnreachableItems, reachableNodes);
+                    possibleUnreachableItems.Clear();
 
                     return true;
                 }
@@ -600,7 +600,7 @@ internal bool HasMainThreadSynchronousTaskWaiting(IJoinableTaskDependent taskIte
                     DependentSynchronousTask? nextTrackingTask = existingTaskTracking.Next;
                     if ((existingTaskTracking.SynchronousTask.State & JoinableTask.JoinableTaskFlags.SynchronouslyBlockingMainThread) == JoinableTask.JoinableTaskFlags.SynchronouslyBlockingMainThread)
                     {
-                        if (existingTaskTracking.SynchronousTask.PotentialUnreachableDependents != null)
+                        if (existingTaskTracking.SynchronousTask.HasPotentialUnreachableDependents)
                         {
                             // This might remove the current tracking item from the linked list, so we capture next node first.
                             if (!CleanUpPotentialUnreachableDependentItems(existingTaskTracking.SynchronousTask, out HashSet<IJoinableTaskDependent>? allReachableNodes) ||
@@ -642,12 +642,9 @@ internal void OnTaskCompleted(IJoinableTaskDependent thisDependentNode)
                             RemoveDependingSynchronousTaskFrom(childrenTasks, existingTaskTracking.SynchronousTask, false);
 
                             HashSet<IJoinableTaskDependent>? potentialUnreachableDependents = existingTaskTracking.SynchronousTask.PotentialUnreachableDependents;
-                            if (potentialUnreachableDependents != null)
+                            if (potentialUnreachableDependents is object && potentialUnreachableDependents.Count > 0)
                             {
-                                if (potentialUnreachableDependents.Remove(thisDependentNode) && potentialUnreachableDependents.Count == 0)
-                                {
-                                    existingTaskTracking.SynchronousTask.PotentialUnreachableDependents = null;
-                                }
+                                potentialUnreachableDependents.Remove(thisDependentNode);
                             }
 
                             existingTaskTracking = existingTaskTracking.Next;
@@ -879,7 +876,7 @@ private static void RemoveDependingSynchronousTaskFrom(IReadOnlyList<IJoinableTa
 
                         RemoveUnreachableDependentItems(syncTask, remainNodes, reachableNodes);
 
-                        syncTask.PotentialUnreachableDependents = null;
+                        syncTask.PotentialUnreachableDependents?.Clear();
                     }
                     else if (syncTask.PotentialUnreachableDependents != remainNodes)
                     {
@@ -890,10 +887,6 @@ private static void RemoveDependingSynchronousTaskFrom(IReadOnlyList<IJoinableTa
                         syncTask.PotentialUnreachableDependents = remainNodes;
                     }
                 }
-                else
-                {
-                    syncTask.PotentialUnreachableDependents = null;
-                }
             }
 
             /// <summary>