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

; 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

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...

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

those look like vector ops to me

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);
    }
}

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

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

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

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

are you saying the non-specialized version gets vectorized?

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:...

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

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...

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

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

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

math stuff like this you want optimized

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?

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

which you is this

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

you perks

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

forgor to reply

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

i was not saying that

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

i gave you a specialised version

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

yeah i'm using that one

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

JIT cannot detect SIMD patterns today

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

sadge

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

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

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

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

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

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

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

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

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

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

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

i'm scared. what did tanner invent this time

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

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

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

https://github.com/dotnet/Silk.NET/tree/feature/math-simd/src/Maths/Silk.NET.Maths/Simd

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

so much work whereas now we don't have to care about the individual ISA

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

oh yeah, basically exactly what net8 does

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

no wait, did we get crossplat in net7?

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

i'm too tired for code rn

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

net7

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

but yeah we were essentially writing our own Vector128Vector128 xplat helper until the real thing came along

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

"my" software rasterizer got quite a nice boost in net8, although it may be the avx512 doing... something, rather than JIT improvements

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

but that code is completely destroyed by inlining limits sadge

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

when aggressive isn't aggressive enough

Maxine•10/20/23, 11:05 PM

you can't do extension operators, can you

Maxine•10/20/23, 11:05 PM

shame

PPerksey when aggressive isn't aggressive enough

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

JIT literally gives up in the middle of my hot methods waaaaaaaaaahhhhhh

Maxine•10/20/23, 11:07 PM

incredibly disgusting

Maxine•10/20/23, 11:08 PM

i'll make it an instance method at least

khitiara•10/20/23, 11:16 PM

why do you need conversion and division to be together?

khitiara•10/20/23, 11:17 PM

like an as method should be good enough and then implement division using the same type

Kkhitiara why do you need conversion and division to be together?

Maxine•10/20/23, 11:33 PM

hm.

Maxine•10/20/23, 11:34 PM

my thought is Vector3 / floatVector3 / float is a very common pattern and useless with most integer values

Maxine•10/20/23, 11:35 PM

alright, yeeted

Maxine•10/20/23, 11:41 PM

design RFC: should static methods be provided

on Vector3<T> (when doing generics, it'd be Vector3<T>.Lerp<TFloat> for instance)
on static Vector3 (Vector3.Lerp<T, TFloat>, but for non-generic methods it wouldn't require specifying the <T>)
on both (pick whichever you want)
on static Vector3 only if the method is generic, otherwise on Vector3<T> (what i'm currently doing, but may be confusing to some)

Maxine•10/20/23, 11:42 PM

oh no, i've invoked tanner

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

i don't know what's happening

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

is this for silk

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

Similar Threads

Similar Threads

Similar Threads