Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

mcs/class/Mono.Parallel/Mono.Threading/CSnzi.cs

@@ -0,0 +1,245 @@
+// 
+// CSnzi.cs
+//  
+// Author:
+//       Jérémie "Garuma" Laval <jeremie.laval@gmail.com>
+// 
+// Copyright (c) 2009 Jérémie "Garuma" Laval
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#if NET_4_0
+using System;
+using System.Threading;
+
+namespace Mono.Threading
+{
+	public abstract class CSnziNode
+	{
+		internal abstract bool Arrive ();
+		internal abstract bool Depart ();
+	}
+	
+	public enum CSnziState
+	{
+		Open,
+		Closed
+	}
+	
+	internal class CSnziLeafNode : CSnziNode
+	{
+		int count;
+		readonly CSnziNode parent;
+		
+		public CSnziLeafNode (CSnziNode parent)
+		{
+			this.parent = parent;
+		}
+
+		#region CSnziNode implementation
+		internal override bool Arrive ()
+		{
+			bool arrivedAtParent = false;
+			int x;
+			
+			do {
+				x = count;
+				if (x == 0 && !arrivedAtParent) {
+					if (parent.Arrive ())
+						arrivedAtParent = true;
+					else
+						return false;
+				}
+			} while (Interlocked.CompareExchange (ref count, x + 1, x) != x);
+			
+			if (arrivedAtParent && x != 0)
+				parent.Depart ();
+			
+			return true;
+		}
+		
+		internal override bool Depart ()
+		{
+			int x = Interlocked.Decrement (ref count);
+			if (x == 1)
+				return parent.Depart ();
+			else
+				return true;
+		}
+		#endregion
+		
+	}
+	
+	internal class CSnziRootNode : CSnziNode
+	{
+		int root;
+		
+		public int Count {
+			get {
+				return root & 0x7FFFFFFF;
+			}
+		}
+					
+		public CSnziState State {
+			get {
+				return (root >> 31) > 0 ? CSnziState.Open : CSnziState.Closed;
+			}
+		}
+		
+		public CSnziRootNode () : this (0, CSnziState.Open)
+		{
+			
+		}
+		
+		public CSnziRootNode (int count, CSnziState state)
+		{
+			root = Encode (count, state);
+		}
+
+		#region CSnziNode implementation
+		internal override bool Arrive ()
+		{
+			int old;
+			int c;
+			CSnziState s;
+			
+			do {
+				old = root;
+				
+				Decode (old, out c, out s);
+				
+				if (c == 0 && s == CSnziState.Closed)
+					return false;
+			} while (Interlocked.CompareExchange (ref root, Encode (c + 1, s), old) != old);
+			
+			return true;
+		}
+		
+		internal override bool Depart ()
+		{
+			int old;
+			int c;
+			CSnziState s;
+			
+			do {
+				old = root;	
+				Decode (old, out c, out s); 
+			} while (Interlocked.CompareExchange (ref root, Encode (c - 1, s), old) != old);
+			
+			return c != 0 && s != CSnziState.Closed;
+		}
+		#endregion
+		
+		public void Open ()
+		{
+			root = Encode (0, CSnziState.Open);
+		}
+		
+		public bool Close ()
+		{
+			int old, newRoot;
+			int c;
+			CSnziState s;
+			
+			do {
+				old = root;
+	
+				Decode (old, out c, out s);
+				if (s != CSnziState.Open)
+					return false;
+				
+				newRoot = Encode (c, CSnziState.Closed);
+			} while (Interlocked.CompareExchange (ref root, newRoot, old) != old);
+			
+			return c == 0;
+		}
+		
+		int Encode (int count, CSnziState state)
+		{
+			return (state == CSnziState.Open) ? (int)(((uint)count) | 0x80000000) : count & 0x7FFFFFFF;
+		}
+		
+		void Decode (int code, out int count, out CSnziState state)
+		{
+			count = code & 0x7FFFFFFF;
+			state = (code >> 31) > 0 ? CSnziState.Open : CSnziState.Closed;
+		}
+	}
+	
+	public class CSnzi
+	{
+		CSnziRootNode root;
+		CSnziLeafNode[] leafs;
+		
+		readonly int LeafCount = Environment.ProcessorCount * 2;
+		
+		public CSnzi ()
+		{
+			leafs = new CSnziLeafNode[LeafCount];
+			root = new CSnziRootNode ();
+			
+			for (int i = 0; i < leafs.Length; i++) {
+				leafs[i] = new CSnziLeafNode (root);
+			}
+		}
+		
+		public CSnziNode Arrive ()
+		{
+			while (true) {
+				if (root.State != CSnziState.Open)
+					return null;
+				
+				CSnziNode leaf = leafs[GetLeafIndex ()];
+				if (leaf.Arrive ())
+					return leaf;
+				else {
+					return null;
+				}
+			}
+		}
+		
+		public bool Depart (CSnziNode node)
+		{
+			return node.Depart ();
+		}
+		
+		public bool Close ()
+		{
+			return root.Close ();
+		}
+		
+		public void Open ()
+		{
+			root.Open ();
+		}
+		
+		public Tuple<bool, CSnziState> Query ()
+		{
+			CSnziRootNode copy = root;
+			
+			return Tuple.Create (copy.Count > 0, copy.State);
+		}
+		
+		int GetLeafIndex ()
+		{
+			return (Thread.CurrentThread.ManagedThreadId - 1) % leafs.Length;
+		}
+	}
+}
+#endif

