#if MONO

using System;
using System.Diagnostics.Tracing;
using System.Runtime;
using System.Runtime.CompilerServices;
using System.Security.Permissions;
namespace System.Threading
{

    internal static class PlatformHelper
    {
        private static volatile int s_processorCount;
        private static volatile int s_lastProcessorCountRefreshTicks;
        private const int PROCESSOR_COUNT_REFRESH_INTERVAL_MS = 30000;
        internal static int ProcessorCount
        {
            get
            {
                int tickCount = Environment.TickCount;
                int num = PlatformHelper.s_processorCount;
                if (num == 0 || tickCount - PlatformHelper.s_lastProcessorCountRefreshTicks >= 30000)
                {
                    num = (PlatformHelper.s_processorCount = Environment.ProcessorCount);
                    PlatformHelper.s_lastProcessorCountRefreshTicks = tickCount;
                }
                return num;
            }
        }
        internal static bool IsSingleProcessor
        {
            get
            {
                return PlatformHelper.ProcessorCount == 1;
            }
        }
    }

    internal static class TimeoutHelper
    {
        public static uint GetTime()
        {
            return (uint)Environment.TickCount;
        }
        public static int UpdateTimeOut(uint startTime, int originalWaitMillisecondsTimeout)
        {
            uint num = TimeoutHelper.GetTime() - startTime;
            if (num > 2147483647u)
            {
                return 0;
            }
            int num2 = originalWaitMillisecondsTimeout - (int)num;
            if (num2 <= 0)
            {
                return 0;
            }
            return num2;
        }
    }

    internal struct CancellationCallbackCoreWorkArguments
    {
        internal SparselyPopulatedArrayFragment<CancellationCallbackInfo> m_currArrayFragment;
        internal int m_currArrayIndex;
        [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
        public CancellationCallbackCoreWorkArguments(SparselyPopulatedArrayFragment<CancellationCallbackInfo> currArrayFragment, int currArrayIndex)
        {
            this.m_currArrayFragment = currArrayFragment;
            this.m_currArrayIndex = currArrayIndex;
        }
    }

    internal class SparselyPopulatedArray<T> where T : class
    {
        private readonly SparselyPopulatedArrayFragment<T> m_head;
        private volatile SparselyPopulatedArrayFragment<T> m_tail;
        internal SparselyPopulatedArrayFragment<T> Tail
        {
            get
            {
                return this.m_tail;
            }
        }
        internal SparselyPopulatedArray(int initialSize)
        {
            this.m_head = (this.m_tail = new SparselyPopulatedArrayFragment<T>(initialSize));
        }
        internal SparselyPopulatedArrayAddInfo<T> Add(T element)
        {
            SparselyPopulatedArrayFragment<T> sparselyPopulatedArrayFragment2;
            int num2;
            while (true)
            {
                SparselyPopulatedArrayFragment<T> sparselyPopulatedArrayFragment = this.m_tail;
                while (sparselyPopulatedArrayFragment.m_next != null)
                {
                    sparselyPopulatedArrayFragment = (this.m_tail = sparselyPopulatedArrayFragment.m_next);
                }
                for (sparselyPopulatedArrayFragment2 = sparselyPopulatedArrayFragment; sparselyPopulatedArrayFragment2 != null; sparselyPopulatedArrayFragment2 = sparselyPopulatedArrayFragment2.m_prev)
                {
                    if (sparselyPopulatedArrayFragment2.m_freeCount < 1)
                    {
                        sparselyPopulatedArrayFragment2.m_freeCount--;
                    }
                    if (sparselyPopulatedArrayFragment2.m_freeCount > 0 || sparselyPopulatedArrayFragment2.m_freeCount < -10)
                    {
                        int length = sparselyPopulatedArrayFragment2.Length;
                        int num = (length - sparselyPopulatedArrayFragment2.m_freeCount) % length;
                        if (num < 0)
                        {
                            num = 0;
                            sparselyPopulatedArrayFragment2.m_freeCount--;
                        }
                        for (int i = 0; i < length; i++)
                        {
                            num2 = (num + i) % length;
                            if (sparselyPopulatedArrayFragment2.m_elements[num2] == null && Interlocked.CompareExchange<T>(ref sparselyPopulatedArrayFragment2.m_elements[num2], element, default(T)) == null)
                            {
                                goto Block_5;
                            }
                        }
                    }
                }
                SparselyPopulatedArrayFragment<T> sparselyPopulatedArrayFragment3 = new SparselyPopulatedArrayFragment<T>((sparselyPopulatedArrayFragment.m_elements.Length == 4096) ? 4096 : (sparselyPopulatedArrayFragment.m_elements.Length * 2), sparselyPopulatedArrayFragment);
                if (Interlocked.CompareExchange<SparselyPopulatedArrayFragment<T>>(ref sparselyPopulatedArrayFragment.m_next, sparselyPopulatedArrayFragment3, null) == null)
                {
                    this.m_tail = sparselyPopulatedArrayFragment3;
                }
            }
        Block_5:
            int num3 = sparselyPopulatedArrayFragment2.m_freeCount - 1;
            sparselyPopulatedArrayFragment2.m_freeCount = ((num3 > 0) ? num3 : 0);
            return new SparselyPopulatedArrayAddInfo<T>(sparselyPopulatedArrayFragment2, num2);
        }
    }

