perf: soft revert of the performance regressions introduced in #1469 (#2885)

Author: Eideren

sources/core/Stride.Core.Serialization/Serialization/LZ4/LZ4Stream.cs

@@ -380,7 +380,7 @@ public override unsafe int Read(byte[] buffer, int offset, int count)
                     fixed (byte* pDst = buffer)
                     {
                         Debug.Assert(pSrc is not null);
-                        Unsafe.CopyBlockUnaligned(pDst + offset, pSrc + bufferOffset, (uint)chunk);
+                        Utilities.CopyWithAlignmentFallback(pDst + offset, pSrc + bufferOffset, (uint)chunk);
                     }
                 }
 
@@ -511,7 +511,7 @@ public override unsafe void Write(byte[] buffer, int offset, int count)
                     fixed (byte* pDst = dataBuffer)
                     {
                         Debug.Assert(pDst is not null);
-                        Unsafe.CopyBlockUnaligned(pDst + bufferOffset, pSrc + offset, (uint)chunk);
+                        Utilities.CopyWithAlignmentFallback(pDst + bufferOffset, pSrc + offset, (uint)chunk);
                     }
                 }
 

sources/core/Stride.Core.Serialization/Storage/Blob.cs

@@ -24,7 +24,7 @@ internal unsafe Blob(ObjectDatabase objectDatabase, ObjectId objectId, IntPtr co
         Debug.Assert(size >= 0);
         this.Size = size;
         this.Content = Marshal.AllocHGlobal(size);
-        Unsafe.CopyBlockUnaligned((void*)this.Content, (void*)content, (uint)size);
+        Utilities.CopyWithAlignmentFallback((void*)this.Content, (void*)content, (uint)size);
     }
 
     internal unsafe Blob(ObjectDatabase objectDatabase, ObjectId objectId, Stream stream)

sources/core/Stride.Core.Serialization/Streaming/ContentChunk.cs

@@ -104,7 +104,7 @@ public unsafe IntPtr GetData(DatabaseFileProvider fileProvider)
                     var read = (uint)stream.Read(buffer, 0, (int)Math.Min(count, bufferCapacity));
                     if (read <= 0)
                         break;
-                    Unsafe.CopyBlockUnaligned(chunkBytesPtr, bufferStart, read);
+                    Utilities.CopyWithAlignmentFallback(chunkBytesPtr, bufferStart, read);
                     chunkBytesPtr += read;
                     count -= read;
                 } while (count > 0);

sources/core/Stride.Core/UnmanagedArray.cs

@@ -8,15 +8,13 @@ namespace Stride.Core;
 [Obsolete("Obtain Memory<T> using GC.Allocate*Array or a Stride-specific allocator mechanism.")]
 public class UnmanagedArray<T> : IDisposable where T : struct
 {
-    private readonly int sizeOfT;
     private readonly bool isShared;
 
     [Obsolete("Obtain Memory<T> using GC.Allocate*Array or a Stride-specific allocator mechanism.")]
     public UnmanagedArray(int length)
     {
         Length = length;
-        sizeOfT = Unsafe.SizeOf<T>();
-        var finalSize = length * sizeOfT;
+        var finalSize = length * Unsafe.SizeOf<T>();
         Pointer = Utilities.AllocateMemory(finalSize);
         isShared = false;
     }
@@ -43,8 +41,10 @@ public T this[int index]
             unsafe
             {
                 var bptr = (byte*)Pointer;
-                bptr += index * sizeOfT;
-                res = Unsafe.ReadUnaligned<T>(bptr);
+                bptr += index * Unsafe.SizeOf<T>();
+                // Pointer is aligned, we expect the struct to be aligned as well;
+                // If the user decides to Pack=1, this scope is the least of their worries
+                res = Unsafe.Read<T>(bptr);
             }
 
             return res;
@@ -60,8 +60,10 @@ public T this[int index]
             unsafe
             {
                 var bptr = (byte*)Pointer;
-                bptr += index * sizeOfT;
-                Unsafe.WriteUnaligned(bptr, value);
+                bptr += index * Unsafe.SizeOf<T>();
+                // Pointer is aligned, we expect the struct to be aligned as well;
+                // If the user decides to Pack=1, this scope is the least of their worries
+                Unsafe.Write(bptr, value);
             }
         }
     }
@@ -72,7 +74,6 @@ public unsafe void Read(T[] destination, int offset = 0)
         {
             throw new ArgumentOutOfRangeException(nameof(offset));
         }
-        // Interop.Read((void*)Pointer, destination, offset, destination.Length);
         new Span<T>((void*)Pointer, destination.Length - offset).CopyTo(destination.AsSpan(offset));
     }
 
