Optimized [ReadOnly]Memory<T> cast to source T

Author: Sergio0694

Microsoft.Toolkit.HighPerformance/Buffers/Internals/ArrayMemoryManager{TFrom,TTo}.cs

@@ -99,10 +99,18 @@ protected override void Dispose(bool disposing)
         }
 
         /// <inheritdoc/>
-        public MemoryManager<T> Cast<T>(int offset, int length)
+        public Memory<T> GetMemory<T>(int offset, int length)
             where T : unmanaged
         {
-            return new ArrayMemoryManager<TFrom, T>(this.array, this.offset + offset, length);
+            // We have a special handling in cases where the user is circling back to the original type
+            // of the wrapped array. In this case we can just return a memory wrapping that array directly,
+            // with offset and length being adjusted, without the memory manager indirection.
+            if (typeof(T) == typeof(TFrom))
+            {
+                return (Memory<T>)(object)this.array.AsMemory(this.offset + offset, length);
+            }
+
+            return new ArrayMemoryManager<TFrom, T>(this.array, this.offset + offset, length).Memory;
         }
 
         /// <summary>

Microsoft.Toolkit.HighPerformance/Buffers/Internals/Interfaces/IMemoryManager.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Buffers;
 
 namespace Microsoft.Toolkit.HighPerformance.Buffers.Internals.Interfaces
@@ -12,13 +13,13 @@ namespace Microsoft.Toolkit.HighPerformance.Buffers.Internals.Interfaces
     internal interface IMemoryManager
     {
         /// <summary>
-        /// Creates a new <see cref="MemoryManager{T}"/> that reinterprets the underlying data for the current instance.
+        /// Creates a new <see cref="Memory{T}"/> that reinterprets the underlying data for the current instance.
         /// </summary>
         /// <typeparam name="T">The target type to cast the items to.</typeparam>
         /// <param name="offset">The starting offset within the data store.</param>
         /// <param name="length">The original used length for the data store.</param>
-        /// <returns>A new <see cref="MemoryManager{T}"/> instance of the specified type, reinterpreting the current items.</returns>
-        MemoryManager<T> Cast<T>(int offset, int length)
+        /// <returns>A new <see cref="Memory{T}"/> instance of the specified type, reinterpreting the current items.</returns>
+        Memory<T> GetMemory<T>(int offset, int length)
             where T : unmanaged;
     }
 }

Microsoft.Toolkit.HighPerformance/Buffers/Internals/ProxyMemoryManager{TFrom,TTo}.cs

@@ -94,10 +94,17 @@ protected override void Dispose(bool disposing)
         }
 
         /// <inheritdoc/>
-        public MemoryManager<T> Cast<T>(int offset, int length)
+        public Memory<T> GetMemory<T>(int offset, int length)
             where T : unmanaged
         {
-            return new ProxyMemoryManager<TFrom, T>(this.memoryManager, this.offset + offset, length);
+            // Like in the other memory manager, we can skip one level of indirection in cases
+            // where the user is just going back to the original memory type, reusing the manager.
+            if (typeof(T) == typeof(TFrom))
+            {
+                return (Memory<T>)(object)this.memoryManager.Memory.Slice(offset, length);
+            }
+
+            return new ProxyMemoryManager<TFrom, T>(this.memoryManager, this.offset + offset, length).Memory;
         }
 
         /// <summary>

Microsoft.Toolkit.HighPerformance/Extensions/ReadOnlyMemoryExtensions.cs

@@ -68,7 +68,7 @@ public static ReadOnlyMemory<TTo> Cast<TFrom, TTo>(this ReadOnlyMemory<TFrom> me
                 // indirection level in the chain of memory managers needed to access the target data buffer to use.
                 if (memoryManager is IMemoryManager wrappingManager)
                 {
-                    return wrappingManager.Cast<TTo>(start, length).Memory;
+                    return wrappingManager.GetMemory<TTo>(start, length);
                 }
 
                 return new ProxyMemoryManager<TFrom, TTo>(memoryManager, start, length).Memory;