    internal class SparselyPopulatedArrayFragment<T> where T : class
    {
        internal readonly T[] m_elements;
        internal volatile int m_freeCount;
        internal volatile SparselyPopulatedArrayFragment<T> m_next;
        internal volatile SparselyPopulatedArrayFragment<T> m_prev;
        internal T this[int index]
        {
            get
            {
                return Volatile.Read<T>(ref this.m_elements[index]);
            }
        }
        internal int Length
        {
            get
            {
                return this.m_elements.Length;
            }
        }
        internal SparselyPopulatedArrayFragment<T> Prev
        {
            get
            {
                return this.m_prev;
            }
        }

        internal SparselyPopulatedArrayFragment(int size)
            : this(size, null)
        {
        }
        internal SparselyPopulatedArrayFragment(int size, SparselyPopulatedArrayFragment<T> prev)
        {
            this.m_elements = new T[size];
            this.m_freeCount = size;
            this.m_prev = prev;
        }
        internal T SafeAtomicRemove(int index, T expectedElement)
        {
            T t = Interlocked.CompareExchange<T>(ref this.m_elements[index], default(T), expectedElement);
            if (t != null)
            {
                this.m_freeCount++;
            }
            return t;
        }
    }

    internal struct SparselyPopulatedArrayAddInfo<T> where T : class
    {
        private SparselyPopulatedArrayFragment<T> m_source;
        private int m_index;
        internal SparselyPopulatedArrayFragment<T> Source
        {
            get
            {
                return this.m_source;
            }
        }
        internal int Index
        {
            get
            {
                return this.m_index;
            }
        }

        internal SparselyPopulatedArrayAddInfo(SparselyPopulatedArrayFragment<T> source, int index)
        {
            this.m_source = source;
            this.m_index = index;
        }
    }

