Merge branch 'master' into remove-texture-upload-finalizer-overhead

osu.Framework/Graphics/Performance/FrameStatisticsDisplay.cs

···
 using osu.Framework.Input.Events;
 using osuTK;
 using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace osu.Framework.Graphics.Performance
 {
     internal class FrameStatisticsDisplay : Container, IStateful<FrameStatisticsMode>
     {
+        internal const int HEIGHT = 100;
+
         protected const int WIDTH = 800;
-        protected const int HEIGHT = 100;
 
         private const int amount_count_steps = 5;
 
···
 
         private readonly Container mainContainer;
         private readonly Container timeBarsContainer;
+
+        private readonly MemoryAllocator uploadAllocator;
 
         private readonly Drawable[] legendMapping = new Drawable[FrameStatistics.NUM_PERFORMANCE_COLLECTION_TYPES];
         private readonly Dictionary<StatisticsCounterType, CounterBar> counterBars = new Dictionary<StatisticsCounterType, CounterBar>();
···
             }
         }
 
-        public FrameStatisticsDisplay(GameThread thread)
+        public FrameStatisticsDisplay(GameThread thread, MemoryAllocator uploadAllocator)
         {
             Name = thread.Name;
             monitor = thread.Monitor;
+            this.uploadAllocator = uploadAllocator;
 
             Origin = Anchor.TopRight;
             AutoSizeAxes = Axes.Both;
···
         private void applyFrameTime(FrameStatistics frame)
         {
             TimeBar timeBar = timeBars[timeBarIndex];
-            var upload = new ArrayPoolTextureUpload(1, HEIGHT)
+            var upload = new ArrayPoolTextureUpload(1, HEIGHT, uploadAllocator)
             {
                 Bounds = new RectangleI(timeBarX, 0, 1, HEIGHT)
             };

osu.Framework/Graphics/Performance/PerformanceOverlay.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Threading;
 using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using SixLabors.ImageSharp.Memory;
+using SixLabors.ImageSharp.PixelFormats;
 
 namespace osu.Framework.Graphics.Performance
 {
     internal class PerformanceOverlay : FillFlowContainer<FrameStatisticsDisplay>, IStateful<FrameStatisticsMode>
     {
-        private readonly IEnumerable<GameThread> threads;
+        private readonly GameThread[] threads;
         private FrameStatisticsMode state;
 
         public event Action<FrameStatisticsMode> StateChanged;
···
                     if (!initialised)
                     {
                         initialised = true;
+
+                        var uploadPool = createUploadPool();
+
                         foreach (GameThread t in threads)
-                            Add(new FrameStatisticsDisplay(t) { State = state });
+                            Add(new FrameStatisticsDisplay(t, uploadPool) { State = state });
                     }
 
                     this.FadeIn(100);
···
             StateChanged?.Invoke(State);
         }
 
+        private ArrayPoolMemoryAllocator createUploadPool()
+        {
+            int uploadSize = FrameStatisticsDisplay.HEIGHT * Unsafe.SizeOf<Rgba32>();
+
+            // bucket size should be enough to allow some overhead when running multi-threaded with draw at 60hz.
+            const int max_expected_thread_update_rate = 2000;
+
+            int bucketSize = threads.Length * (max_expected_thread_update_rate / 60);
+
+            // we already know the fixed size of uploads so there's no need to use i#'s two-tiered pooling system.
+            return new ArrayPoolMemoryAllocator(uploadSize, uploadSize, 1, bucketSize);
+        }
+
         public PerformanceOverlay(IEnumerable<GameThread> threads)
         {
-            this.threads = threads;
+            this.threads = threads.ToArray();
             Direction = FillDirection.Vertical;
         }
     }

osu.Framework/Graphics/Textures/ArrayPoolTextureUpload.cs

···
 using System.Buffers;
 using osu.Framework.Graphics.Primitives;
 using osuTK.Graphics.ES30;
+using SixLabors.ImageSharp.Memory;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace osu.Framework.Graphics.Textures
···
         /// </summary>
         /// <param name="width">The width of the texture.</param>
         /// <param name="height">The height of the texture.</param>
-        public ArrayPoolTextureUpload(int width, int height)
+        /// <param name="memoryAllocator">The source to retrieve memory from. Shared default is used if null.</param>
+        public ArrayPoolTextureUpload(int width, int height, MemoryAllocator memoryAllocator = null)
         {
-            memoryOwner = SixLabors.ImageSharp.Configuration.Default.MemoryAllocator.Allocate<Rgba32>(width * height);
+            memoryOwner = (memoryAllocator ?? SixLabors.ImageSharp.Configuration.Default.MemoryAllocator).Allocate<Rgba32>(width * height);
         }
 
         // ReSharper disable once ConvertToAutoPropertyWithPrivateSetter

osu.Framework/Graphics/Video/VideoTextureUpload.cs

···
 
 namespace osu.Framework.Graphics.Video
 {
-    public unsafe class VideoTextureUpload : ITextureUpload
+    public sealed unsafe class VideoTextureUpload : ITextureUpload
     {
         public readonly AVFrame* Frame;
 
···
         /// </summary>
         /// <param name="frame">The frame to upload.</param>
         /// <param name="freeFrameDelegate">A function to free the frame on disposal.</param>
-        public VideoTextureUpload(AVFrame* frame, FFmpegFuncs.AvFrameFreeDelegate freeFrameDelegate)
+        internal VideoTextureUpload(AVFrame* frame, FFmpegFuncs.AvFrameFreeDelegate freeFrameDelegate)
         {
             Frame = frame;
             this.freeFrameDelegate = freeFrameDelegate;