Threadpool autorelease

docs/workflow/trimming/feature-switches.md

@@ -16,6 +16,7 @@ configurations but their defaults might vary as any SDK can set the defaults dif
 | UseSystemResourceKeys | System.Resources.UseSystemResourceKeys |  Any localizable resources for system assemblies is trimmed when set to true |
 | HttpActivityPropagationSupport | System.Net.Http.EnableActivityPropagation | Any dependency related to diagnostics support for System.Net.Http is trimmed when set to false |
 | StartupHookSupport | System.StartupHookProvider.IsSupported | Startup hooks are disabled when set to false. Startup hook related functionality can be trimmed. |
+| TBD | System.Threading.ThreadPool.EnableDispatchAutoreleasePool | When set to true, creates an NSAutoreleasePool around each thread pool work item on applicable platforms. |
 
 Any feature-switch which defines property can be set in csproj file or
 on the command line as any other MSBuild property. Those without predefined property name

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

@@ -234,6 +234,9 @@ private static bool GetEnableWorkerTracking() =>
                 ? AppContextConfigHelper.GetBooleanConfig("System.Threading.ThreadPool.EnableWorkerTracking", false)
                 : GetEnableWorkerTrackingNative();
 
+        internal static bool EnableDispatchAutoreleasePool { get; } =
+            AppContextConfigHelper.GetBooleanConfig("System.Threading.ThreadPool.EnableDispatchAutoreleasePool", false);
+
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal static extern bool CanSetMinIOCompletionThreads(int ioCompletionThreads);
 

src/libraries/Common/src/Interop/OSX/System.Native/Interop.AutoreleasePool.cs

@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#nullable enable
+using System;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+
+internal static partial class Interop
+{
+    internal static partial class Sys
+    {
+        [SupportedOSPlatform("macos")]
+        [SupportedOSPlatform("ios")]
+        [SupportedOSPlatform("tvos")]
+        [SupportedOSPlatform("watchos")]
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_CreateAutoreleasePool")]
+        internal static extern IntPtr CreateAutoreleasePool();
+
+        [SupportedOSPlatform("macos")]
+        [SupportedOSPlatform("ios")]
+        [SupportedOSPlatform("tvos")]
+        [SupportedOSPlatform("watchos")]
+        [DllImport(Libraries.SystemNative, EntryPoint = "SystemNative_DrainAutoreleasePool")]
+        internal static extern void DrainAutoreleasePool(IntPtr ptr);
+    }
+}

src/libraries/Native/Unix/System.Native/CMakeLists.txt

@@ -29,19 +29,26 @@ set(NATIVE_SOURCES
     pal_sysctl.c
 )
 
+if (CLR_CMAKE_TARGET_OSX OR CLR_CMAKE_TARGET_IOS OR CLR_CMAKE_TARGET_TVOS)
+    list (APPEND NATIVE_SOURCES pal_autoreleasepool.m)
+    set_source_files_properties(pal_autoreleasepool.m PROPERTIES COMPILE_FLAGS -fno-objc-arc)
+else()
+    list (APPEND NATIVE_SOURCES pal_autoreleasepool.c)
+endif()
+
 if (CLR_CMAKE_TARGET_IOS OR CLR_CMAKE_TARGET_TVOS)
