Proposal: Continuous, Automatic, Self-Improving PGO

[NuminaOneiron]

Proposal: Continuous, Automatic, Self-Improving Profile-Guided Optimization (PGO) for .NET

1. Concept

Introduce a persistent, continuously updated Profile-Guided Optimization (PGO) system integrated into the .NET build and runtime pipeline. Instead of treating PGO as a one-off compilation step, the system becomes a long-lived optimization feedback loop:

• Applications collect performance profiles during development, testing, and production
• Profiles are automatically merged into a single evolving dataset
• Every build automatically uses the most recent validated profile
• The compiler and runtime continuously refine execution based on real usage

2. Feasibility

This proposal is not speculative—it is an extension of existing, proven technologies. Modern .NET already has PGO foundations

• Dynamic PGO in the JIT (runtime profiling of hot paths)
• Tiered compilation (methods recompiled based on usage)
• ReadyToRun and Crossgen2 (ahead-of-time optimization)
• Native AOT (static optimization pipeline)

3. Features

Automatic Profile Collection
Profiles can be generated and collected from:

• Debug runs
• Unit and integration tests
• Benchmarks
• Opt-in production telemetry

Profile Merging
Profiles are continuously merged with existing profiles with:

• version-aware merging (runtime + app version)

Compiler Integration
At build time the following steps occur:

• load latest profile
• apply during:
• inlining decisions
• JIT/AOT code layout
• branch prediction optimization
• allocation strategy selection
• emit optimized binary

Build Storage
PGO + optimization artifacts persist across clean/rebuild (not deleted) and stored in:

• .obj-like build outputs or
• dedicated /pgo/ folder

4. Benefits

Automatic real-world optimization

• Applications optimize based on actual usage patterns instead of synthetic benchmarks.

Continuous performance improvement
Each deployment improves the next build:

• fewer regressions
• better hot-path specialization over time

Reduced manual tuning
Removes the need for:

• hand-written micro-optimizations
• speculative performance tuning
• repeated benchmarking cycles

Enables future compiler features
This system becomes a foundation for:

• escape analysis guided by real usage
• adaptive inlining strategies
• layout-aware memory allocation
• region-based allocation heuristics

5. Examples

Simple opt-in usage in .csproj:

<PropertyGroup>
  <EnableContinuousPGO>true</EnableContinuousPGO>
</PropertyGroup>

Compiler flag:
dotnet build -p:ContinuousPGO=enabled

6. Conclusion

Today PGO represents a large untapped performance opportunity. A continuous PGO system transforms .NET from a static compiler-runtime system into a self-improving execution platform. If implemented, this would significantly improve real-world performance without developer intervention, reduce manual optimization effort and unlock future runtime features that depend on accurate execution modeling

[huoyaoyuan]

Looks like AI-generated non-sense.

Mixing PGO data from multiple sources isn't a good idea. Benchmarks and unit tests will typically create false directions. Instead, end-to-end profiling with final product is much more reliable.