Where are the tests for morphing (morph.cpp)?

[lsoft]

I started to read runtime code for self-education, and I wonder if there is the unit tests for optimizations from morph.cpp? for example // Fold "x * 1.0" to "x".

Probably I don't see something obvious, sorry for dumb question.

[SingleAccretion]

The Jit currently does not have "unit" test (with a few one-off exceptions). Most of the testing is functional and lives under src/tests/JIT. You can find some tests there which are meant to exercise specific optimizations, though it can sometimes be challenging to find exactly what you are looking for.

[lsoft]

@SingleAccretion thanks for your answer, I have 2 additional questions if I'm allowed to ask:

1. theoretical: if there is no such 'unit' test, how can people be sure that optimizations are still here and didn't lost?
2. practical: if I want to play with morphing, for example, try to add new optimization, how can I make sure that my changes a. are working? b. do not break something else?

[SingleAccretion]

theoretical: if there is no such 'unit' test, how can people be sure that optimizations are still here and didn't lost?

For all Jit changes, assembly code diffs they cause are evaluated. We have tooling (SPMI), in CI and locally, that allows one to replay tens of thousands of compilations and view how the Jit's output changes. We also have a good number of performance benchmarks that are monitored for regressions. These are the two primary mechanisms that ensure no unexpected things happen.

practical: if I want to play with morphing, for example, try to add new optimization, how can I make sure that my changes a. are working? b. do not break something else?

a) It's a bit of a personal workflow choice; I usually just create a very simple managed method and check whether the changes have the desired outcome. A collection of such methods could be, and often is, turned into a runtime test and committed together with the change.
b) For broader coverage, we have SPMI and the CI testing - which includes not just the tests run on PRs, but also a number of dedicated "jit stress" pipelines where various internal knobs are turned on that perturb the Jit's operation in interesting ways.

[lsoft]

@SingleAccretion thanks! your tips was valuable for me.

I'm going forward and now I have the following dll

