implement review suggestions

antonfirsov · antonfirsov · commit b0646df24c9b · 2020-02-21T03:01:50.000+01:00
diff --git a/src/ImageSharp/Advanced/AdvancedImageExtensions.cs b/src/ImageSharp/Advanced/AdvancedImageExtensions.cs
@@ -61,7 +61,7 @@ private static Configuration GetConfiguration(IConfigurationProvider source)
         /// </remarks>
         public static IMemoryGroup<TPixel> GetPixelMemoryGroup<TPixel>(this ImageFrame<TPixel> source)
             where TPixel : struct, IPixel<TPixel>
-            => source?.PixelBuffer.MemoryGroup.View ?? throw new ArgumentNullException(nameof(source));
+            => source?.PixelBuffer.FastMemoryGroup.View ?? throw new ArgumentNullException(nameof(source));
 
         /// <summary>
         /// Gets the representation of the pixels as a <see cref="IMemoryGroup{T}"/> containing the backing pixel data of the image
diff --git a/src/ImageSharp/Image.Decode.cs b/src/ImageSharp/Image.Decode.cs
@@ -36,7 +36,7 @@ internal static Image<TPixel> CreateUninitialized<TPixel>(
         {
             Buffer2D<TPixel> uninitializedMemoryBuffer =
                 configuration.MemoryAllocator.Allocate2D<TPixel>(width, height);
-            return new Image<TPixel>(configuration, uninitializedMemoryBuffer.MemoryGroup, width, height, metadata);
+            return new Image<TPixel>(configuration, uninitializedMemoryBuffer.FastMemoryGroup, width, height, metadata);
         }
 
         /// <summary>
diff --git a/src/ImageSharp/Image.LoadPixelData.cs b/src/ImageSharp/Image.LoadPixelData.cs
@@ -120,7 +120,7 @@ public static Image<TPixel> LoadPixelData<TPixel>(Configuration config, ReadOnly
 
             var image = new Image<TPixel>(config, width, height);
             data = data.Slice(0, count);
-            data.CopyTo(image.Frames.RootFrame.PixelBuffer.MemoryGroup);
+            data.CopyTo(image.Frames.RootFrame.PixelBuffer.FastMemoryGroup);
 
             return image;
         }
diff --git a/src/ImageSharp/ImageFrame.LoadPixelData.cs b/src/ImageSharp/ImageFrame.LoadPixelData.cs
@@ -45,7 +45,7 @@ internal static ImageFrame<TPixel> LoadPixelData<TPixel>(Configuration configura
             var image = new ImageFrame<TPixel>(configuration, width, height);
 
             data = data.Slice(0, count);
-            data.CopyTo(image.PixelBuffer.MemoryGroup);
+            data.CopyTo(image.PixelBuffer.FastMemoryGroup);
 
             return image;
         }
diff --git a/src/ImageSharp/ImageFrameCollection{TPixel}.cs b/src/ImageSharp/ImageFrameCollection{TPixel}.cs
@@ -351,7 +351,7 @@ private ImageFrame<TPixel> CopyNonCompatibleFrame(ImageFrame source)
                 this.parent.GetConfiguration(),
                 source.Size(),
                 source.Metadata.DeepClone());
-            source.CopyPixelsTo(result.PixelBuffer.MemoryGroup);
+            source.CopyPixelsTo(result.PixelBuffer.FastMemoryGroup);
             return result;
         }
     }
diff --git a/src/ImageSharp/ImageFrame{TPixel}.cs b/src/ImageSharp/ImageFrame{TPixel}.cs
@@ -131,7 +131,7 @@ internal ImageFrame(Configuration configuration, ImageFrame<TPixel> source)
             Guard.NotNull(source, nameof(source));
 
             this.PixelBuffer = this.GetConfiguration().MemoryAllocator.Allocate2D<TPixel>(source.PixelBuffer.Width, source.PixelBuffer.Height);
-            source.PixelBuffer.MemoryGroup.CopyTo(this.PixelBuffer.MemoryGroup);
+            source.PixelBuffer.FastMemoryGroup.CopyTo(this.PixelBuffer.FastMemoryGroup);
         }
 
         /// <summary>
