Unmanaged pooling MemoryAllocator

Directory.Build.props

@@ -26,4 +26,7 @@
     <Optimize>true</Optimize>
   </PropertyGroup>
 
+  <PropertyGroup>
+    <DefineConstants Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)','netcoreapp3.1'))">$(DefineConstants);NETCORE31COMPATIBLE</DefineConstants>
+  </PropertyGroup>
 </Project>

src/ImageSharp/Advanced/AotCompilerTools.cs

@@ -524,7 +524,7 @@ private static void AotCompileDither<TPixel, TDither>()
         private static void AotCompileMemoryManagers<TPixel>()
             where TPixel : unmanaged, IPixel<TPixel>
         {
-            AotCompileMemoryManager<TPixel, ArrayPoolMemoryAllocator>();
+            AotCompileMemoryManager<TPixel, UniformUnmanagedMemoryPoolMemoryAllocator>();
             AotCompileMemoryManager<TPixel, SimpleGcMemoryAllocator>();
         }
 

src/ImageSharp/Configuration.cs

@@ -118,7 +118,7 @@ public int StreamProcessingBufferSize
         /// <summary>
         /// Gets or sets the <see cref="MemoryAllocator"/> that is currently in use.
         /// </summary>
-        public MemoryAllocator MemoryAllocator { get; set; } = ArrayPoolMemoryAllocator.CreateDefault();
+        public MemoryAllocator MemoryAllocator { get; set; } = MemoryAllocator.CreateDefault();
 
         /// <summary>
         /// Gets the maximum header size of all the formats.

src/ImageSharp/ImageFrame{TPixel}.cs

@@ -170,6 +170,9 @@ internal ImageFrame(Configuration configuration, ImageFrame<TPixel> source)
         /// <summary>
         /// Gets the representation of the pixels as a <see cref="Span{T}"/> of contiguous memory
         /// at row <paramref name="rowIndex"/> beginning from the first pixel on that row.
+        /// <para />
+        /// WARNING: Disposing or leaking the underlying image while still working with it's <see cref="Span{T}"/>
+        /// might lead to memory corruption.
         /// </summary>
         /// <param name="rowIndex">The row.</param>
         /// <returns>The <see cref="Span{TPixel}"/></returns>
@@ -185,6 +188,13 @@ public Span<TPixel> GetPixelRowSpan(int rowIndex)
         /// <summary>
         /// Gets the representation of the pixels as a <see cref="Span{T}"/> in the source image's pixel format
         /// stored in row major order, if the backing buffer is contiguous.
+        /// <para />
+        /// To ensure the memory is contiguous, <see cref="Configuration.MemoryAllocator"/> should be initialized
+        /// with a <see cref="MemoryAllocator"/> that enforces larger contiguous buffers.
+        /// See <see cref="MemoryAllocatorOptions.MinimumContiguousBlockSizeBytes"/>.
+        /// <para />
+        /// WARNING: Disposing or leaking the underlying image while still working with it's <see cref="Span{T}"/>
+        /// might lead to memory corruption.
         /// </summary>
         /// <param name="span">The <see cref="Span{T}"/>.</param>
         /// <returns>The <see cref="bool"/>.</returns>

src/ImageSharp/ImageSharp.csproj

@@ -13,8 +13,8 @@
     <PackageTags>Image Resize Crop Gif Jpg Jpeg Bitmap Png Tga NetCore</PackageTags>
     <Description>A new, fully featured, fully managed, cross-platform, 2D graphics API for .NET</Description>
     <Configurations>Debug;Release;Debug-InnerLoop;Release-InnerLoop</Configurations>
+    <DefineConstants Condition="'$(Configuration)' == 'Debug-InnerLoop'">$(DefineConstants);DEBUG</DefineConstants>
   </PropertyGroup>
-
   <Choose>
     <When Condition="$(SIXLABORS_TESTING) == true">
       <PropertyGroup>

src/ImageSharp/Image{TPixel}.cs

