Rework ReaderWriterLockSlim to use simpler Interlocked arithmetic.

[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 001891bbe6c70011becaaf3b23b52dc65e8c0b56..d46376bc0439bde0dbde55c160a338c87010d14a 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,78 +22,71 @@
 //
 //
 
+#if NET_4_0 || BOOTSTRAP_NET_4_0
 using System;
 
 namespace System.Threading
 {
-       
        public struct SpinWait
        {
                // The number of step until SpinOnce yield on multicore machine
-               const           int  step = 20;
+               const           int  step = 5;
+               const           int  maxTime = 50;
                static readonly bool isSingleCpu = (Environment.ProcessorCount == 1);
-               
+
                int ntime;
-               
-               public void SpinOnce () 
+
+               public void SpinOnce ()
                {
-                       // On a single-CPU system, spinning does no good
                        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 = ntime == maxTime ? maxTime : ntime + 1) % step == 0)
+                                       Thread.Yield ();
+                               else
                                        // Multi-CPU system might be hyper-threaded, let other thread run
-                                       Thread.SpinWait (2 * (ntime + 1));
-                               }
+                                       Thread.SpinWait (ntime << 1);
                        }
                }
-               
+
                public static void SpinUntil (Func<bool> predicate)
                {
                        SpinWait sw = new SpinWait ();
                        while (!predicate ())
                                sw.SpinOnce ();
                }
-               
+
                public static bool SpinUntil (Func<bool> predicate, TimeSpan ts)
                {
                        return SpinUntil (predicate, (int)ts.TotalMilliseconds);
                }
-               
+
                public static bool SpinUntil (Func<bool> predicate, int milliseconds)
                {
                        SpinWait sw = new SpinWait ();
                        Watch watch = Watch.StartNew ();
-                       
+
                        while (!predicate ()) {
                                if (watch.ElapsedMilliseconds > milliseconds)
                                        return false;
                                sw.SpinOnce ();
                        }
-                       
+
                        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;
                }
-               
+
                public bool NextSpinWillYield {
                        get {
                                return isSingleCpu ? true : ntime % step == 0;
                        }
                }
-               
+
                public int Count {
                        get {
                                return ntime;