Expose and test APIs for some threading metrics (CoreFX)

src/Common/tests/System/Threading/ThreadTestHelpers.cs

@@ -123,13 +123,29 @@ public static void WaitForConditionWithoutBlocking(Func<bool> condition)
             WaitForConditionWithCustomDelay(condition, () => Thread.Yield());
         }
 
+        public static void WaitForConditionWithoutRelinquishingTimeSlice(Func<bool> condition)
+        {
+            WaitForConditionWithCustomDelay(condition, () => Thread.SpinWait(1));
+        }
+
         public static void WaitForConditionWithCustomDelay(Func<bool> condition, Action delay)
         {
-            var startTime = DateTime.Now;
-            while (!condition())
+            if (condition())
+            {
+                return;
+            }
+
+            var startTime = Environment.TickCount;
+            while (true)
             {
-                Assert.True((DateTime.Now - startTime).TotalMilliseconds < UnexpectedTimeoutMilliseconds);
                 delay();
+
+                if (condition())
+                {
+                    return;
+                }
+
+                Assert.True(Environment.TickCount - startTime < UnexpectedTimeoutMilliseconds);
             }
         }
 

src/System.Threading.Overlapped/tests/Configurations.props

@@ -1,6 +1,7 @@
 <Project DefaultTargets="Build">
   <PropertyGroup>
     <BuildConfigurations>
+      netcoreapp;
       netstandard;
       uap-Windows_NT;
     </BuildConfigurations>

src/System.Threading.Overlapped/tests/System.Threading.Overlapped.Tests.csproj

@@ -2,13 +2,15 @@
   <PropertyGroup>
     <ProjectGuid>{861A3318-35AD-46ac-8257-8D5D2479BAD9}</ProjectGuid>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <Configurations>netstandard-Debug;netstandard-Release;uap-Windows_NT-Debug;uap-Windows_NT-Release</Configurations>
+    <IncludeRemoteExecutor>true</IncludeRemoteExecutor>
+    <Configurations>netcoreapp-Debug;netcoreapp-Release;netstandard-Debug;netstandard-Release;uap-Windows_NT-Debug;uap-Windows_NT-Release</Configurations>
     <TestRuntime>true</TestRuntime>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="DllImport.cs" />
     <Compile Include="ThreadPoolBoundHandle_PreAllocatedOverlappedTests.cs" />
     <Compile Include="ThreadPoolBoundHandle_IntegrationTests.cs" />
+    <Compile Include="ThreadPoolBoundHandle_IntegrationTests.netcoreapp.cs" Condition="'$(TargetGroup)' != 'netstandard'" />
     <Compile Include="ThreadPoolBoundHandle_Helpers.cs" />
     <Compile Include="AsyncResult.cs" />
     <Compile Include="Win32Handle.cs" />
@@ -21,4 +23,9 @@
     <Compile Include="ThreadPoolBoundHandle_BindHandleTests.cs" />
     <Compile Include="OverlappedTests.cs" />
   </ItemGroup>
+  <ItemGroup>
+    <Compile Include="$(CommonTestPath)\System\Threading\ThreadTestHelpers.cs">
+      <Link>CommonTest\System\Threading\ThreadTestHelpers.cs</Link>
+    </Compile>
+  </ItemGroup>
 </Project>

src/System.Threading.Overlapped/tests/ThreadPoolBoundHandle_IntegrationTests.netcoreapp.cs

@@ -0,0 +1,19 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Threading;
+using System.Threading.Tests;
+using Xunit;
+
+public partial class ThreadPoolBoundHandleTests
+{
+    [Fact]
+    [PlatformSpecific(TestPlatforms.Windows)] // ThreadPoolBoundHandle.BindHandle is not supported on Unix
+    public unsafe void MultipleOperationsOverSingleHandle_CompletedWorkItemCountTest()
+    {
+        long initialCompletedWorkItemCount = ThreadPool.CompletedWorkItemCount;
+        MultipleOperationsOverMultipleHandles();
+        ThreadTestHelpers.WaitForCondition(() => ThreadPool.CompletedWorkItemCount - initialCompletedWorkItemCount >= 2);
+    }
+}

src/System.Threading.Thread/tests/System.Threading.Thread.Tests.csproj

@@ -17,7 +17,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="$(CommonTestPath)\System\Threading\ThreadTestHelpers.cs">
-      <Link>CommonTest\System\Threading\ThreadPoolHelpers.cs</Link>
+      <Link>CommonTest\System\Threading\ThreadTestHelpers.cs</Link>
     </Compile>
     <ProjectReference Include="STAMain\STAMain.csproj">
       <Name>STAMain</Name>

src/System.Threading.Thread/tests/ThreadTests.netcoreapp.cs

