JIT: Faster Math.Max/Min for x64

[EgorBo]

Optimize Math.Max/Min to a single instruction on x64 when one of the arguments is a constant (not NaN and whoever will be implementing it has to be careful around -/+0.0)

float Test(float a) => Math.Max(a, 10);

Currently emits:

; Method Tests4:Test(float):float:this
G_M55200_IG01:
       vzeroupper 
G_M55200_IG02:
       vmovss   xmm0, dword ptr [reloc @RWD00]
       vucomiss xmm1, xmm0
       jp       SHORT G_M55200_IG03
       je       SHORT G_M55200_IG06
G_M55200_IG03:
       vucomiss xmm1, xmm1
       jp       SHORT G_M55200_IG05
       vucomiss xmm1, xmm0
       ja       SHORT G_M55200_IG04
       jmp      SHORT G_M55200_IG08
G_M55200_IG04:
       vmovaps  xmm0, xmm1
       jmp      SHORT G_M55200_IG08
G_M55200_IG05:
       vmovaps  xmm0, xmm1
       jmp      SHORT G_M55200_IG08
G_M55200_IG06:
       vmovaps  xmm1, xmm0
       vmovd    eax, xmm1
       test     eax, eax
       jl       SHORT G_M55200_IG07
       jmp      SHORT G_M55200_IG08
G_M55200_IG07:
       vmovss   xmm0, dword ptr [reloc @RWD00]
G_M55200_IG08:
       ret      
RWD00  	dd	41200000h		;        10
; Total bytes of code: 68

Expected codegen:

; Method Tests4:Test(float):float:this
       vzeroupper 
       vmaxss   xmm0, xmm1, dword ptr [reloc @RWD00]
       ret      
RWD00  	dd	41200000h ; 10.0
; Total bytes of code: 12

#65584 did it for ARM where we could do it even for both non-constants

[ghost]

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

Issue Details

---

Optimize Math.Max/Min to a single instruction on x64 when one of the arguments is a constant (not NaN and has to be careful around -/+0.0)

float Test(float a) => Math.Max(a, 10);

Currently emits:

; Method Tests4:Test(float):float:this
G_M55200_IG01:
       vzeroupper 
G_M55200_IG02:
       vmovss   xmm0, dword ptr [reloc @RWD00]
       vucomiss xmm1, xmm0
       jp       SHORT G_M55200_IG03
       je       SHORT G_M55200_IG06
G_M55200_IG03:
       vucomiss xmm1, xmm1
       jp       SHORT G_M55200_IG05
       vucomiss xmm1, xmm0
       ja       SHORT G_M55200_IG04
       jmp      SHORT G_M55200_IG08
G_M55200_IG04:
       vmovaps  xmm0, xmm1
       jmp      SHORT G_M55200_IG08
G_M55200_IG05:
       vmovaps  xmm0, xmm1
       jmp      SHORT G_M55200_IG08
G_M55200_IG06:
       vmovaps  xmm1, xmm0
       vmovd    eax, xmm1
       test     eax, eax
       jl       SHORT G_M55200_IG07
       jmp      SHORT G_M55200_IG08
G_M55200_IG07:
       vmovss   xmm0, dword ptr [reloc @RWD00]
G_M55200_IG08:
       ret      
RWD00  	dd	41200000h		;        10
; Total bytes of code: 68

Expected codegen:

; Method Tests4:Test(float):float:this
       vzeroupper 
       vmaxss   xmm0, xmm1, dword ptr [reloc @RWD00]
       ret      
RWD00  	dd	41200000h ; 10.0
; Total bytes of code: 12

#65584 did it for ARM where we could do it even for both non-constants

Author:	EgorBo
Assignees:	-
Labels:	tenet-performance, area-CodeGen-coreclr, untriaged
Milestone:	-

[tannergooding]

In particular, Math.Max and Math.Min for floating-point have a requirement, from the IEEE 754 spec, that -0.0 be the minimum of it and +0.0. Likewise, they have a requirement that NaN is propagated (if both inputs are NaN, then the exact NaN returned doesn't matter).

x86/x64 provide maxss and minss. These instructions will return the second operand if both operands are 0 (same or differing signs). Likewise, if either input is NaN, the second operand is returned. Otherwise, the correct max/min is returned.

What this functionally means is that if both inputs are unknown, we can't really "optimize" and instead have to use maxss/minss and then some follow up computations. However, if either input is constant then we actually can optimize it down to a single instruction in all cases:

• In the case both are constant, we simply constant fold and it doesn't matter.
• If either input is known to be NaN, it is used as the second argument (ensuring NaN is propagated since either input being NaN means the second argument is returned)
• For maxss, if either input is +0.0 it takes the second argument (ensuring +0.0 is returned if both inputs are zero since both inputs being zero, of either sign, means the second argument is returned)
• For minss, if either input is -0.0 it takes the second argument (ensuring -0.0 is returned if both inputs are zero since both inputs being zero, of either sign, means the second argument is returned)
• Otherwise, for any other known constant input it is the first argument
  • If the unknown is NaN, this ensures it is returned since either input being NaN means the second argument is returned
  • If the unknown is +0.0 for maxss and the known was -0.0, it would ensure +0.0 is returned since both inputs being zero, of either sign, means the second argument is returned
  • If the unknown is -0.0 for minss and the known was +0.0, it would ensure -0.0 is returned since both inputs being zero, of either sign, means the second argument is returned
  • For any other inputs known or unknown; the default handling is already correct

This ensures that Max returns NaN and +0.0 and likewise that Min returns NaN and -0.0 for their respective special cases.

[SkiFoD]

Hey, everyone. I would like to take a look at the issue. @EgorBo Could you please tell me how you made "Math.Max" call to get inlined?

[EgorBo]

Hey, everyone. I would like to take a look at the issue. @EgorBo Could you please tell me how you made "Math.Max" call to get inlined?

Hey, sure! What do you mean inlined? Intrinsic?

[SkiFoD]

I'm trying to get the same emit, but I always get something like this:

So I can't look inside the Math.Max call to invistigate it.

[EgorBo]

@SkiFoD see #65584, it ifdefed special import for Max for x86/64, you need to enable it, most likely you will also have to modify lsraxarch and the xarch emitter

[SkiFoD]

@EgorBo Thank you, so basically you are changing the call to instrinsic use.

[SkiFoD]

@EgorBo Seems like I figured out how to make the changes, but I got a few questions.
Is it all right that the call transforms to the intrinsic use only under a pressure (like if the Math.Max/Min is called in a huge cycle) or if there are envs "COMPlus_TieredCompilation=0" and "COMPlus_JITMinOpts=0" set up?
p.s. For some reason if I used the envs along with "COMPlus_JitDump/JitDisasm" then there are not output in the console :( Have you ever come across with such a behaviour?

[EgorBo]

@EgorBo Seems like I figured out how to make the changes, but I got a few questions. Is it all right that the call transforms to the intrinsic use only under a pressure (like if the Math.Max/Min is called in a huge cycle) or if there are envs "COMPlus_TieredCompilation=0" and "COMPlus_JITMinOpts=0" set up? p.s. For some reason if I used the envs along with "COMPlus_JitDump/JitDisasm" then there are not output in the console :( Have you ever come across with such a behaviour?

Yes, we don't expand intrinsics in tier0 (unoptimized code) - only a few "must expand" ones. So I'd suggest to disable tiered compilation during development

[SkiFoD]

@EgorBo please take a look at my PR, I would like to know what you think of this.

[danmoseley]

linking #65700