unload textures if we're too low on VRAM

Author: pandinocoder

Intersect.Client.Core/Interface/Debugging/DebugWindow.cs

@@ -326,6 +326,7 @@ private Table CreateGPUStatisticsTable(Base parent)
         table.AddRow(Strings.Debug.TextureAllocations, name: "GPUTextureAllocations").Listen(1, new DelegateDataProvider<ulong>(() => Graphics.Renderer.TextureAllocations), NoValue);
         table.AddRow(Strings.Debug.TextureCount, name: "GPUTextureCount").Listen(1, new DelegateDataProvider<ulong>(() => Graphics.Renderer.TextureCount), NoValue);
 
+        table.AddRow(Strings.Debug.UsedVRAM, name: "GPUUsedVRAM").Listen(1, new DelegateDataProvider<string>(() => FileSystemHelper.FormatSize(Graphics.Renderer.UsedMemory)), NoValue);
         table.AddRow(Strings.Debug.FreeVRAM, name: "GPUFreeVRAM").Listen(1, new DelegateDataProvider<string>(() => FileSystemHelper.FormatSize(PlatformStatistics.AvailableGPUMemory)), NoValue);
         table.AddRow(Strings.Debug.TotalVRAM, name: "GPUTotalVRAM").Listen(1, new DelegateDataProvider<string>(() => FileSystemHelper.FormatSize(PlatformStatistics.TotalGPUMemory)), NoValue);
 

Intersect.Client.Core/Localization/Strings.cs

@@ -973,6 +973,9 @@ public partial struct Debug
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
         public static LocalizedString TextureCount = @"Texture Assets";
 
