[Arm64] Store Pair of SIMD&FP registers

[echesakov]

class AdvSimd.Arm64
{
            /// <summary>
            ///   A64: STP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(byte* address, Vector64<byte> value1, Vector64<byte> value2);

            /// <summary>
            ///   A64: STP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(double* address, Vector64<double> value1, Vector64<double> value2);

            /// <summary>
            ///   A64: STP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(short* address, Vector64<short> value1, Vector64<short> value2);

            /// <summary>
            ///   A64: STP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(int* address, Vector64<int> value1, Vector64<int> value2);

            /// <summary>
            ///   A64: STP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(long* address, Vector64<long> value1, Vector64<long> value2);

            /// <summary>
            ///   A64: STP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(sbyte* address, Vector64<sbyte> value1, Vector64<sbyte> value2);

            /// <summary>
            ///   A64: STP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(float* address, Vector64<float> value1, Vector64<float> value2);

            /// <summary>
            ///   A64: STP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(ushort* address, Vector64<ushort> value1, Vector64<ushort> value2);

            /// <summary>
            ///   A64: STP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(uint* address, Vector64<uint> value1, Vector64<uint> value2);

            /// <summary>
            ///   A64: STP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(ulong* address, Vector64<ulong> value1, Vector64<ulong> value2);

            /// <summary>
            ///   A64: STP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(byte* address, Vector128<byte> value1, Vector128<byte> value2);

            /// <summary>
            ///   A64: STP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(double* address, Vector128<double> value1, Vector128<double> value2);

            /// <summary>
            ///   A64: STP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(short* address, Vector128<short> value1, Vector128<short> value2);

            /// <summary>
            ///   A64: STP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(int* address, Vector128<int> value1, Vector128<int> value2);

            /// <summary>
            ///   A64: STP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(long* address, Vector128<long> value1, Vector128<long> value2);

            /// <summary>
            ///   A64: STP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(sbyte* address, Vector128<sbyte> value1, Vector128<sbyte> value2);

            /// <summary>
            ///   A64: STP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(float* address, Vector128<float> value1, Vector128<float> value2);

            /// <summary>
            ///   A64: STP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(ushort* address, Vector128<ushort> value1, Vector128<ushort> value2);

            /// <summary>
            ///   A64: STP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(uint* address, Vector128<uint> value1, Vector128<uint> value2);

            /// <summary>
            ///   A64: STP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePair(ulong* address, Vector128<ulong> value1, Vector128<ulong> value2);

            /// <summary>
            ///   A64: STP St1, St2, [Xn]
            /// </summary>
            public static unsafe void StorePairScalar(int* address, Vector64<int> value1, Vector64<int> value2);

            /// <summary>
            ///   A64: STP St1, St2, [Xn]
            /// </summary>
            public static unsafe void StorePairScalar(float* address, Vector64<float> value1, Vector64<float> value2);

            /// <summary>
            ///   A64: STP St1, St2, [Xn]
            /// </summary>
            public static unsafe void StorePairScalar(uint* address, Vector64<uint> value1, Vector64<uint> value2);

            /// <summary>
            ///   A64: STNP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(byte* address, Vector64<byte> value1, Vector64<byte> value2);

            /// <summary>
            ///   A64: STNP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(double* address, Vector64<double> value1, Vector64<double> value2);

            /// <summary>
            ///   A64: STNP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(short* address, Vector64<short> value1, Vector64<short> value2);

            /// <summary>
            ///   A64: STNP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(int* address, Vector64<int> value1, Vector64<int> value2);

            /// <summary>
            ///   A64: STNP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(long* address, Vector64<long> value1, Vector64<long> value2);

            /// <summary>
            ///   A64: STNP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(sbyte* address, Vector64<sbyte> value1, Vector64<sbyte> value2);

            /// <summary>
            ///   A64: STNP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(float* address, Vector64<float> value1, Vector64<float> value2);

            /// <summary>
            ///   A64: STNP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(ushort* address, Vector64<ushort> value1, Vector64<ushort> value2);

            /// <summary>
            ///   A64: STNP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(uint* address, Vector64<uint> value1, Vector64<uint> value2);

            /// <summary>
            ///   A64: STNP Dt1, Dt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(ulong* address, Vector64<ulong> value1, Vector64<ulong> value2);

            /// <summary>
            ///   A64: STNP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(byte* address, Vector128<byte> value1, Vector128<byte> value2);

            /// <summary>
            ///   A64: STNP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(double* address, Vector128<double> value1, Vector128<double> value2);

            /// <summary>
            ///   A64: STNP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(short* address, Vector128<short> value1, Vector128<short> value2);

