Optimize VectorT.ConditionalSelect for constant masks

[ezhevita]

Resolves #104001.
I’ve also realized that it is not possible to implement this for arrays as I’ve originally intended since we have no immutability guarantees, so instead I’ve made sure it gets optimized with ReadOnlySpan<T> property and static VectorX<T> field.

Example:

[DisassemblyDiagnoser]
public class TestClass
{
    private ReadOnlySpan<byte> Mask => [255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0, 255, 0];

    [Benchmark]
    public byte Span()
    {
        return Vector128.ConditionalSelect(Vector128.Create(Mask), Vector128<byte>.Zero, Vector128<byte>.One)[0];
    }
}

Old codegen:

; Method TestNamespace.TestClass:Span():ubyte:this (FullOpts)
G_M000_IG01:

G_M000_IG02:
       vmovups  xmm0, xmmword ptr [reloc @RWD00]
       vxorps   xmm1, xmm1, xmm1
       vpand    xmm1, xmm1, xmm0
       vpandn   xmm0, xmm0, xmmword ptr [reloc @RWD16]
       vpor     xmm0, xmm0, xmm1
       vmovd    eax, xmm0
       movzx    rax, al

G_M000_IG03:
       ret      
RWD00  	dq	00FF00FF00FF00FFh, 00FF00FF00FF00FFh
RWD16  	dq	0101010101010101h, 0101010101010101h
; Total bytes of code: 36

New codegen:

; Method TestNamespace.TestClass:Span():ubyte:this (FullOpts)
G_M000_IG01:

G_M000_IG02:
       vmovups  xmm0, xmmword ptr [reloc @RWD00]
       vxorps   xmm1, xmm1, xmm1
       vmovups  xmm2, xmmword ptr [reloc @RWD16]
       vpblendvb xmm0, xmm2, xmm1, xmm0
       vmovd    eax, xmm0
       movzx    rax, al

G_M000_IG03:
       ret      
RWD00  	dq	00FF00FF00FF00FFh, 00FF00FF00FF00FFh
RWD16  	dq	0101010101010101h, 0101010101010101h
; Total bytes of code: 34

[dotnet-policy-service]

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch
See info in area-owners.md if you want to be subscribed.

[ezhevita]

@dotnet-policy-service agree

[EgorBo]

do we need these checks? I doubt they save any measurable TP

[tannergooding]

👍, these functions just loop the memory checking if all elements are a given value

[ezhevita]

@tannergooding suggested that these checks should be in place here: https://discord.com/channels/143867839282020352/312132327348240384/1255568916151930990
However ConditionalSelect with all bits set/all bits zero as a mask is pretty useless, so we can get rid of these

[tannergooding]

The consideration is rather just that main loop below already handles this and these checks aren't "cheap", they are just doing a loop and comparison themselves.

So by removing these explicit checks, we can loop once rather than 3 times and still handle all the scenarios.

[EgorBo]

Perhaps, we can name it as ElementsAreAllBitsSetOrZero as well?

[tannergooding]

We've explicitly used the term PerElementMask elsewhere throughout the JIT to encompass the general concept necessary here.

[EgorBo]

nit: comments for parameters are missing

[tannergooding]

This comment isn't applicable to the general query, it was specific to the CndSel lowering logic

[tannergooding]

If you wanted to, you could also update this just a little bit more as there's some very simple cases that we could cover that would also allow us to optimize further.

In particular, you could have this do:

GenTreeHWIntrinsic* intrinsic   = AsHWIntrinsic();
NamedIntrinsic      intrinsicId = intrinsic->GetHWIntrinsicId();

if (HWIntrinsicInfo::ReturnsPerElementMask(intrinsicId))
{
    // We directly return a per-element mask
    return true;
}

bool       isScalar = false;
genTreeOps oper     = intrinsic->HWOperGet(&isScalar);

switch (oper)
{
    case GT_AND:
    case GT_AND_NOT:
    case GT_OR:
    case GT_XOR:
    {
        // We are a binary bitwise operation where both inputs are per-element masks
        return intrinsic->Op(1)->IsVectorPerElementMask(simdBaseType, simdSize)
            && intrinsic->Op(2)->IsVectorPerElementMask(simdBaseType, simdSize);
    }

    case GT_NOT:
    {
        // We are an unary bitwise operation where the input is a per-element mask
        return intrinsic->Op(1)->IsVectorPerElementMask(simdBaseType, simdSize);
    }

    default:
    {
        assert(!GenTreeHWIntrinsic::OperIsBitwiseHWIntrinsic(oper));
        break;
    }
}

return false;

There's others that qualify as well, but I expect they're more rare and the bitwise operations are the most important to consider.