RyuJIT SIMD: Test for equality against zero can be optimized on AVX

[sivarv]

As per Intel TechEmPower benchmark analysis, Kestrel.Internal.Infrastructure.MemoryPoolIterator.Seek() is one of the hot methods. This method uses equality against Vector.Zero

var data = new Vector<byte>(array, index);
var byte0Equals = Vector.Equals(data, byte0Vector);
var byte1Equals = Vector.Equals(data, byte1Vector);
var byte2Equals = Vector.Equals(data, byte2Vector);

if (!byte0Equals.Equals(Vector<byte>.Zero))
{
        byte0Index = FindFirstEqualByte(ref byte0Equals);
}

if (!byte1Equals.Equals(Vector<byte>.Zero))
{
        byte1Index = FindFirstEqualByte(ref byte1Equals);
}
if (!byte2Equals.Equals(Vector<byte>.Zero))
{
        byte2Index = FindFirstEqualByte(ref byte2Equals);
}

That is, SIMD API used is

bool Vector<T>.Equals(Vector<T> v)

Right now RyuJIT backend is generating the following

// Assume that byte0Equals in ymm0 reg
byte0Equals.Equals(Vector<byte>.Zero)

RyuJIT backend should be able to detect equality check against is Vector.Zero and generate the following optimal code

ptest ymm0, ymm0
setz dil
movzx edx, dil

Similarly for in-equality check against zero, we can generate

ptest ymm0, ymm0
setnz dil
movzx edx, dil

[redknightlois]

@sivarv I am not being able to trigger this optimization and couldn't track the actual PR associated with this one. EDIT: Found it, it was staring right toward me.

From this code:

var vx = Unsafe.Read<Vector<byte>>(bpx);
var vy = Unsafe.Read<Vector<byte>>(bpy);

var xor = Vector.Xor(vx, vy);
 if (Vector.EqualsAll(xor, Vector<byte>.Zero))
      break;

What I get is roughly:

vmovupd     ymm0,ymmword ptr [rcx]  // Read vx
vmovupd     ymm1,ymmword ptr [rdx]  // Read vy
vpxor       ymm0,ymm0,ymm1   // XOR vx, vy              
vpxor       ymm1,ymm1,ymm1  //  Zero out reg2
vmovaps     ymm2,ymm0  
vpcmpeqd    ymm2,ymm2,ymm1  
vpmovmskb   r9d,ymm2  
cmp         r9d,0FFFFFFFFh  // Standard compare. 
sete        r9b  
movzx       r9d,r9b  
movzx       r9d,r9b  // Repeated ?
test        r9d,r9d   
jne         00007FFAA1C6CFA6 // Jump on condition (break)

When we could actually do:

vmovupd     ymm0,ymmword ptr [rcx]  // Read vx
vmovupd     ymm1,ymmword ptr [rdx]  // Read vy
vpxor       ymm0,ymm0,ymm1   // XOR vx, vy       
vptest ymm0, ymm0
jne         00007FFAA1C6CFA6 // Jump on condition (break)

Or something like this.
EDIT: No need for the test.

Running this on 2.1 preview yesterday's daily build. (Doing some comparisons with Numerics and new Intrinsic support)

Any ideas?

[redknightlois]

Ohhh it is a missed optimization... This code works:

var vx = Unsafe.Read<Vector<byte>>(bpx);
var vy = Unsafe.Read<Vector<byte>>(bpy);

var xor = Vector.Xor(vx, vy);
if (xor.Equals(Vector<byte>.Zero))
    break;

[mikedn]

Only the instance bool Equals(Vector<T>) method is an intrinsic. EqualsAll is a "normal" method that simply relies on inlining to get the job done. Unfortunately this can result in temporary local variables being introduced and such variables can block other optimizations.

It looks like xor == Vector<byte>.Zero also works fine even though it too relies on inlining. I'd just use ==.