[Jit] Redundant comparisons are not eliminated

[benaadams]

The following code

if (byteValue.Length >= (2 * sizeof(ulong) + sizeof(ushort)))
{
    if (BinaryPrimitives.ReadUInt64LittleEndian(byteValue) == keepChars)
    {

Generates a double comparison once against size 18; and a second against size 8 (which is already guaranteed by the size 18 check)

G_M33915_IG30:
       cmp      r10d, 18
       jl       G_M33915_IG36
       cmp      r10d, 8
       jl       G_M33915_IG59

Method is ParseConnection in this gist https://gist.github.com/benaadams/2ac588cc3dd65088db2bb51f9e4a89e1

Seen in dotnet/aspnetcore#21004

category:cq
theme:assertion-prop
skill-level:intermediate
cost:medium
impact:small

[BruceForstall]

@AndyAyersMS

[AndyAyersMS]

optAssertionPropGlobal_RelOp only looks for exactly matching assertions; it could broaden its horizon to consider any assertion involving the variable part of the comparison.

Specifically, if optGlobalAssertionIsEqualOrNotEqualZero would return assertions where op1.vn matches and not worry if op2.vn matches we could let the caller do further screening to see if any of those assertions is relevant.

We might need to generalize the interaction of the above two methods as there could be many partially matching assertions and we might want to look at them all.

Probably worth some prospecting to see what potential impact this has.

[benaadams]

If you are going there... Jit doesn't seem to pick up where the condition is reversed e.g. > vs <= or < vs >= whether that's ja vs jbe or jl vs jge

This is problematic as Roslyn seems to like reversing the conditionals so it can be hard to get the correct incantation to get them to match and eliminate one.

[AndyAyersMS]

We should be doing some amount of expression canoncalization to reduce diversity in the jit IR. At the very least, moving the variable part of compares to the LHS so we always see x OP k where x is some jit local, OP some relational operator, and k some constant.

The handwavy proposal above would have us examine all the available assertions that involve x. Given x op k and N assertions of the form:

x op0 k0   is true
x op1 k1   is false
x op2 k2   is true
... 

we'd have to check if we could determine the result of x op k.

For single-variable sets of integer relations this comes down to interval math. Range prop does something similar already but it is too narrowly focused on loops and bounds checks.

[benaadams]

Related this

offset++;
if ((uint)offset > (uint)value.Length)
{
    // Consumed enitre string, move to next
    break;
}

value = value.Slice(offset);

generates

G_M33915_IG28:
       inc      r8d
       cmp      r8d, edx
       ja       G_M33915_IG55
       cmp      r8d, edx
       ja       G_M33915_IG60

[AndyAyersMS]

We do not support general relational assertions x OP y -- this may seem like a small distinction since we support x OP k but allowing more general forms here greatly increases complexity.

That being said, for exact redundancies like this, we might be able to do some custom processing by just looking at the predecessor block: if it branches on exactly the same condition as the current block (say the compares have the same value number) then we can optimize. Also probably worth prospecting.

[AndyAyersMS]

@benaadams do you have a more complete example for that "related" fragment?

[benaadams]

do you have a more complete example for that "related" fragment?

ParseConnection in https://gist.github.com/benaadams/02b56912b6174911f81ac1f5152fc593

G_M42236_IG28:
       inc      r8d
       cmp      r8d, edx
       ja       G_M42236_IG55
       cmp      r8d, edx
       ja       G_M42236_IG60