Modern Just-in-Time compilers make extensive use of runtime profiling data as part of their optimization strategies - past behaviour is assumed to predict future behaviour. The profiling data exploited by these compilers includes both the relative execution frequencies of different program paths as well as the values observed for specific program intermediate values. The Eclipse OpenJ9 compiler currently has a form of software profiling used at high optimization levels to gather detailed information about a program’s behaviour. This profiling infrastructure incurs a very high throughput performance penalty in excess of 90% throughput as well as consuming a significant amount of memory. The overhead of profiling is lowered using sampling techniques, but this can lead to loss of precision in profiling results when the period of events coincides even loosely with the sampling frequency of the profiling instrumentation.
Over the last year and a half we have built a new software profiling framework for Eclipse OpenJ9 called JProfiling. This profiling technology lowers the throughput penalty of profiling to approximately a 30% throughput penalty without sampling. Profiling of only execution path frequency can be obtained for a throughput penalty of approximately 10%. This talk will present the profiling techniques we are using as well as our most recent work to make the profiling patchable so that we can include it in nearly all of the compiled bodies produced by our compiler for minimal throughput overhead. This patchable profiling is targeted to help the OpenJ9 runtime adapt to phase changes where past behaviour ceases to be a good predictor of future behaviour. We plan for this infrastructure to be promoted to OMR once some enabling infrastructure is refactored between the OMR and OpenJ9 projects.