```cs if (typeof(T) == typeof(double) && Vector256.IsHardwareAccelerated) { var _this = Vector25

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

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

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

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

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

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

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

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

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

it's very annoying without scoping T to struct

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

yeah without scoping T : struct idk how to do it

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

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

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

like Sse2.AddSse2.Add?

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

yeah

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

System.Runtime.Intrinsics.X86 (and friends)

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

that might work

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

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

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

since it's just a memory comparison

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

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

for AsVector128

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

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

throws out all float rules out of window i see

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

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

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

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

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

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

// USE AN EPSILON DAMNIT!// USE AN EPSILON DAMNIT!

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

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

so i should just create a Span<T> for this and other and equals that?

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

that would both be generalizable and fast

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

possibly

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

if the JIT created the right instructions

Perksey•10/20/23, 10:40 PM

sure but you're trading correctness for performance

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

what do you mean correctness, Vector3 Equals was never meant to use an epsilon

Perksey•10/20/23, 10:40 PM

it is conceivably possible that the same effective float value has differing bits

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

yep i just figured out why this wouldn't work

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

things like -0 and +0

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

NaN equality

PPerksey sure but you're trading correctness for performance

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

i'm not even sure it would be more performant

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

or if it is, its negligable

Perksey•10/20/23, 10:41 PM

it'd be more performant for gigantic structs

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

you're replacing instructions with other instructions

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

true, but not for a small one like vectors

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

matrix probably

Perksey•10/20/23, 10:41 PM

oh yeah

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

but not vectors

Perksey•10/20/23, 10:41 PM

like seriously please just use specialised impls

AAqua i'm not even sure it would be more performant

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

i jsut adapted this

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

maybe there is something i am missing ¯\_(ツ)_/¯

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

should i throw this all out and jus compare XYZ? that's fine with me

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

i've done the experiments with SIMD and vectors

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

and in my tests its far slower than to just do the operations directly

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

because of the amount of extra bulk that goes along with it

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

simd comes into its own when you do an operation multiple times, just once its often worse for perf

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

which is why matrix benefits from simd

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

if i'm wrong please correct me, this is just from the results of my own experiments

TechPizzaOP•10/20/23, 10:44 PM

i would say that using SIMD for Vector4 is perfectly fine

TechPizzaOP•10/20/23, 10:44 PM

Vector2 and Vector3 is way too painful due to not being the size of a Vector128

```cs if (typeof(T) == typeof(double) && Vector256.IsHardwareAccelerated) { var _this = Vector25

Similar Threads