Usage of "constants" Vector

[ycrumeyrolle]

Hi,

When using a Vector class like Vector256<byte> what is the best practice for predefined vector.
Should we use Vector.Create() just in time, or is it better to pre-init the vector in a static field ?

For example:

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;

internal class ConstantVectorAsLocaleVariable
{
    public void XorData(ref byte data, ref byte destination, int length)
    {
        Vector256<byte> mask = Vector256.Create((byte)0x36);

        ref byte endData = ref Unsafe.Add(ref data, length);
        while (Unsafe.IsAddressLessThan(ref data, ref endData))
        {
            var vector = Unsafe.ReadUnaligned<Vector256<byte>>(ref data);
            Unsafe.WriteUnaligned(ref destination, Avx2.Xor(vector, mask));

            data = ref Unsafe.Add(ref data, 32);
        }
    }
}

internal class ConstantVectorAsStaticField
{
    private static readonly Vector256<byte> _mask = Vector256.Create((byte)0x36);

    public void XorData(ref byte data, ref byte destination, int length)
    {
        ref byte endData = ref Unsafe.Add(ref data, length);
        while (Unsafe.IsAddressLessThan(ref data, ref endData))
        {
            var vector = Unsafe.ReadUnaligned<Vector256<byte>>(ref data);
            Unsafe.WriteUnaligned(ref destination, Avx2.Xor(vector, _mask));

            data = ref Unsafe.Add(ref data, 32);
        }
    }
}

internal class ConstantVectorAsStaticFieldAndLocaleVariable
{
    private static readonly Vector256<byte> _mask = Vector256.Create((byte)0x36);

    public void XorData(ref byte data, ref byte destination, int length)
    {
        Vector256<byte> mask = _mask;

        ref byte endData = ref Unsafe.Add(ref data, length);
        while (Unsafe.IsAddressLessThan(ref data, ref endData))
        {
            var vector = Unsafe.ReadUnaligned<Vector256<byte>>(ref data);
            Unsafe.WriteUnaligned(ref destination, Avx2.Xor(vector, mask));

            data = ref Unsafe.Add(ref data, 32);
        }
    }
}

Looking at the dotnet runtime:
https://github.com/dotnet/runtime/blob/master/src/libraries/System.Text.Encodings.Web/src/System/Text/Encodings/Web/Sse2Helper.cs#L103
The vector is initialized once as a static field.

Since here:
https://github.com/dotnet/runtime/blob/master/src/libraries/System.Memory/src/System/Buffers/Text/Base64Decoder.cs#L365
The vector is read just in time.

What are the differences ?

[gfoidl]

See #40900 --> For .NET 5 onwards just use Vector256.Create(...) with constant arguments.

What are the differences ?

For the static readonly the JIT emits code that in the static construction of the type will create the vector, store it to memory and (later) can be read from there.

If the vector elements are of size 1, as byte, sbyte, etc. and as in the Base64-code you linked, the vector is read from the assembly's static data segment directly. This works, as the C# compiler uses a trick for ReadOnlySpans iif element size is 1. See C# ReadOnlySpan and static data for further infos.

---

Vector class like Vector256<byte>

It's a (readonly) struct, striclty speaking 😉

[ycrumeyrolle]

Thanks for the explaination.
2 additional questions:

• Is there a way to safely convert a uint/ulong constant to byte ( endianess issue?) , in order to take advantage of the static data segment?
• I have different ASM code with very similar source code: SharpLab
  Using a local variable change the ASM produced by replacing a push/pop by a vmovupd

[gfoidl]

SharpLab uses .NET Core 3.1 for the JIT-dumps and doesn't show the assembly which current JIT (from .NET 5 and / or master branch) would produce.
See Viewing JIT Dumps for viewing current assembly or use BenchmarkDotNet disassembly diagnoser or https://github.com/EgorBo/Disasmo.

safely convert a uint/ulong constant to byte ( endianess issue?)

In general no. And that's the reason why the C# compiler uses this optimization only on types of size 1.
When we talk about AVX / SSE that implies little endian, so under this constraint you can cast safely.
Note: for Arm this won't work, because of endianess.

take advantage of the static data segment?

For .NET 5+ I'd just use Vector128.Create. Memory-wise the generated constant may have better locality than the assembly's static data segment.
For .NET Core 3.1 and uint/ulong I'd go with static readonly as it's good and the code remains readable. Building up the constants out of bytes, just to safe a little bit (maybe?), will result in a mess. Perf-wise it's much better to try to keep the vectors in registers -- especially for code with loops -- anyway. If the vector is just use once / outside of loops there are quite a lot of other perf-concerns like overhead, alignment, etc. which may have greater "impact" than static readonly vs. ROS-trick.