Address PR feedback

eduardo-vp · eduardo-vp · commit f25c3c93a184 · 2025-07-30T20:28:41.000-07:00
diff --git a/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx b/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx
@@ -3411,7 +3411,7 @@
     <value>The timeout must represent a value between -1 and Int32.MaxValue, inclusive.</value>
   </data>
   <data name="SemaphoreSlim_Wait_TimeSpanTimeoutWrong" xml:space="preserve">
-    <value>The timeout must represent a value between -1 and the maximum allowed timer duration.</value>
+    <value>The timeout must be greater than or equal to -1.</value>
   </data>
   <data name="Serialization_BadParameterInfo" xml:space="preserve">
     <value>Non existent ParameterInfo. Position bigger than member's parameters length.</value>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/ManualResetEventSlim.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/ManualResetEventSlim.cs
@@ -520,7 +520,7 @@ public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)
                     // period of time.  The timeout adjustments only take effect when and if we actually
                     // decide to block in the kernel below.
 
-                    startTime = TimeoutHelper.GetTime();
+                    startTime = (uint)Environment.TickCount;
                     bNeedTimeoutAdjustment = true;
                 }
 
@@ -558,7 +558,8 @@ public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)
                             // update timeout (delays in wait commencement are due to spinning and/or spurious wakeups from other waits being canceled)
                             if (bNeedTimeoutAdjustment)
                             {
-                                realMillisecondsTimeout = TimeoutHelper.UpdateTimeOut(startTime, millisecondsTimeout);
+                                // TimeoutHelper.UpdateTimeOut returns a long but the value is capped as millisecondsTimeout is an int.
+                                realMillisecondsTimeout = (int)TimeoutHelper.UpdateTimeOut(startTime, millisecondsTimeout);
                                 if (realMillisecondsTimeout <= 0)
                                     return false;
                             }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/SemaphoreSlim.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/SemaphoreSlim.cs
@@ -178,7 +178,7 @@ public void Wait()
             if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185
 #endif
             // Call wait with infinite timeout
-            Wait(Timeout.UnsignedInfinite, CancellationToken.None);
+            Wait(Timeout.Infinite, CancellationToken.None);
         }
 
         /// <summary>
@@ -198,7 +198,7 @@ public void Wait(CancellationToken cancellationToken)
             if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185
 #endif
             // Call wait with infinite timeout
-            Wait(Timeout.UnsignedInfinite, cancellationToken);
+            Wait(Timeout.Infinite, cancellationToken);
         }
 
         /// <summary>
@@ -221,14 +221,14 @@ public bool Wait(TimeSpan timeout)
 #endif
             // Validate the timeout
             long totalMilliseconds = (long)timeout.TotalMilliseconds;
-            if (totalMilliseconds < -1 || totalMilliseconds > Timer.MaxSupportedTimeout)
+            if (totalMilliseconds < -1)
             {
                 throw new ArgumentOutOfRangeException(
                     nameof(timeout), timeout, SR.SemaphoreSlim_Wait_TimeSpanTimeoutWrong);
             }
 
             // Call wait with the timeout milliseconds
-            return Wait(totalMilliseconds == Timeout.Infinite ? Timeout.UnsignedInfinite : (uint)totalMilliseconds, CancellationToken.None);
+            return Wait(totalMilliseconds, CancellationToken.None);
         }
 
         /// <summary>
@@ -255,14 +255,14 @@ public bool Wait(TimeSpan timeout, CancellationToken cancellationToken)
 #endif
             // Validate the timeout
             long totalMilliseconds = (long)timeout.TotalMilliseconds;
-            if (totalMilliseconds < -1 || totalMilliseconds > Timer.MaxSupportedTimeout)
+            if (totalMilliseconds < -1)
             {
                 throw new ArgumentOutOfRangeException(
                     nameof(timeout), timeout, SR.SemaphoreSlim_Wait_TimeSpanTimeoutWrong);
             }
 
             // Call wait with the timeout milliseconds
-            return Wait(totalMilliseconds == Timeout.Infinite ? Timeout.UnsignedInfinite : (uint)totalMilliseconds, cancellationToken);
+            return Wait(totalMilliseconds, cancellationToken);
         }
 
         /// <summary>
@@ -309,7 +309,7 @@ public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)
                     nameof(millisecondsTimeout), millisecondsTimeout, SR.SemaphoreSlim_Wait_TimeoutWrong);
             }
 
