using System;
using System.Runtime;
using System.Collections.Generic;
using System.Threading;

namespace System.ServiceModel.Channels
{
        internal class SynchronizedPool<T> where T : class
 {
     private struct Entry
     {
         public int threadID;
         public T value;
     }
     private struct PendingEntry
     {
         public int returnCount;
         public int threadID;
     }
     private static class SynchronizedPoolHelper
     {
         public static readonly int ProcessorCount = SynchronizedPool<T>.SynchronizedPoolHelper.GetProcessorCount();
         private static int GetProcessorCount()
         {
             return Environment.ProcessorCount;
         }
     }
     private class GlobalPool
     {
         private Stack<T> items;
         private int maxCount;
         public int MaxCount
         {
             [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
             get
             {
                 return this.maxCount;
             }
             set
             {
                 lock (this.ThisLock)
                 {
                     while (this.items.Count > value)
                     {
                         this.items.Pop();
                     }
                     this.maxCount = value;
                 }
             }
         }
         private object ThisLock
         {
             get
             {
                 return this;
             }
         }
         public GlobalPool(int maxCount)
         {
             this.items = new Stack<T>();
             this.maxCount = maxCount;
         }
         public void DecrementMaxCount()
         {
             lock (this.ThisLock)
             {
                 if (this.items.Count == this.maxCount)
                 {
                     this.items.Pop();
                 }
                 this.maxCount--;
             }
         }
         public T Take()
         {
             if (this.items.Count > 0)
             {
                 lock (this.ThisLock)
                 {
                     if (this.items.Count > 0)
                     {
                         return this.items.Pop();
                     }
                 }
             }
             return default(T);
         }
         public bool Return(T value)
         {
             if (this.items.Count < this.MaxCount)
             {
                 lock (this.ThisLock)
                 {
                     if (this.items.Count < this.MaxCount)
                     {
                         this.items.Push(value);
                         return true;
                     }
                 }
                 return false;
             }
             return false;
         }
         public void Clear()
         {
             lock (this.ThisLock)
             {
                 this.items.Clear();
             }
         }
     }
     private SynchronizedPool<T>.Entry[] entries;
     private SynchronizedPool<T>.GlobalPool globalPool;
     private int maxCount;
     private SynchronizedPool<T>.PendingEntry[] pending;
     private int promotionFailures;
     private const int maxPendingEntries = 128;
     private const int maxPromotionFailures = 64;
     private const int maxReturnsBeforePromotion = 64;
     private const int maxThreadItemsPerProcessor = 16;
     private object ThisLock
     {
         get
         {
             return this;
         }
     }
     public SynchronizedPool(int maxCount)
     {
         int num = maxCount;
         int num2 = 16 + SynchronizedPool<T>.SynchronizedPoolHelper.ProcessorCount;
         if (num > num2)
         {
             num = num2;
         }
         this.maxCount = maxCount;
         this.entries = new SynchronizedPool<T>.Entry[num];
         this.pending = new SynchronizedPool<T>.PendingEntry[4];
         this.globalPool = new SynchronizedPool<T>.GlobalPool(maxCount);
     }
     public void Clear()
     {
         SynchronizedPool<T>.Entry[] array = this.entries;
         for (int i = 0; i < array.Length; i++)
         {
             array[i].value = default(T);
         }
         this.globalPool.Clear();
     }
     private void HandlePromotionFailure(int thisThreadID)
     {
         int num = this.promotionFailures + 1;
         if (num >= 64)
         {
             lock (this.ThisLock)
             {
                 this.entries = new SynchronizedPool<T>.Entry[this.entries.Length];
                 this.globalPool.MaxCount = this.maxCount;
             }
             this.PromoteThread(thisThreadID);
             return;
         }
         this.promotionFailures = num;
     }
     private bool PromoteThread(int thisThreadID)
     {
         lock (this.ThisLock)
         {
             for (int i = 0; i < this.entries.Length; i++)
             {
                 int threadID = this.entries[i].threadID;
                 if (threadID == thisThreadID)
                 {
                     bool result = true;
                     return result;
                 }
                 if (threadID == 0)
                 {
                     this.globalPool.DecrementMaxCount();
                     this.entries[i].threadID = thisThreadID;
                     bool result = true;
                     return result;
                 }
             }
         }
         return false;
     }
     private void RecordReturnToGlobalPool(int thisThreadID)
     {
         SynchronizedPool<T>.PendingEntry[] array = this.pending;
         int i = 0;
         while (i < array.Length)
         {
             int threadID = array[i].threadID;
             if (threadID == thisThreadID)
             {
                 int num = array[i].returnCount + 1;
                 if (num < 64)
                 {
                     array[i].returnCount = num;
                     return;
                 }
                 array[i].returnCount = 0;
                 if (!this.PromoteThread(thisThreadID))
                 {
                     this.HandlePromotionFailure(thisThreadID);
                     return;
                 }
                 break;
             }
             else
             {
                 if (threadID == 0)
                 {
                     return;
                 }
                 i++;
             }
         }
     }
     private void RecordTakeFromGlobalPool(int thisThreadID)
     {
         SynchronizedPool<T>.PendingEntry[] array = this.pending;
         for (int i = 0; i < array.Length; i++)
         {
             int threadID = array[i].threadID;
             if (threadID == thisThreadID)
             {
                 return;
             }
             if (threadID == 0)
             {
                 lock (array)
                 {
                     if (array[i].threadID == 0)
                     {
                         array[i].threadID = thisThreadID;
                         return;
                     }
                 }
             }
         }
         if (array.Length >= 128)
         {
             this.pending = new SynchronizedPool<T>.PendingEntry[array.Length];
             return;
         }
         SynchronizedPool<T>.PendingEntry[] destinationArray = new SynchronizedPool<T>.PendingEntry[array.Length * 2];
         Array.Copy(array, destinationArray, array.Length);
         this.pending = destinationArray;
     }
     public bool Return(T value)
     {
         int managedThreadId = Thread.CurrentThread.ManagedThreadId;
         return managedThreadId != 0 && (this.ReturnToPerThreadPool(managedThreadId, value) || this.ReturnToGlobalPool(managedThreadId, value));
     }
     private bool ReturnToPerThreadPool(int thisThreadID, T value)
     {
         SynchronizedPool<T>.Entry[] array = this.entries;
         int i = 0;
         while (i < array.Length)
         {
             int threadID = array[i].threadID;
             if (threadID == thisThreadID)
             {
                 if (array[i].value == null)
                 {
                     array[i].value = value;
                     return true;
                 }
                 return false;
             }
             else
             {
                 if (threadID == 0)
                 {
                     break;
                 }
                 i++;
             }
         }
         return false;
     }
     private bool ReturnToGlobalPool(int thisThreadID, T value)
     {
         this.RecordReturnToGlobalPool(thisThreadID);
         return this.globalPool.Return(value);
     }
     public T Take()
     {
         int managedThreadId = Thread.CurrentThread.ManagedThreadId;
         if (managedThreadId == 0)
         {
             return default(T);
         }
         T t = this.TakeFromPerThreadPool(managedThreadId);
         if (t != null)
         {
             return t;
         }
         return this.TakeFromGlobalPool(managedThreadId);
     }
     private T TakeFromPerThreadPool(int thisThreadID)
     {
         SynchronizedPool<T>.Entry[] array = this.entries;
         int i = 0;
         while (i < array.Length)
         {
             int threadID = array[i].threadID;
             if (threadID == thisThreadID)
             {
                 T value = array[i].value;
                 if (value != null)
                 {
                     array[i].value = default(T);
                     return value;
                 }
                 return default(T);
             }
             else
             {
                 if (threadID == 0)
                 {
                     break;
                 }
                 i++;
             }
         }
         return default(T);
     }
     private T TakeFromGlobalPool(int thisThreadID)
     {
         this.RecordTakeFromGlobalPool(thisThreadID);
         return this.globalPool.Take();
     }
 }
 internal abstract class InternalBufferManager
 {
     private class PooledBufferManager : InternalBufferManager
     {
         private abstract class BufferPool
         {
             private class SynchronizedBufferPool : InternalBufferManager.PooledBufferManager.BufferPool
             {
                 private SynchronizedPool<byte[]> innerPool;
                 internal SynchronizedBufferPool(int bufferSize, int limit) : base(bufferSize, limit)
                 {
                     this.innerPool = new SynchronizedPool<byte[]>(limit);
                 }
                 internal override void OnClear()
                 {
                     this.innerPool.Clear();
                 }
                 internal override byte[] Take()
                 {
                     return this.innerPool.Take();
                 }
                 internal override bool Return(byte[] buffer)
                 {
                     return this.innerPool.Return(buffer);
                 }
             }
             private class LargeBufferPool : InternalBufferManager.PooledBufferManager.BufferPool
             {
                 private Stack<byte[]> items;
                 private object ThisLock
                 {
                     get
                     {
                         return this.items;
                     }
                 }
                 internal LargeBufferPool(int bufferSize, int limit) : base(bufferSize, limit)
                 {
                     this.items = new Stack<byte[]>(limit);
                 }
                 internal override void OnClear()
                 {
                     lock (this.ThisLock)
                     {
                         this.items.Clear();
                     }
                 }
                 internal override byte[] Take()
                 {
                     lock (this.ThisLock)
                     {
                         if (this.items.Count > 0)
                         {
                             return this.items.Pop();
                         }
                     }
                     return null;
                 }
                 internal override bool Return(byte[] buffer)
                 {
                     lock (this.ThisLock)
                     {
                         if (this.items.Count < base.Limit)
                         {
                             this.items.Push(buffer);
                             return true;
                         }
                     }
                     return false;
                 }
             }
             private int bufferSize;
             private int count;
             private int limit;
             private int misses;
             private int peak;
             public int BufferSize
             {
                 get
                 {
                     return this.bufferSize;
                 }
             }
             public int Limit
             {
                 get
                 {
                     return this.limit;
                 }
             }
             public int Misses
             {
                 get
                 {
                     return this.misses;
                 }
                 set
                 {
                     this.misses = value;
                 }
             }
             public int Peak
             {
                 get
                 {
                     return this.peak;
                 }
             }
             public BufferPool(int bufferSize, int limit)
             {
                 this.bufferSize = bufferSize;
                 this.limit = limit;
             }
             public void Clear()
             {
                 this.OnClear();
                 this.count = 0;
             }
             public void DecrementCount()
             {
                 int num = this.count - 1;
                 if (num >= 0)
                 {
                     this.count = num;
                 }
             }
             public void IncrementCount()
             {
                 int num = this.count + 1;
                 if (num <= this.limit)
                 {
                     this.count = num;
                     if (num > this.peak)
                     {
                         this.peak = num;
                     }
                 }
             }
             internal abstract byte[] Take();
             internal abstract bool Return(byte[] buffer);
             internal abstract void OnClear();
             internal static InternalBufferManager.PooledBufferManager.BufferPool CreatePool(int bufferSize, int limit)
             {
                 if (bufferSize < 85000)
                 {
                     return new InternalBufferManager.PooledBufferManager.BufferPool.SynchronizedBufferPool(bufferSize, limit);
                 }
                 return new InternalBufferManager.PooledBufferManager.BufferPool.LargeBufferPool(bufferSize, limit);
             }
         }
         private const int minBufferSize = 128;
         private const int maxMissesBeforeTuning = 8;
         private const int initialBufferCount = 1;
         private readonly object tuningLock;
         private int[] bufferSizes;
         private InternalBufferManager.PooledBufferManager.BufferPool[] bufferPools;
         private long memoryLimit;
         private long remainingMemory;
         private bool areQuotasBeingTuned;
         private int totalMisses;
         public PooledBufferManager(long maxMemoryToPool, int maxBufferSize)
         {
             this.tuningLock = new object();
             this.memoryLimit = maxMemoryToPool;

Lines 1–500 of 867. Load more