-    set(NATIVE_SOURCES ${NATIVE_SOURCES}
+    list (APPEND NATIVE_SOURCES
         pal_log.m
         pal_searchpath.m)
 else ()
-    set(NATIVE_SOURCES ${NATIVE_SOURCES}
+    list (APPEND NATIVE_SOURCES
         pal_searchpath.c
         pal_console.c
         pal_log.c)
 endif ()
 
 if (NOT CLR_CMAKE_TARGET_BROWSER)
-    set(NATIVE_SOURCES ${NATIVE_SOURCES} pal_networkchange.c)
+    list (APPEND NATIVE_SOURCES pal_networkchange.c)
 endif ()
 
 include(${CMAKE_CURRENT_LIST_DIR}/extra_libs.cmake)

src/libraries/Native/Unix/System.Native/entrypoints.c

@@ -4,6 +4,7 @@
 #include "../../AnyOS/entrypoints.h"
 
 // Include System.Native headers
+#include "pal_autoreleasepool.h"
 #include "pal_console.h"
 #include "pal_datetime.h"
 #include "pal_errno.h"
@@ -235,6 +236,8 @@ static const Entry s_sysNative[] =
     DllImportEntry(SystemNative_GetGroupList)
     DllImportEntry(SystemNative_GetUid)
     DllImportEntry(SystemNative_LowLevelMonitor_Create)
+    DllImportEntry(SystemNative_CreateAutoreleasePool)
+    DllImportEntry(SystemNative_DrainAutoreleasePool)
 };
 
 EXTERN_C const void* SystemResolveDllImport(const char* name);

src/libraries/Native/Unix/System.Native/extra_libs.cmake

@@ -10,8 +10,10 @@ macro(append_extra_system_libs NativeLibsExtra)
         list(APPEND ${NativeLibsExtra} socket)
     endif ()
 
-    if (CLR_CMAKE_TARGET_IOS OR CLR_CMAKE_TARGET_TVOS)
-        list(APPEND ${NativeLibsExtra} "-framework Foundation")
+    if (CLR_CMAKE_TARGET_OSX OR CLR_CMAKE_TARGET_IOS OR CLR_CMAKE_TARGET_TVOS)
+        include(CMakeFindFrameworks)
+        find_library(FOUNDATION Foundation REQUIRED)
+        list(APPEND ${NativeLibsExtra} ${FOUNDATION})
     endif ()
 
     if (CLR_CMAKE_TARGET_LINUX AND HAVE_GETADDRINFO_A)

src/libraries/Native/Unix/System.Native/pal_autoreleasepool.c

@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#include "pal_autoreleasepool.h"
+#include <stdlib.h>
+#include "pal_utilities.h"
+
+#ifndef _MSC_VER
+// Don't warning about not declaring a function with [[noreturn]] since it's only true in Debug mode.
+#pragma GCC diagnostic ignored "-Wmissing-noreturn"
+#endif
+
+// These functions should not be used, but they need to be defined
+// to satisfy the tooling we used to enable redirecting P/Invokes
+// for the single file scenario.
+void* SystemNative_CreateAutoreleasePool(void)
+{
+    assert_err(false, "Autorelease pools not supported on this platform.", EINVAL);
+    return NULL;
+}
+
+void SystemNative_DrainAutoreleasePool(void* pool)
+{
+    (void)pool;
+    assert_err(false, "Autorelease pools not supported on this platform.", EINVAL);
+}

src/libraries/Native/Unix/System.Native/pal_autoreleasepool.h

@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#pragma once
+
+#include "pal_compiler.h"
+#include "pal_types.h"
+
+/**
+ * Creates an pool to automatically release applicable ref-counted resources.
+ */
+PALEXPORT void* SystemNative_CreateAutoreleasePool(void);
+
+/**
+ * Drains and releases a pool created by SystemNative_CreateAutoreleasePool.
+ */
+PALEXPORT void SystemNative_DrainAutoreleasePool(void* pool);

src/libraries/Native/Unix/System.Native/pal_autoreleasepool.m

@@ -0,0 +1,40 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#include "pal_autoreleasepool.h"
+#include <Foundation/Foundation.h>
+
+@interface PlaceholderObject : NSObject
+- (void)noop:(id)_;
+@end
+
+@implementation PlaceholderObject : NSObject
+- (void)noop:(id)_
+{
+    [self release];
+}
+@end
+
+void* SystemNative_CreateAutoreleasePool(void)
+{
+    if (![NSThread isMultiThreaded])
+    {
+        // Start another no-op thread with the NSThread APIs to get NSThread into multithreaded mode.
+        // The NSAutoReleasePool APIs can't be used on secondary threads until NSThread is in multithreaded mode.
+        // See https://developer.apple.com/documentation/foundation/nsautoreleasepool for more information.
+        PlaceholderObject* placeholderObject = [[PlaceholderObject alloc] init];
+
+        // We need to use detachNewThreadSelector to put NSThread into multithreaded mode.
+        // We can't use detachNewThreadWithBlock since it doesn't change NSThread into multithreaded mode for some reason.
+        // See https://developer.apple.com/documentation/foundation/nswillbecomemultithreadednotification for more information.
+        [NSThread detachNewThreadSelector:@selector(noop:) toTarget:placeholderObject withObject:nil];
+    }
+    assert([NSThread isMultiThreaded]);
+
+    return [[NSAutoreleasePool alloc] init];
+}
+
+void SystemNative_DrainAutoreleasePool(void* pool)
+{
+    [((NSAutoreleasePool*)pool) drain];
+}

src/libraries/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.Shared.xml

@@ -21,5 +21,8 @@
     <type fullname="System.StartupHookProvider" feature="System.StartupHookProvider.IsSupported" featurevalue="false">
       <method signature="System.Boolean get_IsSupported()" body="stub" value="false" />
     </type>
+    <type fullname="System.Threading.ThreadPool" feature="System.Threading.ThreadPool.EnableDispatchAutoreleasePool" featurevalue="false">
+      <method signature="System.Boolean get_EnableDispatchAutoreleasePool()" body="stub" value="false" />
+    </type>
   </assembly>
 </linker>

src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems

@@ -1012,7 +1012,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadInt64PersistentCounter.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadInterruptedException.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadLocal.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadPool.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadPoolWorkQueue.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadPriority.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadStart.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadStartException.cs" />
@@ -1635,6 +1635,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Security\SecureString.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\LowLevelMonitor.Windows.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\TimerQueue.Windows.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadPoolWorkQueue.AutoreleasePool.Unsupported.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\TimeZoneInfo.Win32.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(FeatureComWrappers)' != 'true'">
@@ -1869,6 +1870,8 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Environment.OSX.cs" Condition="'$(IsOSXLike)' == 'true'" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Environment.OSVersion.Unix.cs" Condition="'$(IsOSXLike)' != 'true'" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Environment.SunOS.cs" Condition="'$(Targetsillumos)' == 'true' or '$(TargetsSolaris)' == 'true'" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadPoolWorkQueue.AutoreleasePool.OSX.cs" Condition="'$(IsOSXLike)' == 'true'" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadPoolWorkQueue.AutoreleasePool.Unsupported.cs" Condition="'$(IsOSXLike)' != 'true'" />
     <Compile Include="$(MSBuildThisFileDirectory)System\TimeZoneInfo.GetDisplayName.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\DriveInfoInternal.Unix.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\PersistedFiles.Unix.cs" />
@@ -1879,6 +1882,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\DriveInfoInternal.Browser.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\IO\PersistedFiles.Browser.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\TimeZoneInfo.GetDisplayName.Invariant.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Threading\ThreadPoolWorkQueue.AutoreleasePool.Unsupported.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(IsOSXLike)' == 'true'">
     <Compile Include="$(CommonPath)Interop\OSX\Interop.libobjc.cs">
@@ -1887,6 +1891,8 @@
     <Compile Include="$(CommonPath)Interop\OSX\Interop.Libraries.cs">
       <Link>Common\Interop\OSX\Interop.Libraries.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)Interop\OSX\System.Native\Interop.AutoreleasePool.cs"