-            return Wait(millisecondsTimeout == Timeout.Infinite ? Timeout.UnsignedInfinite : (uint)millisecondsTimeout, cancellationToken);
+            return Wait(millisecondsTimeout, cancellationToken);
         }
 
         /// <summary>
@@ -323,7 +323,7 @@ public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)
         /// <returns>true if the current thread successfully entered the <see cref="SemaphoreSlim"/>; otherwise, false.</returns>
         /// <exception cref="OperationCanceledException"><paramref name="cancellationToken"/> was canceled.</exception>
         [UnsupportedOSPlatform("browser")]
-        private bool Wait(uint millisecondsTimeout, CancellationToken cancellationToken)
+        private bool Wait(long millisecondsTimeout, CancellationToken cancellationToken)
         {
             CheckDispose();
 #if FEATURE_WASM_MANAGED_THREADS
@@ -339,9 +339,9 @@ private bool Wait(uint millisecondsTimeout, CancellationToken cancellationToken)
             }
 
             long startTime = 0;
-            if (millisecondsTimeout != Timeout.UnsignedInfinite && millisecondsTimeout > 0)
+            if (millisecondsTimeout != Timeout.Infinite && millisecondsTimeout > 0)
             {
-                startTime = TimeoutHelper.GetTime64();
+                startTime = Environment.TickCount64;
             }
 
             bool waitSuccessful = false;
@@ -465,7 +465,7 @@ private bool Wait(uint millisecondsTimeout, CancellationToken cancellationToken)
         /// <param name="cancellationToken">The CancellationToken to observe.</param>
         /// <returns>true if the monitor received a signal, false if the timeout expired</returns>
         [UnsupportedOSPlatform("browser")]