mcs/class/Mono.Parallel/Mono.Threading/ReaderWriterLockSlimmer.cs

@@ -0,0 +1,143 @@
+// ReaderWriterLockSlimmer.cs
+//
+// Copyright (c) 2010 Jérémie "Garuma" Laval
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+//
+
+#if NET_4_0
+
+using System;
+using System.Threading;
+
+namespace Mono.Threading
+{
+	public struct ReaderWriterLockSlimmer
+	{
+		const int RwWait = 1;
+		const int RwWrite = 2;
+		const int RwRead = 4;
+
+		int rwlock;
+
+		public void EnterReadLock (ref bool taken)
+		{
+			if (taken)
+				throw new ArgumentException ("taken", "taken needs to be set to false");
+
+			SpinWait sw = new SpinWait ();
+			bool cont = true;
+
+			do {
+				while ((rwlock & (RwWrite | RwWait)) > 0)
+					sw.SpinOnce ();
+
+				try {}
+				finally {
+					if ((Interlocked.Add (ref rwlock, RwRead) & (RwWait | RwWait)) == 0) {
+						taken = true;
+						cont = false;
+					} else {
+						Interlocked.Add (ref rwlock, -RwRead);
+					}
+				}
+			} while (cont);
+		}
+
+		public void TryEnterReadLock (ref bool taken)
+		{
+			if (taken)
+				throw new ArgumentException ("taken", "taken needs to be set to false");
+
+			try {}
+			finally {
+				if ((Interlocked.Add (ref rwlock, RwRead) & (RwWait | RwWrite)) == 0)
+					taken = true;
+				else
+					Interlocked.Add (ref rwlock, -RwRead);
+			}
+		}
+
+		public void ExitReadLock ()
+		{
+			Interlocked.Add (ref rwlock, -RwRead);
+		}
+
+		public void EnterWriteLock (ref bool taken)
+		{
+			if (taken)
+				throw new ArgumentException ("taken", "taken needs to be set to false");
+
+			SpinWait sw = new SpinWait ();
+			int state = rwlock;
+
+			try {
+				do {
+					state = rwlock;
+					if (state < RwWrite) {
+						try {}
+						finally {
+							if (Interlocked.CompareExchange (ref rwlock, RwWrite, state) == state)
+								taken = true;
+						}
+						if (taken)
+							return;
+
+						state = rwlock;
+					}
+
+					while ((state & RwWait) == 0 && Interlocked.CompareExchange (ref rwlock, state | RwWait, state) != state)
+						state = rwlock;
+
+					while (rwlock > RwWait)
+						sw.SpinOnce ();
+				} while (true);
+			} finally {
+				state = rwlock;
+				if (!taken && (state & RwWait) != 0)
+					Interlocked.CompareExchange (ref rwlock, state - RwWait, state);
+			}
+		}
+
+		public void TryEnterWriteLock (ref bool taken)
+		{
+			if (taken)
+				throw new ArgumentException ("taken", "taken needs to be set to false");
+
+			int state = rwlock;
+
+			if (state >= RwWrite)
+				return;
+
+			try {}
+			finally {
+				if (Interlocked.CompareExchange (ref rwlock, RwWrite, state) == state)
+					taken = true;
+			}
+		}
+
+		public void ExitWriteLock ()
+		{
+			Interlocked.Add (ref rwlock, -RwWrite);
+		}
+	}
+}
+
+#endif

