Share the sleep impl between all runtimes on Windows and unix

Author: jkoritzinsky

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

@@ -112,14 +112,6 @@ private void StartCallback()
             startHelper.Run();
         }
 
-        /// <summary>
-        /// Suspends the current thread for timeout milliseconds. If timeout == 0,
-        /// forces the thread to give up the remainder of its timeslice.  If timeout
-        /// == Timeout.Infinite, no timeout will occur.
-        /// </summary>
-        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Sleep")]
-        private static partial void SleepInternal(int millisecondsTimeout);
-
         // Max iterations to be done in SpinWait without switching GC modes.
         private const int SpinWaitCoopThreshold = 1024;
 

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Thread.NativeAot.Windows.cs

@@ -26,59 +26,6 @@ public sealed partial class Thread
 
         partial void PlatformSpecificInitialize();
 
-        internal static void SleepInternal(int millisecondsTimeout)
-        {
-            Debug.Assert(millisecondsTimeout >= Timeout.Infinite);
-
-            CheckForPendingInterrupt();
-
-            Thread currentThread = CurrentThread;
-            if (millisecondsTimeout == Timeout.Infinite)
-            {
-                // Infinite wait - use alertable wait
-                currentThread.SetWaitSleepJoinState();
-                uint result;
-                while (true)
-                {
-                    result = Interop.Kernel32.SleepEx(Timeout.UnsignedInfinite, true);
-                    if (result != Interop.Kernel32.WAIT_IO_COMPLETION)
-                    {
-                        break;
-                    }
-                    CheckForPendingInterrupt();
-                }
-
-                currentThread.ClearWaitSleepJoinState();
-            }
-            else
-            {
-                // Timed wait - use alertable wait
-                currentThread.SetWaitSleepJoinState();
-                long startTime = Environment.TickCount64;
-                while (true)
-                {
-                    uint result = Interop.Kernel32.SleepEx((uint)millisecondsTimeout, true);
-                    if (result != Interop.Kernel32.WAIT_IO_COMPLETION)
-                    {
-                        break;
-                    }
-                    // Check if this was our interrupt APC
-                    CheckForPendingInterrupt();
-                    // Handle APC completion by adjusting timeout and retrying
-                    long currentTime = Environment.TickCount64;
-                    long elapsed = currentTime - startTime;
-                    if (elapsed >= millisecondsTimeout)
-                    {
-                        break;
-                    }
-                    millisecondsTimeout -= (int)elapsed;
-                    startTime = currentTime;
-                }
-
-                currentThread.ClearWaitSleepJoinState();
-            }
-        }
-
         // Platform-specific initialization of foreign threads, i.e. threads not created by Thread.Start
         private void PlatformSpecificInitializeExistingThread()
         {

src/coreclr/vm/comsynchronizable.cpp

@@ -857,17 +857,6 @@ extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread)
     END_QCALL;
 }
 
-extern "C" void QCALLTYPE ThreadNative_Sleep(INT32 iTime)
-{
-    QCALL_CONTRACT;
-
-    BEGIN_QCALL;
-
-    GetThread()->UserSleep(iTime);
-
-    END_QCALL;
-}
-
 #ifdef FEATURE_COMINTEROP
 extern "C" void QCALLTYPE ThreadNative_DisableComObjectEagerCleanup(QCall::ThreadHandle thread)
 {

src/coreclr/vm/comsynchronizable.h

@@ -71,7 +71,6 @@ extern "C" void QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread);
 extern "C" void QCALLTYPE ThreadNative_ResetAbort();
 extern "C" void QCALLTYPE ThreadNative_SpinWait(INT32 iterations);
 extern "C" void QCALLTYPE ThreadNative_Interrupt(QCall::ThreadHandle thread);
-extern "C" void QCALLTYPE ThreadNative_Sleep(INT32 iTime);
 #ifdef FEATURE_COMINTEROP
 extern "C" void QCALLTYPE ThreadNative_DisableComObjectEagerCleanup(QCall::ThreadHandle thread);
 #endif // FEATURE_COMINTEROP

src/coreclr/vm/qcallentrypoints.cpp

@@ -301,7 +301,6 @@ static const Entry s_QCall[] =
     DllImportEntry(ThreadNative_ResetAbort)
     DllImportEntry(ThreadNative_SpinWait)
     DllImportEntry(ThreadNative_Interrupt)
-    DllImportEntry(ThreadNative_Sleep)
     DllImportEntry(ThreadNative_PollGC)
 #ifdef FEATURE_COMINTEROP
     DllImportEntry(ThreadNative_DisableComObjectEagerCleanup)

src/coreclr/vm/threads.cpp

@@ -3703,82 +3703,6 @@ void Thread::UserInterrupt(ThreadInterruptMode mode)
     }
 }
 