@@ -8,6 +8,7 @@ namespace System.Threading.Threads.Tests
 {
     public static partial class ThreadTests
     {
+        [Fact]
         public static void GetCurrentProcessorId()
         {
             Assert.True(Thread.GetCurrentProcessorId() >= 0);

src/System.Threading.ThreadPool/ref/System.Threading.ThreadPool.cs

@@ -21,9 +21,11 @@ public static partial class ThreadPool
         [System.ObsoleteAttribute("ThreadPool.BindHandle(IntPtr) has been deprecated.  Please use ThreadPool.BindHandle(SafeHandle) instead.", false)]
         public static bool BindHandle(System.IntPtr osHandle) { throw null; }
         public static bool BindHandle(System.Runtime.InteropServices.SafeHandle osHandle) { throw null; }
+        public static long CompletedWorkItemCount { get { throw null; } }
         public static void GetAvailableThreads(out int workerThreads, out int completionPortThreads) { throw null; }
         public static void GetMaxThreads(out int workerThreads, out int completionPortThreads) { throw null; }
         public static void GetMinThreads(out int workerThreads, out int completionPortThreads) { throw null; }
+        public static long PendingWorkItemCount { get { throw null; } }
         public static bool QueueUserWorkItem(System.Threading.WaitCallback callBack) { throw null; }
         public static bool QueueUserWorkItem(System.Threading.WaitCallback callBack, object state) { throw null; }
         public static bool QueueUserWorkItem<TState>(System.Action<TState> callBack, TState state, bool preferLocal) { throw null; }
@@ -34,6 +36,7 @@ public static partial class ThreadPool
         public static System.Threading.RegisteredWaitHandle RegisterWaitForSingleObject(System.Threading.WaitHandle waitObject, System.Threading.WaitOrTimerCallback callBack, object state, uint millisecondsTimeOutInterval, bool executeOnlyOnce) { throw null; }
         public static bool SetMaxThreads(int workerThreads, int completionPortThreads) { throw null; }
         public static bool SetMinThreads(int workerThreads, int completionPortThreads) { throw null; }
+        public static int ThreadCount { get { throw null; } }
         [System.CLSCompliantAttribute(false)]
         public unsafe static bool UnsafeQueueNativeOverlapped(System.Threading.NativeOverlapped* overlapped) { throw null; }
         public static bool UnsafeQueueUserWorkItem(System.Threading.IThreadPoolWorkItem callBack, bool preferLocal) { throw null; }

src/System.Threading.ThreadPool/src/ApiCompatBaseline.uapaot.txt

@@ -0,0 +1,4 @@
+Compat issues with assembly System.Threading.ThreadPool:
+MembersMustExist : Member 'System.Threading.ThreadPool.CompletedWorkItemCount.get()' does not exist in the implementation but it does exist in the contract.
+MembersMustExist : Member 'System.Threading.ThreadPool.PendingWorkItemCount.get()' does not exist in the implementation but it does exist in the contract.
+MembersMustExist : Member 'System.Threading.ThreadPool.ThreadCount.get()' does not exist in the implementation but it does exist in the contract.

src/System.Threading.ThreadPool/tests/Configurations.props

@@ -3,6 +3,7 @@
     <BuildConfigurations>
       netcoreapp;
       netstandard;
+      uap;
     </BuildConfigurations>
   </PropertyGroup>
 </Project>

src/System.Threading.ThreadPool/tests/System.Threading.ThreadPool.Tests.csproj

@@ -2,12 +2,12 @@
   <PropertyGroup>
     <ProjectGuid>{403AD1B8-6F95-4A2E-92A2-727606ABD866}</ProjectGuid>
     <IncludeRemoteExecutor>true</IncludeRemoteExecutor>
-    <Configurations>netcoreapp-Debug;netcoreapp-Release;netstandard-Debug;netstandard-Release</Configurations>
+    <Configurations>netcoreapp-Debug;netcoreapp-Release;netstandard-Debug;netstandard-Release;uap-Debug;uap-Release</Configurations>
     <TestRuntime>true</TestRuntime>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="ThreadPoolTests.cs" />
-    <Compile Include="ThreadPoolTests.netcoreapp.cs" Condition="'$(TargetGroup)' == 'netcoreapp'" />
+    <Compile Include="ThreadPoolTests.netcoreapp.cs" Condition="'$(TargetGroup)' != 'netstandard'" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="$(CommonTestPath)\System\Threading\ThreadTestHelpers.cs">

src/System.Threading.ThreadPool/tests/ThreadPoolTests.netcoreapp.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using System.Threading.Tests;
 using Xunit;
 
 namespace System.Threading.ThreadPools.Tests
@@ -188,5 +189,128 @@ private sealed class InvalidWorkItemAndTask : Task, IThreadPoolWorkItem
             public InvalidWorkItemAndTask(Action action) : base(action) { }
             public void Execute() { }
         }
+
+        [Fact]
+        public void MetricsTest()
+        {
+            int processorCount = Environment.ProcessorCount;
+
+            var workStarted = new AutoResetEvent(false);
+            int completeWork = 0;
+            int simultaneousWorkCount = 0;
+            int simultaneousLocalWorkCount = 0;
+            int simultaneousGlobalWorkCount = 0;
+            var allWorkCompleted = new ManualResetEvent(false);
+            Exception backgroundEx = null;
+            Action work = () =>
+            {
+                workStarted.Set();
+                try
+                {
+                    // Blocking can affect thread pool thread injection heuristics, so don't block, pretend like a
+                    // long-running CPU-bound work item
+                    ThreadTestHelpers.WaitForConditionWithoutRelinquishingTimeSlice(
+                        () => Interlocked.CompareExchange(ref completeWork, 0, 0) != 0);
+                }
+                catch (Exception ex)
+                {
+                    Interlocked.CompareExchange(ref backgroundEx, ex, null);
+                }
+                finally
+                {
+                    if (Interlocked.Decrement(ref simultaneousWorkCount) == 0)
+                    {
+                        allWorkCompleted.Set();
+                    }
+                }
+            };
+            WaitCallback threadPoolWork = data => work();
+            Action<object> threadPoolLocalWork = data => work();
+            TimerCallback timerWork = data => work();
+            WaitOrTimerCallback waitWork = (data, timedOut) => work();
+
+            var signaledEvent = new ManualResetEvent(true);
+            var timers = new List<Timer>();
+            int maxSimultaneousWorkCount = 0;
+            Action scheduleWork = () =>
+            {
+                Assert.True(simultaneousWorkCount <= maxSimultaneousWorkCount);
+
+                while (true)
+                {
+                    if (simultaneousWorkCount >= maxSimultaneousWorkCount)
+                    {
+                        break;
+                    }
+                    ++simultaneousWorkCount;
+                    ++simultaneousGlobalWorkCount;
+                    ThreadPool.QueueUserWorkItem(threadPoolWork);
+                    workStarted.CheckedWait();
+
+                    if (simultaneousWorkCount >= maxSimultaneousWorkCount)
+                    {
+                        break;
+                    }
+                    ++simultaneousWorkCount;
+                    ++simultaneousLocalWorkCount;
+                    ThreadPool.QueueUserWorkItem(threadPoolLocalWork, null, preferLocal: true);
+                    workStarted.CheckedWait();
+
+                    if (simultaneousWorkCount >= maxSimultaneousWorkCount)
+                    {
+                        break;
+                    }
+                    ++simultaneousWorkCount;
+                    ++simultaneousGlobalWorkCount;
+                    timers.Add(new Timer(timerWork, null, 1, Timeout.Infinite));
+                    workStarted.CheckedWait();
+
+                    if (simultaneousWorkCount >= maxSimultaneousWorkCount)
+                    {
+                        break;
+                    }
+                    ++simultaneousWorkCount;
+                    ++simultaneousGlobalWorkCount;
+                    ThreadPool.RegisterWaitForSingleObject(
+                        signaledEvent,
+                        waitWork,
+                        null,
+                        ThreadTestHelpers.UnexpectedTimeoutMilliseconds,
+                        true);
+                    workStarted.CheckedWait();
+                }
+
+                Assert.Equal(maxSimultaneousWorkCount, simultaneousWorkCount);
+            };
+
+            long initialCompletedWorkItemCount = ThreadPool.CompletedWorkItemCount;
+
+            // Schedule some simultaneous work that would all be scheduled and verify the thread count
+            maxSimultaneousWorkCount = Math.Max(1, processorCount - 1); // minus one in case this thread is a thread pool thread
+            scheduleWork();
+            Assert.True(ThreadPool.ThreadCount >= maxSimultaneousWorkCount);
+
+            // Schedule more work that would not all be scheduled and roughly verify the pending work item count
+            maxSimultaneousWorkCount = processorCount * 64;
+            scheduleWork();
+            // The following is assuming that no more than (processorCount * 8) work items will be scheduled to run
+            // simultaneously
+            int minExpectedPendingLocalWorkCount = Math.Max(1, simultaneousLocalWorkCount - processorCount * 8);
+            int minExpectedPendingGlobalWorkCount = Math.Max(1, simultaneousGlobalWorkCount - processorCount * 8);
+            int minExpectedPendingWorkCount = minExpectedPendingLocalWorkCount + minExpectedPendingGlobalWorkCount;
+            Assert.True(ThreadPool.PendingWorkItemCount >= minExpectedPendingWorkCount);
+
+            // Complete the work and verify the completed work item count
+            Interlocked.Exchange(ref completeWork, 1);
+            allWorkCompleted.CheckedWait();
+            backgroundEx = Interlocked.CompareExchange(ref backgroundEx, null, null);
+            if (backgroundEx != null)
+            {
+                throw new AggregateException(backgroundEx);
+            }
+            // Wait for work items to exit, for counting
+            ThreadTestHelpers.WaitForCondition(() =>
+                ThreadPool.CompletedWorkItemCount - initialCompletedWorkItemCount >= maxSimultaneousWorkCount);
+        }
     }
 }