mcs/class/Mono.Parallel/Mono.Threading/Snzi.cs

@@ -0,0 +1,308 @@
+// 
+// Snzi.cs
+//  
+// Author:
+//       Jérémie "Garuma" Laval <jeremie.laval@gmail.com>
+// 
+// Copyright (c) 2009 Jérémie "Garuma" Laval
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#if NET_4_0
+using System;
+using System.Threading;
+
+namespace Mono.Threading
+{
+	interface ISnziNode
+	{
+		bool Query { get; }
+		void Arrive ();
+		void Depart ();
+		bool Reset ();
+	}
+	
+	public class Snzi
+	{
+		readonly ISnziNode root;
+		readonly ISnziNode[] nodes;
+		
+		readonly int count = Environment.ProcessorCount;
+			
+		public Snzi ()
+		{
+			nodes = new ISnziNode[count];
+			root = new RootNode ();
+			for (int i = 0; i < count; i++)
+				nodes[i] = new LeafNode (root);
+		}
+		
+		public void Increment ()
+		{	
+			ISnziNode node = nodes[GetRandomIndex ()];
+			node.Arrive ();
+		}
+		
+		public void Decrement ()
+		{
+			ISnziNode node = nodes[GetRandomIndex ()];
+			node.Depart ();
+		}
+		
+		public void Reset ()
+		{
+			ISnziNode node = nodes[GetRandomIndex ()];
+			node.Reset ();
+		}
+		
+		public bool IsSet {
+			get {
+				return !root.Query;
+			}
+		}
+		
+		int GetRandomIndex ()
+		{
+			return (Thread.CurrentThread.ManagedThreadId) % count;
+		}
+		
+		class UnsafeLeafNode : ISnziNode
+		{
+			ISnziNode parent;
+			int var;
+			
+			public UnsafeLeafNode (ISnziNode parent)
+			{
+				this.parent = parent;
+			}
+
+			#region ISnziNode implementation
+			public void Arrive ()
+			{
+				int c = var++;
+				
+				if (c == 0)
+					parent.Arrive ();
+			}
+			
+			public void Depart ()
+			{
+				int c = var--;
+				if (c == 1)
+					parent.Depart ();
+			}
+			
+			public bool Reset ()
+			{
+				throw new System.NotImplementedException();
+			}
+			
+			public bool Query {
+				get {
+					return parent.Query;
+				}
+			}
+			#endregion
+
+		}
+		
+		class LeafNode : ISnziNode
+		{
+			ISnziNode parent;
+			int var;
+			
+			public LeafNode (ISnziNode parent)
+			{
+				this.parent = parent;
+				this.var = 0;
+			}
+
+			#region ISnziNode implementation
+			public void Arrive ()
+			{
+				bool succ = false;
+				int undoArr = 0;
+				while (!succ) {
+					int x = var;
+					short c, v;
+					Decode (x, out c, out v);
+					
+					if (c >= 1)
+						if (Interlocked.CompareExchange (ref var, Encode ((short)(c + 1), v), x) == x)
+							break;
+					
+					if (c == 0) {
+						int temp = Encode (-1, (short)(v + 1));
+						if (Interlocked.CompareExchange (ref var, temp, x) == x) {
+							succ = true;
+							c = -1;
+							v += 1;
+							x = temp;
+						}
+					}
+					
+					if (c == - 1) {
+						parent.Arrive ();
+						if (Interlocked.CompareExchange (ref var, Encode (1, v), x) != x)
+							undoArr += 1;
+					}
+				}
+				for (int i = 0; i < undoArr; i++)
+					parent.Depart ();
+			}
+			
+			public void Depart ()
+			{
+				while (true) {
+					int x = var;
+					short c, v;
+					Decode (x, out c, out v);
+					
+					if (Interlocked.CompareExchange (ref var, Encode ((short)(c - 1), v), x) == x) {
+						if (c == 1)
+							parent.Depart ();
+						return;
+					}
+				}
+			}
+			
+			public bool Reset ()
+			{
+				throw new System.NotImplementedException();
+			}
+			
+			public bool Query {
+				get {
+					return parent.Query;
+				}
+			}
+			#endregion
+			
+			int Encode (short c, short v)
+			{
+				uint temp = 0;
+				temp |= (uint)c;
+				temp |= ((uint)v) << 16;
+				
+				return (int)temp;
+			}
+			
+			void Decode (int value, out short c, out short v)
+			{
+				uint temp = (uint)value;
+				c = (short)(temp & 0xFFFF);
+				v = (short)(temp >> 16);
+			}
+		}
+		
+		class RootNode : ISnziNode
+		{
+			int var = 0;
+			int state = 0;
+
+			#region ISnziNode implementation
+			public void Arrive ()
+			{
+				int temp, x = 0;
+				short c, v;
+				bool a;
+				
+				do {
+					x = var;
+					
+					Decode (x, out c, out a, out v);
+					
+					if (c == 0)
+						temp = Encode (1, true, (short)(v + 1));
+					else
+						temp = Encode ((short)(c + 1), a, v);
+				} while (Interlocked.CompareExchange (ref var, temp, x) != x);
+				
+				Decode (temp, out c, out a, out v);
+
+				if (a) {
+					while (true) {
+						int i = state;
+						int newI = (i & 0x7FFFFFFF) + 1;
+						newI = (int)(((uint)newI) | 0x80000000);
+						if (Interlocked.CompareExchange (ref state, newI, i) == i) {
+							break;
+						}
+					}
+					Interlocked.CompareExchange (ref var, Encode (c, false, v), temp);
+				}
+			}
+			
+			public void Depart ()
+			{
+				while (true) {
+					int x = var;
+					short c, v;
+					bool a;
+					Decode (x, out c, out a, out v);
+					
+					if (Interlocked.CompareExchange (ref var, Encode ((short)(c - 1), false, v), x) == x) {
+						if (c >= 2)
+							return;
+						while (true) {
+							int i = state;
+							if (((short)(var >> 16)) != v)
+								return;
+							int newI = (i & 0x7FFFFFFF) + 1;
+							if (Interlocked.CompareExchange (ref state, newI, i) == i) {
+								return;
+							}
+						}
+					}
+				}
+			}
+			
+			public bool Reset ()
+			{
+				throw new System.NotImplementedException();
+			}
+			
+			public bool Query {
+				get {
+					return (state & 0x80000000) > 0;
+				}
+			}
+			#endregion
+			
+			int Encode (short c, bool a, short v)
+			{
+				uint temp = 0;
+				temp |= (uint)c;
+				temp |= (uint)(a ? 0x8000 : 0);
+				temp |= ((uint)v) << 16;
+				
+				return (int)temp;
+			}
+			
+			void Decode (int value, out short c, out bool a, out short v)
+			{
+				uint temp = (uint)value;
+				c = (short)(temp & 0x7FFF);
+				a = (temp & 0x8000) > 0;
+				v = (short)(temp >> 16);
+			}
+		}
+	}
+}
+#endif

mcs/class/Mono.Parallel/Mono.Threading/SpinLockWrapper.cs

@@ -0,0 +1,51 @@
+// SpinLockWrapper.cs
+//
+// Copyright (c) 2010 Jérémie "Garuma" Laval
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+//
+
+#if NET_4_0
+
+using System;
+using System.Threading;
+using System.Collections.Concurrent;
+using System.Runtime.ConstrainedExecution;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+
+namespace Mono.Threading
+{
+	public class SpinLockWrapper
+	{
+		public SpinLock Lock;
+
+		public SpinLockWrapper () : this (false)
+		{
+
+		}
+
+		public SpinLockWrapper (bool enableTracking)
+		{
+			Lock = new SpinLock (enableTracking);
+		}
+	}
+}
+#endif