    /// <summary>Represents a callback delegate that has been registered with a <see cref="T:System.Threading.CancellationToken" />. </summary>
    [__DynamicallyInvokable]
    [HostProtection(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true)]
    public struct CancellationTokenRegistration : IEquatable<CancellationTokenRegistration>, IDisposable
    {
        private readonly CancellationCallbackInfo m_callbackInfo;
        private readonly SparselyPopulatedArrayAddInfo<CancellationCallbackInfo> m_registrationInfo;
        [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
        internal CancellationTokenRegistration(CancellationCallbackInfo callbackInfo, SparselyPopulatedArrayAddInfo<CancellationCallbackInfo> registrationInfo)
        {
            this.m_callbackInfo = callbackInfo;
            this.m_registrationInfo = registrationInfo;
        }
        [FriendAccessAllowed]
        internal bool TryDeregister()
        {
            if (this.m_registrationInfo.Source == null)
            {
                return false;
            }
            CancellationCallbackInfo cancellationCallbackInfo = this.m_registrationInfo.Source.SafeAtomicRemove(this.m_registrationInfo.Index, this.m_callbackInfo);
            return cancellationCallbackInfo == this.m_callbackInfo;
        }
        /// <summary>Releases all resources used by the current instance of the <see cref="T:System.Threading.CancellationTokenRegistration" /> class.</summary>
        /// <exception cref="T:System.ObjectDisposedException">The token source that created this token registration instance has already been disposed.</exception>
        [__DynamicallyInvokable]
        public void Dispose()
        {
            bool flag = this.TryDeregister();
            CancellationCallbackInfo callbackInfo = this.m_callbackInfo;
            if (callbackInfo != null)
            {
                CancellationTokenSource cancellationTokenSource = callbackInfo.CancellationTokenSource;
                if (cancellationTokenSource.IsCancellationRequested && !cancellationTokenSource.IsCancellationCompleted && !flag && cancellationTokenSource.ThreadIDExecutingCallbacks != Thread.CurrentThread.ManagedThreadId)
                {
                    cancellationTokenSource.WaitForCallbackToComplete(this.m_callbackInfo);
                }
            }
        }
        /// <summary>Determines whether two <see cref="T:System.Threading.CancellationTokenRegistration" /> instances are equal.</summary>
        /// <returns>True if the instances are equal; otherwise, false.</returns>
        /// <param name="left">The first instance.</param>
        /// <param name="right">The second instance.</param>
        [__DynamicallyInvokable]
        public static bool operator ==(CancellationTokenRegistration left, CancellationTokenRegistration right)
        {
            return left.Equals(right);
        }
        /// <summary>Determines whether two <see cref="T:System.Threading.CancellationTokenRegistration" /> instances are not equal.</summary>
        /// <returns>True if the instances are not equal; otherwise, false.</returns>
        /// <param name="left">The first instance.</param>
        /// <param name="right">The second instance.</param>
        [__DynamicallyInvokable]
        public static bool operator !=(CancellationTokenRegistration left, CancellationTokenRegistration right)
        {
            return !left.Equals(right);
        }
        /// <summary>Determines whether the current <see cref="T:System.Threading.CancellationTokenRegistration" /> instance is equal to the specified <see cref="T:System.Threading.CancellationTokenRegistration" />.</summary>
        /// <returns>True, if both this and <paramref name="obj" /> are equal. False, otherwise.Two <see cref="T:System.Threading.CancellationTokenRegistration" /> instances are equal if they both refer to the output of a single call to the same Register method of a <see cref="T:System.Threading.CancellationToken" />.</returns>
        /// <param name="obj">The other object to which to compare this instance.</param>
        [__DynamicallyInvokable]
        public override bool Equals(object obj)
        {
            return obj is CancellationTokenRegistration && this.Equals((CancellationTokenRegistration)obj);
        }
        /// <summary>Determines whether the current <see cref="T:System.Threading.CancellationTokenRegistration" /> instance is equal to the specified <see cref="T:System.Threading.CancellationTokenRegistration" />.</summary>
        /// <returns>True, if both this and <paramref name="other" /> are equal. False, otherwise. Two <see cref="T:System.Threading.CancellationTokenRegistration" /> instances are equal if they both refer to the output of a single call to the same Register method of a <see cref="T:System.Threading.CancellationToken" />.</returns>
        /// <param name="other">The other <see cref="T:System.Threading.CancellationTokenRegistration" /> to which to compare this instance.</param>
        [__DynamicallyInvokable]
        public bool Equals(CancellationTokenRegistration other)
        {
            return this.m_callbackInfo == other.m_callbackInfo && this.m_registrationInfo.Source == other.m_registrationInfo.Source && this.m_registrationInfo.Index == other.m_registrationInfo.Index;
        }
        /// <summary>Serves as a hash function for a <see cref="T:System.Threading.CancellationTokenRegistration" />.</summary>
        /// <returns>A hash code for the current <see cref="T:System.Threading.CancellationTokenRegistration" /> instance.</returns>
        [__DynamicallyInvokable]
        public override int GetHashCode()
        {
            if (this.m_registrationInfo.Source != null)
            {
                return this.m_registrationInfo.Source.GetHashCode() ^ this.m_registrationInfo.Index.GetHashCode();
            }
            return this.m_registrationInfo.Index.GetHashCode();
        }
    }
}

#endif