JIT: Use linear block order for MinOpts in LSRA

[amanasifkhalid]

Follow-up from #108086 (comment). Since LSRA shouldn't create cross-block live registers in MinOpts, LSRA's block ordering shouldn't matter, so just use the lexical order we have on-hand.

cc @dotnet/jit-contrib

[dotnet-policy-service]

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

[AndyAyersMS]

This is quite odd... probably worth figuring out what is going on in libraries pmi (likely very few minops methods, but still...)

[amanasifkhalid]

This is quite odd... probably worth figuring out what is going on in libraries pmi (likely very few minops methods, but still...)

I looked at the JitDisasm summary, and there are only a handful of MinOpts methods in libraries.pmi. The standout method is Microsoft.FSharp.Linq.RuntimeHelpers.LeafExpressionConverter:ConvExprToLinqInContext, which has 2459 basic blocks. I'm not able to run pin.exe on my AMD-based DevBox to take a closer look at the TP cost for this method, but perhaps there's some locality issue with using lexical order for super-large methods? For example, if we need to grab the predecessor of a block, the pred is less likely to be cached if we didn't use an RPO traversal, but this only becomes a problem if we have lots of basic blocks.

[amanasifkhalid]

Per discussion here, I'm going to try using the optimized layout all the time to see if we can get around some of the pitfalls of using a RPO sequence on its own.

[amanasifkhalid]

This is quite odd... probably worth figuring out what is going on in libraries pmi (likely very few minopts methods, but still...)

Sorry for getting back to you so late on this, but I finally got pin working thanks to Jakob. The bulk of the TP regression for the above method is coming from LinearScan::processKills. I did some rudimentary profiling, and both traversals call processKills the same number of times, but when using the lexical order, processKills, ends up doing a lot more work for this method: The inner loop runs for about 3.5x more iterations in total. I wonder if processing register kills in some order that doesn't match control flow resulted in some duplicated work -- perhaps the logic for killing registers can be simplified quite a bit for MinOpts, since we don't have cross-block live registers? @kunalspathak would you expect the register killing behavior to change in MinOpts when the block order changes?