Implemented fast version of ThreadLocal<T>.

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

diff --git a/mcs/class/corlib/System.Threading/AtomicBoolean.cs b/mcs/class/corlib/System.Threading/AtomicBoolean.cs
index 3c76f0925f539044609117c52229c9f4e0bef932..28faf014b29351a105b14c8af4d845bd6a576efd 100644 (file)
--- a/mcs/class/corlib/System.Threading/AtomicBoolean.cs
+++ b/mcs/class/corlib/System.Threading/AtomicBoolean.cs
@@ -1,4 +1,3 @@
-#if NET_4_0 || BOOTSTRAP_NET_4_0
 // AtomicBoolean.cs
 //
 // Copyright (c) 2008 Jérémie "Garuma" Laval
@@ -25,74 +24,163 @@
 
 using System;
 
+#if INSIDE_MONO_PARALLEL
+using System.Threading;
+
+namespace Mono.Threading
+#else
 namespace System.Threading
+#endif
 {
-       internal class AtomicBoolean
+#if INSIDE_MONO_PARALLEL
+       public
+#endif
+       struct AtomicBooleanValue
+       {
+               int flag;
+               const int UnSet = 0;
+               const int Set = 1;
+
+               public bool CompareAndExchange (bool expected, bool newVal)
+               {
+                       int newTemp = newVal ? Set : UnSet;
+                       int expectedTemp = expected ? Set : UnSet;
+
+                       return Interlocked.CompareExchange (ref flag, newTemp, expectedTemp) == expectedTemp;
+               }
+
+               public static AtomicBooleanValue FromValue (bool value)
+               {
+                       AtomicBooleanValue temp = new AtomicBooleanValue ();
+                       temp.Value = value;
+
+                       return temp;
+               }
+
+               public bool TrySet ()
+               {
+                       return !Exchange (true);
+               }
+
+               public bool TryRelaxedSet ()
+               {
+                       return flag == UnSet && !Exchange (true);
+               }
+
+               public bool Exchange (bool newVal)
+               {
+                       int newTemp = newVal ? Set : UnSet;
+                       return Interlocked.Exchange (ref flag, newTemp) == Set;
+               }
+
+               public bool Value {
+                       get {
+                               return flag == Set;
+                       }
+                       set {
+                               Exchange (value);
+                       }
+               }
+
+               public bool Equals (AtomicBooleanValue rhs)
+               {
+                       return this.flag == rhs.flag;
+               }
+
+               public override bool Equals (object rhs)
+               {
+                       return rhs is AtomicBooleanValue ? Equals ((AtomicBooleanValue)rhs) : false;
+               }
+
+               public override int GetHashCode ()
+               {
+                       return flag.GetHashCode ();
+               }
+
+               public static explicit operator bool (AtomicBooleanValue rhs)
+               {
+                       return rhs.Value;
+               }
+
+               public static implicit operator AtomicBooleanValue (bool rhs)
+               {
+                       return AtomicBooleanValue.FromValue (rhs);
+               }
+       }
+
+#if INSIDE_MONO_PARALLEL
+       public
+#endif
+       class AtomicBoolean
        {
                int flag;
                const int UnSet = 0;
                const int Set = 1;
-               
+
                public bool CompareAndExchange (bool expected, bool newVal)
                {
                        int newTemp = newVal ? Set : UnSet;
                        int expectedTemp = expected ? Set : UnSet;
-                       
+
                        return Interlocked.CompareExchange (ref flag, newTemp, expectedTemp) == expectedTemp;
                }
-               
+
                public static AtomicBoolean FromValue (bool value)
                {
                        AtomicBoolean temp = new AtomicBoolean ();
                        temp.Value = value;
-                       
+
                        return temp;
                }
-               
+
                public bool TrySet ()
                {
                        return !Exchange (true);
                }
-               
+
+               public bool TryRelaxedSet ()
+               {
+                       return flag == UnSet && !Exchange (true);
+               }
+
                public bool Exchange (bool newVal)
                {
                        int newTemp = newVal ? Set : UnSet;
                        return Interlocked.Exchange (ref flag, newTemp) == Set;
                }
-               
+
                public bool Value {
                        get {
                                return flag == Set;
-                       } 
+                       }
                        set {
                                Exchange (value);
                        }
                }
-               
+
                public bool Equals (AtomicBoolean rhs)
                {
                        return this.flag == rhs.flag;
                }
-               
+
                public override bool Equals (object rhs)
                {
                        return rhs is AtomicBoolean ? Equals ((AtomicBoolean)rhs) : false;
                }
-               
+
                public override int GetHashCode ()
                {
                        return flag.GetHashCode ();
                }
-               
+
                public static explicit operator bool (AtomicBoolean rhs)
                {
                        return rhs.Value;
                }
-               
+
                public static implicit operator AtomicBoolean (bool rhs)
                {
                        return AtomicBoolean.FromValue (rhs);
                }
        }
 }
-#endif