Improve JIT of static variables which value is already known

[Symbai]

The JIT can be improved when a static variable is declared with a constant value, ideally by treating it like a constant.

Declared as constant

static class Bla
{
	public const double Value1 = 2d;
	public const double Value2 = 5d;

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public static double BlaMethod(double val)
	{
		return val / Value1 / Value2;
	}
}
---------------------------------------------------------
vzeroupper
xchg      ax,ax
vdivsd    xmm0,xmm0,[rel 7FFA`42B2`F0A8h]
vdivsd    xmm0,xmm0,[rel 7FFA`42B2`F0B0h]
ret

Declared as static

static class Bla
{
	public static double Value1 = 2d;
	public static double Value2 = 5d;

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public static double BlaMethod(double val)
	{
		return val / Value1 / Value2;
	}
}
---------------------------------------------------------
sub       rsp,28h
vzeroupper
vmovsd    [rsp+30h],xmm0
mov       rcx,7FFA`42B9`6A88h
mov       edx,2
call      0000`7FFA`A260`70B0h
vmovsd    xmm0,[rsp+30h]
vdivsd    xmm0,xmm0,[rel 7FFA`42B9`6AC0h]
vdivsd    xmm0,xmm0,[rel 7FFA`42B9`6AC8h]
add       rsp,28h
ret

[poizan42]

Did you mean to declare them readonly? Because otherwise the JIT obviously can't make any assumptions about their value.

As an aside, the codegen for the constant case seems inefficient as it is actually just dividing by 10.

[Gnbrkm41]

Without the field being static readonly it cannot substitute the value in the JIT time (as the field can be modified by any thread). Not sure about the constant being not folded, but I assume it's because of things like rounding, as after each division the number will be rounded twice whereas if you fold the constant it'll actually round once, which may produce inaccurate results.

[tannergooding]

Not sure about the constant being not folded, but I assume it's because of things like rounding, as after each division the number will be rounded twice whereas if you fold the constant it'll actually round once, which may produce inaccurate results.

Right, floating-point arithmetic is not the same as normal math. Where in normal math a + b + c is equal whether you do (a + b) + c or a + (b + c), you may get different results when done using floating-point arithmetic (because you must round after each operation).

A trivial example of this is 3.14159f / 21.0f vs 3.14159f / 3.0f / 7.0f. The former computes 0.1495995223522186279296875 (bit representation 0x3E19309E) while the latter computes 0.14959953725337982177734375 (bit representation 0x3E19309F).

The same is true not only for float/double/IEEE arithmetic, but any arithmetic where you are representing arbitrary precision data in finite space.

[Symbai]

Did you mean to declare them readonly? Because otherwise the JIT obviously can't make any assumptions about their value.

Considering readonly produces the same when not, yes.

static class Bla
{
    public static readonly double Value1 = 2d;
    public static readonly double Value2 = 5d;
        
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static double BlaMethod(double val)
    {
        return val / Value1 / Value2;
    }
}
---------------------------------------------------------
sub       rsp,28h
vzeroupper
vmovsd    [rsp+30h],xmm0
mov       rcx,7FFA`4A14`6A88h
mov       edx,2
call      0000`7FFA`A9BE`70B0h
mov       rax,7FFA`4A14`6AC0h
vmovsd    xmm0,[rsp+30h]
vdivsd    xmm0,xmm0,[rax]
mov       rax,7FFA`4A14`6AC8h
vdivsd    xmm0,xmm0,[rax]
add       rsp,28h
ret

And same goes for non float/double.

