Remove no longer used BOOTSTRAP conditionals

[mono.git] / mcs / class / corlib / System.Threading / SpinWait.cs

diff --git a/mcs/class/corlib/System.Threading/SpinWait.cs b/mcs/class/corlib/System.Threading/SpinWait.cs
index 8687bc21c4e0b6cb4573bcd1cb55083e4fdd5bff..136836746cc87e830c772e23c310ae1c822f0600 100644 (file)
--- a/mcs/class/corlib/System.Threading/SpinWait.cs
+++ b/mcs/class/corlib/System.Threading/SpinWait.cs
@@ -1,4 +1,3 @@
-#if NET_4_0 || BOOTSTRAP_NET_4_0
 // SpinWait.cs
 //
 // Copyright (c) 2008 Jérémie "Garuma" Laval
@@ -23,53 +22,55 @@
 //
 //
 
+#if NET_4_0
 using System;
 
 namespace System.Threading
 {
-
        public struct SpinWait
        {
                // The number of step until SpinOnce yield on multicore machine
-               const           int  step = 5;
+               const           int  step = 10;
+               const           int  maxTime = 200;
                static readonly bool isSingleCpu = (Environment.ProcessorCount == 1);
 
                int ntime;
 
                public void SpinOnce ()
                {
-                       // On a single-CPU system, spinning does no good
+                       ntime += 1;
+
                        if (isSingleCpu) {
-                               Yield ();
+                               // On a single-CPU system, spinning does no good
+                               Thread.Yield ();
                        } else {
-                               if (Interlocked.Increment (ref ntime) % step == 0) {
-                                       Yield ();
-                               } else {
+                               if (ntime % step == 0)
+                                       Thread.Yield ();
+                               else
                                        // Multi-CPU system might be hyper-threaded, let other thread run
-                                       Thread.SpinWait (2 * (ntime + 1));
-                               }
+                                       Thread.SpinWait (Math.Min (ntime, maxTime) << 1);
                        }
                }
 
-               public static void SpinUntil (Func<bool> predicate)
+               public static void SpinUntil (Func<bool> condition)
                {
                        SpinWait sw = new SpinWait ();
-                       while (!predicate ())
+                       while (!condition ())
                                sw.SpinOnce ();
                }
 
-               public static bool SpinUntil (Func<bool> predicate, TimeSpan ts)
+               public static bool SpinUntil (Func<bool> condition, TimeSpan timeout)
                {
-                       return SpinUntil (predicate, (int)ts.TotalMilliseconds);
+                       return SpinUntil (condition, (int)timeout.TotalMilliseconds);
                }
 
-               public static bool SpinUntil (Func<bool> predicate, int milliseconds)
+               public static bool SpinUntil (Func<bool> condition, int millisecondsTimeout)
                {
                        SpinWait sw = new SpinWait ();
                        Watch watch = Watch.StartNew ();
 
-                       while (!predicate ()) {
-                               if (watch.ElapsedMilliseconds > milliseconds)
+                       while (!condition ()) {
+                               if (watch.ElapsedMilliseconds > millisecondsTimeout)
                                        return false;
                                sw.SpinOnce ();
                        }
@@ -77,13 +78,6 @@ namespace System.Threading
                        return true;
                }
 
-               void Yield ()
-               {
-                       // Replace sched_yield by Thread.Sleep(0) which does almost the same thing
-                       // (going back in kernel mode and yielding) but avoid the branching and unmanaged bridge
-                       Thread.Sleep (0);
-               }
-
                public void Reset ()
                {
                        ntime = 0;