``` C.Test(System.Numerics.Vector2, System.Numerics.Vector2) L0000: vzeroupper L0003: vmovsd

C.Test(System.Numerics.Vector2, System.Numerics.Vector2)
    L0000: vzeroupper
    L0003: vmovsd xmm0, [esp+0xc]
    L0009: vmovsd xmm1, [esp+4]
    L000f: vaddps xmm0, xmm0, xmm1
    L0013: vmovsd [edx], xmm0
    L0017: ret 0x10

C.Test(Vec2, Vec2)
    L0000: vzeroupper
    L0003: vmovss xmm0, [esp+0xc]
    L0009: vmovss xmm1, [esp+0x10]
    L000f: vmovss xmm2, [esp+4]
    L0015: vmovss xmm3, [esp+8]
    L001b: vaddss xmm0, xmm0, xmm2
    L001f: vaddss xmm1, xmm1, xmm3
    L0023: vmovss [edx], xmm0
    L0027: vmovss [edx+4], xmm1
    L002c: ret 0x10

C.Test(System.Numerics.Vector2, System.Numerics.Vector2)
    L0000: vzeroupper
    L0003: vmovsd xmm0, [esp+0xc]
    L0009: vmovsd xmm1, [esp+4]
    L000f: vaddps xmm0, xmm0, xmm1
    L0013: vmovsd [edx], xmm0
    L0017: ret 0x10

C.Test(Vec2, Vec2)
    L0000: vzeroupper
    L0003: vmovss xmm0, [esp+0xc]
    L0009: vmovss xmm1, [esp+0x10]
    L000f: vmovss xmm2, [esp+4]
    L0015: vmovss xmm3, [esp+8]
    L001b: vaddss xmm0, xmm0, xmm2
    L001f: vaddss xmm1, xmm1, xmm3
    L0023: vmovss [edx], xmm0
    L0027: vmovss [edx+4], xmm1
    L002c: ret 0x10

C.Test(System.Numerics.Vector2, System.Numerics.Vector2)
    L0000: vzeroupper
    L0003: vmovsd xmm0, [esp+0xc]
    L0009: vmovsd xmm1, [esp+4]
    L000f: vaddps xmm0, xmm0, xmm1
    L0013: vmovsd [edx], xmm0
    L0017: ret 0x10

C.Test(Vec2, Vec2)
    L0000: vzeroupper
    L0003: vmovss xmm0, [esp+0xc]
    L0009: vmovss xmm1, [esp+0x10]
    L000f: vmovss xmm2, [esp+4]
    L0015: vmovss xmm3, [esp+8]
    L001b: vaddss xmm0, xmm0, xmm2
    L001f: vaddss xmm1, xmm1, xmm3
    L0023: vmovss [edx], xmm0
    L0027: vmovss [edx+4], xmm1
    L002c: ret 0x10

C.Test(System.Numerics.Vector2, System.Numerics.Vector2)
    L0000: vzeroupper
    L0003: vmovsd xmm0, [esp+0xc]
    L0009: vmovsd xmm1, [esp+4]
    L000f: vaddps xmm0, xmm0, xmm1
    L0013: vmovsd [edx], xmm0
    L0017: ret 0x10

C.Test(Vec2, Vec2)
    L0000: vzeroupper
    L0003: vmovss xmm0, [esp+0xc]
    L0009: vmovss xmm1, [esp+0x10]
    L000f: vmovss xmm2, [esp+4]
    L0015: vmovss xmm3, [esp+8]
    L001b: vaddss xmm0, xmm0, xmm2
    L001f: vaddss xmm1, xmm1, xmm3
    L0023: vmovss [edx], xmm0
    L0027: vmovss [edx+4], xmm1
    L002c: ret 0x10

PerkseyOP•4/9/23, 9:47 PM

definitely interesting

PerkseyOP•4/9/23, 9:47 PM

so it looks like it can recognise that this is an operation that can be vectorized

Lyris the Kitori•4/9/23, 9:47 PM

the JIT really needs to Get Good and detect vectors

PerkseyOP•4/9/23, 9:48 PM

but the special treatment that Vector2 has means that it's already in a register

Aqua•4/9/23, 9:48 PM

interesting

PerkseyOP•4/9/23, 9:48 PM

as those vmovss ops are enregistering the custom type, but TYP_SIMD is assumed to already be in a register as part of the managed callconv

Aqua•4/9/23, 9:48 PM

i can't really read x86 assembly so all i can see here is that vector2 uses vsmovsdvsmovsd and it has a few less instructions

Lyris the Kitori•4/9/23, 9:48 PM

does the same fast codepath get hit if you used a fixed unsafe buffer and not 2 floats

Lyris the Kitori•4/9/23, 9:49 PM

just How Smart is the jit

PerkseyOP•4/9/23, 9:50 PM

PHAHAHAHAHAHAHAHAH

PerkseyOP•4/9/23, 9:50 PM

C.Test(Vec2, Vec2)
    L0000: sub esp, 0x30
    L0003: vzeroupper
    L0006: mov dword ptr [esp+0x2c], 0x3dbb9aab
    L000e: mov eax, [esp+0x34]
    L0012: mov [esp], eax
    L0015: mov eax, [esp+0x38]
    L0019: mov [esp+4], eax
    L001d: mov eax, [esp+0x3c]
    L0021: mov [esp+8], eax
    L0025: mov eax, [esp+0x40]
    L0029: mov [esp+0xc], eax
    L002d: mov eax, [esp+8]
    L0031: mov [esp+0x18], eax
    L0035: mov eax, [esp+0xc]
    L0039: mov [esp+0x1c], eax
    L003d: mov eax, [esp]
    L0040: mov [esp+0x10], eax
    L0044: mov eax, [esp+4]
    L0048: mov [esp+0x14], eax
    L004c: xor eax, eax
    L004e: mov [esp+0x20], eax
    L0052: mov [esp+0x24], eax
    L0056: vmovss xmm0, [esp+0x18]
    L005c: vaddss xmm0, xmm0, [esp+0x10]
    L0062: vmovss [esp+0x20], xmm0
    L0068: vmovss xmm0, [esp+0x1c]
    L006e: vaddss xmm0, xmm0, [esp+0x14]
    L0074: vmovss [esp+0x24], xmm0
    L007a: mov eax, [esp+0x20]
    L007e: mov [edx], eax
    L0080: mov eax, [esp+0x24]
    L0084: mov [edx+4], eax
    L0087: cmp dword ptr [esp+0x2c], 0x3dbb9aab
    L008f: je short L0096
    L0091: call 0x7219a540
    L0096: add esp, 0x30
    L0099: ret 0x10

C.Test(Vec2, Vec2)
    L0000: sub esp, 0x30
    L0003: vzeroupper
    L0006: mov dword ptr [esp+0x2c], 0x3dbb9aab
    L000e: mov eax, [esp+0x34]
    L0012: mov [esp], eax
    L0015: mov eax, [esp+0x38]
    L0019: mov [esp+4], eax
    L001d: mov eax, [esp+0x3c]
    L0021: mov [esp+8], eax
    L0025: mov eax, [esp+0x40]
    L0029: mov [esp+0xc], eax
    L002d: mov eax, [esp+8]
    L0031: mov [esp+0x18], eax
    L0035: mov eax, [esp+0xc]
    L0039: mov [esp+0x1c], eax
    L003d: mov eax, [esp]
    L0040: mov [esp+0x10], eax
    L0044: mov eax, [esp+4]
    L0048: mov [esp+0x14], eax
    L004c: xor eax, eax
    L004e: mov [esp+0x20], eax
    L0052: mov [esp+0x24], eax
    L0056: vmovss xmm0, [esp+0x18]
    L005c: vaddss xmm0, xmm0, [esp+0x10]
    L0062: vmovss [esp+0x20], xmm0
    L0068: vmovss xmm0, [esp+0x1c]
    L006e: vaddss xmm0, xmm0, [esp+0x14]
    L0074: vmovss [esp+0x24], xmm0
    L007a: mov eax, [esp+0x20]
    L007e: mov [edx], eax
    L0080: mov eax, [esp+0x24]
    L0084: mov [edx+4], eax
    L0087: cmp dword ptr [esp+0x2c], 0x3dbb9aab
    L008f: je short L0096
    L0091: call 0x7219a540
    L0096: add esp, 0x30
    L0099: ret 0x10

Aqua•4/9/23, 9:50 PM

mmmmmmmmmm perfect

Lyris the Kitori•4/9/23, 9:50 PM

LMAO

Aqua•4/9/23, 9:50 PM

what code change did you make exactly?

PerkseyOP•4/9/23, 9:50 PM

using System.Numerics;
public class C {
    public Vector2 Test(Vector2 x, Vector2 y) {
        return x + y;
    }
    public Vec2 Test(Vec2 x, Vec2 y) {
        return x + y;
    }
}

public struct Vec2
{
    unsafe fixed float Values[2];
    public static unsafe Vec2 operator +(Vec2 x, Vec2 y)
    {
        Vec2 ret = default;
        ret.Values[0] = x.Values[0] + y.Values[0];
        ret.Values[1] = x.Values[1] + y.Values[1];
        return ret;
    }
}

using System.Numerics;
public class C {
    public Vector2 Test(Vector2 x, Vector2 y) {
        return x + y;
    }
    public Vec2 Test(Vec2 x, Vec2 y) {
        return x + y;
    }
}

public struct Vec2
{
    unsafe fixed float Values[2];
    public static unsafe Vec2 operator +(Vec2 x, Vec2 y)
    {
        Vec2 ret = default;
        ret.Values[0] = x.Values[0] + y.Values[0];
        ret.Values[1] = x.Values[1] + y.Values[1];
        return ret;
    }
}

Lyris the Kitori•4/9/23, 9:50 PM

stupid JIT

Aqua•4/9/23, 9:50 PM

lol

Lyris the Kitori•4/9/23, 9:51 PM

get OutSmarted

chairclr•4/9/23, 9:51 PM

the jit needs to get real

chairclr•4/9/23, 9:51 PM

just in time? more like

chairclr•4/9/23, 9:51 PM

too late

Aqua•4/9/23, 9:52 PM

ah so vzerouppervzeroupper indicates SSE or something
so it seems like it is still trying to vectorize but it is just failing

PPerksey ``` C.Test(System.Numerics.Vector2, System.Numerics.Vector2) L0000: vzeroupp...

