Inject LetStmt of variables that are used downstream modulo some constant.

[mcourteaux]

Continues on #9409. Makes aligned splits work on an aligned split, for which the inner loop is then vectorized with an additional split factor.

Idea for the lowering pass by @abadams

Breaking changes

Checklist

• Tests added or updated (not required for docs, CI config, or typo fixes)
• Documentation updated (if public API changed)
• Python bindings updated (if public API changed)
• Benchmarks are included here if the change is intended to affect performance.
• Commits include AI attribution where applicable (see Code of Conduct)

[codecov]

Codecov Report

❌ Patch coverage is 84.00000% with 32 lines in your changes missing coverage. Please review.
⚠️ Please upload report for BASE (mcourteaux/aligned-split-clean@bf66758). Learn more about missing BASE report.

Files with missing lines	Patch %	Lines
src/InjectModuloVars.cpp	83.93%	13 Missing and 18 partials ⚠️
src/Lower.cpp	80.00%	0 Missing and 1 partial ⚠️

Additional details and impacted files

@@                        Coverage Diff                        @@
##             mcourteaux/aligned-split-clean    #9428   +/-   ##
=================================================================
  Coverage                                  ?   70.27%           
=================================================================
  Files                                     ?      262           
  Lines                                     ?    79764           
  Branches                                  ?    19453           
=================================================================
  Hits                                      ?    56052           
  Misses                                    ?    17889           
  Partials                                  ?     5823           

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[alexreinking]

Andrew and I are mulling over the degree to which the simplifier should own the mechanism of simplifying expressions with ring operations modulo constants. That's as distinct from the policy of when to branch a let for which it might be profitable.

[mcourteaux]

Dev Meeting:

• A new simplifier rewrite rule does the trick in my particular case:

     rewrite(x * c0 + (y * c1 + z), (x * fold(c0 / c1) + y) * c1 + z, c0 % c1 == 0) ||

  This alleviates my immediate need for this PR.
• The modulo reduction logic in this PR should probably be unified with the simplifier itself. A ScopedValue can hold the modulo-constant context for which we are currently simplifying. We need to be careful to clear it at the right places before recursing.
• The root cause of this being an issue at all is that the simplifier does not inline let-bound variables. Instead it does peeling of operations with constant operands into the use-site. This is in my particular case insufficient. The simplifier not inlining lets is something that comes up every now and then as a limitation. We discussed the possibility of an intrinsic in the Halide IR that means: inline lets in the contained expression. Or alternatively an intrinsic saying "this Expr must eventually simplify to a constant". Such an intrinsic now gives control to the author of the pipeline. A typical use case would be: mux(must_simplify_to_const(my_expr), ...). One thing to be wary about here is that if loop partitioning ever supports scalar tails, a mux like this might not simplify anymore due when the steady state was unrolled.
• Andrew briefly thought of something like "reverse peeling". You may try to wrap the value of the variable used further into same operation-tree as where the variable is used, and see if anything simplifies.