+        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+        public static LocalizedString UsedVRAM = @"Used VRAM";
+
         [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
         public static LocalizedString FreeVRAM = @"Free VRAM";
 

Intersect.Client.Core/MonoGame/Graphics/MonoRenderer.Texture.cs

@@ -1,4 +1,5 @@
 using System.Collections.Concurrent;
+using System.Diagnostics.CodeAnalysis;
 using Intersect.Client.Framework.Graphics;
 using Intersect.Core;
 using Intersect.Framework.Reflection;
@@ -11,6 +12,51 @@ namespace Intersect.Client.MonoGame.Graphics;
 internal partial class MonoRenderer
 {
     private readonly ConcurrentDictionary<Texture2D, IGameTexture> _allocatedTextures = [];
+    private long _allocatedTexturesSize;
+
+    public override long UsedMemory => _allocatedTexturesSize;
+
+    private bool AddAllocatedTexture(Texture2D platformTexture, IGameTexture gameTexture)
+    {
+        if (!_allocatedTextures.TryAdd(platformTexture, gameTexture))
+        {
+            return false;
+        }
+
+        _allocatedTexturesSize += MeasureDataSize(platformTexture);
+        return true;
+    }
+
+    private bool RemoveAllocatedTexture(Texture2D platformTexture, [NotNullWhen(true)] out IGameTexture? gameTexture)
+    {
+        if (!_allocatedTextures.TryRemove(platformTexture, out gameTexture))
+        {
+            return false;
+        }
+
+        _allocatedTexturesSize -= MeasureDataSize(platformTexture);
+        return true;
+    }
+
+    private static long MeasureDataSize(Texture2D platformTexture)
+    {
+        var width = platformTexture.Width;
+        var height = platformTexture.Height;
+        return width * height * 4;
+
+        // We don't currently use mipmaps but this may become relevant in the future:
+        // internal static int CalculateMipLevels(int width, int height = 0, int depth = 0)
+        // {
+        //     int mipLevels = 1;
+        //     int num = Math.Max(Math.Max(width, height), depth);
+        //     while (num > 1)
+        //     {
+        //         num /= 2;
+        //         ++mipLevels;
+        //     }
+        //     return mipLevels;
+        // }
+    }
 
     private Texture2D? CreatePlatformTextureFromStream(MonoTexture gameTexture, Stream stream)
     {
@@ -21,7 +67,7 @@ internal partial class MonoRenderer
         }
 
         platformTexture.Disposing += Texture2DOnDisposing;
-        if (!_allocatedTextures.TryAdd(platformTexture, gameTexture))
+        if (!AddAllocatedTexture(platformTexture, gameTexture))
         {
             throw new InvalidOperationException("Failed to record allocated texture");
         }
@@ -64,10 +110,17 @@ public override IGameTexture CreateTextureFromStreamFactory(string assetName, Fu
 
     private void OnPlatformTextureDisposal(Texture2D platformTexture)
     {
-        if (_allocatedTextures.TryRemove(platformTexture, out var gameTexture))
+        if (RemoveAllocatedTexture(platformTexture, out var gameTexture))
         {
             MarkFreed(gameTexture);
         }
+        else
+        {
+            ApplicationContext.CurrentContext.Logger.LogError(
+                "Failed to remove platform texture from allocations, is it not tracked? '{TextureName}'",
+                platformTexture.ToString()
+            );
+        }
     }
 
     private class MonoTexture : GameTexture<Texture2D, MonoRenderer>

Intersect.Client.Core/MonoGame/Graphics/MonoRenderer.cs

@@ -13,7 +13,6 @@
 using Intersect.Core;
 using Intersect.Extensions;
 using Intersect.Framework.Core;
-using Intersect.Framework.SystemInformation;
 using Microsoft.Extensions.Logging;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Content;
@@ -127,10 +126,6 @@ public MonoRenderer(GraphicsDeviceManager graphics, ContentManager contentManage
         mGameWindow = monoGame.Window;
     }
 
-    public override long AvailableMemory => PlatformStatistics.AvailableGPUMemory;
-
-    public override long TotalMemory => PlatformStatistics.TotalGPUMemory;
-
     public IList<string> ValidVideoModes => GetValidVideoModes();
 
     public void UpdateGraphicsState(int width, int height, bool initial = false)

Intersect.Client.Framework/Graphics/GameRenderer.cs

@@ -1,24 +1,53 @@
 using System.Collections.Concurrent;
-using System.Collections.Immutable;
 using Intersect.Client.Framework.GenericClasses;
 using Intersect.Core;
 using Intersect.Framework.Collections;
+using Intersect.Framework.Core;
+using Intersect.Framework.SystemInformation;
 using Microsoft.Extensions.Logging;
 
 namespace Intersect.Client.Framework.Graphics;
 
 public abstract partial class GameRenderer : IGameRenderer, ITextHelper
 {
+    // To test the unloading system, lower InactiveTimeCutoff to 5000 (5 seconds) and raise
+    // MinimumAvailableVRAM to above your GPU RAM (if using Nvidia) or system RAM (if not using Nvidia)
+
+    /// <summary>
+    /// 30 seconds in milliseconds
+    /// </summary>
+    private const long InactiveTimeCutoff = 30_000;
+
     /// <summary>
-    ///     128MiB, which is 2x an uncompressed RGBA 4096x4096 (and half of an uncompressed 8192x8192)
+    ///     128MiB, which is 2x 4096px² atlases, half an 8192px² atlas
     /// </summary>
-    private const int MinimumAvailableVRAM = 134217728;
+    private const long MinimumAvailableVRAM = 134217728;
+
+    /// <summary>
+    /// 30 minutes in milliseconds
+    /// </summary>
+    private const long StaleTimeCutoff = 30 * 60 * 1000;
+
+    /// <summary>
+    /// 1GiB, which is 16x 4096px² atlases, 4x 8192px² atlases, and 1x 16384px² atlas
+    /// </summary>
+    private const long StaleVRAMCutoff = MinimumAvailableVRAM * 8;
+
+    /// <summary>
+    /// 6 hours in milliseconds
+    /// </summary>
+    private const long UnusedTimeCutoff = 6 * 60 * 60 * 1000;
+
+    /// <summary>
+    /// 8GiB, which is 128x 4096px² atlases, 32x 8192px² atlases, and 8x 16384px² atlases
+    /// </summary>
+    private const long UnusedVRAMCutoff = StaleVRAMCutoff * 8;
 
     private readonly ConcurrentDictionary<string, ScreenshotRequest> _screenshotRequestLookup = [];
     private readonly ConcurrentConditionalDequeue<ScreenshotRequest> _screenshotRequests = [];
 
     private readonly HashSet<IGameTexture> _textures = [];
-    private readonly List<IGameTexture> _texturesSortedByExpiration = [];
+    private readonly List<IGameTexture> _texturesSortedByAccessTime = [];
 
     protected float _scale = 1.0f;
 
@@ -47,10 +76,6 @@ public IGameTexture[] Textures
 
     public ulong TextureAllocations { get; private set; }
 
-    public abstract long AvailableMemory { get; }
-
-    public abstract long TotalMemory { get; }
-
     public bool HasOverrideResolution => OverrideResolution != Resolution.Empty;
 
     public bool HasScreenshotRequests => _screenshotRequests.Count > 0;
@@ -246,7 +271,7 @@ protected internal void MarkAllocated(IGameTexture texture)
 
         if (!texture.IsPinned)
         {
-            _texturesSortedByExpiration.AddSorted(texture);
+            _texturesSortedByAccessTime.AddSorted(texture);
         }
 
         if (texture is IGameRenderTexture)
@@ -263,7 +288,7 @@ protected internal void MarkFreed(IGameTexture texture)
     {
         if (!texture.IsPinned)
         {
-            _texturesSortedByExpiration.Remove(texture);
+            _texturesSortedByAccessTime.Remove(texture);
         }
 
         if (texture is IGameRenderTexture)
@@ -290,9 +315,9 @@ protected internal void MarkFreed(IGameTexture texture)
         TextureFreed?.Invoke(this, new TextureEventArgs(texture));
     }
 
-    internal void UpdateExpiration(IGameTexture gameTexture)
+    internal void UpdateAccessTime(IGameTexture gameTexture)
     {
-        _texturesSortedByExpiration.Resort(gameTexture);
+        _texturesSortedByAccessTime.Resort(gameTexture);
     }
 
     public abstract void Init();
@@ -307,17 +332,112 @@ internal void UpdateExpiration(IGameTexture gameTexture)
 
     protected abstract bool RecreateSpriteBatch();
 
+    public abstract long UsedMemory { get; }
+
     /// <summary>
     ///     Called when the frame is done being drawn, generally used to finally display the content to the screen.
     /// </summary>
     public void End()
     {
         DoEnd();
 
-        while (AvailableMemory < MinimumAvailableVRAM && _texturesSortedByExpiration.FirstOrDefault() is { } texture)
+        var usedVRAM = UsedMemory;
+        var availableVRAM = PlatformStatistics.AvailableGPUMemory;
+        var totalVRAM = PlatformStatistics.TotalGPUMemory;
+
+        if (availableVRAM < 0)
+        {
+            if (totalVRAM < 0)
+            {
+                availableVRAM = PlatformStatistics.AvailableSystemMemory;
+            }
+            else
+            {
+                availableVRAM = totalVRAM - usedVRAM;
+            }
+        }
+
+        if (totalVRAM < 0)
         {
-            _texturesSortedByExpiration.Remove(texture);
-            texture.Unload();
+            totalVRAM = availableVRAM + usedVRAM;
+        }
+
+        var now = Timing.Global.MillisecondsUtc;
+
+        var unusedCutoffTime = now - UnusedTimeCutoff;
+        var staleCutoffTime = now - StaleTimeCutoff;
+        var inactiveCutoffTime = now - InactiveTimeCutoff;
+
+        var unusedCutoffSize = UnusedVRAMCutoff < totalVRAM ? UnusedVRAMCutoff : totalVRAM - MinimumAvailableVRAM;
+        var staleCutoffSize = StaleVRAMCutoff < totalVRAM ? StaleVRAMCutoff : totalVRAM - MinimumAvailableVRAM;
+
+        while (_texturesSortedByAccessTime.FirstOrDefault() is { } texture)
+        {
+            var accessTime = texture.AccessTime;
+            if (availableVRAM > MinimumAvailableVRAM)
+            {
+                if (availableVRAM > staleCutoffSize)
+                {
+                    if (availableVRAM > unusedCutoffSize)
+                    {
+                        // Don't unload anything if we've still got (at the time of writing) 8GiB of VRAM
+                        break;
+                    }
+
+                    if (texture.AccessTime > unusedCutoffTime)
+                    {
+                        // It has been used in the last 6 hours, don't unload
+                        break;
+                    }
+
+                    // We're below our unused VRAM threshold and the texture is considered unused, unload it
+                    ApplicationContext.CurrentContext.Logger.LogTrace(
+                        "Unloading {TextureName} because it's unused and we have {AvailableVRAM} bytes of VRAM available (cutoff is {CutoffVRAM})",
+                        texture.Name,
+                        availableVRAM,
+                        unusedCutoffSize
+                    );
+                }
+                else if (texture.AccessTime > staleCutoffTime)
+                {
+                    // We are below our stale VRAM threshold, but the texture is not yet considered stale, don't unload
+                }
+                else
+                {
+                    // We're below our stale VRAM threshold and the texture is considered stale, unload it
+                    ApplicationContext.CurrentContext.Logger.LogTrace(
+                        "Unloading {TextureName} because it's stale and we have {AvailableVRAM} bytes of VRAM available (cutoff is {CutoffVRAM})",
+                        texture.Name,
+                        availableVRAM,
+                        staleCutoffSize
+                    );
+                }
+            }
+            else if (accessTime > inactiveCutoffTime)
+            {
+                // We are below our minimum VRAM threshold, but the texture is still active, don't unload
+                break;
+            }
+            else
+            {
+                ApplicationContext.CurrentContext.Logger.LogTrace(
+                    "Unloading {TextureName} because it's inactive and we have {AvailableVRAM} bytes of VRAM available (cutoff is {CutoffVRAM})",
+                    texture.Name,
+                    availableVRAM,
+                    MinimumAvailableVRAM
+                );
+            }
+
+            // If we've reached this point in the code one of the following is true:
+            // - We are below the unused memory threshold, and the texture is considered to be unused
+            // - We are below the stale memory threshold, and the texture is considered to be stale
+            // - We are below the minimum memory threshold, and the texture is considered to be inactive
+            // In any of these three cases we want to unload the texture
+
+            if (texture.Unload())
+            {
+                _texturesSortedByAccessTime.Remove(texture);
+            }
         }
     }