            /// <summary>
            ///   A64: STNP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(int* address, Vector128<int> value1, Vector128<int> value2);

            /// <summary>
            ///   A64: STNP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(long* address, Vector128<long> value1, Vector128<long> value2);

            /// <summary>
            ///   A64: STNP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(sbyte* address, Vector128<sbyte> value1, Vector128<sbyte> value2);

            /// <summary>
            ///   A64: STNP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(float* address, Vector128<float> value1, Vector128<float> value2);

            /// <summary>
            ///   A64: STNP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(ushort* address, Vector128<ushort> value1, Vector128<ushort> value2);

            /// <summary>
            ///   A64: STNP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(uint* address, Vector128<uint> value1, Vector128<uint> value2);

            /// <summary>
            ///   A64: STNP Qt1, Qt2, [Xn]
            /// </summary>
            public static unsafe void StorePairNonTemporal(ulong* address, Vector128<ulong> value1, Vector128<ulong> value2);

            /// <summary>
            ///   A64: STNP St1, St2, [Xn]
            /// </summary>
            public static unsafe void StorePairScalarNonTemporal(int* address, Vector64<int> value1, Vector64<int> value2);

            /// <summary>
            ///   A64: STNP St1, St2, [Xn]
            /// </summary>
            public static unsafe void StorePairScalarNonTemporal(float* address, Vector64<float> value1, Vector64<float> value2);

            /// <summary>
            ///   A64: STNP St1, St2, [Xn]
            /// </summary>
            public static unsafe void StorePairScalarNonTemporal(uint* address, Vector64<uint> value1, Vector64<uint> value2);
}

[Dotnet-GitSync-Bot]

I couldn't add an area label to this Issue.

Checkout this page to find out which area owner to ping, or please add exactly one area label to help train me in the future.

[echesakov]

@CarolEidt, @tannergooding , @TamarChristinaArm PTAL

[echesakov]

@TamarChristinaArm Is it correct to say that functionality of StorePair on Arm32 can be achieved by using VSTM?

[tannergooding]

I think we should could have better names than value1/value2 to help clarify the order they are stored in.

I wonder if StoreScalarPair is better than StorePairScalar

[echesakov]

I think we should could have better names than value1/value2 to help clarify the order they are stored in.

How about first/second ?

I wonder if StoreScalarPair is better than StorePairScalar

It is an option, but I can't tell which one has more emphasis on that we store a pair

[CarolEidt]

I wonder if StoreScalarPair is better than StorePairScalar

It is an option, but I can't tell which one has more emphasis on that we store a pair

It seems to me that it's useful to have all of these start the same, i.e. StorePairXXX

[TamarChristinaArm]

@TamarChristinaArm Is it correct to say that functionality of StorePair on Arm32 can be achieved by using VSTM?

Yeah that's correct

[TamarChristinaArm]

Question about these store intrinsics in general, how are you guys planning on dealing with the different addressing modes? or are you only interested in a the register addressing modes?

[echesakov]

@TamarChristinaArm

I had a discussion with @BruceForstall where we briefly discussed how we can benefit from post-index addressing modes if we had something like these:

// ST1 { <Vt>.<T> }, [<Xn|SP>], #16
void Store(ref T* address, Vector128<T> value);

For example, if have a loop

Vector128<double> val ;

for (int i = 0; i < count; i++)
{
    /* 
    compute new value of val 
   */

    Store(baseAddr + i * 16, val);
}

a user might want to do some sort of strength reduction manually and have this

Vector128<double> val ;
T* ptr = baseAddr;

for (int i = 0; i < count; i++)
{
    /* 
    compute new value of val 
   */

    Store(ptr, val);
    ptr += 16;
}

and that as a result

Vector128<double> val ;
T* ptr = baseAddr;

for (int i = 0; i < count; i++)
{
    /* 
    compute new value of val 
   */

    Store(ref ptr, val);
}

[tannergooding]

Why can't we just detect and emit the right encoding for baseAddr + i * 16 like we do on x86/x64?

[tannergooding]

For example, see https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA0AXEBDAzgWwB8ABABgAJiBGAOgCUBXAOwwEt8YaBJFqVp3KzC4A3AFgAUGUq1GLdpx4Y+AobhoANABxJxEycQDM5ZrmwAzGJQBM5AMLkA3pPKvKxgGowwGaFWtaADzmADYQ2BgAfOQAsgAUoeEYAFTk2AAm6VBo5PwYuUzpMAgAlE4ubpXEAOzkAMq4nAAy4elePn4BcRlZ5ADUBUUI5KkoJXqVAL6Sk0A=

We already support optimizing things like:

Sse.LoadVector128(addr + index * 4);

into:

vmovups xmm0, [r8+rax*4]