Enable IOPack, IOEnqueue, and IODequeue on Windows

eng/pipelines/runtime.yml

@@ -249,7 +249,7 @@ extends:
             extraStepsTemplate: /eng/pipelines/coreclr/nativeaot-post-build-steps.yml
             extraStepsParameters:
               creator: dotnet-bot
-              testBuildArgs: 'nativeaot tree ";nativeaot;Loader;Interop;tracing/eventpipe/config;tracing/eventpipe/diagnosticport;tracing/eventpipe/reverse;tracing/eventpipe/processenvironment;tracing/eventpipe/simpleruntimeeventvalidation;tracing/eventpipe/processinfo2;" test tracing/eventcounter/runtimecounters.csproj /p:BuildNativeAotFrameworkObjects=true'
+              testBuildArgs: 'nativeaot tree ";nativeaot;Loader;Interop;tracing/eventpipe/config;tracing/eventpipe/diagnosticport;tracing/eventpipe/reverse;tracing/eventpipe/processenvironment;tracing/eventpipe/simpleruntimeeventvalidation;tracing/eventpipe/processinfo2;" test tracing/eventcounter/runtimecounters.csproj test tracing/eventlistener/EventListenerThreadPool.csproj /p:BuildNativeAotFrameworkObjects=true'
               liveLibrariesBuildConfig: Release
             testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig)
             extraVariablesTemplates:

src/coreclr/nativeaot/Runtime/eventpipe/dotnetruntime.cpp

@@ -3122,6 +3122,7 @@ void InitDotNETRuntime(void)
     EventPipeEventThreadPoolWorkerThreadAdjustmentStats = EventPipeAdapter::AddEvent(EventPipeProviderDotNETRuntime,56,65536,0,EP_EVENT_LEVEL_VERBOSE,true);
     EventPipeEventThreadPoolIOEnqueue = EventPipeAdapter::AddEvent(EventPipeProviderDotNETRuntime,63,2147549184,0,EP_EVENT_LEVEL_VERBOSE,true);
     EventPipeEventThreadPoolIODequeue = EventPipeAdapter::AddEvent(EventPipeProviderDotNETRuntime,64,2147549184,0,EP_EVENT_LEVEL_VERBOSE,true);
+    EventPipeEventThreadPoolIOPack = EventPipeAdapter::AddEvent(EventPipeProviderDotNETRuntime,65,65536,0,EP_EVENT_LEVEL_VERBOSE,true);
     EventPipeEventThreadPoolWorkingThreadCount = EventPipeAdapter::AddEvent(EventPipeProviderDotNETRuntime,60,65536,0,EP_EVENT_LEVEL_VERBOSE,true);
     EventPipeEventGCAllocationTick_V4 = EventPipeAdapter::AddEvent(EventPipeProviderDotNETRuntime,10,1,4,EP_EVENT_LEVEL_VERBOSE,true);
     EventPipeEventGCHeapStats_V2 = EventPipeAdapter::AddEvent(EventPipeProviderDotNETRuntime,4,1,2,EP_EVENT_LEVEL_INFORMATIONAL,false);

src/libraries/System.Private.CoreLib/src/System/Threading/Overlapped.cs

@@ -185,11 +185,9 @@ public static void Free(NativeOverlapped* nativeOverlappedPtr)
 
 #if FEATURE_PERFTRACING
 #if !((TARGET_BROWSER || TARGET_WASI) && !FEATURE_WASM_THREADS)
-#if !NATIVEAOT // TODO shipping criteria: no EVENTPIPE-NATIVEAOT-TODO left in the codebase
                 if (NativeRuntimeEventSource.Log.IsEnabled())
                     NativeRuntimeEventSource.Log.ThreadPoolIOPack(pNativeOverlapped);
 #endif
-#endif
 #endif
 
                 NativeOverlapped* pRet = pNativeOverlapped;

src/libraries/System.Private.CoreLib/src/System/Threading/WindowsThreadPool.cs

@@ -3,6 +3,7 @@
 
 using Microsoft.Win32.SafeHandles;
 using System.Diagnostics;
+using System.Diagnostics.Tracing;
 using System.Runtime;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -187,8 +188,13 @@ internal static RegisteredWaitHandle RegisterWaitForSingleObject(
             return registeredWaitHandle;
         }
 
