Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Dispatcher/QuotaThrottle.cs

@@ -0,0 +1,177 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//-----------------------------------------------------------------------------
+
+namespace System.ServiceModel.Dispatcher
+{
+    using System;
+    using System.Diagnostics;
+    using System.ServiceModel.Diagnostics;
+    using System.ServiceModel.Channels;
+    using System.Collections.Generic;
+    using System.Runtime;
+    using System.Threading;
+
+    sealed class QuotaThrottle
+    {
+        int limit;
+        object mutex;
+        WaitCallback release;
+        Queue<object> waiters;
+        bool didTraceThrottleLimit;
+        string propertyName = "ManualFlowControlLimit";
+        string owner;
+
+        internal QuotaThrottle(WaitCallback release, object mutex)
+        {
+            this.limit = Int32.MaxValue;
+            this.mutex = mutex;
+            this.release = release;
+            this.waiters = new Queue<object>();
+        }
+
+        bool IsEnabled
+        {
+            get { return this.limit != Int32.MaxValue; }
+        }
+
+        internal String Owner
+        {
+            set { this.owner = value; }
+        }
+
+        internal int Limit
+        {
+            get { return this.limit; }
+        }
+
+        internal bool Acquire(object o)
+        {
+            lock (this.mutex)
+            {
+                if (this.IsEnabled)
+                {
+                    if (this.limit > 0)
+                    {
+                        this.limit--;
+
+                        if (this.limit == 0)
+                        {
+                            if (DiagnosticUtility.ShouldTraceWarning && !this.didTraceThrottleLimit)
+                            {
+                                this.didTraceThrottleLimit = true;
+
+                                TraceUtility.TraceEvent(
+                                    TraceEventType.Warning,
+                                    TraceCode.ManualFlowThrottleLimitReached,
+                                    SR.GetString(SR.TraceCodeManualFlowThrottleLimitReached,
+                                                 this.propertyName, this.owner));
+                            }
+                        }
+
+                        return true;
+                    }
+                    else
+                    {
+                        this.waiters.Enqueue(o);
+                        return false;
+                    }
+                }
+                else
+                {
+                    return true;
+                }
+            }
+        }
+
+        internal int IncrementLimit(int incrementBy)
+        {
+            if (incrementBy < 0)
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("incrementBy", incrementBy,
+                                                     SR.GetString(SR.ValueMustBeNonNegative)));
+            int newLimit;
+            object[] released = null;
+
+            lock (this.mutex)
+            {
+                if (this.IsEnabled)
+                {
+                    checked { this.limit += incrementBy; }
+                    released = this.LimitChanged();
+                }
+                newLimit = this.limit;
+            }
+
+            if (released != null)
+                this.Release(released);
+
+            return newLimit;
+        }
+
+        object[] LimitChanged()
+        {
+            object[] released = null;
+
+            if (this.IsEnabled)
+            {
+                if ((this.waiters.Count > 0) && (this.limit > 0))
+                {
+                    if (this.limit < this.waiters.Count)
+                    {
+                        released = new object[this.limit];
+                        for (int i = 0; i < this.limit; i++)
+                            released[i] = this.waiters.Dequeue();
+
+                        this.limit = 0;
+                    }
+                    else
+                    {
+                        released = this.waiters.ToArray();
+                        this.waiters.Clear();
+                        this.waiters.TrimExcess();
+
+                        this.limit -= released.Length;
+                    }
+                }
+                this.didTraceThrottleLimit = false;
+            }
+            else
+            {
+                released = this.waiters.ToArray();
+                this.waiters.Clear();
+                this.waiters.TrimExcess();
+            }
+
+            return released;
+        }
+
+        internal void SetLimit(int messageLimit)
+        {
+            if (messageLimit < 0)
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("messageLimit", messageLimit,
+                                                    SR.GetString(SR.ValueMustBeNonNegative)));
+
+            object[] released = null;
+
+            lock (this.mutex)
+            {
+                this.limit = messageLimit;
+                released = this.LimitChanged();
+            }
+
+            if (released != null)
+                this.Release(released);
+        }
+
+        void ReleaseAsync(object state)
+        {
+            this.release(state);
+        }
+
+        internal void Release(object[] released)
+        {
+            for (int i = 0; i < released.Length; i++)
+                ActionItem.Schedule(this.ReleaseAsync, released[i]);
+        }
+    }
+}