Add 'physicalMemoryMode' to SRC.MemoryCache. New mode will follow GC metrics to determine trimming.

src/libraries/System.Runtime.Caching/src/System.Runtime.Caching.csproj

@@ -83,6 +83,7 @@ System.Runtime.Caching.ObjectCache</PackageDescription>
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetPlatformIdentifier)' != 'windows'">
+    <Compile Include="System\Runtime\Caching\MemoryMonitor.Unix.cs" />
     <Compile Include="System\Runtime\Caching\PhysicalMemoryMonitor.Unix.cs" />
   </ItemGroup>
 

src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/ConfigUtil.cs

@@ -13,6 +13,7 @@ internal static class ConfigUtil
     {
         internal const string CacheMemoryLimitMegabytes = "cacheMemoryLimitMegabytes";
         internal const string PhysicalMemoryLimitPercentage = "physicalMemoryLimitPercentage";
+        internal const string PhysicalMemoryMode = "physicalMemoryMode";
         internal const string PollingInterval = "pollingInterval";
         internal const string UseMemoryCacheManager = "useMemoryCacheManager";
         internal const string ThrowOnDisposed = "throwOnDisposed";
@@ -93,5 +94,21 @@ internal static bool GetBooleanValue(NameValueCollection config, string valueNam
 
             return bValue;
         }
+
+        internal static string GetStringValue(NameValueCollection config, string valueName, string defaultValue)
+        {
+            string sValue = config[valueName];
+            return sValue ?? defaultValue;
+        }
+
+        internal static PhysicalMemoryMode ParsePhysicalMemoryMode(string rawValue)
+        {
+            if (!Enum.TryParse<PhysicalMemoryMode>(rawValue, true, out PhysicalMemoryMode mode))
+            {
+                throw new ArgumentException(null, ConfigUtil.PhysicalMemoryMode);
+            }
+
+            return mode;
+        }
     }
 }

src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/MemoryCacheElement.cs

@@ -4,10 +4,32 @@
 using System;
 using System.ComponentModel;
 using System.Configuration;
+using System.Runtime.Caching.Resources;
 using System.Runtime.Versioning;
 
 namespace System.Runtime.Caching.Configuration
 {
+    /// <summary>
+    /// Defines the physical memory monitoring modes for the cache.
+    /// </summary>
+    internal enum PhysicalMemoryMode
+    {
+        /// <summary>
+        /// Legacy mode - uses platform-specific memory detection with GC-induced stats on non-Windows.
+        /// </summary>
+        Legacy = 0,
+
+        /// <summary>
+        /// Standard mode - uses GCMemoryInfo without inducing GC collections.
+        /// </summary>
+        Standard = 1,
+
+        /// <summary>
+        /// GC thresholds mode - uses GCMemoryInfo.HighMemoryLoadThresholdBytes instead of percentage of total memory.
+        /// </summary>
+        GCThresholds = 2
+    }
+
 #if NETCOREAPP
     [UnsupportedOSPlatform("browser")]
 #endif
@@ -28,6 +50,13 @@ internal sealed class MemoryCacheElement : ConfigurationElement
                 null,
                 new IntegerValidator(0, 100),
                 ConfigurationPropertyOptions.None);
+        private static readonly ConfigurationProperty s_propPhysicalMemoryMode =
+            new ConfigurationProperty("physicalMemoryMode",
+                typeof(string),
+                "Legacy",
+                new GenericEnumConverter(typeof(PhysicalMemoryMode)),
+                null,
+                ConfigurationPropertyOptions.None);
         private static readonly ConfigurationProperty s_propCacheMemoryLimitMegabytes =
             new ConfigurationProperty("cacheMemoryLimitMegabytes",
                 typeof(int),
@@ -46,6 +75,7 @@ internal sealed class MemoryCacheElement : ConfigurationElement
         {
             s_propName,
             s_propPhysicalMemoryLimitPercentage,
+            s_propPhysicalMemoryMode,
             s_propCacheMemoryLimitMegabytes,
             s_propPollingInterval
         };
@@ -82,6 +112,10 @@ public string Name
             }
         }
 