@@ -87,8 +88,7 @@ public void Read(T[] destination, int pointerByteOffset, int arrayOffset, int ar
         {
             var ptr = (byte*)Pointer;
             ptr += pointerByteOffset;
-            // Interop.Read(ptr, destination, arrayOffset, arrayLen);
-            new Span<T>(ptr, sizeOfT * arrayLen)
+            new Span<T>(ptr, Unsafe.SizeOf<T>() * arrayLen)
                 .CopyTo(destination.AsSpan(arrayOffset, arrayLen));
         }
     }
@@ -99,7 +99,6 @@ public unsafe void Write(T[] source, int offset = 0)
         {
             throw new ArgumentOutOfRangeException();
         }
-        // Interop.Write((void*)Pointer, source, offset, source.Length);
         source.AsSpan(offset).CopyTo(new Span<T>((void*)Pointer, source.Length - offset));
     }
 
@@ -112,7 +111,6 @@ public unsafe void Write(T[] source, int pointerByteOffset, int arrayOffset, int
 
         var ptr = (byte*)Pointer;
         ptr += pointerByteOffset;
-        // Interop.Write(ptr, source, arrayOffset, arrayLen);
         source.AsSpan(arrayOffset, arrayLen).CopyTo(new Span<T>(ptr, arrayLen));
     }
 

sources/core/Stride.Core/Utilities.cs

