Reduce VBO buffer count to 2

osu.Framework/FrameworkEnvironment.cs

@@ -14,6 +14,7 @@ public static class FrameworkEnvironment
         public static GraphicsSurfaceType? PreferredGraphicsSurface { get; }
         public static string? PreferredGraphicsRenderer { get; }
         public static int? StagingBufferType { get; }
+        public static int? VertexBufferCount { get; }
 
         static FrameworkEnvironment()
         {
@@ -23,6 +24,9 @@ static FrameworkEnvironment()
             PreferredGraphicsSurface = Enum.TryParse<GraphicsSurfaceType>(Environment.GetEnvironmentVariable("OSU_GRAPHICS_SURFACE"), true, out var surface) ? surface : null;
             PreferredGraphicsRenderer = Environment.GetEnvironmentVariable("OSU_GRAPHICS_RENDERER")?.ToLowerInvariant();
 
+            if (int.TryParse(Environment.GetEnvironmentVariable("OSU_GRAPHICS_VBO_COUNT"), out int count))
+                VertexBufferCount = count;
+
             if (int.TryParse(Environment.GetEnvironmentVariable("OSU_GRAPHICS_STAGING_BUFFER_TYPE"), out int stagingBufferImplementation))
                 StagingBufferType = stagingBufferImplementation;
         }

osu.Framework/Graphics/Veldrid/Batches/VeldridVertexBatch.cs

@@ -6,20 +6,33 @@
 using osu.Framework.Graphics.Rendering;
 using osu.Framework.Graphics.Rendering.Vertices;
 using osu.Framework.Graphics.Veldrid.Buffers;
+using osu.Framework.Platform;
 using osu.Framework.Statistics;
 
 namespace osu.Framework.Graphics.Veldrid.Batches
 {
     internal abstract class VeldridVertexBatch<T> : IVertexBatch<T>
         where T : unmanaged, IEquatable<T>, IVertex
     {
-        private readonly List<VeldridVertexBuffer<T>>[] tripleBufferedVertexBuffers = new List<VeldridVertexBuffer<T>>[3];
+        /// <summary>
+        /// Most documentation recommends that three buffers are used to avoid contention.
+        ///
+        /// We already have a triple buffer (see <see cref="GameHost.DrawRoots"/>) at a higher level which guarantees one extra previous buffer,
+        /// so setting this to two here is ample to guarantee we don't hit any weird edge cases (gives a theoretical buffer count of 4, in the worst scenario).
+        ///
+        /// Note that due to the higher level triple buffer, the actual number of buffers we are storing is three times as high as this constant.
+        /// Maintaining this many buffers is a cause of concern from an memory alloc / GPU upload perspective.
+        /// </summary>
+        private const int vertex_buffer_count = 2;
 
-        public List<VeldridVertexBuffer<T>> CurrentVertexBuffers
-        {
-            get => tripleBufferedVertexBuffers[renderer.ResetId % 3];
-            set => tripleBufferedVertexBuffers[renderer.ResetId % 3] = value;
-        }
+        /// <summary>
+        /// Multiple VBOs in a swap chain to try our best to avoid GPU contention.
+        /// </summary>
+        private readonly List<VeldridVertexBuffer<T>>[] vertexBuffers = new List<VeldridVertexBuffer<T>>[FrameworkEnvironment.VertexBufferCount ?? vertex_buffer_count];
+
+        private List<VeldridVertexBuffer<T>> currentVertexBuffers => vertexBuffers[renderer.ResetId % (ulong)vertexBuffers.Length];
+
+        private VeldridVertexBuffer<T> currentVertexBuffer => currentVertexBuffers[currentBufferIndex];
 
         /// <summary>
         /// The number of vertices in each VertexBuffer.
@@ -34,17 +47,15 @@ public List<VeldridVertexBuffer<T>> CurrentVertexBuffers
 
         private readonly VeldridRenderer renderer;
 
-        private VeldridVertexBuffer<T> currentVertexBuffer => CurrentVertexBuffers[currentBufferIndex];
-
         protected VeldridVertexBatch(VeldridRenderer renderer, int bufferSize)
         {
             Size = bufferSize;
             this.renderer = renderer;
 
             AddAction = Add;
 
-            for (int i = 0; i < tripleBufferedVertexBuffers.Length; i++)
-                tripleBufferedVertexBuffers[i] = new List<VeldridVertexBuffer<T>>();
+            for (int i = 0; i < vertexBuffers.Length; i++)
+                vertexBuffers[i] = new List<VeldridVertexBuffer<T>>();
         }
 
         #region Disposal
@@ -59,9 +70,9 @@ protected void Dispose(bool disposing)
         {
             if (disposing)
             {
-                for (int i = 0; i < tripleBufferedVertexBuffers.Length; i++)
+                for (int i = 0; i < vertexBuffers.Length; i++)
                 {
-                    foreach (VeldridVertexBuffer<T> vbo in tripleBufferedVertexBuffers[i])
+                    foreach (VeldridVertexBuffer<T> vbo in vertexBuffers[i])
                         vbo.Dispose();
                 }
             }
@@ -86,15 +97,15 @@ public void Add(T v)
         {
             renderer.SetActiveBatch(this);
 
-            if (currentBufferIndex < CurrentVertexBuffers.Count && currentVertexIndex >= currentVertexBuffer.Size)
+            if (currentBufferIndex < currentVertexBuffers.Count && currentVertexIndex >= currentVertexBuffer.Size)
             {
                 Draw();
                 FrameStatistics.Increment(StatisticsCounterType.VBufOverflow);
             }
 
             // currentIndex will change after Draw() above, so this cannot be in an else-condition
-            while (currentBufferIndex >= CurrentVertexBuffers.Count)
-                CurrentVertexBuffers.Add(CreateVertexBuffer(renderer));
+            while (currentBufferIndex >= currentVertexBuffers.Count)
+                currentVertexBuffers.Add(CreateVertexBuffer(renderer));
 
             if (currentVertexBuffer.SetVertex(currentVertexIndex, v))
             {