+        /// <summary>
+        /// Gets or sets the percentage of physical memory that can be used before cache entries are removed.
+        /// Valid values: 0 (auto-calculated defaults), 1-100 (specific percentage of physical memory).
+        /// </summary>
         [ConfigurationProperty("physicalMemoryLimitPercentage", DefaultValue = (int)0)]
         [IntegerValidator(MinValue = 0, MaxValue = 100)]
         public int PhysicalMemoryLimitPercentage
@@ -96,6 +130,22 @@ public int PhysicalMemoryLimitPercentage
             }
         }
 
+        /// <summary>
+        /// Gets or sets the physical memory monitoring mode.
+        /// Valid values:
+        /// - "Legacy": Platform-specific memory detection (default)
+        /// - "Standard": Use GC.GetGCMemoryInfo().TotalAvailableMemoryBytes without inducing GC
+        /// - "GCThresholds": Follow GC's high memory load threshold
+        /// </summary>
+        [ConfigurationProperty("physicalMemoryMode", DefaultValue = "Legacy")]
+        internal PhysicalMemoryMode PhysicalMemoryMode
+        {
+            get
+            {
+                return (PhysicalMemoryMode)base["physicalMemoryMode"];
+            }
+        }
+
         [ConfigurationProperty("cacheMemoryLimitMegabytes", DefaultValue = (int)0)]
         [IntegerValidator(MinValue = 0)]
         public int CacheMemoryLimitMegabytes

src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Configuration/MemoryCacheSection.cs

@@ -13,9 +13,9 @@ namespace System.Runtime.Caching.Configuration
        <system.runtime.caching>
          <memoryCaches>
            <namedCaches>
-             <add name="Default" physicalMemoryPercentage="0" pollingInterval="00:02:00"/>
-             <add name="Foo" physicalMemoryPercentage="0" pollingInterval="00:02:00"/>
-             <add name="Bar" physicalMemoryPercentage="0" pollingInterval="00:02:00"/>
+             <add name="Default" physicalMemoryPercentage="0" physicalMemoryMode="Legacy" pollingInterval="00:02:00"/>
+             <add name="Foo" physicalMemoryPercentage="0" physicalMemoryMode="Standard" pollingInterval="00:02:00"/>
+             <add name="Bar" physicalMemoryPercentage="0" physicalMemoryMode="GCThresholds" pollingInterval="00:02:00"/>
            </namedCaches>
          </memoryCaches>
        </system.caching>

src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStatistics.cs

@@ -21,6 +21,7 @@ internal sealed class MemoryCacheStatistics : IDisposable
 
         private int _configCacheMemoryLimitMegabytes;
         private int _configPhysicalMemoryLimitPercentage;
+        private PhysicalMemoryMode _configPhysicalMemoryMode;
         private int _configPollingInterval;
         private int _inCacheManagerThread;
         private int _disposed;
@@ -137,6 +138,7 @@ private void InitializeConfiguration(NameValueCollection config)
             {
                 _configCacheMemoryLimitMegabytes = element.CacheMemoryLimitMegabytes;
                 _configPhysicalMemoryLimitPercentage = element.PhysicalMemoryLimitPercentage;
+                _configPhysicalMemoryMode = element.PhysicalMemoryMode;
                 double milliseconds = element.PollingInterval.TotalMilliseconds;
                 _configPollingInterval = (milliseconds < (double)int.MaxValue) ? (int)milliseconds : int.MaxValue;
             }
@@ -145,13 +147,21 @@ private void InitializeConfiguration(NameValueCollection config)
                 _configPollingInterval = ConfigUtil.DefaultPollingTimeMilliseconds;
                 _configCacheMemoryLimitMegabytes = 0;
                 _configPhysicalMemoryLimitPercentage = 0;