+             Link="Common\Interop\OSX\System.Native\Interop.AutoreleasePool.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(SupportsX86Intrinsics)' == 'true'">
     <Compile Include="$(MSBuildThisFileDirectory)System\Runtime\Intrinsics\X86\Aes.cs" />

src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPool.Portable.cs

@@ -31,6 +31,9 @@ public static partial class ThreadPool
             AppContextConfigHelper.GetBooleanConfig("System.Threading.ThreadPool.EnableWorkerTracking", false);
 #endif
 
+        internal static bool EnableDispatchAutoreleasePool { get; } =
+            AppContextConfigHelper.GetBooleanConfig("System.Threading.ThreadPool.EnableDispatchAutoreleasePool", false);
+
         // Threadpool specific initialization of a new thread. Used by OS-provided threadpools. No-op for portable threadpool.
         internal static void InitializeForThreadPoolThread() { }
 

src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPoolWorkQueue.AutoreleasePool.OSX.cs

@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.CompilerServices;
+using System.Runtime.Versioning;
+
+namespace System.Threading
+{
+    internal sealed partial class ThreadPoolWorkQueue
+    {
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        [SupportedOSPlatform("macos")]
+        [SupportedOSPlatform("ios")]
+        [SupportedOSPlatform("tvos")]
+        [SupportedOSPlatform("watchos")]
+        private static void DispatchItemWithAutoreleasePool(object workItem, Thread currentThread)
+        {
+            IntPtr autoreleasePool = Interop.Sys.CreateAutoreleasePool();
+            try
+            {
+#pragma warning disable CS0162 // Unreachable code detected. EnableWorkerTracking may be a constant in some runtimes.
+                if (ThreadPool.EnableWorkerTracking)
+                {
+                    DispatchWorkItemWithWorkerTracking(workItem, currentThread);
+                }
+                else
+                {
+                    DispatchWorkItem(workItem, currentThread);
+                }
+#pragma warning restore CS0162
+            }
+            finally
+            {
+                Interop.Sys.DrainAutoreleasePool(autoreleasePool);
+            }
+        }
+    }
+}

