Suppress wake-up preemption on Linux in LowLevelLifoSemaphore (parallel to Windows SetThreadPriorityBoost)

src/libraries/Common/src/Interop/Unix/System.Native/Interop.WakePreemption.cs

@@ -0,0 +1,16 @@
+// 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.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Sys
+    {
+        [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_SuppressWakePreemption")]
+        internal static unsafe partial int SuppressWakePreemption(int* previousPolicy, int* previousPriority);
+
+        [LibraryImport(Libraries.SystemNative, EntryPoint = "SystemNative_RestoreWakePreemption")]
+        internal static partial int RestoreWakePreemption(int previousPolicy, int previousPriority);
+    }
+}

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

@@ -2468,6 +2468,9 @@
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.Futex.cs" Condition="'$(TargetsLinux)' == 'true'">
       <Link>Common\Interop\Unix\System.Native\Interop.Futex.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.WakePreemption.cs">
+      <Link>Common\Interop\Unix\System.Native\Interop.WakePreemption.cs</Link>
+    </Compile>
     <Compile Include="$(CommonPath)Interop\Unix\System.Native\Interop.GetCpuUtilization.cs">
       <Link>Common\Interop\Unix\System.Native\Interop.GetCpuUtilization.cs</Link>
     </Compile>
@@ -2905,6 +2908,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\PortableThreadPool.Unix.cs" Condition="'$(TargetsWindows)' != 'true' and '$(TargetsBrowser)' != 'true'" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\PortableThreadPool.Windows.cs" Condition="'$(TargetsWindows)' == 'true'" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\LowLevelLifoSemaphore.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Threading\LowLevelLifoSemaphore.WakePreemption.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\PreAllocatedOverlapped.Portable.cs" Condition="'$(TargetsWindows)' == 'true'" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\PreAllocatedOverlapped.Windows.cs" Condition="'$(TargetsWindows)' == 'true'" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\RegisteredWaitHandle.Windows.cs" Condition="'$(TargetsWindows)' == 'true'" />

src/libraries/System.Private.CoreLib/src/System/Threading/LowLevelLifoSemaphore.WakePreemption.cs

@@ -0,0 +1,57 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Threading
+{
+    internal sealed partial class LowLevelLifoSemaphore
+    {
+        private readonly struct WakePreemptionScope
+        {
+#if TARGET_LINUX
+            internal readonly int PreviousPolicy;
+            internal readonly int PreviousPriority;
+
+            internal WakePreemptionScope(int previousPolicy, int previousPriority)
+            {
+                PreviousPolicy = previousPolicy;
+                PreviousPriority = previousPriority;
+            }
+#endif
+        }
+
+        private static WakePreemptionScope SuppressWakePreemption()
+        {
+#if TARGET_WINDOWS
+            // GetCurrentThread() returns a pseudo-handle (-2) that is valid
+            // only on the calling thread and does not need to be closed.
+            Interop.Kernel32.SetThreadPriorityBoost(Interop.Kernel32.GetCurrentThread(), bDisablePriorityBoost: true);
+            return default;
+#elif TARGET_LINUX
+            int previousPolicy = -1;
+            int previousPriority = 0;
+            unsafe
+            {
+                Interop.Sys.SuppressWakePreemption(&previousPolicy, &previousPriority);
+            }
+
+            return new WakePreemptionScope(previousPolicy, previousPriority);
+#else
+            return default;
+#endif
+        }
+
+        private static void RestoreWakePreemption(WakePreemptionScope scope)
+        {
+#if TARGET_WINDOWS
+            Interop.Kernel32.SetThreadPriorityBoost(Interop.Kernel32.GetCurrentThread(), bDisablePriorityBoost: false);
+#elif TARGET_LINUX
+            if (scope.PreviousPolicy != -1)
+            {
+                Interop.Sys.RestoreWakePreemption(scope.PreviousPolicy, scope.PreviousPriority);
+            }
+#else
+            _ = scope;
+#endif
+        }
+    }
+}

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