src/System.Threading.Timer/tests/Configurations.props

@@ -3,6 +3,7 @@
     <BuildConfigurations>
       netcoreapp;
       netstandard;
+      uap;
     </BuildConfigurations>
   </PropertyGroup>
 </Project>

src/System.Threading.Timer/tests/System.Threading.Timer.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <ProjectGuid>{ac20a28f-fda8-45e8-8728-058ead16e44c}</ProjectGuid>
-    <Configurations>netcoreapp-Debug;netcoreapp-Release;netstandard-Debug;netstandard-Release</Configurations>
+    <Configurations>netcoreapp-Debug;netcoreapp-Release;netstandard-Debug;netstandard-Release;uap-Debug;uap-Release</Configurations>
     <TestRuntime>true</TestRuntime>
     <IncludeRemoteExecutor>true</IncludeRemoteExecutor>
   </PropertyGroup>
@@ -10,12 +10,7 @@
     <Compile Include="TimerChangeTests.cs" />
     <Compile Include="TimerFiringTests.cs" />
   </ItemGroup>
-  <ItemGroup Condition="'$(TargetGroup)' == 'netcoreapp'">
+  <ItemGroup Condition="'$(TargetGroup)' != 'netstandard'">
     <Compile Include="TimerDisposeTests.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <Compile Include="$(CommonTestPath)\System\Threading\ThreadTestHelpers.cs">
