Add config var

src/coreclr/src/System.Private.CoreLib/System.Private.CoreLib.csproj

@@ -21,6 +21,7 @@
     <ILLinkTrimXml>$(IntermediateOutputPath)System.Private.CoreLib.xml</ILLinkTrimXml>
     <ILLinkDirectory>$(MSBuildThisFileDirectory)src\ILLink\</ILLinkDirectory>
 
+    <FeaturePortableThreadPool>true</FeaturePortableThreadPool>
     <FeatureSharedLowLevelLock>true</FeatureSharedLowLevelLock>
   </PropertyGroup>
 

src/coreclr/src/System.Private.CoreLib/src/System/Threading/ThreadPool.CoreCLR.cs

@@ -193,45 +193,131 @@ public static partial class ThreadPool
         // Time in ms for which ThreadPoolWorkQueue.Dispatch keeps executing work items before returning to the OS
         private const uint DispatchQuantum = 30;
 
+        internal static readonly bool UsePortableThreadPool = InitializeConfigAndDetermineUsePortableThreadPool();
+
         internal static readonly bool EnableWorkerTracking = GetEnableWorkerTracking();
 
         internal static bool KeepDispatching(int startTickCount)
         {
+            if (UsePortableThreadPool)
+            {
+                return true;
+            }
+
             // Note: this function may incorrectly return false due to TickCount overflow
             // if work item execution took around a multiple of 2^32 milliseconds (~49.7 days),
             // which is improbable.
             return (uint)(Environment.TickCount - startTickCount) < DispatchQuantum;
         }
 
