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
421 lines
19 KiB
C#
421 lines
19 KiB
C#
using System;
|
|
using System.Globalization;
|
|
using System.Web;
|
|
using System.Web.Util;
|
|
using System.Threading;
|
|
using System.Diagnostics;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using Debug = System.Web.Util.Debug;
|
|
|
|
//
|
|
// Welcome to the CacheManager class, CM for short. CM monitors private bytes for the
|
|
// worker process. If the Private Bytes limit is about to be exceeded, CM will trim
|
|
// the cache (as necessary), and induce a GC to prevent the process from recycling.
|
|
//
|
|
// A timer thread is used to monitor Private Bytes. The interval is adjusted depending
|
|
// on the current memory pressure. The maximum interval is every 2 minutes, and the
|
|
// minimum interval is every 5 seconds.
|
|
//
|
|
|
|
namespace System.Web.Hosting {
|
|
internal class CacheManager: IDisposable {
|
|
const int HIGH_FREQ_INTERVAL_S = 5;
|
|
const int HIGH_FREQ_INTERVAL_MS = 5 * Msec.ONE_SECOND;
|
|
const int MEDIUM_FREQ_INTERVAL_S = 30;
|
|
const int MEDIUM_FREQ_INTERVAL_MS = 30 * Msec.ONE_SECOND;
|
|
const int LOW_FREQ_INTERVAL_S = 120;
|
|
const int LOW_FREQ_INTERVAL_MS = 120 * Msec.ONE_SECOND;
|
|
const int MEGABYTE_SHIFT = 20;
|
|
const long MEGABYTE = 1L << MEGABYTE_SHIFT; // 1048576
|
|
const int SAMPLE_COUNT = 2;
|
|
const int DELTA_SAMPLE_COUNT = 10;
|
|
|
|
private ApplicationManager _appManager;
|
|
|
|
private long _totalCacheSize;
|
|
private long _trimDurationTicks;
|
|
private int _lastTrimPercent = 10; // starts at 10, but changes to fit workload
|
|
private long _inducedGCMinInterval = TimeSpan.TicksPerSecond * 5; // starts at 5 seconds, but changes to fit workload
|
|
private DateTime _inducedGCFinishTime = DateTime.MinValue;
|
|
private long _inducedGCDurationTicks;
|
|
private int _inducedGCCount;
|
|
private long _inducedGCPostPrivateBytes;
|
|
private long _inducedGCPrivateBytesChange;
|
|
|
|
private int _currentPollInterval = MEDIUM_FREQ_INTERVAL_MS;
|
|
private DateTime _timerSuspendTime = DateTime.MinValue;
|
|
private int _inPBytesMonitorThread;
|
|
private Timer _timer;
|
|
private Object _timerLock = new object();
|
|
|
|
private long _limit; // the "effective" worker process Private Bytes limit
|
|
private long _highPressureMark;
|
|
private long _mediumPressureMark;
|
|
private long _lowPressureMark;
|
|
private long[] _deltaSamples; // a history of the increase in private bytes per second
|
|
private int _idxDeltaSamples;
|
|
private long _maxDelta; // the maximum expected increase in private bytes per second
|
|
private long _minMaxDelta; // _maxDelta must always be at least this large
|
|
private long[] _samples; // a history of the sample values (private bytes for the process)
|
|
private DateTime[] _sampleTimes; // time at which samples were taken
|
|
private int _idx;
|
|
|
|
private bool _useGetProcessMemoryInfo;
|
|
private uint _pid;
|
|
private bool _disposed;
|
|
|
|
private CacheManager() {}
|
|
|
|
internal CacheManager(ApplicationManager appManager, long privateBytesLimit) {
|
|
#if PERF
|
|
SafeNativeMethods.OutputDebugString(String.Format("Creating CacheManager with PrivateBytesLimit = {0:N}\n", privateBytesLimit));
|
|
#endif
|
|
// don't create timer if there's no memory limit
|
|
if (privateBytesLimit <= 0) {
|
|
return;
|
|
}
|
|
|
|
_appManager = appManager;
|
|
_limit = privateBytesLimit;
|
|
|
|
_pid = (uint) SafeNativeMethods.GetCurrentProcessId();
|
|
|
|
// the initial expected maximum increase in private bytes is 2MB per second per CPU
|
|
_minMaxDelta = 2 * MEGABYTE * SystemInfo.GetNumProcessCPUs();
|
|
AdjustMaxDeltaAndPressureMarks(_minMaxDelta);
|
|
|
|
_samples = new long[SAMPLE_COUNT];
|
|
_sampleTimes = new DateTime[SAMPLE_COUNT];
|
|
_useGetProcessMemoryInfo = (VersionInfo.ExeName == "w3wp");
|
|
_deltaSamples = new long[DELTA_SAMPLE_COUNT];
|
|
|
|
// start timer with initial poll interval
|
|
_timer = new Timer(new TimerCallback(this.PBytesMonitorThread), null, _currentPollInterval, _currentPollInterval);
|
|
}
|
|
|
|
|
|
void Adjust() {
|
|
// not thread-safe, only invoke from timer callback
|
|
Debug.Assert(_inPBytesMonitorThread == 1);
|
|
|
|
Debug.Assert(SAMPLE_COUNT == 2);
|
|
// current sample
|
|
long s2 = _samples[_idx];
|
|
// previous sample
|
|
long s1 = _samples[_idx ^ 1];
|
|
|
|
// adjust _maxDelta and pressure marks
|
|
if (s2 > s1 && s1 > 0) {
|
|
// current time
|
|
DateTime d2 = _sampleTimes[_idx];
|
|
// previous time
|
|
DateTime d1 = _sampleTimes[_idx ^ 1];
|
|
|
|
long numBytes = s2 - s1;
|
|
long numSeconds = (long)Math.Round(d2.Subtract(d1).TotalSeconds);
|
|
if (numSeconds > 0) {
|
|
long delta = numBytes / numSeconds;
|
|
_deltaSamples[_idxDeltaSamples] = delta;
|
|
_idxDeltaSamples = (_idxDeltaSamples + 1) % DELTA_SAMPLE_COUNT;
|
|
// update rate of change in private bytes and pressure marks
|
|
AdjustMaxDeltaAndPressureMarks(delta);
|
|
}
|
|
}
|
|
|
|
lock (_timerLock) {
|
|
if (_timer == null) {
|
|
return;
|
|
}
|
|
|
|
// adjust timer frequency
|
|
if (s2 > _mediumPressureMark) {
|
|
if (_currentPollInterval > HIGH_FREQ_INTERVAL_MS) {
|
|
_currentPollInterval = HIGH_FREQ_INTERVAL_MS;
|
|
_timer.Change(_currentPollInterval, _currentPollInterval);
|
|
}
|
|
}
|
|
else if (s2 > _lowPressureMark) {
|
|
if (_currentPollInterval > MEDIUM_FREQ_INTERVAL_MS) {
|
|
_currentPollInterval = MEDIUM_FREQ_INTERVAL_MS;
|
|
_timer.Change(_currentPollInterval, _currentPollInterval);
|
|
}
|
|
}
|
|
else {
|
|
if (_currentPollInterval != LOW_FREQ_INTERVAL_MS) {
|
|
_currentPollInterval = LOW_FREQ_INTERVAL_MS;
|
|
_timer.Change(_currentPollInterval, _currentPollInterval);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void AdjustMaxDeltaAndPressureMarks(long delta) {
|
|
// not thread-safe...only invoke from ctor or timer callback
|
|
Debug.Assert(_inPBytesMonitorThread == 1 || _timer == null);
|
|
|
|
// The value of _maxDelta is the largest rate of change we've seen,
|
|
// but it is reduced if the rate is now consistently less than what
|
|
// it once was.
|
|
long newMaxDelta = _maxDelta;
|
|
if (delta > newMaxDelta) {
|
|
// set maxDelta to the current rate of change
|
|
newMaxDelta = delta;
|
|
}
|
|
else {
|
|
// if _maxDelta is at least four times larger than every sample rate in the history,
|
|
// then reduce _maxDelta
|
|
bool reduce = true;
|
|
long maxDelta = _maxDelta / 4;
|
|
foreach (long rate in _deltaSamples) {
|
|
if (rate > maxDelta) {
|
|
reduce = false;
|
|
break;
|
|
}
|
|
}
|
|
if (reduce) {
|
|
newMaxDelta = maxDelta * 2;
|
|
}
|
|
}
|
|
|
|
// ensure that maxDelta is sufficiently large so that the _highPressureMark is sufficiently
|
|
// far away from the memory limit
|
|
newMaxDelta = Math.Max(newMaxDelta, _minMaxDelta);
|
|
|
|
// Do we have a new maxDelta? If so, adjust it and pressure marks.
|
|
if (_maxDelta != newMaxDelta) {
|
|
// adjust _maxDelta
|
|
_maxDelta = newMaxDelta;
|
|
// instead of using _maxDelta, use twice _maxDelta since recycling is
|
|
// expensive and the real delta fluctuates
|
|
_highPressureMark = Math.Max(_limit * 9 / 10, _limit - (_maxDelta * 2 * HIGH_FREQ_INTERVAL_S));
|
|
_lowPressureMark = Math.Max(_limit * 6 / 10, _limit - (_maxDelta * 2 * LOW_FREQ_INTERVAL_S));
|
|
_mediumPressureMark = Math.Max((_highPressureMark + _lowPressureMark) / 2 , _limit - (_maxDelta * 2 * MEDIUM_FREQ_INTERVAL_S));
|
|
_mediumPressureMark = Math.Min(_highPressureMark , _mediumPressureMark);
|
|
|
|
#if PERF
|
|
SafeNativeMethods.OutputDebugString(String.Format("CacheManager.AdjustMaxDeltaAndPressureMarks: _highPressureMark={0:N}, _mediumPressureMark={1:N}, _lowPressureMark={2:N}, _maxDelta={3:N}\n", _highPressureMark, _mediumPressureMark, _lowPressureMark, _maxDelta));
|
|
#endif
|
|
|
|
#if DBG
|
|
Debug.Trace("CacheMemory", "AdjustMaxDeltaAndPressureMarks "
|
|
+ "delta=" + delta
|
|
+ ", _maxDelta=" + _maxDelta
|
|
+ ", _highPressureMark=" + _highPressureMark
|
|
+ ", _mediumPressureMark=" + _mediumPressureMark
|
|
+ ", _lowPressureMark=" + _lowPressureMark);
|
|
#endif
|
|
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods", Justification="Need to call GC.Collect.")]
|
|
private void CollectInfrequently(long privateBytes) {
|
|
// not thread-safe, only invoke from timer callback
|
|
Debug.Assert(_inPBytesMonitorThread == 1);
|
|
|
|
// The Server GC on x86 can traverse ~200mb per CPU per second, and the maximum heap size
|
|
// is about 3400mb, so the worst case scenario on x86 would take about 8 seconds to collect
|
|
// on a dual CPU box.
|
|
//
|
|
// The Server GC on x64 can traverse ~300mb per CPU per second, so a 6000 MB heap will take
|
|
// about 10 seconds to collect on a dual CPU box. The worst case scenario on x64 would make
|
|
// you want to return your hardware for a refund.
|
|
|
|
long timeSinceInducedGC = DateTime.UtcNow.Subtract(_inducedGCFinishTime).Ticks;
|
|
bool infrequent = (timeSinceInducedGC > _inducedGCMinInterval);
|
|
|
|
// if we haven't collected recently, or if the trim percent is low (less than 50%),
|
|
// we need to collect again
|
|
if (infrequent || _lastTrimPercent < 50) {
|
|
|
|
// if we're inducing GC too frequently, increase the trim percentage, but don't go above 50%
|
|
if (!infrequent) {
|
|
_lastTrimPercent = Math.Min(50, _lastTrimPercent + 10);
|
|
}
|
|
// if we're inducing GC infrequently, we may want to decrease the trim percentage
|
|
else if (_lastTrimPercent > 10 && timeSinceInducedGC > 2 * _inducedGCMinInterval) {
|
|
_lastTrimPercent = Math.Max(10, _lastTrimPercent - 10);
|
|
}
|
|
int percent = (_totalCacheSize > 0) ? _lastTrimPercent : 0;
|
|
long trimmedOrExpired = 0;
|
|
if (percent > 0) {
|
|
Stopwatch sw1 = Stopwatch.StartNew();
|
|
trimmedOrExpired = _appManager.TrimCaches(percent);
|
|
sw1.Stop();
|
|
_trimDurationTicks = sw1.Elapsed.Ticks;
|
|
}
|
|
|
|
//
|
|
|
|
if (trimmedOrExpired == 0 || _appManager.ShutdownInProgress) {
|
|
return;
|
|
}
|
|
|
|
// collect and record statistics
|
|
Stopwatch sw2 = Stopwatch.StartNew();
|
|
GC.Collect();
|
|
sw2.Stop();
|
|
|
|
_inducedGCCount++; // only used for debugging
|
|
_inducedGCFinishTime = DateTime.UtcNow;
|
|
_inducedGCDurationTicks = sw2.Elapsed.Ticks;
|
|
_inducedGCPostPrivateBytes = NextSample();
|
|
_inducedGCPrivateBytesChange = privateBytes - _inducedGCPostPrivateBytes;
|
|
// target 3.3% Time in GC, but don't induce a GC more than once every 5 seconds
|
|
// Notes on calculation below: If G is duration of garbage collection and T is duration
|
|
// between starting the next collection, then G/T is % Time in GC. If we target 3.3%,
|
|
// then G/T = 3.3% = 33/1000, so T = G * 1000/33.
|
|
_inducedGCMinInterval = Math.Max(_inducedGCDurationTicks * 1000 / 33, 5 * TimeSpan.TicksPerSecond);
|
|
// no more frequently than every 60 seconds if change is less than 1%
|
|
if (_inducedGCPrivateBytesChange * 100 <= privateBytes) {
|
|
_inducedGCMinInterval = Math.Max(_inducedGCMinInterval, 60 * TimeSpan.TicksPerSecond);
|
|
}
|
|
#if DBG
|
|
Debug.Trace("CacheMemory", "GC.COLLECT STATS "
|
|
+ "TrimCaches(" + percent + ")"
|
|
+ ", trimDurationSeconds=" + (_trimDurationTicks/TimeSpan.TicksPerSecond)
|
|
+ ", trimmedOrExpired=" + trimmedOrExpired
|
|
+ ", #secondsSinceInducedGC=" + (timeSinceInducedGC/TimeSpan.TicksPerSecond)
|
|
+ ", InducedGCCount=" + _inducedGCCount
|
|
+ ", gcDurationSeconds=" + (_inducedGCDurationTicks/TimeSpan.TicksPerSecond)
|
|
+ ", PrePrivateBytes=" + privateBytes
|
|
+ ", PostPrivateBytes=" + _inducedGCPostPrivateBytes
|
|
+ ", PrivateBytesChange=" + _inducedGCPrivateBytesChange
|
|
+ ", gcMinIntervalSeconds=" + (_inducedGCMinInterval/TimeSpan.TicksPerSecond));
|
|
#endif
|
|
|
|
#if PERF
|
|
SafeNativeMethods.OutputDebugString(" ** COLLECT **: "
|
|
+ percent + "%, "
|
|
+ (_trimDurationTicks/TimeSpan.TicksPerSecond) + " seconds"
|
|
+ ", infrequent=" + infrequent
|
|
+ ", removed=" + trimmedOrExpired
|
|
+ ", sinceIGC=" + (timeSinceInducedGC/TimeSpan.TicksPerSecond)
|
|
+ ", IGCCount=" + _inducedGCCount
|
|
+ ", IGCDuration=" + (_inducedGCDurationTicks/TimeSpan.TicksPerSecond)
|
|
+ ", preBytes=" + privateBytes
|
|
+ ", postBytes=" + _inducedGCPostPrivateBytes
|
|
+ ", byteChange=" + _inducedGCPrivateBytesChange
|
|
+ ", IGCMinInterval=" + (_inducedGCMinInterval/TimeSpan.TicksPerSecond) + "\n");
|
|
#endif
|
|
|
|
}
|
|
}
|
|
|
|
internal long GetUpdatedTotalCacheSize(long sizeUpdate) {
|
|
if (sizeUpdate != 0) {
|
|
long totalSize = Interlocked.Add(ref _totalCacheSize, sizeUpdate);
|
|
#if PERF
|
|
SafeNativeMethods.OutputDebugString("CacheManager.GetUpdatedTotalCacheSize:"
|
|
+ " _totalCacheSize= " + totalSize
|
|
+ ", sizeUpdate=" + sizeUpdate + "\n");
|
|
#endif
|
|
|
|
return totalSize;
|
|
}
|
|
else {
|
|
return _totalCacheSize;
|
|
}
|
|
}
|
|
|
|
public void Dispose() {
|
|
_disposed = true;
|
|
Dispose(true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
protected virtual void Dispose(bool disposing) {
|
|
if (disposing) {
|
|
// managed and unmanaged resources can be touched/released
|
|
DisposeTimer();
|
|
}
|
|
else {
|
|
// the finalizer is calling, so don't touch managed state
|
|
}
|
|
}
|
|
|
|
private void DisposeTimer() {
|
|
lock (_timerLock) {
|
|
if (_timer != null) {
|
|
_timer.Dispose();
|
|
_timer = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void PBytesMonitorThread(object state) {
|
|
// callbacks are queued and can unleash all at once, so concurrent invocations must be prevented
|
|
if (Interlocked.Exchange(ref _inPBytesMonitorThread, 1) != 0)
|
|
return;
|
|
|
|
try {
|
|
if (_disposed) {
|
|
return;
|
|
}
|
|
|
|
#if DBG
|
|
Debug.Trace("CacheMemory", "\r\n\r\n***BEG** PBytesMonitorThread " + DateTime.Now.ToString("T", CultureInfo.InvariantCulture));
|
|
#endif
|
|
// get another sample
|
|
long privateBytes = NextSample();
|
|
|
|
// adjust frequency of timer and pressure marks after the sample is captured
|
|
Adjust();
|
|
|
|
if (privateBytes > _highPressureMark) {
|
|
// induce a GC if necessary
|
|
CollectInfrequently(privateBytes);
|
|
}
|
|
|
|
#if DBG
|
|
Debug.Trace("CacheMemory", "**END** PBytesMonitorThread "
|
|
+ "privateBytes=" + privateBytes
|
|
+ ", _highPressureMark=" + _highPressureMark);
|
|
#endif
|
|
|
|
}
|
|
finally {
|
|
Interlocked.Exchange(ref _inPBytesMonitorThread, 0);
|
|
}
|
|
}
|
|
|
|
private long NextSample() {
|
|
// not thread-safe, only invoke from timer callback
|
|
Debug.Assert(_inPBytesMonitorThread == 1);
|
|
|
|
// NtQuerySystemInformation is a very expensive call. A new function
|
|
// exists on XP Pro and later versions of the OS and it performs much
|
|
// better. The name of that function is GetProcessMemoryInfo. For hosting
|
|
// scenarios where a larger number of w3wp.exe instances are running, we
|
|
// want to use the new API (VSWhidbey 417366).
|
|
long privateBytes;
|
|
if (_useGetProcessMemoryInfo) {
|
|
long privatePageCount;
|
|
UnsafeNativeMethods.GetPrivateBytesIIS6(out privatePageCount, true /*nocache*/);
|
|
privateBytes = privatePageCount;
|
|
}
|
|
else {
|
|
uint dummy;
|
|
uint privatePageCount = 0;
|
|
// this is a very expensive call
|
|
UnsafeNativeMethods.GetProcessMemoryInformation(_pid, out privatePageCount, out dummy, true /*nocache*/);
|
|
privateBytes = (long)privatePageCount << MEGABYTE_SHIFT;
|
|
}
|
|
|
|
// increment the index (it's either 1 or 0)
|
|
Debug.Assert(SAMPLE_COUNT == 2);
|
|
_idx = _idx ^ 1;
|
|
// remember the sample time
|
|
_sampleTimes[_idx] = DateTime.UtcNow;
|
|
// remember the sample value
|
|
_samples[_idx] = privateBytes;
|
|
|
|
#if PERF
|
|
SafeNativeMethods.OutputDebugString(String.Format("CacheManager.NextSample: privateBytes={0:N}, _highPresureMark={1:N}\n", privateBytes, _highPressureMark));
|
|
#endif
|
|
|
|
return privateBytes;
|
|
}
|
|
}
|
|
}
|