/// <summary> /// New AddMemoryPressure implementation (used by RCW and the CLRServicesImpl class) /// 1. Less sensitive than the original implementation (start budget 3 MB) /// 2. Focuses more on newly added memory pressure /// 3. Budget adjusted by effectiveness of last 3 triggered GC (add / remove ratio, max 10x) /// 4. Budget maxed with 30% of current managed GC size /// 5. If Gen2 GC is happening naturally, ignore past pressure /// /// Here's a brief description of the ideal algorithm for Add/Remove memory pressure: /// Do a GC when (HeapStart is less than X * MemPressureGrowth) where /// - HeapStart is GC Heap size after doing the last GC /// - MemPressureGrowth is the net of Add and Remove since the last GC /// - X is proportional to our guess of the ummanaged memory death rate per GC interval, /// and would be calculated based on historic data using standard exponential approximation: /// Xnew = UMDeath/UMTotal * 0.5 + Xprev /// </summary> /// <param name="bytesAllocated"></param> public static void AddMemoryPressure(long bytesAllocated) { if (bytesAllocated <= 0) { throw new ArgumentOutOfRangeException("bytesAllocated", SR.ArgumentOutOfRange_NeedPosNum); } #if !BIT64 if (bytesAllocated > Int32.MaxValue) { throw new ArgumentOutOfRangeException("bytesAllocated", SR.ArgumentOutOfRange_MustBeNonNegInt32); } #endif CheckCollectionCount(); uint p = s_iteration % PressureCount; long newMemValue = InterlockedAddMemoryPressure(ref s_addPressure[p], bytesAllocated); Debug.Assert(PressureCount == 4, "GC.AddMemoryPressure contains unrolled loops which depend on the PressureCount"); if (newMemValue >= MinGCMemoryPressureBudget) { long add = s_addPressure[0] + s_addPressure[1] + s_addPressure[2] + s_addPressure[3] - s_addPressure[p]; long rem = s_removePressure[0] + s_removePressure[1] + s_removePressure[2] + s_removePressure[3] - s_removePressure[p]; long budget = MinGCMemoryPressureBudget; if (s_iteration >= PressureCount) // wait until we have enough data points { // Adjust according to effectiveness of GC // Scale budget according to past m_addPressure / m_remPressure ratio if (add >= rem * MaxGCMemoryPressureRatio) { budget = MinGCMemoryPressureBudget * MaxGCMemoryPressureRatio; } else if (add > rem) { Debug.Assert(rem != 0); // Avoid overflow by calculating addPressure / remPressure as fixed point (1 = 1024) budget = (add * 1024 / rem) * budget / 1024; } } // If still over budget, check current managed heap size if (newMemValue >= budget) { long heapOver3 = RuntimeImports.RhGetCurrentObjSize() / 3; if (budget < heapOver3) //Max { budget = heapOver3; } if (newMemValue >= budget) { // last check - if we would exceed 20% of GC "duty cycle", do not trigger GC at this time if ((RuntimeImports.RhGetGCNow() - RuntimeImports.RhGetLastGCStartTime(2)) > (RuntimeImports.RhGetLastGCDuration(2) * 5)) { RuntimeImports.RhCollect(2, InternalGCCollectionMode.NonBlocking); CheckCollectionCount(); } } } } }