Mientras comparaba algunos tipos de vectores personalizados, descubrí que, para mi sorpresa, mi tipo Vector2 es mucho más lento para muchas operaciones básicas cuando se lee desde una matriz que mi tipo Vector4 (y Vector3), a pesar de que el código en sí tiene menos operaciones, campos y variables Aquí hay un ejemplo muy simplificado que demuestra esto:

 using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using BenchmarkDotNet.Attributes; using BenchmarkDotNet.Running; namespace VectorTest { [StructLayout(LayoutKind.Sequential, Pack = 4)] public struct TestStruct4 { public float X, Y, Z, W; [MethodImpl(MethodImplOptions.AggressiveInlining)] public TestStruct4(float x, float y, float z, float w) { X = x; Y = y; Z = z; W = w; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static TestStruct4 operator +(in TestStruct4 a, in TestStruct4 b) { return new TestStruct4( aX + bX, aY + bY, aZ + bZ, aW + bW); } } [StructLayout(LayoutKind.Sequential, Pack = 4)] public struct TestStruct2 { public float X, Y; [MethodImpl(MethodImplOptions.AggressiveInlining)] public TestStruct2(float x, float y) { X = x; Y = y; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static TestStruct2 operator +(in TestStruct2 a, in TestStruct2 b) { return new TestStruct2( aX + bX, aY + bY); } } public class Program { private const int COUNT = 10000; private static readonly TestStruct4[] s_arr4 = new TestStruct4[COUNT]; private static readonly TestStruct2[] s_arr2 = new TestStruct2[COUNT]; static unsafe void Main() { for(int i = 0; i < s_arr4.Length; i++) s_arr4[i] = new TestStruct4(i, i * 2, i * 3, i * 4); for(int i = 0; i < s_arr2.Length; i++) s_arr2[i] = new TestStruct2(i, i * 2); BenchmarkRunner.Run<Program>(); } [Benchmark] public TestStruct4 BenchmarkTestStruct4() { TestStruct4 ret = default; for (int i = 0; i < COUNT; i++) ret += s_arr4[i]; return ret; } [Benchmark] public TestStruct2 BenchmarkTestStruct2() { TestStruct2 ret = default; for (int i = 0; i < COUNT; i++) ret += s_arr2[i]; return ret; } } }

La ejecución de este punto de referencia da como resultado:

Como puede ver, TestStruct2 es más del doble de lento que TestStruct4 (al menos en mi computadora). Dado que TestStruct2 es esencialmente idéntico a TestStruct4 excepto que tiene menos campos y tiene que hacer menos adiciones, hubiera esperado que, en el peor de los casos, tuviera la misma velocidad que TestStruct4, pero en realidad es más lento. ¿Alguien puede explicar por qué es esto?

La experimentación adicional ha revelado que, si agrego otro flotador o dos de relleno a MyStruct2 (y uso Unsafe.SkipInit para evitar el costo de inicializarlos), entonces el rendimiento mejora para igualar el de MyStruct4. Entonces, supongo que hay algún tipo de problema de alineación con MyStruct2, pero no entiendo qué podría ser específicamente. Pegar el código en SharpLab no revela ninguna diferencia obvia obvia en el ASM (aunque es posible que no entienda el ASM lo suficientemente bien como para detectar algo).

EDITAR: Esto se ejecuta en .NET 5 en Windows 10 de 64 bits.

(Nota: NO estoy interesado en tener una discusión sobre si es prudente escribir los propios tipos de vectores cuando ya hay muchos tipos existentes. Tengo mis razones para hacerlo y están fuera del tema de esta pregunta, que Pregunto por curiosidad académica para entender por qué hay una diferencia de rendimiento tan grande).

EDITAR: según lo solicitado, aquí están los diseños de bytes de las dos estructuras:

 Type layout for 'TestStruct4' Size: 16 bytes. Paddings: 0 bytes (%0 of empty space) |===========================| | 0-3: Single X (4 bytes) | |---------------------------| | 4-7: Single Y (4 bytes) | |---------------------------| | 8-11: Single Z (4 bytes) | |---------------------------| | 12-15: Single W (4 bytes) | |===========================| Type layout for 'TestStruct2' Size: 8 bytes. Paddings: 0 bytes (%0 of empty space) |===========================| | 0-3: Single X (4 bytes) | |---------------------------| | 4-7: Single Y (4 bytes) | |===========================|