@@ -206,6 +206,9 @@ internal Image(Configuration configuration, ImageMetadata metadata, IEnumerable<
         /// <summary>
         /// Gets the representation of the pixels as a <see cref="Span{T}"/> of contiguous memory
         /// at row <paramref name="rowIndex"/> beginning from the first pixel on that row.
+        /// <para />
+        /// WARNING: Disposing or leaking the underlying image while still working with it's <see cref="Span{T}"/>
+        /// might lead to memory corruption.
         /// </summary>
         /// <param name="rowIndex">The row.</param>
         /// <returns>The <see cref="Span{TPixel}"/></returns>

src/ImageSharp/IndexedImageFrame{TPixel}.cs

@@ -75,6 +75,9 @@ internal IndexedImageFrame(Configuration configuration, int width, int height, R
         /// <summary>
         /// Gets the representation of the pixels as a <see cref="ReadOnlySpan{T}"/> of contiguous memory
         /// at row <paramref name="rowIndex"/> beginning from the first pixel on that row.
+        /// <para />
+        /// WARNING: Disposing or leaking the underlying <see cref="IndexedImageFrame{TPixel}"/> while still working with it's <see cref="Span{T}"/>
+        /// might lead to memory corruption.
         /// </summary>
         /// <param name="rowIndex">The row index in the pixel buffer.</param>
         /// <returns>The pixel row as a <see cref="ReadOnlySpan{T}"/>.</returns>

src/ImageSharp/Memory/Allocators/AllocationOptions.cs

@@ -1,21 +1,30 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
+using System;
+
 namespace SixLabors.ImageSharp.Memory
 {
     /// <summary>
     /// Options for allocating buffers.
     /// </summary>
+    [Flags]
     public enum AllocationOptions
     {
         /// <summary>
         /// Indicates that the buffer should just be allocated.
         /// </summary>
-        None,
+        None = 0,
 
         /// <summary>
         /// Indicates that the allocated buffer should be cleaned following allocation.
         /// </summary>
-        Clean
+        Clean = 1,
+
+        /// <summary>
+        /// Affects only group allocations.
+        /// Indicates that the requested <see cref="MemoryGroup{T}"/> or <see cref="Buffer2D{T}"/> should be made of contiguous blocks up to <see cref="int.MaxValue"/>.
+        /// </summary>
+        Contiguous = 2
     }
 }

src/ImageSharp/Memory/Allocators/AllocationOptionsExtensions.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Memory
+{
+    internal static class AllocationOptionsExtensions
+    {
+        public static bool Has(this AllocationOptions options, AllocationOptions flag) => (options & flag) == flag;
+    }
+}

src/ImageSharp/Memory/Allocators/ArrayPoolMemoryAllocator.Buffer{T}.cs

@@ -10,7 +10,7 @@
 namespace SixLabors.ImageSharp.Memory
 {
     /// <summary>
-    /// Contains <see cref="Buffer{T}"/> and <see cref="ManagedByteBuffer"/>.
+    /// Contains <see cref="Buffer{T}"/>.
     /// </summary>
     public partial class ArrayPoolMemoryAllocator
     {
@@ -87,19 +87,5 @@ private static void ThrowObjectDisposedException()
                 throw new ObjectDisposedException("ArrayPoolMemoryAllocator.Buffer<T>");
             }
         }
-
-        /// <summary>
-        /// The <see cref="IManagedByteBuffer"/> implementation of <see cref="ArrayPoolMemoryAllocator"/>.
-        /// </summary>
-        private sealed class ManagedByteBuffer : Buffer<byte>, IManagedByteBuffer
-        {
-            public ManagedByteBuffer(byte[] data, int length, ArrayPool<byte> sourcePool)
-                : base(data, length, sourcePool)
-            {
-            }
-
-            /// <inheritdoc />
-            public byte[] Array => this.Data;
-        }
     }
 }

src/ImageSharp/Memory/Allocators/ArrayPoolMemoryAllocator.CommonFactoryMethods.cs

@@ -36,7 +36,7 @@ public partial class ArrayPoolMemoryAllocator
         /// This is the default. Should be good for most use cases.
         /// </summary>
         /// <returns>The memory manager.</returns>
-        public static ArrayPoolMemoryAllocator CreateDefault()
+        public static new ArrayPoolMemoryAllocator CreateDefault()
         {
             return new ArrayPoolMemoryAllocator(
                 DefaultMaxPooledBufferSizeInBytes,

src/ImageSharp/Memory/Allocators/ArrayPoolMemoryAllocator.cs

@@ -10,6 +10,7 @@ namespace SixLabors.ImageSharp.Memory
     /// <summary>
     /// Implements <see cref="MemoryAllocator"/> by allocating memory from <see cref="ArrayPool{T}"/>.
     /// </summary>
+    [Obsolete("ArrayPoolMemoryAllocator is obsolete. Use MemoryAllocator.CreateDefault() instead.")]
     public sealed partial class ArrayPoolMemoryAllocator : MemoryAllocator
     {
         private readonly int maxArraysPerBucketNormalPool;
@@ -136,35 +137,15 @@ public override IMemoryOwner<T> Allocate<T>(int length, AllocationOptions option
             byte[] byteArray = pool.Rent(bufferSizeInBytes);
 
             var buffer = new Buffer<T>(byteArray, length, pool);
-            if (options == AllocationOptions.Clean)
+            if (options.Has(AllocationOptions.Clean))
             {
                 buffer.GetSpan().Clear();
             }
 
             return buffer;
         }
 
-        /// <inheritdoc />
-        public override IManagedByteBuffer AllocateManagedByteBuffer(int length, AllocationOptions options = AllocationOptions.None)
-        {
-            Guard.MustBeGreaterThanOrEqualTo(length, 0, nameof(length));
-
-            ArrayPool<byte> pool = this.GetArrayPool(length);
-            byte[] byteArray = pool.Rent(length);
-
-            var buffer = new ManagedByteBuffer(byteArray, length, pool);
-            if (options == AllocationOptions.Clean)
-            {
-                buffer.GetSpan().Clear();
-            }
-
-            return buffer;
-        }
-
-        private static int GetLargeBufferThresholdInBytes(int maxPoolSizeInBytes)
-        {
-            return maxPoolSizeInBytes / 4;
-        }
+        private static int GetLargeBufferThresholdInBytes(int maxPoolSizeInBytes) => maxPoolSizeInBytes / 4;
 
         [MethodImpl(InliningOptions.ColdPath)]
         private static void ThrowInvalidAllocationException<T>(int length, int max) =>

src/ImageSharp/Memory/Allocators/Internals/BasicArrayBuffer.cs

@@ -2,11 +2,12 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.Buffers;
 
 namespace SixLabors.ImageSharp.Memory.Internals
 {
     /// <summary>
-    /// Wraps an array as an <see cref="IManagedByteBuffer"/> instance.
+    /// Wraps an array as an <see cref="MemoryManager{T}"/> instance.
     /// </summary>
     /// <inheritdoc />
     internal class BasicArrayBuffer<T> : ManagedBufferBase<T>
@@ -57,4 +58,4 @@ protected override object GetPinnableObject()
             return this.Array;
         }
     }
-}
+}