-        private static unsafe void NativeOverlappedCallback(nint overlappedPtr) =>
+        private static unsafe void NativeOverlappedCallback(nint overlappedPtr)
+        {
+            if (NativeRuntimeEventSource.Log.IsEnabled())
+                NativeRuntimeEventSource.Log.ThreadPoolIODequeue((NativeOverlapped*)overlappedPtr);
+
             IOCompletionCallbackHelper.PerformSingleIOCompletionCallback(0, 0, (NativeOverlapped*)overlappedPtr);
+        }
 
         [SupportedOSPlatform("windows")]
         public static unsafe bool UnsafeQueueNativeOverlapped(NativeOverlapped* overlapped)
@@ -200,6 +206,10 @@ public static unsafe bool UnsafeQueueNativeOverlapped(NativeOverlapped* overlapp
 
             // OS doesn't signal handle, so do it here
             overlapped->InternalLow = (IntPtr)0;
+
+            if (NativeRuntimeEventSource.Log.IsEnabled())
+                NativeRuntimeEventSource.Log.ThreadPoolIOEnqueue(overlapped);
+
             // Both types of callbacks are executed on the same thread pool
             return ThreadPool.UnsafeQueueUserWorkItem(NativeOverlappedCallback, (nint)overlapped, preferLocal: false);
         }

src/tests/tracing/eventlistener/EventListenerThreadPool.cs

@@ -13,14 +13,20 @@ internal sealed class RuntimeEventListener : EventListener
         public volatile int TPWorkerThreadStartCount = 0;
         public volatile int TPWorkerThreadStopCount = 0;
         public volatile int TPWorkerThreadWaitCount = 0;
+        public volatile int TPIOPack = 0;
+        public volatile int TPIOEnqueue = 0;
+        public volatile int TPIODequeue = 0;
 
-    public ManualResetEvent TPWaitEvent = new ManualResetEvent(false);
+        public ManualResetEvent TPWaitWorkerThreadEvent = new ManualResetEvent(false);
+        public ManualResetEvent TPWaitIOPackEvent = new ManualResetEvent(false);
+        public ManualResetEvent TPWaitIOEnqueueEvent = new ManualResetEvent(false);
+        public ManualResetEvent TPWaitIODequeueEvent = new ManualResetEvent(false);
 
         protected override void OnEventSourceCreated(EventSource source)
         {
             if (source.Name.Equals("Microsoft-Windows-DotNETRuntime"))
             {
-                EnableEvents(source, EventLevel.Informational, (EventKeywords)0x10000);
+                EnableEvents(source, EventLevel.Verbose, (EventKeywords)0x10000);
             }
         }
 
@@ -29,17 +35,32 @@ protected override void OnEventWritten(EventWrittenEventArgs eventData)
             if (eventData.EventName.Equals("ThreadPoolWorkerThreadStart"))
             {
                 Interlocked.Increment(ref TPWorkerThreadStartCount);
-                TPWaitEvent.Set();
+                TPWaitWorkerThreadEvent.Set();
             }
             else if (eventData.EventName.Equals("ThreadPoolWorkerThreadStop"))
             {
                 Interlocked.Increment(ref TPWorkerThreadStopCount);
-                TPWaitEvent.Set();
+                TPWaitWorkerThreadEvent.Set();
             }
             else if (eventData.EventName.Equals("ThreadPoolWorkerThreadWait"))
             {
                 Interlocked.Increment(ref TPWorkerThreadWaitCount);
-                TPWaitEvent.Set();
+                TPWaitWorkerThreadEvent.Set();
+            }
+            else if (eventData.EventName.Equals("ThreadPoolIOPack"))
+            {
+                Interlocked.Increment(ref TPIOPack);
+                TPWaitIOPackEvent.Set();
+            }
+            else if (eventData.EventName.Equals("ThreadPoolIOEnqueue"))
+            {
+                Interlocked.Increment(ref TPIOEnqueue);
+                TPWaitIOEnqueueEvent.Set();
+            }
+            else if (eventData.EventName.Equals("ThreadPoolIODequeue"))
+            {
+                Interlocked.Increment(ref TPIODequeue);
+                TPWaitIODequeueEvent.Set();
             }
         }
     }
