c# - Caro para envolver System.Numerics.VectorX-¿por qué?

simd ryujit

Question

TL; DR : ¿Por qué está ajustando el tipo System.Numerics.Vectors caro, y hay algo que pueda hacer al respecto?

Considere la siguiente pieza de código:

[MethodImpl(MethodImplOptions.NoInlining)]
private static long GetIt(long a, long b)
{
    var x = AddThem(a, b);
    return x;
}

private static long AddThem(long a, long b)
{
    return a + b;
}

Esto JIT en (x64):

00007FFDA3F94500  lea         rax,[rcx+rdx]  
00007FFDA3F94504  ret  

y x86:

00EB2E20  push        ebp  
00EB2E21  mov         ebp,esp  
00EB2E23  mov         eax,dword ptr [ebp+10h]  
00EB2E26  mov         edx,dword ptr [ebp+14h]  
00EB2E29  add         eax,dword ptr [ebp+8]  
00EB2E2C  adc         edx,dword ptr [ebp+0Ch]  
00EB2E2F  pop         ebp  
00EB2E30  ret         10h  

Ahora, si envuelvo esto en una estructura, por ejemplo

public struct SomeWrapper
{
    public long X;
    public SomeWrapper(long X) { this.X = X; }
    public static SomeWrapper operator +(SomeWrapper a, SomeWrapper b)
    {
        return new SomeWrapper(a.X + b.X);
    }
}

y cambiar GetIt , por ejemplo

private static long GetIt(long a, long b)
{
    var x = AddThem(new SomeWrapper(a), new SomeWrapper(b)).X;
    return x;
}
private static SomeWrapper AddThem(SomeWrapper a, SomeWrapper b)
{
    return a + b;
}

El resultado de JITted sigue siendo exactamente el mismo que cuando se usan los tipos nativos directamente (el AddThem y el operador y constructor sobrecargados de SomeWrapper están todos en línea). Como se esperaba.

Ahora, si intento esto con los tipos habilitados para SIMD, por ejemplo, System.Numerics.Vector4 :

[MethodImpl(MethodImplOptions.NoInlining)]
private static Vector4 GetIt(Vector4 a, Vector4 b)
{
    var x = AddThem(a, b);
    return x;
}

se introduce en:

00007FFDA3F94640  vmovupd     xmm0,xmmword ptr [rdx]  
00007FFDA3F94645  vmovupd     xmm1,xmmword ptr [r8]  
00007FFDA3F9464A  vaddps      xmm0,xmm0,xmm1  
00007FFDA3F9464F  vmovupd     xmmword ptr [rcx],xmm0  
00007FFDA3F94654  ret  

Sin embargo, si Vector4 el Vector4 en una estructura (similar al primer ejemplo):

public struct SomeWrapper
{
    public Vector4 X;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public SomeWrapper(Vector4 X) { this.X = X; }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static SomeWrapper operator+(SomeWrapper a, SomeWrapper b)
    {
        return new SomeWrapper(a.X + b.X);
    }
}
[MethodImpl(MethodImplOptions.NoInlining)]
private static Vector4 GetIt(Vector4 a, Vector4 b)
{
    var x = AddThem(new SomeWrapper(a), new SomeWrapper(b)).X;
    return x;
}

Mi código ahora está JITted en mucho más:

