Fixed offset/length computation with double cast

Author: Sergio0694

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

@@ -8,6 +8,7 @@
 using System.Runtime.InteropServices;
 using Microsoft.Toolkit.HighPerformance.Buffers.Internals.Interfaces;
 using Microsoft.Toolkit.HighPerformance.Extensions;
+using RuntimeHelpers = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers;
 
 namespace Microsoft.Toolkit.HighPerformance.Buffers.Internals
 {
@@ -53,16 +54,18 @@ public override Span<TTo> GetSpan()
         {
 #if SPAN_RUNTIME_SUPPORT
             ref TFrom r0 = ref this.array.DangerousGetReferenceAt(this.offset);
+            ref TTo r1 = ref Unsafe.As<TFrom, TTo>(ref r0);
+            int length = RuntimeHelpers.ConvertLength<TFrom, TTo>(this.length);
 
-            Span<TFrom> span = MemoryMarshal.CreateSpan(ref r0, this.length);
+            return MemoryMarshal.CreateSpan(ref r1, length);
 #else
             Span<TFrom> span = this.array.AsSpan(this.offset, this.length);
-#endif
 
             // We rely on MemoryMarshal.Cast here to deal with calculating the effective
             // size of the new span to return. This will also make the behavior consistent
             // for users that are both using this type as well as casting spans directly.
             return MemoryMarshal.Cast<TFrom, TTo>(span);
+#endif
         }
 
         /// <inheritdoc/>
@@ -102,15 +105,22 @@ protected override void Dispose(bool disposing)
         public Memory<T> GetMemory<T>(int offset, int length)
             where T : unmanaged
         {
+            // We need to calculate the right offset and length of the new Memory<T>. The local offset
+            // is the original offset into the wrapped TFrom[] array, while the input offset is the one
+            // with respect to TTo items in the Memory<TTo> instance that is currently being cast.
+            int
+                absoluteOffset = this.offset + RuntimeHelpers.ConvertLength<TTo, TFrom>(offset),
+                absoluteLength = RuntimeHelpers.ConvertLength<TTo, TFrom>(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 (Memory<T>)(object)this.array.AsMemory(absoluteOffset, absoluteLength);
             }
 
-            return new ArrayMemoryManager<TFrom, T>(this.array, this.offset + offset, length).Memory;
+            return new ArrayMemoryManager<TFrom, T>(this.array, absoluteOffset, absoluteLength).Memory;
         }
 
         /// <summary>

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

@@ -7,6 +7,7 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Microsoft.Toolkit.HighPerformance.Buffers.Internals.Interfaces;
+using RuntimeHelpers = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers;
 
 namespace Microsoft.Toolkit.HighPerformance.Buffers.Internals
 {
@@ -97,14 +98,18 @@ protected override void Dispose(bool disposing)
         public Memory<T> GetMemory<T>(int offset, int length)
             where T : unmanaged
         {
-            // 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.
+            // Like in the other memory manager, calculate the absolute offset and length
+            int
+                absoluteOffset = this.offset + RuntimeHelpers.ConvertLength<TTo, TFrom>(offset),
+                absoluteLength = RuntimeHelpers.ConvertLength<TTo, TFrom>(length);
+
+            // Skip one indirection level and slice the original memory manager, if possible
             if (typeof(T) == typeof(TFrom))
             {
-                return (Memory<T>)(object)this.memoryManager.Memory.Slice(offset, length);
+                return (Memory<T>)(object)this.memoryManager.Memory.Slice(absoluteOffset, absoluteLength);
             }
 
-            return new ProxyMemoryManager<TFrom, T>(this.memoryManager, this.offset + offset, length).Memory;
+            return new ProxyMemoryManager<TFrom, T>(this.memoryManager, absoluteOffset, absoluteLength).Memory;
         }
 
         /// <summary>

Microsoft.Toolkit.HighPerformance/Helpers/HashCode{T}.cs

@@ -9,6 +9,7 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Microsoft.Toolkit.HighPerformance.Helpers.Internals;
+using RuntimeHelpers = System.Runtime.CompilerServices.RuntimeHelpers;
 
 namespace Microsoft.Toolkit.HighPerformance.Helpers
 {

Microsoft.Toolkit.HighPerformance/Helpers/Internals/RuntimeHelpers.cs

@@ -0,0 +1,54 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// 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.Diagnostics.Contracts;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Toolkit.HighPerformance.Helpers.Internals
+{
+    /// <summary>
+    /// A helper class that with utility methods for dealing with references, and other low-level details.
+    /// </summary>
+    internal static class RuntimeHelpers
+    {
+        /// <summary>
+        /// Converts a length of items from one size to another. This method exposes the logic from
+        /// <see cref="MemoryMarshal.Cast{TFrom,TTo}(Span{TFrom})"/>, just for the length conversion.
+        /// </summary>
+        /// <typeparam name="TFrom">The source type of items.</typeparam>
+        /// <typeparam name="TTo">The target type of items.</typeparam>
+        /// <param name="length">The input length to convert.</param>
+        /// <returns>The converted length for the specified argument and types.</returns>
+        [Pure]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ConvertLength<TFrom, TTo>(int length)
+            where TFrom : unmanaged
+            where TTo : unmanaged
+        {
+            uint fromSize = (uint)Unsafe.SizeOf<TFrom>();
+            uint toSize = (uint)Unsafe.SizeOf<TTo>();
+            uint fromLength = (uint)length;
+            int toLength;
+
+            if (fromSize == toSize)
+            {
+                toLength = (int)fromLength;
+            }
+            else if (fromSize == 1)
+            {
+                toLength = (int)(fromLength / toSize);
+            }
+            else
+            {
+                ulong toLengthUInt64 = (ulong)fromLength * fromSize / toSize;
+
+                toLength = checked((int)toLengthUInt64);
+            }
+
+            return toLength;
+        }
+    }
+}