src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPoolWorkQueue.AutoreleasePool.Unsupported.cs

@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Versioning;
+
+namespace System.Threading
+{
+    internal sealed partial class ThreadPoolWorkQueue
+    {
+        [SupportedOSPlatform("macos")]
+        [SupportedOSPlatform("ios")]
+        [SupportedOSPlatform("tvos")]
+        [SupportedOSPlatform("watchos")]
+        private static void DispatchItemWithAutoreleasePool(object workItem, Thread currentThread)
+        {
+            Debug.Fail("DispatchItemWithAutoreleasePool should only be called on macOS-like platforms.");
+        }
+    }
+}

src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPool.cs → src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPoolWorkQueue.cs

@@ -23,7 +23,7 @@
 
 namespace System.Threading
 {
-    internal sealed class ThreadPoolWorkQueue
+    internal sealed partial class ThreadPoolWorkQueue
     {
         internal static class WorkStealingQueueList
         {
@@ -691,23 +691,19 @@ internal static bool Dispatch()
                     //
                     // Execute the workitem outside of any finally blocks, so that it can be aborted if needed.
                     //
-#pragma warning disable CS0162 // Unreachable code detected. EnableWorkerTracking may be a constant in some runtimes.
-                    if (ThreadPool.EnableWorkerTracking)
+                    if (OperatingSystem.IsIOS() || OperatingSystem.IsTvOS() || OperatingSystem.IsWatchOS() ||
+                        (OperatingSystem.IsMacOS() && ThreadPool.EnableDispatchAutoreleasePool))
                     {
-                        DispatchWorkItemWithWorkerTracking(workItem, currentThread);
+                        DispatchItemWithAutoreleasePool(workItem, currentThread);
                     }
-                    else if (workItem is Task task)
+#pragma warning disable CS0162 // Unreachable code detected. EnableWorkerTracking may be a constant in some runtimes.
+                    else if (ThreadPool.EnableWorkerTracking)
                     {
-                        // Check for Task first as it's currently faster to type check
-                        // for Task and then Unsafe.As for the interface, rather than
-                        // vice versa, in particular when the object implements a bunch
-                        // of interfaces.
-                        task.ExecuteFromThreadPool(currentThread);
+                        DispatchWorkItemWithWorkerTracking(workItem, currentThread);
                     }
                     else
                     {
-                        Debug.Assert(workItem is IThreadPoolWorkItem);
-                        Unsafe.As<IThreadPoolWorkItem>(workItem).Execute();
+                        DispatchWorkItem(workItem, currentThread);
                     }
 #pragma warning restore CS0162
 
@@ -781,22 +777,28 @@ private static void DispatchWorkItemWithWorkerTracking(object workItem, Thread c
             {
                 ThreadPool.ReportThreadStatus(isWorking: true);
                 reportedStatus = true;
-                if (workItem is Task task)
-                {
-                    task.ExecuteFromThreadPool(currentThread);
-                }
-                else
-                {
-                    Debug.Assert(workItem is IThreadPoolWorkItem);
-                    Unsafe.As<IThreadPoolWorkItem>(workItem).Execute();
-                }
+                DispatchWorkItem(workItem, currentThread);
             }
             finally
             {
                 if (reportedStatus)
                     ThreadPool.ReportThreadStatus(isWorking: false);
             }
         }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void DispatchWorkItem(object workItem, Thread currentThread)
+        {
+            if (workItem is Task task)
+            {
+                task.ExecuteFromThreadPool(currentThread);
+            }
+            else
+            {
+                Debug.Assert(workItem is IThreadPoolWorkItem);
+                Unsafe.As<IThreadPoolWorkItem>(workItem).Execute();
+            }
+        }
     }
 
     // Holds a WorkStealingQueue, and removes it from the list when this object is no longer referenced.