+        private static unsafe bool InitializeConfigAndDetermineUsePortableThreadPool()
+        {
+            bool usePortableThreadPool = false;
+            int configVariableIndex = 0;
+            while (true)
+            {
+                int nextConfigVariableIndex =
+                    GetNextConfigUInt32Value(
+                        configVariableIndex,
+                        out uint configValue,
+                        out bool isBoolean,
+                        out char* appContextConfigNameUnsafe);
+                if (nextConfigVariableIndex < 0)
+                {
+                    break;
+                }
+
+                Debug.Assert(nextConfigVariableIndex > configVariableIndex);
+                configVariableIndex = nextConfigVariableIndex;
+
+                if (appContextConfigNameUnsafe == null)
+                {
+                    // Special case for UsePortableThreadPool, which doesn't go into the AppContext
+                    Debug.Assert(configValue != 0);
+                    Debug.Assert(isBoolean);
+                    usePortableThreadPool = true;
+                    continue;
+                }
+
+                var appContextConfigName = new string(appContextConfigNameUnsafe);
+                if (isBoolean)
+                {
+                    AppContext.SetSwitch(appContextConfigName, configValue != 0);
+                }
+                else
+                {
+                    AppContext.SetData(appContextConfigName, configValue);
+                }
+            }
+
+            return usePortableThreadPool;
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern unsafe int GetNextConfigUInt32Value(
+            int configVariableIndex,
+            out uint configValue,
+            out bool isBoolean,
+            out char* appContextConfigName);
+
         public static bool SetMaxThreads(int workerThreads, int completionPortThreads)
         {
-            return
-                workerThreads >= 0 &&
-                completionPortThreads >= 0 &&
-                SetMaxThreadsNative(workerThreads, completionPortThreads);
+            if (workerThreads < 0 || completionPortThreads < 0)
+            {
+                return false;
+            }
+
+            if (UsePortableThreadPool && !PortableThreadPool.ThreadPoolInstance.SetMaxThreads(workerThreads))
+            {
+                return false;
+            }
+
+            return SetMaxThreadsNative(workerThreads, completionPortThreads);
         }
 
         public static void GetMaxThreads(out int workerThreads, out int completionPortThreads)
         {
             GetMaxThreadsNative(out workerThreads, out completionPortThreads);
+
+            if (UsePortableThreadPool)
+            {
+                workerThreads = PortableThreadPool.ThreadPoolInstance.GetMaxThreads();
+            }
         }
 
         public static bool SetMinThreads(int workerThreads, int completionPortThreads)
         {
-            return
-                workerThreads >= 0 &&
-                completionPortThreads >= 0 &&
-                SetMinThreadsNative(workerThreads, completionPortThreads);
+            if (workerThreads < 0 || completionPortThreads < 0)
+            {
+                return false;
+            }
+
+            if (UsePortableThreadPool && !PortableThreadPool.ThreadPoolInstance.SetMinThreads(workerThreads))
+            {
+                return false;
+            }
+
+            return SetMinThreadsNative(workerThreads, completionPortThreads);
         }
 
         public static void GetMinThreads(out int workerThreads, out int completionPortThreads)
         {
             GetMinThreadsNative(out workerThreads, out completionPortThreads);
+
+            if (UsePortableThreadPool)
+            {
+                workerThreads = PortableThreadPool.ThreadPoolInstance.GetMinThreads();
+            }
         }
 
         public static void GetAvailableThreads(out int workerThreads, out int completionPortThreads)
         {
             GetAvailableThreadsNative(out workerThreads, out completionPortThreads);
+
+            if (UsePortableThreadPool)
+            {
+                workerThreads = PortableThreadPool.ThreadPoolInstance.GetAvailableThreads();
+            }
         }
 
         /// <summary>
@@ -240,28 +326,38 @@ public static void GetAvailableThreads(out int workerThreads, out int completion
         /// <remarks>
         /// For a thread pool implementation that may have different types of threads, the count includes all types.
         /// </remarks>
-        public static extern int ThreadCount
-        {
-            [MethodImpl(MethodImplOptions.InternalCall)]
-            get;
-        }
+        public static int ThreadCount =>
+            (UsePortableThreadPool ? PortableThreadPool.ThreadPoolInstance.ThreadCount : 0) + GetThreadCount();
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern int GetThreadCount();
 
         /// <summary>
         /// Gets the number of work items that have been processed so far.
         /// </summary>
         /// <remarks>
         /// For a thread pool implementation that may have different types of work items, the count includes all types.
         /// </remarks>
-        public static long CompletedWorkItemCount => GetCompletedWorkItemCount();
+        public static long CompletedWorkItemCount
+        {
+            get
+            {
+                long count = GetCompletedWorkItemCount();
+                if (UsePortableThreadPool)
+                {
+                    count += PortableThreadPool.ThreadPoolInstance.CompletedWorkItemCount;
+                }
+                return count;
+            }
+        }
 
         [DllImport(RuntimeHelpers.QCall, CharSet = CharSet.Unicode)]
         private static extern long GetCompletedWorkItemCount();
 
-        private static extern long PendingUnmanagedWorkItemCount
-        {
-            [MethodImpl(MethodImplOptions.InternalCall)]
-            get;
-        }
+        private static long PendingUnmanagedWorkItemCount => UsePortableThreadPool ? 0 : GetPendingUnmanagedWorkItemCount();
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern long GetPendingUnmanagedWorkItemCount();
 
         private static RegisteredWaitHandle RegisterWaitForSingleObject(
              WaitHandle waitObject,
@@ -295,8 +391,19 @@ bool compressStack
             return registeredWaitHandle;
         }
 
+        internal static void RequestWorkerThread()
+        {
+            if (UsePortableThreadPool)
+            {
+                PortableThreadPool.ThreadPoolInstance.RequestWorker();
+                return;
+            }
+
+            RequestWorkerThreadNative();
+        }
+
         [DllImport(RuntimeHelpers.QCall, CharSet = CharSet.Unicode)]
-        internal static extern Interop.BOOL RequestWorkerThread();
+        private static extern Interop.BOOL RequestWorkerThreadNative();
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern unsafe bool PostQueuedCompletionStatus(NativeOverlapped* overlapped);
@@ -322,19 +429,46 @@ public static unsafe bool UnsafeQueueNativeOverlapped(NativeOverlapped* overlapp
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void GetAvailableThreadsNative(out int workerThreads, out int completionPortThreads);
 
+        internal static bool NotifyWorkItemComplete()
+        {
+            if (UsePortableThreadPool)
+            {
+                return PortableThreadPool.ThreadPoolInstance.NotifyWorkItemComplete();
+            }
+
+            return NotifyWorkItemCompleteNative();
+        }
+
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal static extern bool NotifyWorkItemComplete();
+        private static extern bool NotifyWorkItemCompleteNative();
+
+        internal static void ReportThreadStatus(bool isWorking)
+        {
+            if (UsePortableThreadPool)
+            {
+                // TODO: PortableThreadPool - Implement worker tracking
+                return;
+            }
+
+            ReportThreadStatusNative(isWorking);
+        }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal static extern void ReportThreadStatus(bool isWorking);
+        private static extern void ReportThreadStatusNative(bool isWorking);
 
         internal static void NotifyWorkItemProgress()
         {
+            if (UsePortableThreadPool)
+            {
+                PortableThreadPool.ThreadPoolInstance.NotifyWorkItemComplete();
+                return;
+            }
+
             NotifyWorkItemProgressNative();
         }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        internal static extern void NotifyWorkItemProgressNative();
+        private static extern void NotifyWorkItemProgressNative();
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern bool GetEnableWorkerTracking();

src/coreclr/src/inc/clrconfigvalues.h

@@ -569,6 +569,7 @@ RETAIL_CONFIG_DWORD_INFO(EXTERNAL_Thread_AssignCpuGroups, W("Thread_AssignCpuGro
 ///
 /// Threadpool
 ///
+RETAIL_CONFIG_DWORD_INFO(INTERNAL_ThreadPool_UsePortableThreadPool, W("ThreadPool_UsePortableThreadPool"), 0, "Uses the managed portable thread pool implementation instead of the unmanaged one.")
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_ThreadPool_ForceMinWorkerThreads, W("ThreadPool_ForceMinWorkerThreads"), 0, "Overrides the MinThreads setting for the ThreadPool worker pool")
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_ThreadPool_ForceMaxWorkerThreads, W("ThreadPool_ForceMaxWorkerThreads"), 0, "Overrides the MaxThreads setting for the ThreadPool worker pool")
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_ThreadPool_DisableStarvationDetection, W("ThreadPool_DisableStarvationDetection"), 0, "Disables the ThreadPool feature that forces new threads to be added when workitems run for too long")
@@ -581,8 +582,6 @@ RETAIL_CONFIG_DWORD_INFO(INTERNAL_ThreadPool_UnfairSemaphoreSpinLimit, W("Thread
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_ThreadPool_UnfairSemaphoreSpinLimit, W("ThreadPool_UnfairSemaphoreSpinLimit"), 0x46, "Maximum number of spins a thread pool worker thread performs before waiting for work")
 #endif // TARGET_ARM64
 
-CONFIG_DWORD_INFO(INTERNAL_ThreadpoolTickCountAdjustment, W("ThreadpoolTickCountAdjustment"), 0, "")
-
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_HillClimbing_Disable,                             W("HillClimbing_Disable"),                            0, "Disables hill climbing for thread adjustments in the thread pool");
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_HillClimbing_WavePeriod,                          W("HillClimbing_WavePeriod"),                         4, "");
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_HillClimbing_TargetSignalToNoiseRatio,            W("HillClimbing_TargetSignalToNoiseRatio"),           300, "");

src/coreclr/src/vm/ceemain.cpp

@@ -176,6 +176,10 @@
 #include "stacksampler.h"
 #endif
 
+#ifndef CROSSGEN_COMPILE
+#include "win32threadpool.h"
+#endif
+
 #include <shlwapi.h>
 
 #include "bbsweep.h"
@@ -674,6 +678,8 @@ void EEStartupHelper()
         // This needs to be done before the EE has started
         InitializeStartupFlags();
 
+        ThreadpoolMgr::StaticInitialize();
+
         MethodDescBackpatchInfoTracker::StaticInitialize();
         CodeVersionManager::StaticInitialize();
         TieredCompilationManager::StaticInitialize();