src/ImageSharp/Memory/Allocators/Internals/Gen2GcCallback.cs

@@ -0,0 +1,115 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+// Port of BCL internal utility:
+// https://github.com/dotnet/runtime/blob/57bfe474518ab5b7cfe6bf7424a79ce3af9d6657/src/libraries/System.Private.CoreLib/src/System/Gen2GcCallback.cs
+#if NETCORE31COMPATIBLE
+using System;
+using System.Runtime.ConstrainedExecution;
+using System.Runtime.InteropServices;
+
+namespace SixLabors.ImageSharp.Memory.Internals
+{
+    /// <summary>
+    /// Schedules a callback roughly every gen 2 GC (you may see a Gen 0 an Gen 1 but only once)
+    /// (We can fix this by capturing the Gen 2 count at startup and testing, but I mostly don't care)
+    /// </summary>
+    internal sealed class Gen2GcCallback : CriticalFinalizerObject
+    {
+        private readonly Func<bool> callback0;
+        private readonly Func<object, bool> callback1;
+        private GCHandle weakTargetObj;
+
+        private Gen2GcCallback(Func<bool> callback)
+        {
+            this.callback0 = callback;
+        }
+
+        private Gen2GcCallback(Func<object, bool> callback, object targetObj)
+        {
+            this.callback1 = callback;
+            this.weakTargetObj = GCHandle.Alloc(targetObj, GCHandleType.Weak);
+        }
+
+        ~Gen2GcCallback()
+        {
+            if (this.weakTargetObj.IsAllocated)
+            {
+                // Check to see if the target object is still alive.
+                object targetObj = this.weakTargetObj.Target;
+                if (targetObj == null)
+                {
+                    // The target object is dead, so this callback object is no longer needed.
+                    this.weakTargetObj.Free();
+                    return;
+                }
+
+                // Execute the callback method.
+                try
+                {
+                    if (!this.callback1(targetObj))
+                    {
+                        // If the callback returns false, this callback object is no longer needed.
+                        this.weakTargetObj.Free();
+                        return;
+                    }
+                }
+                catch
+                {
+                    // Ensure that we still get a chance to resurrect this object, even if the callback throws an exception.
+#if DEBUG
+                    // Except in DEBUG, as we really shouldn't be hitting any exceptions here.
+                    throw;
+#endif
+                }
+            }
+            else
+            {
+                // Execute the callback method.
+                try
+                {
+                    if (!this.callback0())
+                    {
+                        // If the callback returns false, this callback object is no longer needed.
+                        return;
+                    }
+                }
+                catch
+                {
+                    // Ensure that we still get a chance to resurrect this object, even if the callback throws an exception.
+#if DEBUG
+                    // Except in DEBUG, as we really shouldn't be hitting any exceptions here.
+                    throw;
+#endif
+                }
+            }
+
+            // Resurrect ourselves by re-registering for finalization.
+            GC.ReRegisterForFinalize(this);
+        }
+
+        /// <summary>
+        /// Schedule 'callback' to be called in the next GC.  If the callback returns true it is
+        /// rescheduled for the next Gen 2 GC.  Otherwise the callbacks stop.
+        /// </summary>
+        public static void Register(Func<bool> callback)
+        {
+            // Create a unreachable object that remembers the callback function and target object.
+            _ = new Gen2GcCallback(callback);
+        }
+
+        /// <summary>
+        /// Schedule 'callback' to be called in the next GC.  If the callback returns true it is
+        /// rescheduled for the next Gen 2 GC.  Otherwise the callbacks stop.
+        ///
+        /// NOTE: This callback will be kept alive until either the callback function returns false,
+        /// or the target object dies.
+        /// </summary>
+        public static void Register(Func<object, bool> callback, object targetObj)
+        {
+            // Create a unreachable object that remembers the callback function and target object.
+            _ = new Gen2GcCallback(callback, targetObj);
+        }
+    }
+}
+#endif