initial

Ragon.Common/External/NetStack.Threading/ArrayQueue.cs

@@ -0,0 +1,150 @@
+/*
+ *  Copyright (c) 2019 Stanislav Denisov
+ *
+ *  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.
+ */
+
+using System;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace NetStack.Threading {
+	[StructLayout(LayoutKind.Explicit, Size = 192)]
+	public sealed class ArrayQueue {
+		[FieldOffset(0)]
+		private readonly Entry[] _array;
+		[FieldOffset(8)]
+		private readonly int _arrayMask;
+		[FieldOffset(64)]
+		private int _enqueuePosition;
+		[FieldOffset(128)]
+		private int _dequeuePosition;
+
+		public int Count {
+			get {
+				return _enqueuePosition - _dequeuePosition;
+			}
+		}
+
+		public ArrayQueue(int capacity) {
+			if (capacity < 2)
+				throw new ArgumentException("Queue size should be greater than or equal to two");
+
+			if ((capacity & (capacity - 1)) != 0)
+				throw new ArgumentException("Queue size should be a power of two");
+
+			_arrayMask = capacity - 1;
+			_array = new Entry[capacity];
+			_enqueuePosition = 0;
+			_dequeuePosition = 0;
+		}
+
+		public void Enqueue(object item) {
+			while (true) {
+				if (TryEnqueue(item))
+					break;
+
+				Thread.SpinWait(1);
+			}
+		}
+
+		public bool TryEnqueue(object item) {
+			var array = _array;
+			var position = _enqueuePosition;
+			var index = position & _arrayMask;
+
+			if (array[index].IsSet != 0)
+				return false;
+
+			array[index].element = item;
+			array[index].IsSet = 1;
+
+			#if NET_4_6 || NET_STANDARD_2_0
+				Volatile.Write(ref _enqueuePosition, position + 1);
+			#else
+				Thread.MemoryBarrier();
+				_enqueuePosition = position + 1;
+			#endif
+
+			return true;
+		}
+
+		public object Dequeue() {
+			while (true) {
+				object element;
+
+				if (TryDequeue(out element))
+					return element;
+			}
+		}
+
+		public bool TryDequeue(out object result) {
+			var array = _array;
+			var position = _dequeuePosition;
+			var index = position & _arrayMask;
+
+			if (array[index].IsSet == 0) {
+				result = default(object);
+
+				return false;
+			}
+
+			result = array[index].element;
+			array[index].element = default(object);
+			array[index].IsSet = 0;
+
+			#if NET_4_6 || NET_STANDARD_2_0
+				Volatile.Write(ref _dequeuePosition, position + 1);
+			#else
+				Thread.MemoryBarrier();
+				_dequeuePosition = position + 1;
+			#endif
+
+			return true;
+		}
+
+		[StructLayout(LayoutKind.Explicit, Size = 16)]
+		private struct Entry {
+			[FieldOffset(0)]
+			private int isSet;
+			[FieldOffset(8)]
+			internal object element;
+
+			internal int IsSet {
+				get {
+					#if NET_4_6 || NET_STANDARD_2_0
+						return Volatile.Read(ref isSet);
+					#else
+						Thread.MemoryBarrier();
+						return isSet;
+					#endif
+				}
+
+				set {
+					#if NET_4_6 || NET_STANDARD_2_0
+						Volatile.Write(ref isSet, value);
+					#else
+						Thread.MemoryBarrier();
+						isSet = value;
+					#endif
+				}
+			}
+		}
+	}
+}

Ragon.Common/External/NetStack.Threading/ConcurrentBuffer.cs