float a = 123;
float c = a * 1f;
Console.WriteLine($"c is {c}");

 .method private hidebysig static void
    '<Main>$'(
      string[] args
    ) cil managed
  {
    .entrypoint
    .maxstack 3
    .locals init (
      [0] float32 c,
      [1] valuetype [System.Runtime]System.Runtime.CompilerServices.DefaultInterpolatedStringHandler V_1
    )

    // [1 1 - 1 15]
    IL_0000: ldc.r4       123

    // [4 1 - 4 18]
    IL_0005: ldc.r4       1
    IL_000a: mul
    IL_000b: stloc.0      // c

    // [6 1 - 6 32]
    IL_000c: ldloca.s     V_1
    IL_000e: ldc.i4.5
    IL_000f: ldc.i4.1
    IL_0010: call         instance void [System.Runtime]System.Runtime.CompilerServices.DefaultInterpolatedStringHandler::.ctor(int32, int32)
    IL_0015: ldloca.s     V_1
    IL_0017: ldstr        "c is "
    IL_001c: call         instance void [System.Runtime]System.Runtime.CompilerServices.DefaultInterpolatedStringHandler::AppendLiteral(string)
    IL_0021: ldloca.s     V_1
    IL_0023: ldloc.0      // c
    IL_0024: call         instance void [System.Runtime]System.Runtime.CompilerServices.DefaultInterpolatedStringHandler::AppendFormatted<float32>(!!0/*float32*/)
    IL_0029: ldloca.s     V_1
    IL_002b: call         instance string [System.Runtime]System.Runtime.CompilerServices.DefaultInterpolatedStringHandler::ToStringAndClear()
    IL_0030: call         void [System.Console]System.Console::WriteLine(string)
    IL_0035: ret

I can to debug this dll and I able to catch breakpoints in GenTree* Compiler::fgOptimizeMultiply(GenTreeOp* mul) successfully.

It's a bit strange for me, but double multiplierValue = op2->AsDblCon()->gtDconVal; see 123 instead of 1.0, so // Fold "x * 1.0" to "x". is not invoked and I suspect the optimization is not in action.

To make sure, I need (somehow) to see the actual ASM code which jit emits. Could someone shed some light how to extract ASM from debugged jit?

[SingleAccretion]

see 123 instead of 1.0

Ordinarily, I would expect this expression to have been folded by the time we get to post-order. Are you running with optimizations on (aka TC turned off, DOTNET_TieredCompilation=0)?

To make sure, I need (somehow) to see the actual ASM code which jit emits. Could someone shed some light how to extract ASM from debugged jit?

DOTNET_JitDisasm=<method name> is the environment variable for that. However, for actual Jit development, you likely want the much more informative Jit dumps instead.

[lsoft]

@SingleAccretion

Are you running with optimizations on

I'm debugging on windows.x64.debug coreclr binaries and release configuration of my dll.

DOTNET_TieredCompilation=0

I set <TieredCompilation>false</TieredCompilation> to csproj, is it enough? I have now:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <TieredCompilation>false</TieredCompilation>
 </PropertyGroup>

</Project>

using System.Runtime.CompilerServices;

Mult();


[MethodImpl(MethodImplOptions.NoInlining)]
void Mult()
{
    float a = 123;
    //float b = 1;

    float c = a * 1f;

    Console.WriteLine($"c is {c}");
}

and I see the following:

I can't check ASM right now, due to I don't receive jit dumps. I followed that instruction but I've lost something probably (no idea what).

(HKCU too)

[lsoft]

addition: I get something big (18 MB) like:

****** START compiling System.Runtime.CompilerServices.CastHelpers:StelemRef(System.Array,long,System.Object) (MethodHash=dcdda805)
Generating code for Windows x64
OPTIONS: compCodeOpt = BLENDED_CODE
OPTIONS: compDbgCode = false
OPTIONS: compDbgInfo = true
OPTIONS: compDbgEnC  = false
OPTIONS: compProcedureSplitting   = false
OPTIONS: compProcedureSplittingEH = false
OPTIONS: No PGO data
IL to import:
IL_0000  02                ldarg.0     
IL_0001  28 4b 07 00 2b    call         0x2B00074B
IL_0006  03                ldarg.1     

...

*************** Finishing PHASE Morph - Structs/AddrExp
Trees after Morph - Structs/AddrExp

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight   IBC  lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1           [000..008)                                     i
BB02 [0001]  1  0    BB01                  1    100    [008..017)-> BB05 ( cond ) T0      try {       keep i try IBC
BB04 [0011]  1  0    BB02                  0      0    [008..009)                 T0                  i rare IBC
BB05 [0012]  2  0    BB02,BB04             1    100    [008..009)                 T0                  i IBC
BB06 [0013]  1  0    BB05                  1           [???..???)-> BB08 ( cond ) T0                  keep internal
BB07 [0002]  1  0    BB06                  1           [017..02B)                 T0                  i
BB08 [0003]  2  0    BB06,BB07             1           [02B..033)                 T0      }           i
BB10 [0015]  1       BB08                  1           [033..036)-> BB16 ( cond )                     keep i cfb
BB11 [0016]  1       BB10                  1           [036..03D)-> BB16 (always)                     i
BB13 [0004]  1     0                       1           [033..036)-> BB15 ( cond )    H0   fault {     keep i
BB14 [0005]  1     0 BB13                  1           [036..03C)                    H0               i
BB15 [0006]  2     0 BB13,BB14             1           [03C..03D)        (finret)    H0   }           i
BB16 [0007]  2       BB10,BB11             1           [03D..03F)        (return)                     i
-----------------------------------------------------------------------------------------------------------------------------------------

...

That's not I need, no info about my dll exists here...

[SingleAccretion]

I set <TieredCompilation>false</TieredCompilation> to csproj, is it enough?

Depends on how you get the app to run; corerun will not read the runtime config this feeds, dotnet/apphost will.

no info about my dll exists here...

I have a suspicion the Mult function there is a local function, with a mangled name (e. g. Program:<<Main>$>g__Mult).

[lsoft]

@SingleAccretion You're right. I switched to static method of static class and now I have ****** START compiling Calc:Mult() (MethodHash=c2fa73b3) dump, 1.6MB of text 😁

could you share any tips to read such files?

[SingleAccretion]

Glad it worked in the end!

could you share any tips to read such files?

There is some useful information in the documentation.

Personally, I find Notepad++ to be a good tool for reading the dumps, mainly due to fast search; syntax highlighting (C# one works well) is also useful.

Beyond that, one is usually not "reading" the dump, but searching through it, either for specific phases (Starting PHASE ... messages), or trees (Crtl+F [000012] - the "tree ID", forward and backward with [Shift]+Enter), looking for information of interest (in your case, specific transformations being applied). Most things that do significant work write something to the dump; for some you have to drop down to manual debugging, though.