+                _configPhysicalMemoryMode = PhysicalMemoryMode.Legacy;
             }
 
             if (config != null)
             {
                 _configPollingInterval = ConfigUtil.GetIntValueFromTimeSpan(config, ConfigUtil.PollingInterval, _configPollingInterval);
                 _configCacheMemoryLimitMegabytes = ConfigUtil.GetIntValue(config, ConfigUtil.CacheMemoryLimitMegabytes, _configCacheMemoryLimitMegabytes, true, int.MaxValue);
                 _configPhysicalMemoryLimitPercentage = ConfigUtil.GetIntValue(config, ConfigUtil.PhysicalMemoryLimitPercentage, _configPhysicalMemoryLimitPercentage, true, 100);
+
+                // Handle physicalMemoryMode from config
+                string physicalMemoryModeRaw = ConfigUtil.GetStringValue(config, ConfigUtil.PhysicalMemoryMode, "Legacy");
+                if (!string.IsNullOrWhiteSpace(physicalMemoryModeRaw))
+                {
+                    _configPhysicalMemoryMode = ConfigUtil.ParsePhysicalMemoryMode(physicalMemoryModeRaw);
+                }
             }
 #if !NETCOREAPP
             if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && _configPhysicalMemoryLimitPercentage > 0)
@@ -261,7 +271,7 @@ internal MemoryCacheStatistics(MemoryCache memoryCache, NameValueCollection conf
             _timerLock = new object();
             InitializeConfiguration(config);
             _pollingInterval = _configPollingInterval;
-            _physicalMemoryMonitor = new PhysicalMemoryMonitor(_configPhysicalMemoryLimitPercentage);
+            _physicalMemoryMonitor = new PhysicalMemoryMonitor(_configPhysicalMemoryLimitPercentage, _configPhysicalMemoryMode);
             InitDisposableMembers();
         }
 
@@ -359,6 +369,14 @@ internal void UpdateConfig(NameValueCollection config)
             int cacheMemoryLimitMegabytes = ConfigUtil.GetIntValue(config, ConfigUtil.CacheMemoryLimitMegabytes, _configCacheMemoryLimitMegabytes, true, int.MaxValue);
             int physicalMemoryLimitPercentage = ConfigUtil.GetIntValue(config, ConfigUtil.PhysicalMemoryLimitPercentage, _configPhysicalMemoryLimitPercentage, true, 100);
 
+            // Parse physicalMemoryMode from config
+            PhysicalMemoryMode physicalMemoryMode = _configPhysicalMemoryMode;
+            string physicalMemoryModeRaw = ConfigUtil.GetStringValue(config, ConfigUtil.PhysicalMemoryMode, "Legacy");
+            if (!string.IsNullOrWhiteSpace(physicalMemoryModeRaw))
+            {
+                physicalMemoryMode = ConfigUtil.ParsePhysicalMemoryMode(physicalMemoryModeRaw);
+            }
+
             if (pollingInterval != _configPollingInterval)
             {
                 lock (_timerLock)
@@ -368,7 +386,8 @@ internal void UpdateConfig(NameValueCollection config)
             }
 
             if (cacheMemoryLimitMegabytes == _configCacheMemoryLimitMegabytes
-                && physicalMemoryLimitPercentage == _configPhysicalMemoryLimitPercentage)
+                && physicalMemoryLimitPercentage == _configPhysicalMemoryLimitPercentage
+                && physicalMemoryMode == _configPhysicalMemoryMode)
             {
                 return;
             }
@@ -393,10 +412,12 @@ internal void UpdateConfig(NameValueCollection config)
                         _cacheMemoryMonitor.SetLimit(cacheMemoryLimitMegabytes);
                         _configCacheMemoryLimitMegabytes = cacheMemoryLimitMegabytes;
                     }