@@ -186,7 +186,7 @@ internal void CopyTo(Buffer2D<TPixel> target)
                 throw new ArgumentException("ImageFrame<TPixel>.CopyTo(): target must be of the same size!", nameof(target));
             }
 
-            this.PixelBuffer.MemoryGroup.CopyTo(target.MemoryGroup);
+            this.PixelBuffer.FastMemoryGroup.CopyTo(target.FastMemoryGroup);
         }
 
         /// <summary>
@@ -222,15 +222,15 @@ internal override void CopyPixelsTo<TDestinationPixel>(MemoryGroup<TDestinationP
         {
             if (typeof(TPixel) == typeof(TDestinationPixel))
             {
-                this.PixelBuffer.MemoryGroup.TransformTo(destination, (s, d) =>
+                this.PixelBuffer.FastMemoryGroup.TransformTo(destination, (s, d) =>
                 {
                     Span<TPixel> d1 = MemoryMarshal.Cast<TDestinationPixel, TPixel>(d);
                     s.CopyTo(d1);
                 });
                 return;
             }
 
-            this.PixelBuffer.MemoryGroup.TransformTo(destination, (s, d) =>
+            this.PixelBuffer.FastMemoryGroup.TransformTo(destination, (s, d) =>
             {
                 PixelOperations<TPixel>.Instance.To(this.GetConfiguration(), s, d);
             });
@@ -291,7 +291,7 @@ internal ImageFrame<TPixel2> CloneAs<TPixel2>(Configuration configuration)
         /// <param name="value">The value to initialize the bitmap with.</param>
         internal void Clear(TPixel value)
         {
-            MemoryGroup<TPixel> group = this.PixelBuffer.MemoryGroup;
+            MemoryGroup<TPixel> group = this.PixelBuffer.FastMemoryGroup;
 
             if (value.Equals(default))
             {
diff --git a/src/ImageSharp/Memory/Buffer2DExtensions.cs b/src/ImageSharp/Memory/Buffer2DExtensions.cs
@@ -24,7 +24,7 @@ public static IMemoryGroup<T> GetMemoryGroup<T>(this Buffer2D<T> buffer)
             where T : struct
         {
             Guard.NotNull(buffer, nameof(buffer));
-            return buffer.MemoryGroup.View;
+            return buffer.FastMemoryGroup.View;
         }
 
         /// <summary>
@@ -42,12 +42,12 @@ internal static Span<T> GetSingleSpan<T>(this Buffer2D<T> buffer)
             where T : struct
         {
             Guard.NotNull(buffer, nameof(buffer));
-            if (buffer.MemoryGroup.Count > 1)
+            if (buffer.FastMemoryGroup.Count > 1)
             {
                 throw new InvalidOperationException("GetSingleSpan is only valid for a single-buffer group!");
             }
 
-            return buffer.MemoryGroup.Single().Span;
+            return buffer.FastMemoryGroup.Single().Span;
         }
 
         /// <summary>
@@ -65,12 +65,12 @@ internal static Memory<T> GetSingleMemory<T>(this Buffer2D<T> buffer)
             where T : struct
         {
             Guard.NotNull(buffer, nameof(buffer));
-            if (buffer.MemoryGroup.Count > 1)
+            if (buffer.FastMemoryGroup.Count > 1)
             {
                 throw new InvalidOperationException("GetSingleMemory is only valid for a single-buffer group!");
             }
 
-            return buffer.MemoryGroup.Single();
+            return buffer.FastMemoryGroup.Single();
         }
 
         /// <summary>
diff --git a/src/ImageSharp/Memory/Buffer2D{T}.cs b/src/ImageSharp/Memory/Buffer2D{T}.cs
@@ -28,7 +28,7 @@ public sealed class Buffer2D<T> : IDisposable
         /// <param name="height">The number of rows.</param>
         internal Buffer2D(MemoryGroup<T> memoryGroup, int width, int height)
         {
-            this.MemoryGroup = memoryGroup;
+            this.FastMemoryGroup = memoryGroup;
             this.Width = width;
             this.Height = height;
 
@@ -49,24 +49,31 @@ internal Buffer2D(MemoryGroup<T> memoryGroup, int width, int height)
         public int Height { get; private set; }
 
         /// <summary>
-        /// Gets the backing <see cref="MemoryGroup{T}"/>.
+        /// Gets the backing <see cref="IMemoryGroup{T}"/>.
+        /// </summary>
+        /// <returns>The MemoryGroup.</returns>
+        public IMemoryGroup<T> MemoryGroup => this.FastMemoryGroup.View;
+
+        /// <summary>
+        /// Gets the backing <see cref="MemoryGroup{T}"/> without the view abstraction.
         /// </summary>
         /// <remarks>
         /// This property has been kept internal intentionally.
-        /// It's public counterpart is <see cref="Buffer2DExtensions.GetMemoryGroup{T}"/>,
+        /// It's public counterpart is <see cref="MemoryGroup"/>,
         /// which only exposes the view of the MemoryGroup.
         /// </remarks>
-        internal MemoryGroup<T> MemoryGroup { get; }
+        internal MemoryGroup<T> FastMemoryGroup { get; }
 
         /// <summary>
         /// Gets a reference to the element at the specified position.
         /// </summary>
         /// <param name="x">The x coordinate (row)</param>
         /// <param name="y">The y coordinate (position at row)</param>
         /// <returns>A reference to the element.</returns>
-        internal ref T this[int x, int y]
+        /// <exception cref="IndexOutOfRangeException">When index is out of range of the buffer.</exception>
+        public ref T this[int x, int y]
         {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            [MethodImpl(InliningOptions.ShortMethod)]
             get
             {
                 DebugGuard.MustBeGreaterThanOrEqualTo(x, 0, nameof(x));
@@ -83,7 +90,7 @@ internal Buffer2D(MemoryGroup<T> memoryGroup, int width, int height)
         /// </summary>
         public void Dispose()
         {
-            this.MemoryGroup.Dispose();
+            this.FastMemoryGroup.Dispose();
             this.cachedMemory = default;
         }
 
@@ -148,7 +155,7 @@ internal Memory<T> GetSafeRowMemory(int y)
         {
             DebugGuard.MustBeGreaterThanOrEqualTo(y, 0, nameof(y));
             DebugGuard.MustBeLessThan(y, this.Height, nameof(y));
-            return this.MemoryGroup.View.GetBoundedSlice(y * this.Width, this.Width);
+            return this.FastMemoryGroup.View.GetBoundedSlice(y * this.Width, this.Width);
         }
 
         /// <summary>
@@ -157,12 +164,12 @@ internal Memory<T> GetSafeRowMemory(int y)
         /// </summary>
         internal static void SwapOrCopyContent(Buffer2D<T> destination, Buffer2D<T> source)
         {
-            bool swap = MemoryGroup<T>.SwapOrCopyContent(destination.MemoryGroup, source.MemoryGroup);
+            bool swap = MemoryGroup<T>.SwapOrCopyContent(destination.FastMemoryGroup, source.FastMemoryGroup);
             SwapOwnData(destination, source, swap);
         }
 
         [MethodImpl(InliningOptions.ColdPath)]
-        private Memory<T> GetRowMemorySlow(int y) => this.MemoryGroup.GetBoundedSlice(y * this.Width, this.Width);
+        private Memory<T> GetRowMemorySlow(int y) => this.FastMemoryGroup.GetBoundedSlice(y * this.Width, this.Width);
 
         [MethodImpl(InliningOptions.ColdPath)]
         private ref T GetElementSlow(int x, int y)
diff --git a/src/ImageSharp/Memory/BufferArea{T}.cs b/src/ImageSharp/Memory/BufferArea{T}.cs
@@ -94,7 +94,7 @@ public Span<T> GetRowSpan(int y)
             int xx = this.Rectangle.X;
             int width = this.Rectangle.Width;
 
-            return this.DestinationBuffer.MemoryGroup.GetBoundedSlice(yy + xx, width).Span;
+            return this.DestinationBuffer.FastMemoryGroup.GetBoundedSlice(yy + xx, width).Span;
         }
 
         /// <summary>
@@ -140,7 +140,7 @@ public void Clear()
             // Optimization for when the size of the area is the same as the buffer size.
             if (this.IsFullBufferArea)
             {
-                this.DestinationBuffer.MemoryGroup.Clear();
+                this.DestinationBuffer.FastMemoryGroup.Clear();
                 return;
             }
 
diff --git a/src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroup{T}.Consumed.cs b/src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroup{T}.Consumed.cs
@@ -11,7 +11,7 @@ namespace SixLabors.ImageSharp.Memory
     internal abstract partial class MemoryGroup<T>
     {
         // Analogous to the "consumed" variant of MemorySource
-        private class Consumed : MemoryGroup<T>
+        private sealed class Consumed : MemoryGroup<T>
         {
             private readonly Memory<T>[] source;
 
diff --git a/src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroup{T}.Owned.cs b/src/ImageSharp/Memory/DiscontiguousBuffers/MemoryGroup{T}.Owned.cs
@@ -11,7 +11,7 @@ namespace SixLabors.ImageSharp.Memory
     // Analogous to the "owned" variant of MemorySource
     internal abstract partial class MemoryGroup<T>
     {
-        private class Owned : MemoryGroup<T>
+        private sealed class Owned : MemoryGroup<T>
         {
             private IMemoryOwner<T>[] memoryOwners;
 
@@ -25,6 +25,8 @@ public Owned(IMemoryOwner<T>[] memoryOwners, int bufferLength, long totalLength,
 
             public bool Swappable { get; }
 
+            private bool IsDisposed => this.memoryOwners == null;
+
             public override int Count
             {
                 get
@@ -51,7 +53,7 @@ public override IEnumerator<Memory<T>> GetEnumerator()
 
             public override void Dispose()
             {
-                if (this.memoryOwners == null)
+                if (this.IsDisposed)
                 {
                     return;
                 }
diff --git a/tests/ImageSharp.Tests/Memory/Buffer2DTests.cs b/tests/ImageSharp.Tests/Memory/Buffer2DTests.cs
@@ -46,8 +46,8 @@ public unsafe void Construct(int bufferCapacity, int width, int height)
             {
                 Assert.Equal(width, buffer.Width);
                 Assert.Equal(height, buffer.Height);
-                Assert.Equal(width * height, buffer.MemoryGroup.TotalLength);
-                Assert.True(buffer.MemoryGroup.BufferLength % width == 0);
+                Assert.Equal(width * height, buffer.FastMemoryGroup.TotalLength);
+                Assert.True(buffer.FastMemoryGroup.BufferLength % width == 0);
             }
         }
 
@@ -64,7 +64,7 @@ public unsafe void Construct_Empty(int bufferCapacity, int width, int height)
             {
                 Assert.Equal(width, buffer.Width);
                 Assert.Equal(height, buffer.Height);
-                Assert.Equal(0, buffer.MemoryGroup.TotalLength);
+                Assert.Equal(0, buffer.FastMemoryGroup.TotalLength);
                 Assert.Equal(0, buffer.GetSingleSpan().Length);
             }
         }
@@ -76,7 +76,7 @@ public void Allocate2DOveraligned(int bufferCapacity, int width, int height, int
             this.MemoryAllocator.BufferCapacityInBytes = sizeof(int) * bufferCapacity;
 
             using Buffer2D<int> buffer = this.MemoryAllocator.Allocate2DOveraligned<int>(width, height, alignmentMultiplier);
-            MemoryGroup<int> memoryGroup = buffer.MemoryGroup;
+            MemoryGroup<int> memoryGroup = buffer.FastMemoryGroup;
             int expectedAlignment = width * alignmentMultiplier;
 
             Assert.Equal(expectedAlignment, memoryGroup.BufferLength);
@@ -113,8 +113,8 @@ public unsafe void GetRowSpanY(int bufferCapacity, int width, int height, int y,
 
                 Assert.Equal(width, span.Length);
 
-                int expectedSubBufferOffset = (width * y) - (expectedBufferIndex * buffer.MemoryGroup.BufferLength);
-                Assert.SpanPointsTo(span, buffer.MemoryGroup[expectedBufferIndex], expectedSubBufferOffset);
+                int expectedSubBufferOffset = (width * y) - (expectedBufferIndex * buffer.FastMemoryGroup.BufferLength);
+                Assert.SpanPointsTo(span, buffer.FastMemoryGroup[expectedBufferIndex], expectedSubBufferOffset);
             }
         }
 
@@ -172,10 +172,10 @@ public unsafe void Indexer(int bufferCapacity, int width, int height, int x, int
 
             using (Buffer2D<TestStructs.Foo> buffer = this.MemoryAllocator.Allocate2D<TestStructs.Foo>(width, height))
             {
-                int bufferIndex = (width * y) / buffer.MemoryGroup.BufferLength;
-                int subBufferStart = (width * y) - (bufferIndex * buffer.MemoryGroup.BufferLength);
+                int bufferIndex = (width * y) / buffer.FastMemoryGroup.BufferLength;
+                int subBufferStart = (width * y) - (bufferIndex * buffer.FastMemoryGroup.BufferLength);
 
-                Span<TestStructs.Foo> span = buffer.MemoryGroup[bufferIndex].Span.Slice(subBufferStart);
+                Span<TestStructs.Foo> span = buffer.FastMemoryGroup[bufferIndex].Span.Slice(subBufferStart);
 
                 ref TestStructs.Foo actual = ref buffer[x, y];
 
@@ -194,13 +194,13 @@ public void SwapOrCopyContent_WhenBothAllocated()
                 a[1, 3] = 666;
                 b[1, 3] = 444;
 
-                Memory<int> aa = a.MemoryGroup.Single();
-                Memory<int> bb = b.MemoryGroup.Single();
+                Memory<int> aa = a.FastMemoryGroup.Single();
+                Memory<int> bb = b.FastMemoryGroup.Single();
 
                 Buffer2D<int>.SwapOrCopyContent(a, b);
 
-                Assert.Equal(bb, a.MemoryGroup.Single());
-                Assert.Equal(aa, b.MemoryGroup.Single());
+                Assert.Equal(bb, a.FastMemoryGroup.Single());
+                Assert.Equal(aa, b.FastMemoryGroup.Single());
 
                 Assert.Equal(new Size(3, 7), a.Size());
                 Assert.Equal(new Size(10, 5), b.Size());
@@ -287,5 +287,18 @@ public void CopyColumns_InvokeMultipleTimes()
                 }
             }
         }
+
+        [Fact]
+        public void PublicMemoryGroup_IsMemoryGroupView()
+        {
+            using Buffer2D<int> buffer1 = this.MemoryAllocator.Allocate2D<int>(10, 10);
+            using Buffer2D<int> buffer2 = this.MemoryAllocator.Allocate2D<int>(10, 10);
+            IMemoryGroup<int> mgBefore = buffer1.MemoryGroup;
+
+            Buffer2D<int>.SwapOrCopyContent(buffer1, buffer2);
+
+            Assert.False(mgBefore.IsValid);
+            Assert.NotSame(mgBefore, buffer1.MemoryGroup);
+        }
     }
 }
diff --git a/tests/ImageSharp.Tests/TestUtilities/ImageProviders/SolidProvider.cs b/tests/ImageSharp.Tests/TestUtilities/ImageProviders/SolidProvider.cs
@@ -54,7 +54,7 @@ public override Image<TPixel> GetImage()
                 Image<TPixel> image = base.GetImage();
                 Color color = new Rgba32(this.r, this.g, this.b, this.a);
 
-                image.GetRootFramePixelBuffer().MemoryGroup.Fill(color.ToPixel<TPixel>());
+                image.GetRootFramePixelBuffer().FastMemoryGroup.Fill(color.ToPixel<TPixel>());
                 return image;
             }
 
diff --git a/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/MagickReferenceDecoder.cs b/tests/ImageSharp.Tests/TestUtilities/ReferenceCodecs/MagickReferenceDecoder.cs
@@ -54,7 +54,7 @@ public Image<TPixel> Decode<TPixel>(Configuration configuration, Stream stream)
         {
             using var magickImage = new MagickImage(stream);
             var result = new Image<TPixel>(configuration, magickImage.Width, magickImage.Height);
-            MemoryGroup<TPixel> resultPixels = result.GetRootFramePixelBuffer().MemoryGroup;
+            MemoryGroup<TPixel> resultPixels = result.GetRootFramePixelBuffer().FastMemoryGroup;
 
             using (IPixelCollection pixels = magickImage.GetPixelsUnsafe())
             {

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ internal static Image<TPixel> CreateUninitialized<TPixel>(`
`36`	`36`	`{`
`37`	`37`	`Buffer2D<TPixel> uninitializedMemoryBuffer =`
`38`	`38`	`configuration.MemoryAllocator.Allocate2D<TPixel>(width, height);`
`39`		`- return new Image<TPixel>(configuration, uninitializedMemoryBuffer.MemoryGroup, width, height, metadata);`
	`39`	`+ return new Image<TPixel>(configuration, uninitializedMemoryBuffer.FastMemoryGroup, width, height, metadata);`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ public static Image<TPixel> LoadPixelData<TPixel>(Configuration config, ReadOnly`
`120`	`120`
`121`	`121`	`var image = new Image<TPixel>(config, width, height);`
`122`	`122`	`data = data.Slice(0, count);`
`123`		`- data.CopyTo(image.Frames.RootFrame.PixelBuffer.MemoryGroup);`
	`123`	`+ data.CopyTo(image.Frames.RootFrame.PixelBuffer.FastMemoryGroup);`
`124`	`124`
`125`	`125`	`return image;`
`126`	`126`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ internal static ImageFrame<TPixel> LoadPixelData<TPixel>(Configuration configura`
`45`	`45`	`var image = new ImageFrame<TPixel>(configuration, width, height);`
`46`	`46`
`47`	`47`	`data = data.Slice(0, count);`
`48`		`- data.CopyTo(image.PixelBuffer.MemoryGroup);`
	`48`	`+ data.CopyTo(image.PixelBuffer.FastMemoryGroup);`
`49`	`49`
`50`	`50`	`return image;`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -351,7 +351,7 @@ private ImageFrame<TPixel> CopyNonCompatibleFrame(ImageFrame source)`
`351`	`351`	`this.parent.GetConfiguration(),`
`352`	`352`	`source.Size(),`
`353`	`353`	`source.Metadata.DeepClone());`
`354`		`- source.CopyPixelsTo(result.PixelBuffer.MemoryGroup);`
	`354`	`+ source.CopyPixelsTo(result.PixelBuffer.FastMemoryGroup);`
`355`	`355`	`return result;`
`356`	`356`	`}`
`357`	`357`	`}`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ internal ImageFrame(Configuration configuration, ImageFrame<TPixel> source)`
`131`	`131`	`Guard.NotNull(source, nameof(source));`
`132`	`132`
`133`	`133`	`this.PixelBuffer = this.GetConfiguration().MemoryAllocator.Allocate2D<TPixel>(source.PixelBuffer.Width, source.PixelBuffer.Height);`
`134`		`- source.PixelBuffer.MemoryGroup.CopyTo(this.PixelBuffer.MemoryGroup);`
	`134`	`+ source.PixelBuffer.FastMemoryGroup.CopyTo(this.PixelBuffer.FastMemoryGroup);`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`/// <summary>`
`@@ -186,7 +186,7 @@ internal void CopyTo(Buffer2D<TPixel> target)`
`186`	`186`	`throw new ArgumentException("ImageFrame<TPixel>.CopyTo(): target must be of the same size!", nameof(target));`
`187`	`187`	`}`
`188`	`188`
`189`		`- this.PixelBuffer.MemoryGroup.CopyTo(target.MemoryGroup);`
	`189`	`+ this.PixelBuffer.FastMemoryGroup.CopyTo(target.FastMemoryGroup);`
`190`	`190`	`}`
`191`	`191`
`192`	`192`	`/// <summary>`
`@@ -222,15 +222,15 @@ internal override void CopyPixelsTo<TDestinationPixel>(MemoryGroup<TDestinationP`
`222`	`222`	`{`
`223`	`223`	`if (typeof(TPixel) == typeof(TDestinationPixel))`
`224`	`224`	`{`
`225`		`- this.PixelBuffer.MemoryGroup.TransformTo(destination, (s, d) =>`
	`225`	`+ this.PixelBuffer.FastMemoryGroup.TransformTo(destination, (s, d) =>`
`226`	`226`	`{`
`227`	`227`	`Span<TPixel> d1 = MemoryMarshal.Cast<TDestinationPixel, TPixel>(d);`
`228`	`228`	`s.CopyTo(d1);`
`229`	`229`	`});`
`230`	`230`	`return;`
`231`	`231`	`}`
`232`	`232`
`233`		`- this.PixelBuffer.MemoryGroup.TransformTo(destination, (s, d) =>`
	`233`	`+ this.PixelBuffer.FastMemoryGroup.TransformTo(destination, (s, d) =>`
`234`	`234`	`{`
`235`	`235`	`PixelOperations<TPixel>.Instance.To(this.GetConfiguration(), s, d);`
`236`	`236`	`});`
`@@ -291,7 +291,7 @@ internal ImageFrame<TPixel2> CloneAs<TPixel2>(Configuration configuration)`
`291`	`291`	`/// <param name="value">The value to initialize the bitmap with.</param>`
`292`	`292`	`internal void Clear(TPixel value)`
`293`	`293`	`{`
`294`		`- MemoryGroup<TPixel> group = this.PixelBuffer.MemoryGroup;`
	`294`	`+ MemoryGroup<TPixel> group = this.PixelBuffer.FastMemoryGroup;`
`295`	`295`
`296`	`296`	`if (value.Equals(default))`
`297`	`297`	`{`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public static IMemoryGroup<T> GetMemoryGroup<T>(this Buffer2D<T> buffer)`
`24`	`24`	`where T : struct`
`25`	`25`	`{`
`26`	`26`	`Guard.NotNull(buffer, nameof(buffer));`
`27`		`- return buffer.MemoryGroup.View;`
	`27`	`+ return buffer.FastMemoryGroup.View;`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`/// <summary>`
`@@ -42,12 +42,12 @@ internal static Span<T> GetSingleSpan<T>(this Buffer2D<T> buffer)`
`42`	`42`	`where T : struct`
`43`	`43`	`{`
`44`	`44`	`Guard.NotNull(buffer, nameof(buffer));`
`45`		`- if (buffer.MemoryGroup.Count > 1)`
	`45`	`+ if (buffer.FastMemoryGroup.Count > 1)`
`46`	`46`	`{`
`47`	`47`	`throw new InvalidOperationException("GetSingleSpan is only valid for a single-buffer group!");`
`48`	`48`	`}`
`49`	`49`
`50`		`- return buffer.MemoryGroup.Single().Span;`
	`50`	`+ return buffer.FastMemoryGroup.Single().Span;`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`/// <summary>`
`@@ -65,12 +65,12 @@ internal static Memory<T> GetSingleMemory<T>(this Buffer2D<T> buffer)`
`65`	`65`	`where T : struct`
`66`	`66`	`{`
`67`	`67`	`Guard.NotNull(buffer, nameof(buffer));`
`68`		`- if (buffer.MemoryGroup.Count > 1)`
	`68`	`+ if (buffer.FastMemoryGroup.Count > 1)`
`69`	`69`	`{`
`70`	`70`	`throw new InvalidOperationException("GetSingleMemory is only valid for a single-buffer group!");`
`71`	`71`	`}`
`72`	`72`
`73`		`- return buffer.MemoryGroup.Single();`
	`73`	`+ return buffer.FastMemoryGroup.Single();`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ public Span<T> GetRowSpan(int y)`
`94`	`94`	`int xx = this.Rectangle.X;`
`95`	`95`	`int width = this.Rectangle.Width;`
`96`	`96`
`97`		`- return this.DestinationBuffer.MemoryGroup.GetBoundedSlice(yy + xx, width).Span;`
	`97`	`+ return this.DestinationBuffer.FastMemoryGroup.GetBoundedSlice(yy + xx, width).Span;`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`/// <summary>`
`@@ -140,7 +140,7 @@ public void Clear()`
`140`	`140`	`// Optimization for when the size of the area is the same as the buffer size.`
`141`	`141`	`if (this.IsFullBufferArea)`
`142`	`142`	`{`
`143`		`- this.DestinationBuffer.MemoryGroup.Clear();`
	`143`	`+ this.DestinationBuffer.FastMemoryGroup.Clear();`
`144`	`144`	`return;`
`145`	`145`	`}`
`146`	`146`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ namespace SixLabors.ImageSharp.Memory`
`11`	`11`	`internal abstract partial class MemoryGroup<T>`
`12`	`12`	`{`
`13`	`13`	`// Analogous to the "consumed" variant of MemorySource`
`14`		`- private class Consumed : MemoryGroup<T>`
	`14`	`+ private sealed class Consumed : MemoryGroup<T>`
`15`	`15`	`{`
`16`	`16`	`private readonly Memory<T>[] source;`
`17`	`17`