PerkseyOP•4/9/23, 9:52 PM

actually i know what this is, tanner did say he got some code working that recognises SIMD-like data structures but hasn't got around to recognising operations affecting the entire SIMD-like structure (i.e. when you're adding all elements)

AAqua ah so `vzeroupper` indicates SSE or something so it seems like it is still tryin...

Lyris the Kitori•4/9/23, 9:52 PM

it sets the upper zero to v when

Aqua•4/9/23, 9:52 PM

ah yes

PPerksey actually i know what this is, tanner did say he got some code working that recog...

Aqua•4/9/23, 9:53 PM

that would be an awesome feature to have

PerkseyOP•4/9/23, 9:53 PM

vzeroupper just cleans out the bits of the registers that aren't cleared out by default (128+)

Aqua•4/9/23, 9:53 PM

i'm curious about how it handles a generic struct using .net 7's INumber stuff

Aqua•4/9/23, 9:53 PM

ima try it

Lyris the Kitori•4/9/23, 9:53 PM

can i just get a runptyping instruction that runs my whole app in a single clock cycle

chairclr•4/9/23, 9:54 PM

IVector incoming?

AAqua that would be an awesome feature to have

PerkseyOP•4/9/23, 9:54 PM

well if you want to implement it, here's the file you need to change https://github.com/dotnet/runtime/blob/main/src/coreclr/jit/importer.cpp