-      <Link>CommonTest\System\Threading\ThreadTestHelpers.cs</Link>
-    </Compile>
-  </ItemGroup>
 </Project>

src/System.Threading.Timer/tests/TimerFiringTests.cs

@@ -10,7 +10,6 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Threading.Tests;
 using Xunit;
 using Xunit.Sdk;
 
@@ -338,57 +337,4 @@ private static async Task PeriodAsync(int period, int iterations)
             await tcs.Task.ConfigureAwait(false);
         }
     }
-
-    [Fact]
-    public void TimersCreatedConcurrentlyOnDifferentThreadsAllFire()
-    {
-        int processorCount = Environment.ProcessorCount;
-
-        int timerTickCount = 0;
-        TimerCallback timerCallback = _ => Interlocked.Increment(ref timerTickCount);
-
-        var threadStarted = new AutoResetEvent(false);
-        var createTimers = new ManualResetEvent(false);
-        var timers = new Timer[processorCount];
-        Action<object> createTimerThreadStart = data =>
-        {
-            int i = (int)data;
-            var sw = new Stopwatch();
-            threadStarted.Set();
-            createTimers.WaitOne();
-
-            // Use the CPU a bit around creating the timer to try to have some of these threads run concurrently
-            sw.Restart();
-            do
-            {
-                Thread.SpinWait(1000);
-            } while (sw.ElapsedMilliseconds < 10);
-
-            timers[i] = new Timer(timerCallback, null, 1, Timeout.Infinite);
-
-            // Use the CPU a bit around creating the timer to try to have some of these threads run concurrently
-            sw.Restart();
-            do
-            {
-                Thread.SpinWait(1000);
-            } while (sw.ElapsedMilliseconds < 10);
-        };
-
-        var waitsForThread = new Action[timers.Length];
-        for (int i = 0; i < timers.Length; ++i)
-        {
-            var t = ThreadTestHelpers.CreateGuardedThread(out waitsForThread[i], createTimerThreadStart);
-            t.IsBackground = true;
-            t.Start(i);
-            threadStarted.CheckedWait();
-        }
-
-        createTimers.Set();
-        ThreadTestHelpers.WaitForCondition(() => timerTickCount == timers.Length);
-
-        foreach (var waitForThread in waitsForThread)
-        {
-            waitForThread();
-        }
-    }
 }

src/System.Threading/ref/System.Threading.cs

@@ -228,6 +228,7 @@ public static void Enter(object obj) { }
         public static void Enter(object obj, ref bool lockTaken) { }
         public static void Exit(object obj) { }
         public static bool IsEntered(object obj) { throw null; }
+        public static long LockContentionCount { get { throw null; } }
         public static void Pulse(object obj) { }
         public static void PulseAll(object obj) { }
         public static bool TryEnter(object obj) { throw null; }