-                    if (physicalMemoryLimitPercentage != _configPhysicalMemoryLimitPercentage)
+                    if (physicalMemoryLimitPercentage != _configPhysicalMemoryLimitPercentage
+                        || physicalMemoryMode != _configPhysicalMemoryMode)
                     {
-                        _physicalMemoryMonitor.SetLimit(physicalMemoryLimitPercentage);
+                        _physicalMemoryMonitor.SetLimit(physicalMemoryLimitPercentage, physicalMemoryMode);
                         _configPhysicalMemoryLimitPercentage = physicalMemoryLimitPercentage;
+                        _configPhysicalMemoryMode = physicalMemoryMode;
                     }
                 }
             }

src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryMonitor.Unix.cs

@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Specialized;
+using System.Security;
+using System.Runtime.InteropServices;
+
+
+namespace System.Runtime.Caching
+{
+    internal abstract partial class MemoryMonitor
+    {
+#if NETCOREAPP
+#pragma warning disable CA1810 // explicit static cctor
+        static MemoryMonitor()
+        {
+            // Get stats from GC.
+            GCMemoryInfo memInfo = GC.GetGCMemoryInfo();
+
+            // s_totalPhysical/TotalPhysical are used in two places:
+            //   1. PhysicalMemoryMonitor - to determine the high pressure level. We really just need to know if we have more memory than a 2005-era x86 machine.
+            //   2. CacheMemoryMonitor - for setting the "Auto" memory limit of the cache size - which is never enforced anyway because we don't have SRef's in .NET Core.
+            // Which is to say, it's OK if 'TotalAvailableMemoryBytes' is not an exact representation of the physical memory on the machine, as long as it is in the ballpark of magnitude.
+            s_totalPhysical = memInfo.TotalAvailableMemoryBytes;
+
+            // s_totalVirtual/TotalVirtual on the other hand is only used to decide if an x86 Windows machine is running in /3GB mode or not...
+            //  ... but only so it can appropriately set the "Auto" memory limit of the cache size - which again, is never enforced in .Net Core.
+            //  So we don't need to worry about it here.
+            //s_totalVirtual = default(long);
+        }
+#pragma warning restore CA1810
+#endif
+    }
+}

src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/PhysicalMemoryMonitor.Unix.cs

@@ -25,7 +25,7 @@ internal sealed partial class PhysicalMemoryMonitor : MemoryMonitor
 #if NETCOREAPP
         private int lastGCCount;
 
-        protected override int GetCurrentPressure()
+        private int LegacyGetCurrentPressure()
         {
             // Try to refresh GC stats if they haven't been updated since our last check.
             int ccount = GC.CollectionCount(0);
@@ -39,7 +39,7 @@ protected override int GetCurrentPressure()
             // Get stats from GC.
             GCMemoryInfo memInfo = GC.GetGCMemoryInfo();
 
-            if (memInfo.TotalAvailableMemoryBytes >= memInfo.MemoryLoadBytes)
+            if (memInfo.TotalAvailableMemoryBytes > memInfo.MemoryLoadBytes)
             {
                 int memoryLoad = (int)((float)memInfo.MemoryLoadBytes * 100.0 / (float)memInfo.TotalAvailableMemoryBytes);
                 return Math.Max(1, memoryLoad);
@@ -50,7 +50,7 @@ protected override int GetCurrentPressure()
             return (memInfo.MemoryLoadBytes > 0) ? 100 : 0;
         }
 #else
-        protected override int GetCurrentPressure() => 0;
+        private static int LegacyGetCurrentPressure() => 0;
 #endif
     }
 }

src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/PhysicalMemoryMonitor.Windows.cs

@@ -10,7 +10,7 @@ namespace System.Runtime.Caching
 {
     internal sealed partial class PhysicalMemoryMonitor : MemoryMonitor
     {
-        protected override unsafe int GetCurrentPressure()
+        private static unsafe int LegacyGetCurrentPressure()
         {
             Interop.Kernel32.MEMORYSTATUSEX memoryStatus = default;
             memoryStatus.dwLength = (uint)sizeof(Interop.Kernel32.MEMORYSTATUSEX);