@@ -0,0 +1,153 @@
+/*
+ *  Copyright (c) 2018 Alexander Nikitin, Stanislav Denisov
+ *
+ *  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.
+ */
+
+using System;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace NetStack.Threading {
+	[StructLayout(LayoutKind.Explicit, Size = 192)]
+	public sealed class ConcurrentBuffer {
+		[FieldOffset(0)]
+		private readonly Cell[] _buffer;
+		[FieldOffset(8)]
+		private readonly int _bufferMask;
+		[FieldOffset(64)]
+		private int _enqueuePosition;
+		[FieldOffset(128)]
+		private int _dequeuePosition;
+
+		public int Count {
+			get {
+				return _enqueuePosition - _dequeuePosition;
+			}
+		}
+
+		public ConcurrentBuffer(int bufferSize) {
+			if (bufferSize < 2)
+				throw new ArgumentException("Buffer size should be greater than or equal to two");
+
+			if ((bufferSize & (bufferSize - 1)) != 0)
+				throw new ArgumentException("Buffer size should be a power of two");
+
+			_bufferMask = bufferSize - 1;
+			_buffer = new Cell[bufferSize];
+
+			for (var i = 0; i < bufferSize; i++) {
+				_buffer[i] = new Cell(i, null);
+			}
+
+			_enqueuePosition = 0;
+			_dequeuePosition = 0;
+		}
+
+		public void Enqueue(object item) {
+			while (true) {
+				if (TryEnqueue(item))
+					break;
+
+				Thread.SpinWait(1);
+			}
+		}
+
+		public bool TryEnqueue(object item) {
+			do {
+				var buffer = _buffer;
+				var position = _enqueuePosition;
+				var index = position & _bufferMask;
+				var cell = buffer[index];
+
+				if (cell.Sequence == position && Interlocked.CompareExchange(ref _enqueuePosition, position + 1, position) == position) {
+					buffer[index].Element = item;
+
+					#if NET_4_6 || NET_STANDARD_2_0
+						Volatile.Write(ref buffer[index].Sequence, position + 1);
+					#else
+						Thread.MemoryBarrier();
+						buffer[index].Sequence = position + 1;
+					#endif
+
+					return true;
+				}
+
+				if (cell.Sequence < position)
+					return false;
+			}
+
+			while (true);
+		}
+
+		public object Dequeue() {
+			while (true) {
+				object element;
+
+				if (TryDequeue(out element))
+					return element;
+			}
+		}
+
+		public bool TryDequeue(out object result) {
+			do {
+				var buffer = _buffer;
+				var bufferMask = _bufferMask;
+				var position = _dequeuePosition;
+				var index = position & bufferMask;
+				var cell = buffer[index];
+
+				if (cell.Sequence == position + 1 && Interlocked.CompareExchange(ref _dequeuePosition, position + 1, position) == position) {
+					result = cell.Element;
+					buffer[index].Element = null;
+
+					#if NET_4_6 || NET_STANDARD_2_0
+						Volatile.Write(ref buffer[index].Sequence, position + bufferMask + 1);
+					#else
+						Thread.MemoryBarrier();
+						buffer[index].Sequence = position + bufferMask + 1;
+					#endif
+
+					return true;
+				}
+
+				if (cell.Sequence < position + 1) {
+					result = default(object);
+
+					return false;
+				}
+			}
+
+			while (true);
+		}
+
+		[StructLayout(LayoutKind.Explicit, Size = 16)]
+		private struct Cell {
+			[FieldOffset(0)]
+			public int Sequence;
+			[FieldOffset(8)]
+			public object Element;
+
+			public Cell(int sequence, object element) {
+				Sequence = sequence;
+				Element = element;
+			}
+		}
+	}
+}

Ragon.Common/External/NetStack.Threading/ConcurrentPool.cs

