reduce overhead when running in no main thread mode (#1502)

* Do not track nested factory when there is no main thread

Generally, post to context would not be used as SwitchToMainThread is no-op in this context. Even it is being called under certain corner cases, it would just queue the same work item to the thread pool multiple times, so better to prevent the allocation in the first place.

* Do not turn on SynchronouslyBlockingMainThread flag on when the JTF is used in no main thread mode.

Because IsOnMainThread is just to check the thread id, this can be turned on randomly when the code is running in the initial thread pool thread. It would turn on expensive dependency tracking graph, which is not what we expect to do.

* stop creating main thread synchronization context when running in no main thread mode.

---------

Co-authored-by: Lifeng Lu <[email protected]>

Author: lifengl

src/Microsoft.VisualStudio.Threading/JoinableTask.cs

@@ -8,7 +8,6 @@
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using JoinRelease = Microsoft.VisualStudio.Threading.JoinableTaskCollection.JoinRelease;
@@ -147,7 +146,7 @@ internal JoinableTask(JoinableTaskFactory owner, bool synchronouslyBlocking, str
             this.state |= JoinableTaskFlags.StartedSynchronously | JoinableTaskFlags.CompletingSynchronously;
         }
 
-        if (owner.Context.IsOnMainThread)
+        if (owner.Context.IsOnMainThread && !this.JoinableTaskContext.IsNoOpContext)
         {
             this.state |= JoinableTaskFlags.StartedOnMainThread;
             if (synchronouslyBlocking)
@@ -321,7 +320,7 @@ internal SynchronizationContext? ApplicableJobSyncContext
     {
         get
         {
-            if (this.JoinableTaskContext.IsOnMainThread)
+            if (this.JoinableTaskContext.IsOnMainThread && !this.JoinableTaskContext.IsNoOpContext)
             {
                 if (this.mainThreadJobSyncContext is null)
                 {
@@ -977,7 +976,7 @@ internal void CompleteOnCurrentThread()
         {
             bool onMainThread = false;
             JoinableTaskFlags additionalFlags = JoinableTaskFlags.CompletingSynchronously;
-            if (this.JoinableTaskContext.IsOnMainThread)
+            if (this.JoinableTaskContext.IsOnMainThread && !this.JoinableTaskContext.IsNoOpContext)
             {
                 additionalFlags |= JoinableTaskFlags.SynchronouslyBlockingMainThread;
                 onMainThread = true;

src/Microsoft.VisualStudio.Threading/JoinableTaskFactory.cs

@@ -28,7 +28,7 @@ public partial class JoinableTaskFactory
     /// </summary>
     private readonly JoinableTaskContext owner;
 
-    private readonly SynchronizationContext mainThreadJobSyncContext;
+    private readonly SynchronizationContext? mainThreadJobSyncContext;
 
     /// <summary>
     /// The collection to add all created tasks to. May be <see langword="null" />.
@@ -71,7 +71,7 @@ internal JoinableTaskFactory(JoinableTaskContext owner, JoinableTaskCollection?
 
         this.owner = owner;
         this.jobCollection = collection;
-        this.mainThreadJobSyncContext = new JoinableTaskSynchronizationContext(this);
+        this.mainThreadJobSyncContext = owner.IsNoOpContext ? null : new JoinableTaskSynchronizationContext(this);
     }
 
     /// <summary>
@@ -1017,20 +1017,23 @@ internal RunFramework(JoinableTaskFactory factory, JoinableTask joinable)
             {
                 JoinableTaskDependencyGraph.AddDependency(this.previousJoinable, joinable);
 
-                // By definition we inherit the nesting factories of our immediate nesting task.
-                ListOfOftenOne<JoinableTaskFactory> nestingFactories = this.previousJoinable.NestingFactories;
-
-                // And we may add our immediate nesting parent's factory to the list of
-                // ancestors if it isn't already in the list.
-                if (this.previousJoinable.Factory != this.factory)
+                if (!factory.Context.IsNoOpContext)
                 {
-                    if (!nestingFactories.Contains(this.previousJoinable.Factory))
+                    // By definition we inherit the nesting factories of our immediate nesting task.
+                    ListOfOftenOne<JoinableTaskFactory> nestingFactories = this.previousJoinable.NestingFactories;
+
+                    // And we may add our immediate nesting parent's factory to the list of
+                    // ancestors if it isn't already in the list.
+                    if (this.previousJoinable.Factory != this.factory)
                     {
-                        nestingFactories.Add(this.previousJoinable.Factory);
+                        if (!nestingFactories.Contains(this.previousJoinable.Factory))
+                        {
+                            nestingFactories.Add(this.previousJoinable.Factory);
+                        }
                     }
-                }
 
-                this.joinable.NestingFactories = nestingFactories;
+                    this.joinable.NestingFactories = nestingFactories;
+                }
             }
 
             if (joinable.GetTokenizedParent() is JoinableTask tokenizedParent)