@@ -34,6 +34,50 @@ namespace Stride.Core;
 /// </summary>
 public static class Utilities
 {
+    // MUST BE A METHOD AND AGGRESSIVELY INLINED, OTHERWISE THE JIT WILL NOT ELIMINATE THE BRANCH
+    [MethodImpl(MethodImplOptions.AggressiveInlining)] 
+    private static bool IsUnalignedSafe() =>
+        RuntimeInformation.ProcessArchitecture is Architecture.X64 or Architecture.X86 or Architecture.Arm64;
+
+    /// <inheritdoc cref="AlignmentFallbackDoc"/>
+    /// <inheritdoc cref="Unsafe.CopyBlock(ref byte, ref readonly byte, uint)"/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static unsafe void CopyWithAlignmentFallback(ref byte destination, ref readonly byte source, uint byteCount)
+    {
+        if (IsUnalignedSafe())
+            fixed (void* src = &source, dst = &destination)
+                Buffer.MemoryCopy(src, dst, byteCount, byteCount);
+        else
+            Unsafe.CopyBlockUnaligned(ref destination, in source, byteCount);
+    }
+
+    /// <inheritdoc cref="AlignmentFallbackDoc"/>
+    /// <inheritdoc cref="Unsafe.CopyBlock(ref byte, ref readonly byte, uint)"/>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static unsafe void CopyWithAlignmentFallback(void* destination, void* source, uint byteCount)
+    {
+        if (IsUnalignedSafe())
+            Buffer.MemoryCopy(source, destination, byteCount, byteCount);
+        else
+            Unsafe.CopyBlockUnaligned(destination, source, byteCount);
+    }
+
+    /// <summary>
+    /// Zero out memory at the address provided
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static unsafe void Clear(void* startAddress, uint byteCount)
+    {
+        // Span swaps between InitBlockUnaligned and _ZeroMemory depending on the size
+        new Span<byte>(startAddress, (int)byteCount).Clear();
+    }
+
+    /// <remarks>
+    /// Some of the architecture dotnet runs on do not support arbitrary unaligned reads or writes,
+    /// use this instead of other memcopy if you aren't sure whether the pointers you passed in are aligned.
+    /// </remarks>
+    static void AlignmentFallbackDoc() { }
+
     /// <summary>
     /// Allocate an aligned memory buffer.
     /// </summary>

sources/engine/Stride.Engine/Animations/AnimationBlender.cs

@@ -179,15 +179,15 @@ public static unsafe void Blend(CoreAnimationOperation blendOperation, float ble
                     if (factorLeft > 0.0f && factorRight == 0.0f)
                     {
                         *resultData++ = 1.0f;
-                        Unsafe.CopyBlockUnaligned(resultData, sourceLeftData, (uint)channel.Size);
+                        Utilities.CopyWithAlignmentFallback(resultData, sourceLeftData, (uint)channel.Size);
                         continue;
                     }
 
                     // Use right value
                     if (factorRight > 0.0f && factorLeft == 0.0f)
                     {
                         *resultData++ = 1.0f;
-                        Unsafe.CopyBlockUnaligned(resultData, sourceRightData, (uint)channel.Size);
+                        Utilities.CopyWithAlignmentFallback(resultData, sourceRightData, (uint)channel.Size);
                         continue;
                     }
 
@@ -202,7 +202,7 @@ public static unsafe void Blend(CoreAnimationOperation blendOperation, float ble
                             switch (channel.BlendType)
                             {
                                 case BlendType.Blit:
-                                    Unsafe.CopyBlockUnaligned(
+                                    Utilities.CopyWithAlignmentFallback(
                                         resultData,
                                         blendFactor < 0.5f ? sourceLeftData : sourceRightData,
                                         (uint)channel.Size);
@@ -229,7 +229,7 @@ public static unsafe void Blend(CoreAnimationOperation blendOperation, float ble
                             switch (channel.BlendType)
                             {
                                 case BlendType.Blit:
-                                    Unsafe.CopyBlockUnaligned(resultData, sourceLeftData, (uint)channel.Size);
+                                    Utilities.CopyWithAlignmentFallback(resultData, sourceLeftData, (uint)channel.Size);
                                     break;
                                 case BlendType.Float2:
                                     Vector2 rightValue2;
@@ -257,7 +257,7 @@ public static unsafe void Blend(CoreAnimationOperation blendOperation, float ble
                             switch (channel.BlendType)
                             {
                                 case BlendType.Blit:
-                                    Unsafe.CopyBlockUnaligned(resultData, sourceLeftData, (uint)channel.Size);
+                                    Utilities.CopyWithAlignmentFallback(resultData, sourceLeftData, (uint)channel.Size);
                                     break;
                                 case BlendType.Float2:
                                     Vector2 rightValue2;

sources/engine/Stride.Engine/Animations/AnimationClipEvaluator.cs

@@ -114,7 +114,7 @@ public unsafe void AddCurveValues(CompressedTimeSpan newTime, AnimationClipResul
                     var channel = Channels.Items[index];
 
                     // For now, objects are not supported, so treat everything as a blittable struct.
-                    channel.Curve?.AddValue(newTime, (IntPtr)(structures + channel.Offset + sizeof(float)));
+                    channel.Curve?.AddValue(newTime, (structures + channel.Offset + sizeof(float)));
                 }
             }
         }

sources/engine/Stride.Engine/Animations/AnimationCurve.cs

@@ -50,7 +50,7 @@ public abstract class AnimationCurve
         /// </summary>
         /// <param name="newTime">The new time.</param>
         /// <param name="location">The location.</param>
-        public abstract void AddValue(CompressedTimeSpan newTime, IntPtr location);
+        public abstract unsafe void AddValue(CompressedTimeSpan newTime, byte* location);
 
         /// <summary>
         /// Meant for internal use, to call AnimationData{T}.FromAnimationChannels() without knowing the generic type.
@@ -142,9 +142,9 @@ public int FindKeyIndex(CompressedTimeSpan time)
         }
 
         /// <inheritdoc/>
-        public override unsafe void AddValue(CompressedTimeSpan newTime, nint location)
+        public override unsafe void AddValue(CompressedTimeSpan newTime, byte* location)
         {
-            var value = Unsafe.ReadUnaligned<T>((void*)location);
+            var value = Unsafe.ReadUnaligned<T>(location);
             KeyFrames.Add(new(newTime, value));
         }
 

sources/engine/Stride.Engine/Updater/UpdatableField.cs

@@ -73,7 +73,7 @@ ldarg data
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public unsafe void SetBlittable(IntPtr obj, IntPtr data)
         {
-            Unsafe.CopyBlockUnaligned((void*)obj, (void*)data, (uint)Size);
+            Utilities.CopyWithAlignmentFallback((void*)obj, (void*)data, (uint)Size);
         }
 
         /// <summary>

sources/engine/Stride.Graphics/Buffer.cs

@@ -326,7 +326,7 @@ public unsafe void GetData<T>(CommandList commandList, Buffer stagingTexture, Sp
             // Map the staging resource to a CPU accessible memory
             var mappedResource = commandList.MapSubresource(stagingTexture, 0, MapMode.Read);
             fixed (void* pointer = toData)
-                Unsafe.CopyBlockUnaligned(pointer, (void*)mappedResource.DataBox.DataPointer, (uint)toDataInBytes);
+                Utilities.CopyWithAlignmentFallback(pointer, (void*)mappedResource.DataBox.DataPointer, (uint)toDataInBytes);
             // Make sure that we unmap the resource in case of an exception
             commandList.UnmapSubresource(mappedResource);
         }
@@ -386,7 +386,7 @@ public unsafe void SetData<T>(CommandList commandList, ReadOnlySpan<T> fromData,
                         throw new ArgumentException("offset is only supported for textured declared with ResourceUsage.Default", "offsetInBytes");
 
                     var mappedResource = commandList.MapSubresource(this, 0, Usage == GraphicsResourceUsage.Staging ? MapMode.Write : MapMode.WriteDiscard);
-                    Unsafe.CopyBlockUnaligned((void*)mappedResource.DataBox.DataPointer, pointer, (uint)sizeInBytes);
+                    Utilities.CopyWithAlignmentFallback((void*)mappedResource.DataBox.DataPointer, pointer, (uint)sizeInBytes);
                     commandList.UnmapSubresource(mappedResource);
                 }
             }