@@ -50,30 +71,59 @@ static int Main()
         {
             using (RuntimeEventListener listener = new RuntimeEventListener())
             {
-                int someNumber = 0;
-                Task[] tasks = new Task[100];
-                for (int i = 0; i < tasks.Length; i++) 
+
+                // Test this part in CoreCLR only
+                if (!TestLibrary.Utilities.IsNativeAot)
                 {
-                    tasks[i] = Task.Run(() => { someNumber += 1; });
+                    int someNumber = 0;
+                    Task[] tasks = new Task[100];
+                    for (int i = 0; i < tasks.Length; i++)
+                    {
+                        tasks[i] = Task.Run(() => { someNumber += 1; });
+                    }
+
+                    listener.TPWaitWorkerThreadEvent.WaitOne(TimeSpan.FromMinutes(3));
+
+                    bool workerThreadEventsOk = listener.TPWorkerThreadStartCount > 0 ||
+                                                listener.TPWorkerThreadStopCount > 0 ||
+                                                listener.TPWorkerThreadWaitCount > 0;
+
+                    if (!workerThreadEventsOk)
+                    {
+                        Console.WriteLine("Test Failed: Did not see any of the expected events.");
+                        Console.WriteLine($"ThreadPoolWorkerThreadStartCount: {listener.TPWorkerThreadStartCount}");
+                        Console.WriteLine($"ThreadPoolWorkerThreadStopCount: {listener.TPWorkerThreadStopCount}");
+                        Console.WriteLine($"ThreadPoolWorkerThreadWaitCount: {listener.TPWorkerThreadWaitCount}");
+                        return -1;
+                    }
                 }
 
-                listener.TPWaitEvent.WaitOne(TimeSpan.FromMinutes(3));
+                // Test this part in both CoreCLR and NativeAOT
+                Overlapped overlapped = new Overlapped();
 
-                if (listener.TPWorkerThreadStartCount > 0 ||
-                    listener.TPWorkerThreadStopCount > 0 ||
-                    listener.TPWorkerThreadWaitCount > 0)
+                unsafe
                 {
-                    Console.WriteLine("Test Passed.");
-                    return 100;
+                    NativeOverlapped* nativeOverlapped = overlapped.Pack(null);
+                    ThreadPool.UnsafeQueueNativeOverlapped(nativeOverlapped);
                 }
-                else
+
+                listener.TPWaitIOPackEvent.WaitOne(TimeSpan.FromMinutes(3));
+                listener.TPWaitIOEnqueueEvent.WaitOne(TimeSpan.FromMinutes(3));
+                listener.TPWaitIODequeueEvent.WaitOne(TimeSpan.FromMinutes(3));
+
+                if (!(listener.TPIOPack > 0 && listener.TPIOEnqueue > 0 && listener.TPIODequeue > 0))
                 {
-                    Console.WriteLine("Test Failed: Did not see any of the expected events.");
-                    Console.WriteLine($"ThreadPoolWorkerThreadStartCount: {listener.TPWorkerThreadStartCount}");
-                    Console.WriteLine($"ThreadPoolWorkerThreadStopCount: {listener.TPWorkerThreadStopCount}");
-                    Console.WriteLine($"ThreadPoolWorkerThreadWaitCount: {listener.TPWorkerThreadWaitCount}");
+                    Console.WriteLine("Test Failed: Did not see all of the expected events.");
+                    Console.WriteLine($"ThreadPoolIOPack: {listener.TPIOPack}");
+                    Console.WriteLine($"ThreadPoolIOEnqueue: {listener.TPIOEnqueue}");
+                    Console.WriteLine($"ThreadPoolIODequeue: {listener.TPIODequeue}");
                     return -1;
                 }
+                else
+                {
+                    Console.WriteLine("Test Passed.");
+                    return 100;
+                }
             }
         }
     }

src/tests/tracing/eventlistener/EventListenerThreadPool.csproj

@@ -10,5 +10,6 @@
   <ItemGroup>
     <Compile Include="EventListenerThreadPool.cs" />
     <ProjectReference Include="../common/common.csproj" />
+    <ProjectReference Include="$(TestSourceDir)Common\CoreCLRTestLibrary\CoreCLRTestLibrary.csproj" />
   </ItemGroup>
 </Project>