00007FFDA3F84A02  sub         rsp,0B8h  
00007FFDA3F84A09  mov         rsi,rcx  
00007FFDA3F84A0C  lea         rdi,[rsp+10h]  
00007FFDA3F84A11  mov         ecx,1Ch  
00007FFDA3F84A16  xor         eax,eax  
00007FFDA3F84A18  rep stos    dword ptr [rdi]  
00007FFDA3F84A1A  mov         rcx,rsi  
00007FFDA3F84A1D  vmovupd     xmm0,xmmword ptr [rdx]  
00007FFDA3F84A22  vmovupd     xmmword ptr [rsp+60h],xmm0  
00007FFDA3F84A29  vmovupd     xmm0,xmmword ptr [rsp+60h]  
00007FFDA3F84A30  lea         rax,[rsp+90h]  
00007FFDA3F84A38  vmovupd     xmmword ptr [rax],xmm0  
00007FFDA3F84A3D  vmovupd     xmm0,xmmword ptr [r8]  
00007FFDA3F84A42  vmovupd     xmmword ptr [rsp+50h],xmm0  
00007FFDA3F84A49  vmovupd     xmm0,xmmword ptr [rsp+50h]  
00007FFDA3F84A50  lea         rax,[rsp+80h]  
00007FFDA3F84A58  vmovupd     xmmword ptr [rax],xmm0  
00007FFDA3F84A5D  vmovdqu     xmm0,xmmword ptr [rsp+90h]  
00007FFDA3F84A67  vmovdqu     xmmword ptr [rsp+40h],xmm0  
00007FFDA3F84A6E  vmovdqu     xmm0,xmmword ptr [rsp+80h]  
00007FFDA3F84A78  vmovdqu     xmmword ptr [rsp+30h],xmm0  
00007FFDA3F84A7F  vmovdqu     xmm0,xmmword ptr [rsp+40h]  
00007FFDA3F84A86  vmovdqu     xmmword ptr [rsp+20h],xmm0  
00007FFDA3F84A8D  vmovdqu     xmm0,xmmword ptr [rsp+30h]  
00007FFDA3F84A94  vmovdqu     xmmword ptr [rsp+10h],xmm0  
00007FFDA3F84A9B  vmovups     xmm0,xmmword ptr [rsp+20h]  
00007FFDA3F84AA2  vmovups     xmm1,xmmword ptr [rsp+10h]  
00007FFDA3F84AA9  vaddps      xmm0,xmm0,xmm1  
00007FFDA3F84AAE  lea         rax,[rsp]  
00007FFDA3F84AB2  vmovupd     xmmword ptr [rax],xmm0  
00007FFDA3F84AB7  vmovdqu     xmm0,xmmword ptr [rsp]  
00007FFDA3F84ABD  vmovdqu     xmmword ptr [rsp+70h],xmm0  
00007FFDA3F84AC4  vmovups     xmm0,xmmword ptr [rsp+70h]  
00007FFDA3F84ACB  vmovupd     xmmword ptr [rsp+0A0h],xmm0  
00007FFDA3F84AD5  vmovupd     xmm0,xmmword ptr [rsp+0A0h]  
00007FFDA3F84ADF  vmovupd     xmmword ptr [rcx],xmm0  
00007FFDA3F84AE4  add         rsp,0B8h  
00007FFDA3F84AEB  pop         rsi  
00007FFDA3F84AEC  pop         rdi  
00007FFDA3F84AED  ret  

Parece que el JIT ahora ha decidido por alguna razón que no puede usar solo los registros, y en su lugar usa variables temporales, pero no puedo entender por qué. Primero pensé que podría tratarse de un problema de alineación, pero luego no puedo entender por qué primero se cargan en xmm0 y luego se deciden por un viaje de ida y vuelta a la memoria.

¿Que esta pasando aqui? Y lo más importante, ¿puedo arreglarlo?

La razón por la que me gustaría envolver la estructura de esta manera es que tengo un montón de código heredado que utiliza una API cuya implementación se beneficiaría de la bondad de SIMD.

EDIT : Entonces, después de investigar un poco en la fuente principal , descubrí que en realidad no es nada especial acerca de las clases de System.Numerics. Solo tengo que agregar el atributo System.Numerics.JitIntrinsic a mis métodos. El JIT reemplazará mi implementación con la suya propia. JitIntrinsic es privado? No hay problema, solo copia y pégalo. La pregunta original aún permanece sin embargo (incluso si ahora tengo una solución).

Answer 1

El problema viene del hecho de que un Vector4 contiene 4 largos y DirectX Vector4 contiene 4 Flotadores. En cada caso, pasar los vectores solo para agregar X hace que el código sea mucho más complejo porque W, Y y Z tienen que ser copiados incluso si no se modifican. Los vectores se copian durante cada "nuevo SomeWrapper (v)" y fuera de la función una última vez para afectar el resultado a la variable.

Optimizar el código de la estructura es muy complicado. Con struct, ahorras tiempo de asignación de pila, pero debido a varias copias, el código se vuelve más largo.

Dos cosas pueden ayudarte:

1) No utilice envoltorios, pero los métodos de extensión evitan la copia en el envoltorio.

2) No asigne nuevos vectores a valores de retorno, pero use uno de ellos cuando sea posible (optimice el código pero no ayude a hacer que el tipo sea invariable, como otros tipos aritméticos, así que use con extrema precaución).

Muestra:

struct Vector
{
    public long X;
    public long Y;
}

static class VectorExtension
{ 
    public static void AddToMe(this Vector v, long x, long y)
    {
        v.X += x;
        v.Y += y;
    }

    public static void AddToMe(this Vector v, Vector v2)
    {
        v.X += v2.X;
        v.Y += v2.Y;
    }
}

Answer 2

Rendimiento deficiente al ajustar Numerics.Vector fue un problema del compilador y la solución se comprometió a dominar el 20 de enero de 2017:

https://github.com/dotnet/coreclr/issues/7508

No sé cómo funciona exactamente la propagación en este proyecto, pero parece que la solución será parte de la versión 2.0.0 .