-        private bool WaitUntilCountOrTimeout(uint millisecondsTimeout, long startTime, CancellationToken cancellationToken)
+        private bool WaitUntilCountOrTimeout(long millisecondsTimeout, long startTime, CancellationToken cancellationToken)
         {
 #if TARGET_WASI
             if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185
@@ -481,7 +481,7 @@ private bool WaitUntilCountOrTimeout(uint millisecondsTimeout, long startTime, C
                 // Since Monitor.Wait will handle the actual wait and it accepts an int timeout,
                 // we may need to cap the timeout to int.MaxValue.
                 bool timeoutIsCapped = false;
-                if (millisecondsTimeout != Timeout.UnsignedInfinite)
+                if (millisecondsTimeout != Timeout.Infinite)
                 {
                     long remainingWaitMilliseconds = TimeoutHelper.UpdateTimeOut(startTime, millisecondsTimeout);
                     if (remainingWaitMilliseconds <= 0)
@@ -531,7 +531,7 @@ private bool WaitUntilCountOrTimeout(uint millisecondsTimeout, long startTime, C
         /// <returns>A task that will complete when the semaphore has been entered.</returns>
         public Task WaitAsync()
         {
-            return WaitAsync(Timeout.UnsignedInfinite, default);
+            return WaitAsync(Timeout.Infinite, default);
         }
 
         /// <summary>
@@ -547,7 +547,7 @@ public Task WaitAsync()
         /// </exception>
         public Task WaitAsync(CancellationToken cancellationToken)
         {
-            return WaitAsync(Timeout.UnsignedInfinite, cancellationToken);
+            return WaitAsync(Timeout.Infinite, cancellationToken);
         }
 
         /// <summary>
@@ -619,14 +619,14 @@ public Task<bool> WaitAsync(TimeSpan timeout, CancellationToken cancellationToke
         {
             // Validate the timeout
             long totalMilliseconds = (long)timeout.TotalMilliseconds;
-            if (totalMilliseconds < -1 || totalMilliseconds > Timer.MaxSupportedTimeout)
+            if (totalMilliseconds < -1)
             {
                 throw new ArgumentOutOfRangeException(
                     nameof(timeout), timeout, SR.SemaphoreSlim_Wait_TimeSpanTimeoutWrong);
             }
 
             // Call wait with the timeout milliseconds
-            return WaitAsync(totalMilliseconds == Timeout.Infinite ? Timeout.UnsignedInfinite : (uint)totalMilliseconds, cancellationToken);
+            return WaitAsync(totalMilliseconds, cancellationToken);
         }
 
         /// <summary>
@@ -655,7 +655,7 @@ public Task<bool> WaitAsync(int millisecondsTimeout, CancellationToken cancellat
                     nameof(millisecondsTimeout), millisecondsTimeout, SR.SemaphoreSlim_Wait_TimeoutWrong);
             }
 
-            return WaitAsync(millisecondsTimeout == Timeout.Infinite ? Timeout.UnsignedInfinite : (uint)millisecondsTimeout, cancellationToken);
+            return WaitAsync(millisecondsTimeout, cancellationToken);
         }
 
         /// <summary>
@@ -673,7 +673,7 @@ public Task<bool> WaitAsync(int millisecondsTimeout, CancellationToken cancellat
         /// </returns>
         /// <exception cref="ObjectDisposedException">The current instance has already been
         /// disposed.</exception>
-        private Task<bool> WaitAsync(uint millisecondsTimeout, CancellationToken cancellationToken)
+        private Task<bool> WaitAsync(long millisecondsTimeout, CancellationToken cancellationToken)
         {
             CheckDispose();
 
@@ -702,7 +702,7 @@ private Task<bool> WaitAsync(uint millisecondsTimeout, CancellationToken cancell
                 {
                     Debug.Assert(m_currentCount == 0, "m_currentCount should never be negative");
                     TaskNode asyncWaiter = CreateAndAddAsyncWaiter();
-                    return (millisecondsTimeout == Timeout.UnsignedInfinite && !cancellationToken.CanBeCanceled) ?
+                    return (millisecondsTimeout == Timeout.Infinite && !cancellationToken.CanBeCanceled) ?
                         asyncWaiter :
                         WaitUntilCountOrTimeoutAsync(asyncWaiter, millisecondsTimeout, cancellationToken);
                 }
@@ -767,13 +767,13 @@ private bool RemoveAsyncWaiter(TaskNode task)
         /// <param name="millisecondsTimeout">The timeout.</param>
         /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>The task to return to the caller.</returns>
-        private async Task<bool> WaitUntilCountOrTimeoutAsync(TaskNode asyncWaiter, uint millisecondsTimeout, CancellationToken cancellationToken)
+        private async Task<bool> WaitUntilCountOrTimeoutAsync(TaskNode asyncWaiter, long millisecondsTimeout, CancellationToken cancellationToken)
         {
             Debug.Assert(asyncWaiter is not null, "Waiter should have been constructed");
             Debug.Assert(Monitor.IsEntered(m_lockObjAndDisposed), "Requires the lock be held");
 
             await ((Task)asyncWaiter.WaitAsync(
-                TimeSpan.FromMilliseconds(millisecondsTimeout == Timeout.UnsignedInfinite ? (long)Timeout.Infinite : (long)millisecondsTimeout),
+                TimeSpan.FromMilliseconds(millisecondsTimeout),
                 cancellationToken)).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
 
             if (cancellationToken.IsCancellationRequested)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/SpinLock.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/SpinLock.cs
@@ -287,10 +287,10 @@ private void ContinueTryEnter(int millisecondsTimeout, ref bool lockTaken)
                     nameof(millisecondsTimeout), millisecondsTimeout, SR.SpinLock_TryEnter_ArgumentOutOfRange);
             }
 
-            uint startTime = 0;
+            int startTime = 0;
             if (millisecondsTimeout != Timeout.Infinite && millisecondsTimeout != 0)
             {
-                startTime = TimeoutHelper.GetTime();
+                startTime = Environment.TickCount;
             }
 
             if (IsThreadOwnerTrackingEnabled)
@@ -404,7 +404,7 @@ private void DecrementWaiters()
         /// <summary>
         /// ContinueTryEnter for the thread tracking mode enabled
         /// </summary>
-        private void ContinueTryEnterWithThreadTracking(int millisecondsTimeout, uint startTime, ref bool lockTaken)
+        private void ContinueTryEnterWithThreadTracking(int millisecondsTimeout, int startTime, ref bool lockTaken)
         {
             Debug.Assert(IsThreadOwnerTrackingEnabled);
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/SpinWait.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/SpinWait.cs
@@ -312,10 +312,10 @@ public static bool SpinUntil(Func<bool> condition, int millisecondsTimeout)
                    nameof(millisecondsTimeout), millisecondsTimeout, SR.SpinWait_SpinUntil_TimeoutWrong);
             }
             ArgumentNullException.ThrowIfNull(condition);
-            uint startTime = 0;
+            int startTime = 0;
             if (millisecondsTimeout != 0 && millisecondsTimeout != Timeout.Infinite)
             {
-                startTime = TimeoutHelper.GetTime();
+                startTime = Environment.TickCount;
             }
             SpinWait spinner = default;
             while (!condition())
@@ -329,7 +329,7 @@ public static bool SpinUntil(Func<bool> condition, int millisecondsTimeout)
 
                 if (millisecondsTimeout != Timeout.Infinite && spinner.NextSpinWillYield)
                 {
-                    if (millisecondsTimeout <= (TimeoutHelper.GetTime() - startTime))
+                    if (millisecondsTimeout <= (uint)(Environment.TickCount - startTime))
                     {
                         return false;
                     }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/TimeoutHelper.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/TimeoutHelper.cs
@@ -6,77 +6,35 @@
 namespace System.Threading
 {
     /// <summary>
-    /// A helper class to capture a start time using <see cref="Environment.TickCount"/> as a time in milliseconds.
-    /// Also updates a given timeout by subtracting the current time from the start time.
+    /// A helper class to update a given timeout by subtracting the current time from the start time.
     /// </summary>
     internal static class TimeoutHelper
     {
-        /// <summary>
-        /// Returns <see cref="Environment.TickCount"/> as a start time in milliseconds as a <see cref="uint"/>.
-        /// <see cref="Environment.TickCount"/> rolls over from positive to negative every ~25 days, then ~25 days to back to positive again.
-        /// <see cref="uint"/> is used to ignore the sign and double the range to 50 days.
-        /// </summary>
-        public static uint GetTime()
-        {
-            return (uint)Environment.TickCount;
-        }
-
-        /// <summary>
-        /// Returns <see cref="Environment.TickCount64"/> as a start time in milliseconds.
-        /// </summary>
-        public static long GetTime64()
-        {
-            return Environment.TickCount64;
-        }
-
         /// <summary>
         /// Helper function to measure and update the elapsed time
         /// </summary>
         /// <param name="startTime"> The first time (in milliseconds) observed when the wait started</param>
         /// <param name="originalWaitMillisecondsTimeout">The original wait timeout in milliseconds</param>
         /// <returns>The new wait time in milliseconds</returns>
-        public static int UpdateTimeOut(uint startTime, int originalWaitMillisecondsTimeout)
+        public static long UpdateTimeOut(long startTime, long originalWaitMillisecondsTimeout)
         {
             // The function must be called in case the time out is not infinite
             Debug.Assert(originalWaitMillisecondsTimeout != Timeout.Infinite);
 
-            uint elapsedMilliseconds = (GetTime() - startTime);
+            ulong elapsedMilliseconds = (ulong)(Environment.TickCount64 - startTime);
 
-            // Check the elapsed milliseconds is greater than max int because this property is uint
-            if (elapsedMilliseconds > int.MaxValue)
+            if (elapsedMilliseconds > long.MaxValue)
             {
                 return 0;
             }
 
-            // Subtract the elapsed time from the current wait time
-            int currentWaitTimeout = originalWaitMillisecondsTimeout - (int)elapsedMilliseconds;
+            long currentWaitTimeout = originalWaitMillisecondsTimeout - (long)elapsedMilliseconds;
             if (currentWaitTimeout <= 0)
             {
                 return 0;
             }
 
             return currentWaitTimeout;
         }
-
-        /// <summary>
-        /// Helper function to measure and update the elapsed time
-        /// </summary>
-        /// <param name="startTime"> The first time (in milliseconds) observed when the wait started</param>
-        /// <param name="originalWaitMillisecondsTimeout">The original wait timeout in milliseconds</param>
-        /// <returns>The new wait time in milliseconds</returns>
-        public static long UpdateTimeOut(long startTime, uint originalWaitMillisecondsTimeout)
-        {
-            // The function must be called in case the time out is not infinite
-            Debug.Assert(originalWaitMillisecondsTimeout != Timeout.UnsignedInfinite);
-
-            long elapsedMilliseconds = GetTime64() - startTime;
-
-            if (originalWaitMillisecondsTimeout <= elapsedMilliseconds)
-            {
-                return 0;
-            }
-
-            return originalWaitMillisecondsTimeout - elapsedMilliseconds;
-        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -520,7 +520,7 @@ public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)`
`520`	`520`	`// period of time. The timeout adjustments only take effect when and if we actually`
`521`	`521`	`// decide to block in the kernel below.`
`522`	`522`
`523`		`- startTime = TimeoutHelper.GetTime();`
	`523`	`+ startTime = (uint)Environment.TickCount;`
`524`	`524`	`bNeedTimeoutAdjustment = true;`
`525`	`525`	`}`
`526`	`526`
`@@ -558,7 +558,8 @@ public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)`
`558`	`558`	`// update timeout (delays in wait commencement are due to spinning and/or spurious wakeups from other waits being canceled)`
`559`	`559`	`if (bNeedTimeoutAdjustment)`
`560`	`560`	`{`
`561`		`- realMillisecondsTimeout = TimeoutHelper.UpdateTimeOut(startTime, millisecondsTimeout);`
	`561`	`+ // TimeoutHelper.UpdateTimeOut returns a long but the value is capped as millisecondsTimeout is an int.`
	`562`	`+ realMillisecondsTimeout = (int)TimeoutHelper.UpdateTimeOut(startTime, millisecondsTimeout);`
`562`	`563`	`if (realMillisecondsTimeout <= 0)`
`563`	`564`	`return false;`
`564`	`565`	`}`
Original file line number	Diff line number	Diff line change
`@@ -178,7 +178,7 @@ public void Wait()`
`178`	`178`	`if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185`
`179`	`179`	`#endif`
`180`	`180`	`// Call wait with infinite timeout`
`181`		`- Wait(Timeout.UnsignedInfinite, CancellationToken.None);`
	`181`	`+ Wait(Timeout.Infinite, CancellationToken.None);`
`182`	`182`	`}`
`183`	`183`
`184`	`184`	`/// <summary>`
`@@ -198,7 +198,7 @@ public void Wait(CancellationToken cancellationToken)`
`198`	`198`	`if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185`
`199`	`199`	`#endif`
`200`	`200`	`// Call wait with infinite timeout`
`201`		`- Wait(Timeout.UnsignedInfinite, cancellationToken);`
	`201`	`+ Wait(Timeout.Infinite, cancellationToken);`
`202`	`202`	`}`
`203`	`203`
`204`	`204`	`/// <summary>`
`@@ -221,14 +221,14 @@ public bool Wait(TimeSpan timeout)`
`221`	`221`	`#endif`
`222`	`222`	`// Validate the timeout`
`223`	`223`	`long totalMilliseconds = (long)timeout.TotalMilliseconds;`
`224`		`- if (totalMilliseconds < -1 \|\| totalMilliseconds > Timer.MaxSupportedTimeout)`
	`224`	`+ if (totalMilliseconds < -1)`
`225`	`225`	`{`
`226`	`226`	`throw new ArgumentOutOfRangeException(`
`227`	`227`	`nameof(timeout), timeout, SR.SemaphoreSlim_Wait_TimeSpanTimeoutWrong);`
`228`	`228`	`}`
`229`	`229`
`230`	`230`	`// Call wait with the timeout milliseconds`
`231`		`- return Wait(totalMilliseconds == Timeout.Infinite ? Timeout.UnsignedInfinite : (uint)totalMilliseconds, CancellationToken.None);`
	`231`	`+ return Wait(totalMilliseconds, CancellationToken.None);`
`232`	`232`	`}`
`233`	`233`
`234`	`234`	`/// <summary>`
`@@ -255,14 +255,14 @@ public bool Wait(TimeSpan timeout, CancellationToken cancellationToken)`
`255`	`255`	`#endif`
`256`	`256`	`// Validate the timeout`
`257`	`257`	`long totalMilliseconds = (long)timeout.TotalMilliseconds;`
`258`		`- if (totalMilliseconds < -1 \|\| totalMilliseconds > Timer.MaxSupportedTimeout)`
	`258`	`+ if (totalMilliseconds < -1)`
`259`	`259`	`{`
`260`	`260`	`throw new ArgumentOutOfRangeException(`
`261`	`261`	`nameof(timeout), timeout, SR.SemaphoreSlim_Wait_TimeSpanTimeoutWrong);`
`262`	`262`	`}`
`263`	`263`
`264`	`264`	`// Call wait with the timeout milliseconds`
`265`		`- return Wait(totalMilliseconds == Timeout.Infinite ? Timeout.UnsignedInfinite : (uint)totalMilliseconds, cancellationToken);`
	`265`	`+ return Wait(totalMilliseconds, cancellationToken);`
`266`	`266`	`}`
`267`	`267`
`268`	`268`	`/// <summary>`
`@@ -309,7 +309,7 @@ public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)`
`309`	`309`	`nameof(millisecondsTimeout), millisecondsTimeout, SR.SemaphoreSlim_Wait_TimeoutWrong);`
`310`	`310`	`}`
`311`	`311`
`312`		`- return Wait(millisecondsTimeout == Timeout.Infinite ? Timeout.UnsignedInfinite : (uint)millisecondsTimeout, cancellationToken);`
	`312`	`+ return Wait(millisecondsTimeout, cancellationToken);`
`313`	`313`	`}`
`314`	`314`
`315`	`315`	`/// <summary>`
`@@ -323,7 +323,7 @@ public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)`
`323`	`323`	`/// <returns>true if the current thread successfully entered the <see cref="SemaphoreSlim"/>; otherwise, false.</returns>`
`324`	`324`	`/// <exception cref="OperationCanceledException"><paramref name="cancellationToken"/> was canceled.</exception>`
`325`	`325`	`[UnsupportedOSPlatform("browser")]`
`326`		`- private bool Wait(uint millisecondsTimeout, CancellationToken cancellationToken)`
	`326`	`+ private bool Wait(long millisecondsTimeout, CancellationToken cancellationToken)`
`327`	`327`	`{`
`328`	`328`	`CheckDispose();`
`329`	`329`	`#if FEATURE_WASM_MANAGED_THREADS`
`@@ -339,9 +339,9 @@ private bool Wait(uint millisecondsTimeout, CancellationToken cancellationToken)`
`339`	`339`	`}`
`340`	`340`
`341`	`341`	`long startTime = 0;`
`342`		`- if (millisecondsTimeout != Timeout.UnsignedInfinite && millisecondsTimeout > 0)`
	`342`	`+ if (millisecondsTimeout != Timeout.Infinite && millisecondsTimeout > 0)`
`343`	`343`	`{`
`344`		`- startTime = TimeoutHelper.GetTime64();`
	`344`	`+ startTime = Environment.TickCount64;`
`345`	`345`	`}`
`346`	`346`
`347`	`347`	`bool waitSuccessful = false;`
`@@ -465,7 +465,7 @@ private bool Wait(uint millisecondsTimeout, CancellationToken cancellationToken)`
`465`	`465`	`/// <param name="cancellationToken">The CancellationToken to observe.</param>`
`466`	`466`	`/// <returns>true if the monitor received a signal, false if the timeout expired</returns>`
`467`	`467`	`[UnsupportedOSPlatform("browser")]`
`468`		`- private bool WaitUntilCountOrTimeout(uint millisecondsTimeout, long startTime, CancellationToken cancellationToken)`
	`468`	`+ private bool WaitUntilCountOrTimeout(long millisecondsTimeout, long startTime, CancellationToken cancellationToken)`
`469`	`469`	`{`
`470`	`470`	`#if TARGET_WASI`
`471`	`471`	`if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185`
`@@ -481,7 +481,7 @@ private bool WaitUntilCountOrTimeout(uint millisecondsTimeout, long startTime, C`
`481`	`481`	`// Since Monitor.Wait will handle the actual wait and it accepts an int timeout,`
`482`	`482`	`// we may need to cap the timeout to int.MaxValue.`
`483`	`483`	`bool timeoutIsCapped = false;`
`484`		`- if (millisecondsTimeout != Timeout.UnsignedInfinite)`
	`484`	`+ if (millisecondsTimeout != Timeout.Infinite)`
`485`	`485`	`{`
`486`	`486`	`long remainingWaitMilliseconds = TimeoutHelper.UpdateTimeOut(startTime, millisecondsTimeout);`
`487`	`487`	`if (remainingWaitMilliseconds <= 0)`
`@@ -531,7 +531,7 @@ private bool WaitUntilCountOrTimeout(uint millisecondsTimeout, long startTime, C`
`531`	`531`	`/// <returns>A task that will complete when the semaphore has been entered.</returns>`
`532`	`532`	`public Task WaitAsync()`
`533`	`533`	`{`
`534`		`- return WaitAsync(Timeout.UnsignedInfinite, default);`
	`534`	`+ return WaitAsync(Timeout.Infinite, default);`
`535`	`535`	`}`
`536`	`536`
`537`	`537`	`/// <summary>`
`@@ -547,7 +547,7 @@ public Task WaitAsync()`
`547`	`547`	`/// </exception>`
`548`	`548`	`public Task WaitAsync(CancellationToken cancellationToken)`
`549`	`549`	`{`
`550`		`- return WaitAsync(Timeout.UnsignedInfinite, cancellationToken);`
	`550`	`+ return WaitAsync(Timeout.Infinite, cancellationToken);`
`551`	`551`	`}`
`552`	`552`
`553`	`553`	`/// <summary>`
`@@ -619,14 +619,14 @@ public Task<bool> WaitAsync(TimeSpan timeout, CancellationToken cancellationToke`
`619`	`619`	`{`
`620`	`620`	`// Validate the timeout`
`621`	`621`	`long totalMilliseconds = (long)timeout.TotalMilliseconds;`
`622`		`- if (totalMilliseconds < -1 \|\| totalMilliseconds > Timer.MaxSupportedTimeout)`
	`622`	`+ if (totalMilliseconds < -1)`
`623`	`623`	`{`
`624`	`624`	`throw new ArgumentOutOfRangeException(`
`625`	`625`	`nameof(timeout), timeout, SR.SemaphoreSlim_Wait_TimeSpanTimeoutWrong);`
`626`	`626`	`}`
`627`	`627`
`628`	`628`	`// Call wait with the timeout milliseconds`
`629`		`- return WaitAsync(totalMilliseconds == Timeout.Infinite ? Timeout.UnsignedInfinite : (uint)totalMilliseconds, cancellationToken);`
	`629`	`+ return WaitAsync(totalMilliseconds, cancellationToken);`
`630`	`630`	`}`
`631`	`631`
`632`	`632`	`/// <summary>`
`@@ -655,7 +655,7 @@ public Task<bool> WaitAsync(int millisecondsTimeout, CancellationToken cancellat`
`655`	`655`	`nameof(millisecondsTimeout), millisecondsTimeout, SR.SemaphoreSlim_Wait_TimeoutWrong);`
`656`	`656`	`}`
`657`	`657`
`658`		`- return WaitAsync(millisecondsTimeout == Timeout.Infinite ? Timeout.UnsignedInfinite : (uint)millisecondsTimeout, cancellationToken);`
	`658`	`+ return WaitAsync(millisecondsTimeout, cancellationToken);`
`659`	`659`	`}`
`660`	`660`
`661`	`661`	`/// <summary>`
`@@ -673,7 +673,7 @@ public Task<bool> WaitAsync(int millisecondsTimeout, CancellationToken cancellat`
`673`	`673`	`/// </returns>`
`674`	`674`	`/// <exception cref="ObjectDisposedException">The current instance has already been`
`675`	`675`	`/// disposed.</exception>`
`676`		`- private Task<bool> WaitAsync(uint millisecondsTimeout, CancellationToken cancellationToken)`
	`676`	`+ private Task<bool> WaitAsync(long millisecondsTimeout, CancellationToken cancellationToken)`
`677`	`677`	`{`
`678`	`678`	`CheckDispose();`
`679`	`679`
`@@ -702,7 +702,7 @@ private Task<bool> WaitAsync(uint millisecondsTimeout, CancellationToken cancell`
`702`	`702`	`{`
`703`	`703`	`Debug.Assert(m_currentCount == 0, "m_currentCount should never be negative");`
`704`	`704`	`TaskNode asyncWaiter = CreateAndAddAsyncWaiter();`
`705`		`- return (millisecondsTimeout == Timeout.UnsignedInfinite && !cancellationToken.CanBeCanceled) ?`
	`705`	`+ return (millisecondsTimeout == Timeout.Infinite && !cancellationToken.CanBeCanceled) ?`
`706`	`706`	`asyncWaiter :`
`707`	`707`	`WaitUntilCountOrTimeoutAsync(asyncWaiter, millisecondsTimeout, cancellationToken);`
`708`	`708`	`}`
`@@ -767,13 +767,13 @@ private bool RemoveAsyncWaiter(TaskNode task)`
`767`	`767`	`/// <param name="millisecondsTimeout">The timeout.</param>`
`768`	`768`	`/// <param name="cancellationToken">The cancellation token.</param>`
`769`	`769`	`/// <returns>The task to return to the caller.</returns>`
`770`		`- private async Task<bool> WaitUntilCountOrTimeoutAsync(TaskNode asyncWaiter, uint millisecondsTimeout, CancellationToken cancellationToken)`
	`770`	`+ private async Task<bool> WaitUntilCountOrTimeoutAsync(TaskNode asyncWaiter, long millisecondsTimeout, CancellationToken cancellationToken)`
`771`	`771`	`{`
`772`	`772`	`Debug.Assert(asyncWaiter is not null, "Waiter should have been constructed");`
`773`	`773`	`Debug.Assert(Monitor.IsEntered(m_lockObjAndDisposed), "Requires the lock be held");`
`774`	`774`
`775`	`775`	`await ((Task)asyncWaiter.WaitAsync(`
`776`		`- TimeSpan.FromMilliseconds(millisecondsTimeout == Timeout.UnsignedInfinite ? (long)Timeout.Infinite : (long)millisecondsTimeout),`
	`776`	`+ TimeSpan.FromMilliseconds(millisecondsTimeout),`
`777`	`777`	`cancellationToken)).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);`
`778`	`778`
`779`	`779`	`if (cancellationToken.IsCancellationRequested)`
Original file line number	Diff line number	Diff line change
`@@ -287,10 +287,10 @@ private void ContinueTryEnter(int millisecondsTimeout, ref bool lockTaken)`
`287`	`287`	`nameof(millisecondsTimeout), millisecondsTimeout, SR.SpinLock_TryEnter_ArgumentOutOfRange);`
`288`	`288`	`}`
`289`	`289`
`290`		`- uint startTime = 0;`
	`290`	`+ int startTime = 0;`
`291`	`291`	`if (millisecondsTimeout != Timeout.Infinite && millisecondsTimeout != 0)`
`292`	`292`	`{`
`293`		`- startTime = TimeoutHelper.GetTime();`
	`293`	`+ startTime = Environment.TickCount;`
`294`	`294`	`}`
`295`	`295`
`296`	`296`	`if (IsThreadOwnerTrackingEnabled)`
`@@ -404,7 +404,7 @@ private void DecrementWaiters()`
`404`	`404`	`/// <summary>`
`405`	`405`	`/// ContinueTryEnter for the thread tracking mode enabled`
`406`	`406`	`/// </summary>`
`407`		`- private void ContinueTryEnterWithThreadTracking(int millisecondsTimeout, uint startTime, ref bool lockTaken)`
	`407`	`+ private void ContinueTryEnterWithThreadTracking(int millisecondsTimeout, int startTime, ref bool lockTaken)`
`408`	`408`	`{`
`409`	`409`	`Debug.Assert(IsThreadOwnerTrackingEnabled);`
`410`	`410`
Original file line number	Diff line number	Diff line change
`@@ -312,10 +312,10 @@ public static bool SpinUntil(Func<bool> condition, int millisecondsTimeout)`
`312`	`312`	`nameof(millisecondsTimeout), millisecondsTimeout, SR.SpinWait_SpinUntil_TimeoutWrong);`
`313`	`313`	`}`
`314`	`314`	`ArgumentNullException.ThrowIfNull(condition);`
`315`		`- uint startTime = 0;`
	`315`	`+ int startTime = 0;`
`316`	`316`	`if (millisecondsTimeout != 0 && millisecondsTimeout != Timeout.Infinite)`
`317`	`317`	`{`
`318`		`- startTime = TimeoutHelper.GetTime();`
	`318`	`+ startTime = Environment.TickCount;`
`319`	`319`	`}`
`320`	`320`	`SpinWait spinner = default;`
`321`	`321`	`while (!condition())`
`@@ -329,7 +329,7 @@ public static bool SpinUntil(Func<bool> condition, int millisecondsTimeout)`
`329`	`329`
`330`	`330`	`if (millisecondsTimeout != Timeout.Infinite && spinner.NextSpinWillYield)`
`331`	`331`	`{`
`332`		`- if (millisecondsTimeout <= (TimeoutHelper.GetTime() - startTime))`
	`332`	`+ if (millisecondsTimeout <= (uint)(Environment.TickCount - startTime))`
`333`	`333`	`{`
`334`	`334`	`return false;`
`335`	`335`	`}`