memory clearing should not be UniformUnmanagedMemoryPool concern

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

@@ -52,7 +52,7 @@ namespace SixLabors.ImageSharp.Memory.Internals
 
         public int Capacity { get; }
 
-        public UnmanagedMemoryHandle Rent(AllocationOptions allocationOptions = AllocationOptions.None)
+        public UnmanagedMemoryHandle Rent()
         {
             UnmanagedMemoryHandle[] buffersLocal = this.buffers;
 
@@ -81,11 +81,6 @@ namespace SixLabors.ImageSharp.Memory.Internals
                 buffer = UnmanagedMemoryHandle.Allocate(this.BufferLength);
             }
 
-            if (allocationOptions.Has(AllocationOptions.Clean))
-            {
-                this.GetSpan(buffer).Clear();
-            }
-
             return buffer;
         }
 

src/ImageSharp/Memory/Allocators/UniformUnmanagedMemoryPoolMemoryAllocator.cs

@@ -98,10 +98,14 @@ namespace SixLabors.ImageSharp.Memory
 
             if (lengthInBytes <= this.poolBufferSizeInBytes)
             {
-                UnmanagedMemoryHandle array = this.pool.Rent(options);
+                UnmanagedMemoryHandle array = this.pool.Rent();
                 if (array != null)
                 {
-                    return new UniformUnmanagedMemoryPool.FinalizableBuffer<T>(this.pool, array, length);
+                    var buffer = new UniformUnmanagedMemoryPool.FinalizableBuffer<T>(this.pool, array, length);
+                    if (options.Has(AllocationOptions.Clean))
+                    {
+                        buffer.Clear();
+                    }
                 }
             }
 
@@ -124,10 +128,15 @@ namespace SixLabors.ImageSharp.Memory
             if (totalLengthInBytes <= this.poolBufferSizeInBytes)
             {
                 // Optimized path renting single array from the pool
-                UnmanagedMemoryHandle array = this.pool.Rent(options);
+                UnmanagedMemoryHandle array = this.pool.Rent();
                 if (array != null)
                 {
                     var buffer = new UniformUnmanagedMemoryPool.FinalizableBuffer<T>(this.pool, array, (int)totalLength);
+                    if (options.Has(AllocationOptions.Clean))
+                    {
+                        buffer.Clear();
+                    }
+
                     return MemoryGroup<T>.CreateContiguous(buffer, options.Has(AllocationOptions.Clean));
                 }
             }

src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroup{T}.Owned.cs

@@ -30,8 +30,8 @@ namespace SixLabors.ImageSharp.Memory
                 this.View = new MemoryGroupView<T>(this);
             }
 
-            public Owned(UniformUnmanagedMemoryPool pool, UnmanagedMemoryHandle[] pooledArrays, int bufferLength, long totalLength, int sizeOfLastBuffer)
-                : this(CreateBuffers(pool, pooledArrays, bufferLength, sizeOfLastBuffer), bufferLength, totalLength, true)
+            public Owned(UniformUnmanagedMemoryPool pool, UnmanagedMemoryHandle[] pooledArrays, int bufferLength, long totalLength, int sizeOfLastBuffer, AllocationOptions options)
+                : this(CreateBuffers(pool, pooledArrays, bufferLength, sizeOfLastBuffer, options), bufferLength, totalLength, true)
             {
                 this.pooledHandles = pooledArrays;
                 this.unmanagedMemoryPool = pool;
@@ -66,16 +66,29 @@ namespace SixLabors.ImageSharp.Memory
                 UniformUnmanagedMemoryPool pool,
                 UnmanagedMemoryHandle[] pooledBuffers,
                 int bufferLength,
-                int sizeOfLastBuffer)
+                int sizeOfLastBuffer,
+                AllocationOptions options)
             {
                 var result = new IMemoryOwner<T>[pooledBuffers.Length];
                 for (int i = 0; i < pooledBuffers.Length - 1; i++)
                 {
                     pooledBuffers[i].AssignedToNewOwner();
-                    result[i] = new UniformUnmanagedMemoryPool.Buffer<T>(pool, pooledBuffers[i], bufferLength);
+                    var currentBuffer = new UniformUnmanagedMemoryPool.Buffer<T>(pool, pooledBuffers[i], bufferLength);
+                    if (options.Has(AllocationOptions.Clean))
+                    {
+                        currentBuffer.Clear();
+                    }
+
+                    result[i] = currentBuffer;
+                }
+
+                var lastBuffer = new UniformUnmanagedMemoryPool.Buffer<T>(pool, pooledBuffers[pooledBuffers.Length - 1], sizeOfLastBuffer);
+                if (options.Has(AllocationOptions.Clean))
+                {
+                    lastBuffer.Clear();
                 }
 
-                result[result.Length - 1] = new UniformUnmanagedMemoryPool.Buffer<T>(pool, pooledBuffers[pooledBuffers.Length - 1], sizeOfLastBuffer);
+                result[result.Length - 1] = lastBuffer;
                 return result;
             }