mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
572 lines
18 KiB
C#
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
|
|
}
|
|
}
|
|
}
|
|
}
|