@@ -320,15 +320,14 @@ private bool Block(int timeoutMs)
 
             if (blockerNode != null)
             {
-#if TARGET_WINDOWS
-                // Disable the priority boost that Windows would normally apply
+                // Suppress the wake-up preemption that the OS would normally apply
                 // when this thread is unblocked. The semaphore is used to park workers.
-                // A transient priority boost on wake provides no benefit here and can
-                // result in woken thread preempting already working threads.
-                // GetCurrentThread() returns a pseudo-handle (-2) that is valid
-                // only on the calling thread and does not need to be closed.
-                Interop.Kernel32.SetThreadPriorityBoost(Interop.Kernel32.GetCurrentThread(), bDisablePriorityBoost: true);
-#endif
+                // A transient wake-up advantage provides no benefit here and can result in
+                // the woken thread preempting already-working threads. On Windows this
+                // disables SetThreadPriorityBoost. On Linux this temporarily switches the
+                // thread to SCHED_BATCH, which sched(7) documents as applying "a small
+                // scheduling penalty with respect to wakeup behavior".
+                WakePreemptionScope wakePreemptionScope = SuppressWakePreemption();
 
                 try
                 {
@@ -349,10 +348,7 @@ private bool Block(int timeoutMs)
                 }
                 finally
                 {
-#if TARGET_WINDOWS
-                    // restore the default.
-                    Interop.Kernel32.SetThreadPriorityBoost(Interop.Kernel32.GetCurrentThread(), bDisablePriorityBoost: false);
-#endif
+                    RestoreWakePreemption(wakePreemptionScope);
                 }
             }
 

src/native/libs/System.Native/entrypoints.c

@@ -257,6 +257,8 @@ static const Entry s_sysNative[] =
     DllImportEntry(SystemNative_LowLevelFutex_WaitOnAddressTimeout)
     DllImportEntry(SystemNative_LowLevelFutex_WakeByAddressSingle)
 #endif
+    DllImportEntry(SystemNative_SuppressWakePreemption)
+    DllImportEntry(SystemNative_RestoreWakePreemption)
     DllImportEntry(SystemNative_LoadLibrary)
     DllImportEntry(SystemNative_GetLoadLibraryError)
     DllImportEntry(SystemNative_GetProcAddress)

src/native/libs/System.Native/pal_threading.c

@@ -36,6 +36,8 @@
 #pragma clang diagnostic ignored "-Wjump-misses-init"
 #endif
 
+#define WAKE_PREEMPTION_PREVIOUS_POLICY_UNSUPPORTED (-1)
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // LowLevelMonitor - Represents a non-recursive mutex and condition
 
@@ -297,6 +299,65 @@ void SystemNative_LowLevelFutex_WakeByAddressSingle(int32_t* address)
 
 #endif  // defined(TARGET_LINUX)
 
+int32_t SystemNative_SuppressWakePreemption(int32_t* previousPolicy, int32_t* previousPriority)
+{
+    assert(previousPolicy != NULL);
+    assert(previousPriority != NULL);
+
+    *previousPolicy = WAKE_PREEMPTION_PREVIOUS_POLICY_UNSUPPORTED;
+    *previousPriority = 0;
+
+#if defined(TARGET_LINUX)
+    struct sched_param previousParameters;
+
+    int previousPolicyLocal = sched_getscheduler(0);
+    if (previousPolicyLocal == -1)
+    {
+        return errno;
+    }
+
+    if (sched_getparam(0, &previousParameters) != 0)
+    {
+        return errno;
+    }
+
+    struct sched_param suppressedParameters;
+    suppressedParameters.sched_priority = 0;
+
+    if (sched_setscheduler(0, SCHED_BATCH, &suppressedParameters) != 0)
+    {
+        return errno;
+    }
+
+    *previousPolicy = previousPolicyLocal;
+    *previousPriority = previousParameters.sched_priority;
+#endif
+
+    return 0;
+}
+
+int32_t SystemNative_RestoreWakePreemption(int32_t previousPolicy, int32_t previousPriority)
+{
+    if (previousPolicy == WAKE_PREEMPTION_PREVIOUS_POLICY_UNSUPPORTED)
+    {
+        return 0;
+    }
+
+#if defined(TARGET_LINUX)
+    struct sched_param previousParameters;
+    previousParameters.sched_priority = previousPriority;
+
+    if (sched_setscheduler(0, previousPolicy, &previousParameters) != 0)
+    {
+        return errno;
+    }
+#else
+    (void)previousPriority; // unused
+#endif
+
+    return 0;
+}
+
 int32_t SystemNative_CreateThread(uintptr_t stackSize, void *(*startAddress)(void*), void *parameter)
 {
     bool result = false;

src/native/libs/System.Native/pal_threading.h

@@ -29,6 +29,10 @@ PALEXPORT int32_t SystemNative_LowLevelFutex_WaitOnAddressTimeout(int32_t* addre
 
 PALEXPORT void SystemNative_LowLevelFutex_WakeByAddressSingle(int32_t* address);
 
+PALEXPORT int32_t SystemNative_SuppressWakePreemption(int32_t* previousPolicy, int32_t* previousPriority);
+
+PALEXPORT int32_t SystemNative_RestoreWakePreemption(int32_t previousPolicy, int32_t previousPriority);
+
 PALEXPORT int32_t SystemNative_CreateThread(uintptr_t stackSize, void *(*startAddress)(void*), void *parameter);
 
 PALEXPORT int32_t SystemNative_SchedGetCpu(void);