```cs if (Vector128.IsHardwareAccelerated && typeof(T) == typeof(float)) { return Unsafe.BitCast

M

Maxine•10/20/23, 10:46 PM

is that a .net 8 method

M

Maxine•10/20/23, 10:47 PM

i like it

PPerksey ```cs if (Vector128.IsHardwareAccelerated && typeof(T) == typeof(float)) { r...

A

Aqua•10/20/23, 10:48 PM

again, just replacing instructions with other instructions
sure,

BitCast

BitCast

BitCast

BitCast may be fast, but you're introducing a comparison, a function call, etc.

M

Maxine•10/20/23, 10:48 PM

uh

M

Maxine•10/20/23, 10:48 PM

those should be inlined

M

Maxine•10/20/23, 10:48 PM

typeof(T) == typeof(Y) gets inlined

A

Aqua•10/20/23, 10:48 PM

hmmm yes fair point

M

Maxine•10/20/23, 10:48 PM

IsHardwareAcceleration gets eliminated

A

Aqua•10/20/23, 10:48 PM

i know that

M

Maxine•10/20/23, 10:49 PM

the most expensive thing here is the new Vector4

P

PerkseyOP•10/20/23, 10:49 PM

yeah all of that will be inlined and understood by the JIT

M

Maxine•10/20/23, 10:49 PM

and the SIMD itself

M

Maxine•10/20/23, 10:49 PM

for short and byte, the default equality should get optimized into a simple comparison, right?

A

Aqua•10/20/23, 10:49 PM

how does nativeaot handle this situation?

P

PerkseyOP•10/20/23, 10:49 PM

the same way the JIT does

P

PerkseyOP•10/20/23, 10:49 PM

because it is the JIT

P

PerkseyOP•10/20/23, 10:49 PM

just ahead of time

A

Aqua•10/20/23, 10:49 PM

i thought nativeaot had to do intrinsics checks at runtime?

A

Aqua•10/20/23, 10:50 PM

(the nativeaot question is more of a curiosity question)

A

Aqua•10/20/23, 10:51 PM

meh, regardless, i'm not so sure its faster than just doing a pure comparison but i am no simd expert nor do i know the intricasies of the jit/aot compiler/runtime particularly well

M

Maxine•10/20/23, 10:53 PM

v2

GenericVector.cs36.88KB

P

PerkseyOP•10/20/23, 10:53 PM

NativeAOT uses RyuJIT codegen, just has a different EE (mostly)

AAqua i thought nativeaot had to do intrinsics checks at runtime?

T

TechPizza•10/20/23, 10:54 PM

you compile it against a baseline

P

PerkseyOP•10/20/23, 10:54 PM

; Assembly listing for method NumTests:TestNum(System.Numerics.Vector4,System.Numerics.Vector4):bool (FullOpts)
; Emitting BLENDED_CODE for X64 with AVX - Windows
; FullOpts code
; optimized code
; rsp based frame
; partially interruptible
; No PGO data
; 0 inlinees with PGO data; 1 single block inlinees; 2 inlinees without PGO data

G_M000_IG01:                ;; offset=0x0000
       vzeroupper 
 
G_M000_IG02:                ;; offset=0x0003
       vmovups  xmm0, xmmword ptr [rcx]
       vmovups  xmm1, xmmword ptr [rdx]
       vcmpps   xmm2, xmm0, xmm1, 0
       vcmpps   xmm0, xmm0, xmm0, 0
       vcmpps   xmm1, xmm1, xmm1, 0
       vorps    xmm0, xmm0, xmm1
       vpcmpeqd xmm1, xmm1, xmm1
       vxorps   xmm0, xmm0, xmm1
       vorps    xmm0, xmm2, xmm0
       vpcmpeqd xmm0, xmm0, xmm1
       vpmovmskb eax, xmm0
       cmp      eax, 0xFFFF
       sete     al
       movzx    rax, al
 
G_M000_IG03:                ;; offset=0x003D
       ret      
 
; Total bytes of code 62

; Assembly listing for method NumTests:TestMan(Vector4`1[float],Vector4`1[float]):bool (FullOpts)
; Emitting BLENDED_CODE for X64 with AVX - Windows
; FullOpts code
; optimized code
; rsp based frame
; partially interruptible
; No PGO data
; 0 inlinees with PGO data; 1 single block inlinees; 2 inlinees without PGO data

G_M000_IG01:                ;; offset=0x0000
       vzeroupper 
 
G_M000_IG02:                ;; offset=0x0003
       vmovups  xmm0, xmmword ptr [rdx]
       vmovups  xmm1, xmmword ptr [rcx]
       vcmpps   xmm2, xmm1, xmm1, 0
       vcmpps   xmm3, xmm0, xmm0, 0
       vorps    xmm2, xmm2, xmm3
       vpcmpeqd xmm3, xmm3, xmm3
       vxorps   xmm2, xmm2, xmm3
       vcmpps   xmm0, xmm1, xmm0, 0
       vorps    xmm0, xmm0, xmm2
       vpcmpeqd xmm0, xmm0, xmm3
       vpmovmskb eax, xmm0
       cmp      eax, 0xFFFF
       sete     al
       movzx    rax, al
 
G_M000_IG03:                ;; offset=0x003D
       ret      
 
; Total bytes of code 62

; Assembly listing for method NumTests:TestNum(System.Numerics.Vector4,System.Numerics.Vector4):bool (FullOpts)
; Emitting BLENDED_CODE for X64 with AVX - Windows
; FullOpts code
; optimized code
; rsp based frame
; partially interruptible
; No PGO data
; 0 inlinees with PGO data; 1 single block inlinees; 2 inlinees without PGO data

G_M000_IG01:                ;; offset=0x0000
       vzeroupper 
 
G_M000_IG02:                ;; offset=0x0003
       vmovups  xmm0, xmmword ptr [rcx]
       vmovups  xmm1, xmmword ptr [rdx]
       vcmpps   xmm2, xmm0, xmm1, 0
       vcmpps   xmm0, xmm0, xmm0, 0
       vcmpps   xmm1, xmm1, xmm1, 0
       vorps    xmm0, xmm0, xmm1
       vpcmpeqd xmm1, xmm1, xmm1
       vxorps   xmm0, xmm0, xmm1
       vorps    xmm0, xmm2, xmm0
       vpcmpeqd xmm0, xmm0, xmm1
       vpmovmskb eax, xmm0
       cmp      eax, 0xFFFF
       sete     al
       movzx    rax, al
 
G_M000_IG03:                ;; offset=0x003D
       ret      
 
; Total bytes of code 62

; Assembly listing for method NumTests:TestMan(Vector4`1[float],Vector4`1[float]):bool (FullOpts)
; Emitting BLENDED_CODE for X64 with AVX - Windows
; FullOpts code
; optimized code
; rsp based frame
; partially interruptible
; No PGO data
; 0 inlinees with PGO data; 1 single block inlinees; 2 inlinees without PGO data

G_M000_IG01:                ;; offset=0x0000
       vzeroupper 
 
G_M000_IG02:                ;; offset=0x0003
       vmovups  xmm0, xmmword ptr [rdx]
       vmovups  xmm1, xmmword ptr [rcx]
       vcmpps   xmm2, xmm1, xmm1, 0
       vcmpps   xmm3, xmm0, xmm0, 0
       vorps    xmm2, xmm2, xmm3
       vpcmpeqd xmm3, xmm3, xmm3
       vxorps   xmm2, xmm2, xmm3
       vcmpps   xmm0, xmm1, xmm0, 0
       vorps    xmm0, xmm0, xmm2
       vpcmpeqd xmm0, xmm0, xmm3
       vpmovmskb eax, xmm0
       cmp      eax, 0xFFFF
       sete     al
       movzx    rax, al
 
G_M000_IG03:                ;; offset=0x003D
       ret      
 
; Total bytes of code 62

; Assembly listing for method NumTests:TestNum(System.Numerics.Vector4,System.Numerics.Vector4):bool (FullOpts)
; Emitting BLENDED_CODE for X64 with AVX - Windows
; FullOpts code
; optimized code
; rsp based frame
; partially interruptible
; No PGO data
; 0 inlinees with PGO data; 1 single block inlinees; 2 inlinees without PGO data

G_M000_IG01:                ;; offset=0x0000
       vzeroupper 
 
G_M000_IG02:                ;; offset=0x0003
       vmovups  xmm0, xmmword ptr [rcx]
       vmovups  xmm1, xmmword ptr [rdx]
       vcmpps   xmm2, xmm0, xmm1, 0
       vcmpps   xmm0, xmm0, xmm0, 0
       vcmpps   xmm1, xmm1, xmm1, 0
       vorps    xmm0, xmm0, xmm1
       vpcmpeqd xmm1, xmm1, xmm1
       vxorps   xmm0, xmm0, xmm1
       vorps    xmm0, xmm2, xmm0
       vpcmpeqd xmm0, xmm0, xmm1
       vpmovmskb eax, xmm0
       cmp      eax, 0xFFFF
       sete     al
       movzx    rax, al
 
G_M000_IG03:                ;; offset=0x003D
       ret      
 
; Total bytes of code 62

; Assembly listing for method NumTests:TestMan(Vector4`1[float],Vector4`1[float]):bool (FullOpts)
; Emitting BLENDED_CODE for X64 with AVX - Windows
; FullOpts code
; optimized code
; rsp based frame
; partially interruptible
; No PGO data
; 0 inlinees with PGO data; 1 single block inlinees; 2 inlinees without PGO data

G_M000_IG01:                ;; offset=0x0000
       vzeroupper 
 
G_M000_IG02:                ;; offset=0x0003
       vmovups  xmm0, xmmword ptr [rdx]
       vmovups  xmm1, xmmword ptr [rcx]
       vcmpps   xmm2, xmm1, xmm1, 0
       vcmpps   xmm3, xmm0, xmm0, 0
       vorps    xmm2, xmm2, xmm3
       vpcmpeqd xmm3, xmm3, xmm3
       vxorps   xmm2, xmm2, xmm3
       vcmpps   xmm0, xmm1, xmm0, 0
       vorps    xmm0, xmm0, xmm2
       vpcmpeqd xmm0, xmm0, xmm3
       vpmovmskb eax, xmm0
       cmp      eax, 0xFFFF
       sete     al
       movzx    rax, al
 
G_M000_IG03:                ;; offset=0x003D
       ret      
 
; Total bytes of code 62

; Assembly listing for method NumTests:TestNum(System.Numerics.Vector4,System.Numerics.Vector4):bool (FullOpts)
; Emitting BLENDED_CODE for X64 with AVX - Windows
; FullOpts code
; optimized code
; rsp based frame
; partially interruptible
; No PGO data
; 0 inlinees with PGO data; 1 single block inlinees; 2 inlinees without PGO data

G_M000_IG01:                ;; offset=0x0000
       vzeroupper 
 
G_M000_IG02:                ;; offset=0x0003
       vmovups  xmm0, xmmword ptr [rcx]
       vmovups  xmm1, xmmword ptr [rdx]
       vcmpps   xmm2, xmm0, xmm1, 0
       vcmpps   xmm0, xmm0, xmm0, 0
       vcmpps   xmm1, xmm1, xmm1, 0
       vorps    xmm0, xmm0, xmm1
       vpcmpeqd xmm1, xmm1, xmm1
       vxorps   xmm0, xmm0, xmm1
       vorps    xmm0, xmm2, xmm0
       vpcmpeqd xmm0, xmm0, xmm1
       vpmovmskb eax, xmm0
       cmp      eax, 0xFFFF
       sete     al
       movzx    rax, al
 
G_M000_IG03:                ;; offset=0x003D
       ret      
 
; Total bytes of code 62

; Assembly listing for method NumTests:TestMan(Vector4`1[float],Vector4`1[float]):bool (FullOpts)
; Emitting BLENDED_CODE for X64 with AVX - Windows
; FullOpts code
; optimized code
; rsp based frame
; partially interruptible
; No PGO data
; 0 inlinees with PGO data; 1 single block inlinees; 2 inlinees without PGO data

G_M000_IG01:                ;; offset=0x0000
       vzeroupper 
 
G_M000_IG02:                ;; offset=0x0003
       vmovups  xmm0, xmmword ptr [rdx]
       vmovups  xmm1, xmmword ptr [rcx]
       vcmpps   xmm2, xmm1, xmm1, 0
       vcmpps   xmm3, xmm0, xmm0, 0
       vorps    xmm2, xmm2, xmm3
       vpcmpeqd xmm3, xmm3, xmm3
       vxorps   xmm2, xmm2, xmm3
       vcmpps   xmm0, xmm1, xmm0, 0
       vorps    xmm0, xmm0, xmm2
       vpcmpeqd xmm0, xmm0, xmm3
       vpmovmskb eax, xmm0
       cmp      eax, 0xFFFF
       sete     al
       movzx    rax, al
 
G_M000_IG03:                ;; offset=0x003D
       ret      
 
; Total bytes of code 62

T

TechPizza•10/20/23, 10:54 PM

Vector128/Vector256.Equals for floats and double is special-cased so it's slower btw

PPerksey ``` ; Assembly listing for method NumTests:TestNum(System.Numerics.Vector4,Syste...

M

Maxine•10/20/23, 10:54 PM

those look like vector ops to me

P

PerkseyOP•10/20/23, 10:55 PM

public struct Vector4<T> where T: IEquatable<T>
{
    T x;
    T y;
    T z;
    T w;
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public bool Equals(Vector4<T> other)
    {
        if (Vector128.IsHardwareAccelerated && typeof(T) == typeof(float))
        {
            return Unsafe.BitCast<Vector4<T>, Vector4>(this).AsVector128().Equals(Unsafe.BitCast<Vector4<T>, Vector4>(other).AsVector128());
        }
        return other.x.Equals(x) && other.y.Equals(y) && other.z.Equals(z) && other.w.Equals(w);
    }
}
public static class NumTests
{
   static bool TestNum(Vector4 l, Vector4 r)
    {
        return l.Equals(r);
    }

    static bool TestMan(Vector4<float> l, Vector4<float> r)
    {
        return l.Equals(r);
    }
}

public struct Vector4<T> where T: IEquatable<T>
{
    T x;
    T y;
    T z;
    T w;
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public bool Equals(Vector4<T> other)
    {
        if (Vector128.IsHardwareAccelerated && typeof(T) == typeof(float))
        {
            return Unsafe.BitCast<Vector4<T>, Vector4>(this).AsVector128().Equals(Unsafe.BitCast<Vector4<T>, Vector4>(other).AsVector128());
        }
        return other.x.Equals(x) && other.y.Equals(y) && other.z.Equals(z) && other.w.Equals(w);
    }
}
public static class NumTests
{
   static bool TestNum(Vector4 l, Vector4 r)
    {
        return l.Equals(r);
    }

    static bool TestMan(Vector4<float> l, Vector4<float> r)
    {
        return l.Equals(r);
    }
}

public struct Vector4<T> where T: IEquatable<T>
{
    T x;
    T y;
    T z;
    T w;
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public bool Equals(Vector4<T> other)
    {
        if (Vector128.IsHardwareAccelerated && typeof(T) == typeof(float))
        {
            return Unsafe.BitCast<Vector4<T>, Vector4>(this).AsVector128().Equals(Unsafe.BitCast<Vector4<T>, Vector4>(other).AsVector128());
        }
        return other.x.Equals(x) && other.y.Equals(y) && other.z.Equals(z) && other.w.Equals(w);
    }
}
public static class NumTests
{
   static bool TestNum(Vector4 l, Vector4 r)
    {
        return l.Equals(r);
    }

    static bool TestMan(Vector4<float> l, Vector4<float> r)
    {
        return l.Equals(r);
    }
}

public struct Vector4<T> where T: IEquatable<T>
{
    T x;
    T y;
    T z;
    T w;
    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
    public bool Equals(Vector4<T> other)
    {
        if (Vector128.IsHardwareAccelerated && typeof(T) == typeof(float))
        {
            return Unsafe.BitCast<Vector4<T>, Vector4>(this).AsVector128().Equals(Unsafe.BitCast<Vector4<T>, Vector4>(other).AsVector128());
        }
        return other.x.Equals(x) && other.y.Equals(y) && other.z.Equals(z) && other.w.Equals(w);
    }
}
public static class NumTests
{
   static bool TestNum(Vector4 l, Vector4 r)
    {
        return l.Equals(r);
    }

    static bool TestMan(Vector4<float> l, Vector4<float> r)
    {
        return l.Equals(r);
    }
}

AAqua meh, regardless, i'm not so sure its faster than just doing a pure comparison bu...

T

TechPizza•10/20/23, 10:55 PM

tldr: just look at the disasm and try to get the amount of instructions down catnod

M

Maxine•10/20/23, 10:55 PM

are you saying the non-specialized version gets vectorized?

M

Maxine•10/20/23, 10:56 PM

that makes things easier

TTechPizza tldr: just look at the disasm and try to get the amount of instructions down <a:...

A

Aqua•10/20/23, 10:56 PM

i stopped hyperoptimizing a long time ago, it just isn't worth the effort 90% of the time
if it works and its not stupid slow then its good

T

TechPizza•10/20/23, 10:56 PM

it does not get vectorized per say. modern software doesn't use x87

AAqua i stopped hyperoptimizing a long time ago, it just isn't worth the effort 90% of...

M

Maxine•10/20/23, 10:56 PM

i don't optimize anything unless it's for shit like this

L

Lyris the Kitori•10/20/23, 10:57 PM

math stuff like this you want optimized

M

Maxine•10/20/23, 10:57 PM

where like yeah, you want this to have as little overhead as regular Vector3

MMaxine are you saying the non-specialized version gets vectorized?

P

PerkseyOP•10/20/23, 10:57 PM

which you is this

M

Maxine•10/20/23, 10:57 PM

you perks

M

Maxine•10/20/23, 10:57 PM

forgor to reply

P

PerkseyOP•10/20/23, 10:57 PM

i was not saying that

P

PerkseyOP•10/20/23, 10:57 PM

i gave you a specialised version

M

Maxine•10/20/23, 10:57 PM

yeah i'm using that one

P

PerkseyOP•10/20/23, 10:57 PM

JIT cannot detect SIMD patterns today

M

Maxine•10/20/23, 10:58 PM

sadge

M

Maxine•10/20/23, 10:58 PM

then again neither can LLVM half the time

MMaxine i don't optimize anything unless it's for shit like this

A

Aqua•10/20/23, 10:58 PM

yeah i get it, for math you want things as fast as you can

A

Aqua•10/20/23, 10:58 PM

write the math library in C and call into it with p/invoke when

P

PerkseyOP•10/20/23, 10:59 PM

i must say though with the xplat helpers SIMD is so much easier

P

PerkseyOP•10/20/23, 10:59 PM

like have any of you seen the

feature/math-simd

feature/math-simd

feature/math-simd

feature/math-simd branch

PPerksey like have any of you seen the `feature/math-simd` branch

T

TechPizza•10/20/23, 11:00 PM

i'm scared. what did tanner invent this time

P

PerkseyOP•10/20/23, 11:00 PM

nono this was the WIP work to vectorize silk.net.maths

```cs if (Vector128.IsHardwareAccelerated && typeof(T) == typeof(float)) { return Unsafe.BitCast

Similar Threads