Aqua•4/9/23, 9:54 PM

ah yes only 15k lines

PerkseyOP•4/9/23, 9:55 PM

the method names as well

PerkseyOP•4/9/23, 9:55 PM

https://cdn.discordapp.com/attachments/312132327348240384/835105799747403806/unknown.png

Aqua•4/9/23, 9:55 PM

hahahaha

chairclr•4/9/23, 9:55 PM

there two hard problems in programming

chairclr•4/9/23, 9:55 PM

number one i forgot

chairclr•4/9/23, 9:55 PM

number two is naming things

PerkseyOP•4/9/23, 9:56 PM

and number three is off by one errors

chairclr•4/9/23, 9:56 PM

tru

PerkseyOP•4/9/23, 9:56 PM

everytime i tell that joke people always miss the joke

Lyris the Kitori•4/9/23, 9:56 PM

by one

Aqua•4/9/23, 9:56 PM

how tf do you get sharplab to produce nice assembly like what you were seeing

Aqua•4/9/23, 9:56 PM

mine just produces garbage

Aqua•4/9/23, 9:57 PM

well not garbage but not any useful output

AAqua how tf do you get sharplab to produce nice assembly like what you were seeing

chairclr•4/9/23, 9:57 PM

uhh turn to release..?

khitiara•4/9/23, 9:57 PM

i got vectorized fully generic dot product and elementwise operations on generic spans going over here if anyone wants that

PerkseyOP•4/9/23, 9:57 PM

"the two hardest things in programming are cache invalidation, naming things, and off by one errors"
"yeahhh trueee"

PerkseyOP•4/9/23, 9:57 PM

NO ACKNOWLEDGEMENT OF JOKE

``` C.Test(System.Numerics.Vector2, System.Numerics.Vector2) L0000: vzeroupper L0003: vmovsd

Similar Threads

Similar Threads

Similar Threads