[Help with SIMD] Good way to create missing SIMD functions for Vector128<float> type

[dbriard]

Hi,
I am new to c# SIMD and I would like to create some kind of SimdHelper with new functions that I could use with Vector128.
Basically, I want to port code from DirectXMath, or my custom C++ functions to use with Vector128...

What would be the recommanded what to do that.
Here an example of what I would like to do:

    [MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
public static unsafe Vector128<float> Round(Vector128<float> V)
    {
        if (Sse41.IsSupported)
        {
            return Sse41.RoundToNearestInteger(V);
        }
    else if (Sse2.IsSupported)
    {
[...]
    }
    else
    {
// code that do not use SIMD here
    }
  } 

1. Is the function prototype ok?

2. I am not sure how to deal with the last else case. Do I have to store the input vector into an array, do the operation on the array, and reload the array to result the result? Is there a cleaner more recommanded way?

3. What if I need constant into the function such as mask? Is that ok to do that:

public static readonly uint[] NegativeZero = new uint[4] { 0x80000000, 0x80000000, 0x80000000, 0x80000000 };
    public static readonly uint[] AbsMask = new uint[4] { 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF };

    [MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
    public static unsafe Vector128<float> Round(Vector128<float> V)
    {
        if (Sse41.IsSupported)
        {
            return Sse41.RoundToNearestInteger(V);
        }
        else if (Vector128.IsHardwareAccelerated)
        {
            fixed (uint* pNegativeZero = &NegativeZero[0])
            fixed (uint* pAbsMask = &AbsMask[0])
            {
                var negativeZeroVector = Vector128.Load((float*) pNegativeZero);
                var absMaskVector = Vector128.Load((float*) pAbsMask);
                var sign = Sse.And(V, negativeZeroVector);

4. Should I use Sse instead of generic Vector128? or is it exactly the same? (i.e. Sse.Add instead of Vector128.Add) ?
5. Using Vector128 with Vector128.IsHardwareAccelerated instead of See, would result in optimized code for ARM processors right?

Thank you for your help!

[EgorBo]

I'd recommend reading our vectorization guidelines.

Is the function prototype ok?

Depends on what you need, typically, it's expected to check some specific ISAs (or VectorX) IsAccelerated property and use completely different path for the whole algorithm if target platforms doesn't support needed SIMD. Sometimes it's ok to provide a software fallback for some SIMD API if it's not accelerated while the rest are OK.

What if I need constant into the function such as mask

Just created them in place with Vector128.Create there is no need in static readonly fields

Should I use Sse instead of generic Vector128?

Generally, it's better to use the generic (aka crossplat) APIs to get ARM acceleration for free

Using Vector128 with Vector128.IsHardwareAccelerated instead of See, would result in optimized code for ARM processors right?

Correct

[dbriard]

Thank you so much @EgorBo !

I didn't know about this guide, it is great source of information :) and good to know that I can create the constant in place at no cost. And use the operators directly instead of Add, And, etc.

Depends on what you need, typically, it's expected to check some specific ISAs (or VectorX) IsAccelerated property and use completely different path for the whole algorithm if target platforms doesn't support needed SIMD. Sometimes it's ok to provide a software fallback for some SIMD API if it's not accelerated while the rest are OK.
In fact it is about building blocks for complex algorithms, such as Cos or Pow function that are not available. Or even rewriting simple functions when I don't need extra check overhead of the buildin function, and to make the code more readable. Exactly what DirectXMath offer in C++.
According to your answer, it is better to write 3 Cos functions, one for each architecture, instead of one with if else cases? and call the good one in each code path of main algorithm. The if else in my sample do not magically disappear in the compiled code?

Just to be sure, are functions like my example inlined or is there unnecessary copies of the vector inputs? May be I should use 'in' keywords?

I found in the docs that Vector 128 has [] operator but I didn't have had time to try, it is more readable than writing Store and Load to a temporary variable to use fallback scalar function. But what is recommended if for example I need Math.Pow function on a Vector128 in the middle of a big vectorized code path? Store/Load, [], GetElement/Create?? If I need to store, is there a way to create a c# aligned managed variable? Like XMFLOAT4 in DirectXMath that is always aligned?

Is it more efficient to use scalar Vector operations on the remainder elements, instead of scalar code directly on the data? (For the case of an image, where there is remainder every row.). Does this break a full vector pipeline or something? And is CreateScalar or CreateScalarUnsafe more efficient than Create? (for remainders)

Thank you again if you could answer those additional questions. As I need to write tons of code, I would better to avoid as many mistakes as possibles as it take lot of time to test each code patch, especially for WASM which is very long to compile and something slow on several Vector128 functions (I.e Abs).

P.s. Vector128 Min and Max, fail to compile for WASM in .Net7, is it know behavior?