Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

572 lines
18 KiB
C#

//----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
namespace System.Runtime
{
using System;
using System.Collections.Generic;
using System.Threading;
#if DEBUG
using System.Collections.Concurrent;
using System.Diagnostics;
using System.Globalization;
using System.Security;
using System.Security.Permissions;
#endif //DEBUG
abstract class InternalBufferManager
{
protected InternalBufferManager()
{
}
public abstract byte[] TakeBuffer(int bufferSize);
public abstract void ReturnBuffer(byte[] buffer);
public abstract void Clear();
public static InternalBufferManager Create(long maxBufferPoolSize, int maxBufferSize)
{
if (maxBufferPoolSize == 0)
{
return GCBufferManager.Value;
}
else
{
Fx.Assert(maxBufferPoolSize > 0 && maxBufferSize >= 0, "bad params, caller should verify");
return new PooledBufferManager(maxBufferPoolSize, maxBufferSize);
}
}
class PooledBufferManager : InternalBufferManager
{
const int minBufferSize = 128;
const int maxMissesBeforeTuning = 8;
const int initialBufferCount = 1;
readonly object tuningLock;
int[] bufferSizes;
BufferPool[] bufferPools;
long memoryLimit;
long remainingMemory;
bool areQuotasBeingTuned;
int totalMisses;
#if DEBUG
ConcurrentDictionary<int, string> buffersPooled = new ConcurrentDictionary<int, string>();
#endif //DEBUG
public PooledBufferManager(long maxMemoryToPool, int maxBufferSize)
{
this.tuningLock = new object();
this.memoryLimit = maxMemoryToPool;
this.remainingMemory = maxMemoryToPool;
List<BufferPool> bufferPoolList = new List<BufferPool>();
for (int bufferSize = minBufferSize;;)
{
long bufferCountLong = this.remainingMemory / bufferSize;
int bufferCount = bufferCountLong > int.MaxValue ? int.MaxValue : (int)bufferCountLong;
if (bufferCount > initialBufferCount)
{
bufferCount = initialBufferCount;
}
bufferPoolList.Add(BufferPool.CreatePool(bufferSize, bufferCount));
this.remainingMemory -= (long)bufferCount * bufferSize;
if (bufferSize >= maxBufferSize)
{
break;
}
long newBufferSizeLong = (long)bufferSize * 2;
if (newBufferSizeLong > (long)maxBufferSize)
{
bufferSize = maxBufferSize;
}
else
{
bufferSize = (int)newBufferSizeLong;
}
}
this.bufferPools = bufferPoolList.ToArray();
this.bufferSizes = new int[bufferPools.Length];
for (int i = 0; i < bufferPools.Length; i++)
{
this.bufferSizes[i] = bufferPools[i].BufferSize;
}
}
public override void Clear()
{
#if DEBUG
this.buffersPooled.Clear();
#endif //DEBUG
for (int i = 0; i < this.bufferPools.Length; i++)
{
BufferPool bufferPool = this.bufferPools[i];
bufferPool.Clear();
}
}
void ChangeQuota(ref BufferPool bufferPool, int delta)
{
if (TraceCore.BufferPoolChangeQuotaIsEnabled(Fx.Trace))
{
TraceCore.BufferPoolChangeQuota(Fx.Trace, bufferPool.BufferSize, delta);
}
BufferPool oldBufferPool = bufferPool;
int newLimit = oldBufferPool.Limit + delta;
BufferPool newBufferPool = BufferPool.CreatePool(oldBufferPool.BufferSize, newLimit);
for (int i = 0; i < newLimit; i++)
{
byte[] buffer = oldBufferPool.Take();
if (buffer == null)
{
break;
}
newBufferPool.Return(buffer);
newBufferPool.IncrementCount();
}
this.remainingMemory -= oldBufferPool.BufferSize * delta;
bufferPool = newBufferPool;
}
void DecreaseQuota(ref BufferPool bufferPool)
{
ChangeQuota(ref bufferPool, -1);
}
int FindMostExcessivePool()
{
long maxBytesInExcess = 0;
int index = -1;
for (int i = 0; i < this.bufferPools.Length; i++)
{
BufferPool bufferPool = this.bufferPools[i];
if (bufferPool.Peak < bufferPool.Limit)
{
long bytesInExcess = (bufferPool.Limit - bufferPool.Peak) * (long)bufferPool.BufferSize;
if (bytesInExcess > maxBytesInExcess)
{
index = i;
maxBytesInExcess = bytesInExcess;
}
}
}
return index;
}
int FindMostStarvedPool()
{
long maxBytesMissed = 0;
int index = -1;
for (int i = 0; i < this.bufferPools.Length; i++)
{
BufferPool bufferPool = this.bufferPools[i];
if (bufferPool.Peak == bufferPool.Limit)
{
long bytesMissed = bufferPool.Misses * (long)bufferPool.BufferSize;
if (bytesMissed > maxBytesMissed)
{
index = i;
maxBytesMissed = bytesMissed;
}
}
}
return index;
}
BufferPool FindPool(int desiredBufferSize)
{
for (int i = 0; i < this.bufferSizes.Length; i++)
{
if (desiredBufferSize <= this.bufferSizes[i])
{
return this.bufferPools[i];
}
}
return null;
}
void IncreaseQuota(ref BufferPool bufferPool)
{
ChangeQuota(ref bufferPool, 1);
}
public override void ReturnBuffer(byte[] buffer)
{
Fx.Assert(buffer != null, "caller must verify");
#if DEBUG
int hash = buffer.GetHashCode();
if (!this.buffersPooled.TryAdd(hash, CaptureStackTrace()))
{
string originalStack;
if (!this.buffersPooled.TryGetValue(hash, out originalStack))
{
originalStack = "NULL";
}
Fx.Assert(
string.Format(
CultureInfo.InvariantCulture,
"Buffer '{0}' has already been returned to the bufferManager before. Previous CallStack: {1} Current CallStack: {2}",
hash,
originalStack,
CaptureStackTrace()));
}
#endif //DEBUG
BufferPool bufferPool = FindPool(buffer.Length);
if (bufferPool != null)
{
if (buffer.Length != bufferPool.BufferSize)
{
throw Fx.Exception.Argument("buffer", InternalSR.BufferIsNotRightSizeForBufferManager);
}
if (bufferPool.Return(buffer))
{
bufferPool.IncrementCount();
}
}
}
public override byte[] TakeBuffer(int bufferSize)
{
Fx.Assert(bufferSize >= 0, "caller must ensure a non-negative argument");
BufferPool bufferPool = FindPool(bufferSize);
byte[] returnValue;
if (bufferPool != null)
{
byte[] buffer = bufferPool.Take();
if (buffer != null)
{
bufferPool.DecrementCount();
returnValue = buffer;
}
else
{
if (bufferPool.Peak == bufferPool.Limit)
{
bufferPool.Misses++;
if (++totalMisses >= maxMissesBeforeTuning)
{
TuneQuotas();
}
}
if (TraceCore.BufferPoolAllocationIsEnabled(Fx.Trace))
{
TraceCore.BufferPoolAllocation(Fx.Trace, bufferPool.BufferSize);
}
returnValue = Fx.AllocateByteArray(bufferPool.BufferSize);
}
}
else
{
if (TraceCore.BufferPoolAllocationIsEnabled(Fx.Trace))
{
TraceCore.BufferPoolAllocation(Fx.Trace, bufferSize);
}
returnValue = Fx.AllocateByteArray(bufferSize);
}
#if DEBUG
string dummy;
this.buffersPooled.TryRemove(returnValue.GetHashCode(), out dummy);
#endif //DEBUG
return returnValue;
}
#if DEBUG
[SecuritySafeCritical]
[PermissionSet(SecurityAction.Assert, Unrestricted = true)]
private static string CaptureStackTrace()
{
return new StackTrace(true).ToString();
}
#endif //DEBUG
void TuneQuotas()
{
if (this.areQuotasBeingTuned)
{
return;
}
bool lockHeld = false;
try
{
Monitor.TryEnter(this.tuningLock, ref lockHeld);
// Don't bother if another thread already has the lock
if (!lockHeld || this.areQuotasBeingTuned)
{
return;
}
this.areQuotasBeingTuned = true;
}
finally
{
if (lockHeld)
{
Monitor.Exit(this.tuningLock);
}
}
// find the "poorest" pool
int starvedIndex = FindMostStarvedPool();
if (starvedIndex >= 0)
{
BufferPool starvedBufferPool = this.bufferPools[starvedIndex];
if (this.remainingMemory < starvedBufferPool.BufferSize)
{
// find the "richest" pool
int excessiveIndex = FindMostExcessivePool();
if (excessiveIndex >= 0)
{
// steal from the richest
DecreaseQuota(ref this.bufferPools[excessiveIndex]);
}
}
if (this.remainingMemory >= starvedBufferPool.BufferSize)
{
// give to the poorest
IncreaseQuota(ref this.bufferPools[starvedIndex]);
}
}
// reset statistics
for (int i = 0; i < this.bufferPools.Length; i++)
{
BufferPool bufferPool = this.bufferPools[i];
bufferPool.Misses = 0;
}
this.totalMisses = 0;
this.areQuotasBeingTuned = false;
}
abstract class BufferPool
{
int bufferSize;
int count;
int limit;
int misses;
int peak;
public BufferPool(int bufferSize, int limit)
{
this.bufferSize = bufferSize;
this.limit = limit;
}
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 void Clear()
{
this.OnClear();
this.count = 0;
}
public void DecrementCount()
{
int newValue = this.count - 1;
if (newValue >= 0)
{
this.count = newValue;
}
}
public void IncrementCount()
{
int newValue = this.count + 1;
if (newValue <= this.limit)
{
this.count = newValue;
if (newValue > this.peak)
{
this.peak = newValue;
}
}
}
internal abstract byte[] Take();
internal abstract bool Return(byte[] buffer);
internal abstract void OnClear();
internal static BufferPool CreatePool(int bufferSize, int limit)
{
// To avoid many buffer drops during training of large objects which
// get allocated on the LOH, we use the LargeBufferPool and for
// bufferSize < 85000, the SynchronizedPool. However if bufferSize < 85000
// and (bufferSize + array-overhead) > 85000, this would still use
// the SynchronizedPool even though it is allocated on the LOH.
if (bufferSize < 85000)
{
return new SynchronizedBufferPool(bufferSize, limit);
}
else
{
return new LargeBufferPool(bufferSize, limit);
}
}
class SynchronizedBufferPool : BufferPool
{
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);
}
}
class LargeBufferPool : BufferPool
{
Stack<byte[]> items;
internal LargeBufferPool(int bufferSize, int limit)
: base(bufferSize, limit)
{
this.items = new Stack<byte[]>(limit);
}
object ThisLock
{
get
{
return this.items;
}
}
internal override void OnClear()
{
lock (ThisLock)
{
this.items.Clear();
}
}
internal override byte[] Take()
{
lock (ThisLock)
{
if (this.items.Count > 0)
{
return this.items.Pop();
}
}
return null;
}
internal override bool Return(byte[] buffer)
{
lock (ThisLock)
{
if (this.items.Count < this.Limit)
{
this.items.Push(buffer);
return true;
}
}
return false;
}
}
}
}
class GCBufferManager : InternalBufferManager
{
static GCBufferManager value = new GCBufferManager();
GCBufferManager()
{
}
public static GCBufferManager Value
{
get { return value; }
}
public override void Clear()
{
}
public override byte[] TakeBuffer(int bufferSize)
{
return Fx.AllocateByteArray(bufferSize);
}
public override void ReturnBuffer(byte[] buffer)
{
// do nothing, GC will reclaim this buffer
}
}
}
}