@@ -0,0 +1,173 @@
+/*
+ *  Copyright (c) 2018 Virgile Bello, Stanislav Denisov
+ *
+ *  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.
+ */
+
+using System;
+using System.Threading;
+
+namespace NetStack.Threading {
+	public sealed class ConcurrentPool<T> where T : class {
+		#if NET_4_6 || NET_STANDARD_2_0
+			private SpinLock _lock;
+		#else
+			private object _lock;
+		#endif
+		private readonly Func<T> _factory;
+		private Segment _head;
+		private Segment _tail;
+
+		public ConcurrentPool(int capacity, Func<T> factory) {
+			#if NET_4_6 || NET_STANDARD_2_0
+				_lock = new SpinLock();
+			#else
+				_lock = new Object();
+			#endif
+			_head = _tail = new Segment(capacity);
+			_factory = factory;
+		}
+
+		public T Acquire() {
+			while (true) {
+				var localHead = _head;
+				var count = localHead.Count;
+
+				if (count == 0) {
+					if (localHead.Next != null) {
+						#if NET_4_6 || NET_STANDARD_2_0
+							bool lockTaken = false;
+
+							try {
+								_lock.Enter(ref lockTaken);
+
+								if (_head.Next != null && _head.Count == 0)
+									_head = _head.Next;
+							}
+
+							finally {
+								if (lockTaken)
+									_lock.Exit(false);
+							}
+						#else
+							try {
+								Monitor.Enter(_lock);
+
+								if (_head.Next != null && _head.Count == 0)
+									_head = _head.Next;
+							}
+
+							finally {
+								Monitor.Exit(_lock);
+							}
+						#endif
+					} else {
+						return _factory();
+					}
+				} else if (Interlocked.CompareExchange(ref localHead.Count, count - 1, count) == count) {
+					var localLow = Interlocked.Increment(ref localHead.Low) - 1;
+					var index = localLow & localHead.Mask;
+					T item;
+					#if NET_4_6 || NET_STANDARD_2_0
+						var spinWait = new SpinWait();
+					#endif
+
+					while ((item = Interlocked.Exchange(ref localHead.Items[index], null)) == null) {
+						#if NET_4_6 || NET_STANDARD_2_0
+							spinWait.SpinOnce();
+						#else
+							Thread.SpinWait(1);
+						#endif
+					}
+
+					return item;
+				}
+			}
+		}
+
+		public void Release(T item) {
+			while (true) {
+				var localTail = _tail;
+				var count = localTail.Count;
+
+				if (count == localTail.Items.Length) {
+					#if NET_4_6 || NET_STANDARD_2_0
+						bool lockTaken = false;
+
+						try {
+							_lock.Enter(ref lockTaken);
+
+							if (_tail.Next == null && count == _tail.Items.Length)
+								_tail = _tail.Next = new Segment(_tail.Items.Length << 1);
+						}
+
+						finally {
+							if (lockTaken)
+								_lock.Exit(false);
+						}
+					#else
+						try {
+							Monitor.Enter(_lock);
+
+							if (_tail.Next == null && count == _tail.Items.Length)
+								_tail = _tail.Next = new Segment(_tail.Items.Length << 1);
+						}
+
+						finally {
+							Monitor.Exit(_lock);
+						}
+					#endif
+				} else if (Interlocked.CompareExchange(ref localTail.Count, count + 1, count) == count) {
+					var localHigh = Interlocked.Increment(ref localTail.High) - 1;
+					var index = localHigh & localTail.Mask;
+					#if NET_4_6 || NET_STANDARD_2_0
+						var spinWait = new SpinWait();
+					#endif
+
+					while (Interlocked.CompareExchange(ref localTail.Items[index], item, null) != null) {
+						#if NET_4_6 || NET_STANDARD_2_0
+							spinWait.SpinOnce();
+						#else
+							Thread.SpinWait(1);
+						#endif
+					}
+
+					return;
+				}
+			}
+		}
+
+		private class Segment {
+			public readonly T[] Items;
+			public readonly int Mask;
+			public int Low;
+			public int High;
+			public int Count;
+			public Segment Next;
+
+			public Segment(int size) {
+				if (size <= 0 || ((size & (size - 1)) != 0))
+					throw new ArgumentOutOfRangeException("Segment size must be power of two");
+
+				Items = new T[size];
+				Mask = size - 1;
+			}
+		}
+	}
+}