it also will definitely not generate the instructions you want

PPerksey it also will definitely not generate the instructions you want

M

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

i know, i'll have to think about this

M

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

is there a way to check if T is an unmanaged type that the JIT can eliminate

TTechPizza actually i'm just messing with you

T

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

no i'm not, AsPointer on

this

this

, ouch

TTechPizza no i'm not, AsPointer on `this`, ouch

M

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

it's a struct

M

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

it's not gonna get moved

T

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

but it's location can be in a class

M

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

but the operation is performed in a register

T

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

how so? it would try loading the field from the class

K

khitiara•10/20/23, 10:24 PM

my gut is to try and get a span to self and use vector<T> or span copy

M

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

i thought about that too

K

khitiara•10/20/23, 10:24 PM

or span copy using vector<T> for optimization

M

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

but that feels like it would also generate the wrong instructions

P

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

the operation isn't in a register unless you're using the functions that are 1:1 mappings to native instructions and even then there's implicit enregistration if it's not already

M

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

also Unsafe.SizeOf should be fine here if T is guaranteed to be unmanaged by checking RuntimeHelpers.IsReferenceOrContainsReferences, right?

T

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

Unsafe.SizeOf works on any T

M

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

fair

MMaxine maybe this optimization is generalizable?

T

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

and the codegen for this in net7 is very poor

M

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

do you guys have any better ideas, if this is possible at all?

P

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

just specialize it

P

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

or use BTEC SIMD

P

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

aka

System.Numerics.Vector

System.Numerics.Vector

P

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

but it's effectively deprecated until

ISimdVector

ISimdVector

comes out

P

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

like it works

P

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

but noone uses it

P

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

oh and you'd still need to specialise anyway by the looks of things

P

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

yeah just specialise it

T

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

eyo, don't bully my Vector<T> like that

PPerksey yeah just specialise it

M

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

what do you mean by specialize

P

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

typeof(T) == typeof(double)

typeof(T) == typeof(double)

M

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

yeah fair

T

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

if (typeof(T) == typeof(double) && Vector256.IsHardwareAccelerated)
{
    var _this = Vector256.Create(
        Unsafe.As<T, double>(ref Unsafe.AsRef(X)),
        Unsafe.As<T, double>(ref Unsafe.AsRef(Y)), 
        Unsafe.As<T, double>(ref Unsafe.AsRef(Z)), 
        0);
    
    var _other = Vector256.Create(
        Unsafe.As<T, double>(ref Unsafe.AsRef(other.X)),
        Unsafe.As<T, double>(ref Unsafe.AsRef(other.Y)), 
        Unsafe.As<T, double>(ref Unsafe.AsRef(other.Z)), 
        0);

    return _this.Equals(_other);
}

if (typeof(T) == typeof(double) && Vector256.IsHardwareAccelerated)
{
    var _this = Vector256.Create(
        Unsafe.As<T, double>(ref Unsafe.AsRef(X)),
        Unsafe.As<T, double>(ref Unsafe.AsRef(Y)), 
        Unsafe.As<T, double>(ref Unsafe.AsRef(Z)), 
        0);
    
    var _other = Vector256.Create(
        Unsafe.As<T, double>(ref Unsafe.AsRef(other.X)),
        Unsafe.As<T, double>(ref Unsafe.AsRef(other.Y)), 
        Unsafe.As<T, double>(ref Unsafe.AsRef(other.Z)), 
        0);

    return _this.Equals(_other);
}

if (typeof(T) == typeof(double) && Vector256.IsHardwareAccelerated)
{
    var _this = Vector256.Create(
        Unsafe.As<T, double>(ref Unsafe.AsRef(X)),
        Unsafe.As<T, double>(ref Unsafe.AsRef(Y)), 
        Unsafe.As<T, double>(ref Unsafe.AsRef(Z)), 
        0);
    
    var _other = Vector256.Create(
        Unsafe.As<T, double>(ref Unsafe.AsRef(other.X)),
        Unsafe.As<T, double>(ref Unsafe.AsRef(other.Y)), 
        Unsafe.As<T, double>(ref Unsafe.AsRef(other.Z)), 
        0);

    return _this.Equals(_other);
}