-// Implementation of Thread.Sleep().
-void Thread::UserSleep(INT32 time)
-{
-    CONTRACTL {
-        THROWS;
-        GC_TRIGGERS;
-    }
-    CONTRACTL_END;
-
-    INCONTRACT(_ASSERTE(!GetThread()->GCNoTrigger()));
-
-    DWORD   res;
-
-    // Before going to pre-emptive mode the thread needs to be flagged as waiting for
-    // the debugger. This used to be accomplished by the TS_Interruptible flag but that
-    // doesn't work reliably, see DevDiv Bugs 699245.
-    ThreadStateNCStackHolder tsNC(TRUE, TSNC_DebuggerSleepWaitJoin);
-    GCX_PREEMP();
-
-    // A word about ordering for Interrupt.  If someone tries to interrupt a thread
-    // that's in the interruptible state, we queue an APC.  But if they try to interrupt
-    // a thread that's not in the interruptible state, we just record that fact.  So
-    // we have to set TS_Interruptible before we test to see whether someone wants to
-    // interrupt us or else we have a race condition that causes us to skip the APC.
-    SetThreadState(TS_Interruptible);
-
-    // If someone has interrupted us, we should not enter the wait.
-    if (IsUserInterrupted())
-    {
-        HandleThreadInterrupt();
-    }
-
-    ThreadStateHolder tsh(TRUE, TS_Interruptible | TS_Interrupted);
-
-    ResetThreadState(TS_Interrupted);
-
-    DWORD dwTime = (DWORD)time;
-retry:
-
-    ULONGLONG start = minipal_lowres_ticks();
-
-    res = ClrSleepEx (dwTime, TRUE);
-
-    if (res == WAIT_IO_COMPLETION)
-    {
-        // We could be woken by some spurious APC or an EE APC queued to
-        // interrupt us. In the latter case the TS_Interrupted bit will be set
-        // in the thread state bits. Otherwise we just go back to sleep again.
-        if ((m_State & TS_Interrupted))
-        {
-            HandleThreadInterrupt();
-        }
-
-        if (dwTime == INFINITE)
-        {
-            goto retry;
-        }
-        else
-        {
-            ULONGLONG actDuration = minipal_lowres_ticks() - start;
-
-            if (dwTime > actDuration)
-            {
-                dwTime -= (DWORD)actDuration;
-                goto retry;
-            }
-            else
-            {
-                res = WAIT_TIMEOUT;
-            }
-        }
-    }
-    _ASSERTE(res == WAIT_TIMEOUT || res == WAIT_OBJECT_0);
-}
-
-
 // Correspondence between an EE Thread and an exposed System.Thread:
 OBJECTREF Thread::GetExposedObject()
 {

src/coreclr/vm/threads.h

@@ -1803,8 +1803,6 @@ class Thread
     static bool    SysSweepThreadsForDebug(bool forceSync);
     static void    SysResumeFromDebug(AppDomain *pAppDomain);
 
-    void           UserSleep(INT32 time);
-
 private:
 
     // Specifies type of thread abort.

src/libraries/System.Private.CoreLib/src/System/Threading/Thread.Windows.cs

@@ -18,13 +18,58 @@ public sealed partial class Thread
     {
         internal static void UninterruptibleSleep0() => Interop.Kernel32.Sleep(0);
 
-#if MONO
-        private static void SleepInternal(int millisecondsTimeout)
+        internal static void SleepInternal(int millisecondsTimeout)
         {
-            Debug.Assert(millisecondsTimeout >= -1);
-            Interop.Kernel32.Sleep((uint)millisecondsTimeout);
+            Debug.Assert(millisecondsTimeout >= Timeout.Infinite);
+
+            CheckForPendingInterrupt();
+
+            Thread currentThread = CurrentThread;
+            if (millisecondsTimeout == Timeout.Infinite)
+            {
+                // Infinite wait - use alertable wait
+                currentThread.SetWaitSleepJoinState();
+                uint result;
+                while (true)
+                {
+                    result = Interop.Kernel32.SleepEx(Timeout.UnsignedInfinite, true);
+                    if (result != Interop.Kernel32.WAIT_IO_COMPLETION)
+                    {
+                        break;
+                    }
+                    CheckForPendingInterrupt();
+                }
+
+                currentThread.ClearWaitSleepJoinState();
+            }
+            else
+            {
+                // Timed wait - use alertable wait
+                currentThread.SetWaitSleepJoinState();
+                long startTime = Environment.TickCount64;
+                while (true)
+                {
+                    uint result = Interop.Kernel32.SleepEx((uint)millisecondsTimeout, true);
+                    if (result != Interop.Kernel32.WAIT_IO_COMPLETION)
+                    {
+                        break;
+                    }
+                    // Check if this was our interrupt APC
+                    CheckForPendingInterrupt();
+                    // Handle APC completion by adjusting timeout and retrying
+                    long currentTime = Environment.TickCount64;
+                    long elapsed = currentTime - startTime;
+                    if (elapsed >= millisecondsTimeout)
+                    {
+                        break;
+                    }
+                    millisecondsTimeout -= (int)elapsed;
+                    startTime = currentTime;
+                }
+
+                currentThread.ClearWaitSleepJoinState();
+            }
         }
-#endif
 
         internal static int GetCurrentProcessorNumber()
         {