given the type will always be there since "no breaking changes"*, theres no reason at this point

P

Perksey•4/9/23, 9:44 PM

but yeah the reason why we don't recommend Silk.NET.Maths more actively is because they're not optimized. there was a big project at one point to establish cross-platform optimization that wouldn't make us not on-par with System.Numerics, but as fast as you damn well could from C# user code (because System.Numerics has special code paths in the JIT that give it extra performance)

A

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

i did a benchmark between a bog standard vector3 implementation (no simd) and a system.numerics one
the bog standard one was twice as fast

A

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

no i have no idea why

A

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

i did the benchmark properly

P

Perksey•4/9/23, 9:45 PM

huh interesting

A

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

granted i was just adding vectors together but still

LLyris the Kitori given the type will always be there since "no breaking changes"*, theres no reas...

M

Machinarius•4/9/23, 9:45 PM

That's a good policy, hate when I upgrade my libs and everything breaks.

P

Perksey•4/9/23, 9:45 PM

i wonder whether the JIT has got power-ups

A

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

it probably can get much faster if it enters tier 1, and i suspect the SIMD versions are significantly faster when calculating dot products etc
i only did a small amount of testing

A

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

nativeaot performance benchmarks would be interesting though

P

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

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

P

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

definitely interesting

P

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

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

L

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

the JIT really needs to Get Good and detect vectors

P

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

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

A

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

interesting

P

Perksey•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

A

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

i can't really read x86 assembly so all i can see here is that vector2 uses

vsmovsd

vsmovsd

vsmovsd

vsmovsd and it has a few less instructions

L

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

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

L

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

just How Smart is the jit

P

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

PHAHAHAHAHAHAHAHAH

P

Perksey•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

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

A

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

mmmmmmmmmm perfect

L

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

LMAO

A

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

what code change did you make exactly?

P

Perksey•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;
    }
}

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

L

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

stupid JIT

A

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

lol

L

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

get OutSmarted

C

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

the jit needs to get real

C

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

just in time? more like

C

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

too late

A

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

ah so

vzeroupper

vzeroupper

vzeroupper

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

P

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

L

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

it sets the upper zero to v when

A

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

A

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

that would be an awesome feature to have

P

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

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

A

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

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

A

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

ima try it

L

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

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

C

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

IVector incoming?

AAqua that would be an awesome feature to have

P

Perksey•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

A

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

ah yes only 15k lines

P

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

the method names as well

P

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

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

A

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

hahahaha

C

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

there two hard problems in programming

C

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

number one i forgot

C

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

number two is naming things

given the type will always be there since "no breaking changes"*, theres no reason at this point

Similar Threads

Similar Threads

Similar Threads