if (typeof(T) == typeof(double) && Vector256.IsHardwareAccelerated)
{
    var _this = Vector256.Create(
        Unsafe.As<T, double>(ref Unsafe.AsRef(X)),
        Unsafe.As<T, double>(ref Unsafe.AsRef(Y)), 
        Unsafe.As<T, double>(ref Unsafe.AsRef(Z)), 
        0);
    
    var _other = Vector256.Create(
        Unsafe.As<T, double>(ref Unsafe.AsRef(other.X)),
        Unsafe.As<T, double>(ref Unsafe.AsRef(other.Y)), 
        Unsafe.As<T, double>(ref Unsafe.AsRef(other.Z)), 
        0);

    return _this.Equals(_other);
}

is a little better

K

khitiara•10/20/23, 10:34 PM

also note silkx which this is to be a part of is intended to target net8 and up if any net8 optimizations impact things

TTechPizza ```cs if (typeof(T) == typeof(double) && Vector256.IsHardwareAccelerated) { ...

T

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

although net7 JIT can't e.g. see when you pass in constants, so it's pretty bad

P

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

we're all making coreclr optimisation assumptions here don't forget

P

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

mono does do intrinsics properly when used explicitly

Kkhitiara also note silkx which this is to be a part of is intended to target net8 and up ...

M

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

i mean, if you can figure out a generalized vectorized Equals, i'd love to see it, this is where i stopped

        if (!RuntimeHelpers.IsReferenceOrContainsReferences<T>())
        {
            var size = Unsafe.SizeOf<T>();

            if (Vector128.IsHardwareAccelerated && (size * Count) < 16)
            {
                Span<byte> data = stackalloc byte[32];
                data.Clear(); // optional?

                var copy = this; // make you guys happy
                MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref copy, 1)).CopyTo(data);
                MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref other, 1)).CopyTo(data[16..]);
                
                MemoryMarshal.Cast<byte, Vector128<>()
            }
        }

        if (!RuntimeHelpers.IsReferenceOrContainsReferences<T>())
        {
            var size = Unsafe.SizeOf<T>();

            if (Vector128.IsHardwareAccelerated && (size * Count) < 16)
            {
                Span<byte> data = stackalloc byte[32];
                data.Clear(); // optional?

                var copy = this; // make you guys happy
                MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref copy, 1)).CopyTo(data);
                MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref other, 1)).CopyTo(data[16..]);
                
                MemoryMarshal.Cast<byte, Vector128<>()
            }
        }

        if (!RuntimeHelpers.IsReferenceOrContainsReferences<T>())
        {
            var size = Unsafe.SizeOf<T>();

            if (Vector128.IsHardwareAccelerated && (size * Count) < 16)
            {
                Span<byte> data = stackalloc byte[32];
                data.Clear(); // optional?

                var copy = this; // make you guys happy
                MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref copy, 1)).CopyTo(data);
                MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref other, 1)).CopyTo(data[16..]);
                
                MemoryMarshal.Cast<byte, Vector128<>()
            }
        }

        if (!RuntimeHelpers.IsReferenceOrContainsReferences<T>())
        {
            var size = Unsafe.SizeOf<T>();

            if (Vector128.IsHardwareAccelerated && (size * Count) < 16)
            {
                Span<byte> data = stackalloc byte[32];
                data.Clear(); // optional?

                var copy = this; // make you guys happy
                MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref copy, 1)).CopyTo(data);
                MemoryMarshal.AsBytes(MemoryMarshal.CreateSpan(ref other, 1)).CopyTo(data[16..]);
                
                MemoryMarshal.Cast<byte, Vector128<>()
            }
        }

M

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

it's very annoying without scoping T to struct

K

khitiara•10/20/23, 10:36 PM

yeah without scoping T : struct idk how to do it

M

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

can i call low-level SIMD instructions direclty? :3

A

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

like

Sse2.Add

Sse2.Add

?

M

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

yeah

P

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

System.Runtime.Intrinsics.X86 (and friends)

M

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

that might work

M

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

casting a Vector3<int> to Vector3 (float) for equality should be fine, right

M

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

since it's just a memory comparison

A

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

eehhhh
i really don't see how this is any faster than just doing a logical compare

AAqua eehhhh i really don't see how this is any faster than just doing a logical compa...

M

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

for AsVector128

MMaxine casting a Vector3<int> to Vector3 (float) for equality should be fine, right

T

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

throws out all float rules out of window i see

P

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

doesn't Span have a really efficient equality implementation already?

A

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

intrinsics can often be slower if you're just using them for one singular operation

it also will definitely not generate the instructions you want

Similar Threads