static class Bla
{
    public static readonly int Value1 = 2;
    public static readonly int Value2 = 5;
        
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static int BlaMethod(int val)
    {
        return val + Value1 + Value2;
    }
}
---------------------------------------------------------
push      rsi
sub       rsp,20h
mov       esi,ecx
mov       rcx,7FFA`4A17`6A88h
mov       edx,2
call      0000`7FFA`A9BE`70B0h
mov       rax,7FFA`4A17`6ABCh
add       esi,[rax]
mov       rax,7FFA`4A17`6AC0h
add       esi,[rax]
mov       eax,esi
add       rsp,20h
pop       rsi
ret
---------------------------------------------------------
static class Bla
{
    public const int Value1 = 2;
    public const int Value2 = 5;
        
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static int BlaMethod(int val)
    {
        return val + Value1 + Value2;
    }
}
---------------------------------------------------------
nop       dword [rax+rax]
lea       eax,[rcx+7]
ret

[stephentoub]

Considering readonly produces the same when not, yes.

Once tiered compilation kicks in and recompiles it for tier 1, static readonlys should become consts. Here's what I see:

using System;
using System.Runtime.CompilerServices;

class Program
{
    static void Main()
    {
        while (true) Call();
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    static double Call() => Bla.BlaMethod(42);
}

static class Bla
{
    public static readonly double Value1 = 2d;
    public static readonly double Value2 = 5d;
        
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static double BlaMethod(double val)
    {
        return val / Value1 / Value2;
    }
}

When it first compiles in Tier 0, it creates:

G_M59608_IG01:
       55                   push     rbp
       4883EC20             sub      rsp, 32
       C5F877               vzeroupper
       488D6C2420           lea      rbp, [rsp+20H]
                                                ;; bbWeight=1    PerfScore 2.75
G_M59608_IG02:
       C5FB100513000000     vmovsd   xmm0, qword ptr [reloc @RWD00]
       E8DEFBFFFF           call     Bla:BlaMethod(double):double
       90                   nop
                                                ;; bbWeight=1    PerfScore 3.25
G_M59608_IG03:
       488D6500             lea      rsp, [rbp]
       5D                   pop      rbp
       C3                   ret
                                                ;; bbWeight=1    PerfScore 2.00
RWD00  dq       4045000000000000h

but then when it recompiles in Tier 1, we get:

G_M59609_IG01:
       C5F877               vzeroupper
                                                ;; bbWeight=1    PerfScore 1.00
G_M59609_IG02:
       C5FB100505000000     vmovsd   xmm0, qword ptr [reloc @RWD00]
                                                ;; bbWeight=1    PerfScore 2.00
G_M59609_IG03:
       C3                   ret
                                                ;; bbWeight=1    PerfScore 1.00
RWD00  dq       4010CCCCCCCCCCCDh

And if I change my code to make your BlaMethod not inlined:

using System;
using System.Runtime.CompilerServices;

class Program
{
    static void Main()
    {
        while (true) Call();
    }

    static double Call() => Bla.BlaMethod(42);
}

static class Bla
{
    public static readonly double Value1 = 2d;
    public static readonly double Value2 = 5d;
        
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static double BlaMethod(double val)
    {
        return val / Value1 / Value2;
    }
}

for Tier 0 I get:

_M50308_IG01:
       55                   push     rbp
       4883EC40             sub      rsp, 64
       C5F877               vzeroupper
       C5F829742430         vmovaps  qword ptr [rsp+30H], xmm6
       488D6C2440           lea      rbp, [rsp+40H]
       C5FB114510           vmovsd   qword ptr [rbp+10H], xmm0
                                                ;; bbWeight=1    PerfScore 6.25
G_M50308_IG02:
       C5FB107510           vmovsd   xmm6, qword ptr [rbp+10H]
       48B918F3CF05FB7F0000 mov      rcx, 0x7FFB05CFF318
       BA02000000           mov      edx, 2
       E82F72BA5F           call     CORINFO_HELP_GETSHARED_NONGCSTATIC_BASE
       C5F828C6             vmovaps  xmm0, xmm6
       C5FB5E05B3E00900     vdivsd   xmm0, qword ptr [reloc classVar[0x5d23250]]
       C5FB1145E8           vmovsd   qword ptr [rbp-18H], xmm0
       48B918F3CF05FB7F0000 mov      rcx, 0x7FFB05CFF318
       BA02000000           mov      edx, 2
       E80A72BA5F           call     CORINFO_HELP_GETSHARED_NONGCSTATIC_BASE
       C5FB1045E8           vmovsd   xmm0, qword ptr [rbp-18H]
       C5FB5E0595E00900     vdivsd   xmm0, qword ptr [reloc classVar[0x5d23260]]
                                                ;; bbWeight=1    PerfScore 35.75
G_M50308_IG03:
       C5F828742430         vmovaps  xmm6, qword ptr [rsp+30H]
       488D6500             lea      rsp, [rbp]
       5D                   pop      rbp
       C3                   ret

and then for Tier 1:

G_M50308_IG01:
       C5F877               vzeroupper
                                                ;; bbWeight=1    PerfScore 1.00
G_M50308_IG02:
       C5FB59050D000000     vmulsd   xmm0, qword ptr [reloc @RWD00]
       C5FB5E050D000000     vdivsd   xmm0, qword ptr [reloc @RWD08]
                                                ;; bbWeight=1    PerfScore 19.00
G_M50308_IG03:
       C3                   ret
                                                ;; bbWeight=1    PerfScore 1.00
RWD00  dq       3FE0000000000000h
RWD08  dq       4014000000000000h

And if I instead make the static readonlys into consts:

using System;
using System.Runtime.CompilerServices;

class Program
{
    static void Main()
    {
        while (true) Call();
    }

    static double Call() => Bla.BlaMethod(42);
}

static class Bla
{
    public const double Value1 = 2d;
    public const double Value2 = 5d;
        
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static double BlaMethod(double val)
    {
        return val / Value1 / Value2;
    }
}

for Tier 1 I get the same thing:

G_M50308_IG01:
       C5F877               vzeroupper
                                                ;; bbWeight=1    PerfScore 1.00
G_M50308_IG02:
       C5FB59050D000000     vmulsd   xmm0, qword ptr [reloc @RWD00]
       C5FB5E050D000000     vdivsd   xmm0, qword ptr [reloc @RWD08]
                                                ;; bbWeight=1    PerfScore 19.00
G_M50308_IG03:
       C3                   ret
                                                ;; bbWeight=1    PerfScore 1.00
RWD00  dq       3FE0000000000000h
RWD08  dq       4014000000000000h

So it looks like it's doing it correctly.

[Symbai]

Right forgot about that