Using profile information to assist classic code optimizations
Software—Practice & Experience
Reconciling responsiveness with performance in pure object-oriented languages
ACM Transactions on Programming Languages and Systems (TOPLAS)
An approach for exploring code improving transformations
ACM Transactions on Programming Languages and Systems (TOPLAS)
Adaptive optimization in the Jalapeño JVM
OOPSLA '00 Proceedings of the 15th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Using annotations to reduce dynamic optimization time
Proceedings of the ACM SIGPLAN 2001 conference on Programming language design and implementation
Microsoft C# Language Specifications
Microsoft C# Language Specifications
On-Line Algorithms Versus Off-Line Algorithms: How Much is it Worth to Know the Future?
Proceedings of the IFIP 12th World Computer Congress on Algorithms, Software, Architecture - Information Processing '92, Volume 1 - Volume I
Coupling on-line and off-line profile information to improve program performance
Proceedings of the international symposium on Code generation and optimization: feedback-directed and runtime optimization
Soot - a Java bytecode optimization framework
CASCON '99 Proceedings of the 1999 conference of the Centre for Advanced Studies on Collaborative research
Efficient implementation of the smalltalk-80 system
POPL '84 Proceedings of the 11th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Gprof: A call graph execution profiler
SIGPLAN '82 Proceedings of the 1982 SIGPLAN symposium on Compiler construction
Advanced Algorithms
Adaptive systems for the dynamic run-time optimization of programs.
Adaptive systems for the dynamic run-time optimization of programs.
Java(TM) Language Specification, The (3rd Edition) (Java (Addison-Wesley))
Java(TM) Language Specification, The (3rd Edition) (Java (Addison-Wesley))
Generating new general compiler optimization settings
Proceedings of the 19th annual international conference on Supercomputing
Experiences with Multi-threading and Dynamic Class Loading in a Java Just-In-Time Compiler
Proceedings of the International Symposium on Code Generation and Optimization
The DaCapo benchmarks: java benchmarking development and analysis
Proceedings of the 21st annual ACM SIGPLAN conference on Object-oriented programming systems, languages, and applications
Dynamic compilation: the benefits of early investing
Proceedings of the 3rd international conference on Virtual execution environments
JavaTM just-in-time compiler and virtual machine improvements for server and middleware applications
VM'04 Proceedings of the 3rd conference on Virtual Machine Research And Technology Symposium - Volume 3
The java hotspotTM server compiler
JVM'01 Proceedings of the 2001 Symposium on JavaTM Virtual Machine Research and Technology Symposium - Volume 1
Phase-based adaptive recompilation in a JVM
Proceedings of the 6th annual IEEE/ACM international symposium on Code generation and optimization
Design of the Java HotSpot™ client compiler for Java 6
ACM Transactions on Architecture and Code Optimization (TACO)
Novel online profiling for virtual machines
Proceedings of the 6th ACM SIGPLAN/SIGOPS international conference on Virtual execution environments
Taming reflection: Aiding static analysis in the presence of reflection and custom class loaders
Proceedings of the 33rd International Conference on Software Engineering
Generalized just-in-time trace compilation using a parallel task farm in a dynamic binary translator
Proceedings of the 32nd ACM SIGPLAN conference on Programming language design and implementation
JIT Compilation Policy on Single-Core and Multi-core Machines
INTERACT '11 Proceedings of the 2011 15th Workshop on Interaction between Compilers and Computer Architectures
VEE '12 Proceedings of the 8th ACM SIGPLAN/SIGOPS conference on Virtual Execution Environments
Compilation queuing and graph caching for dynamic compilers
Proceedings of the sixth ACM workshop on Virtual machines and intermediate languages
Performance potential of optimization phase selection during dynamic JIT compilation
Proceedings of the 9th ACM SIGPLAN/SIGOPS international conference on Virtual execution environments
Cloud platforms and embedded computing: the operating systems of the future
Proceedings of the 50th Annual Design Automation Conference
Exploring single and multilevel JIT compilation policy for modern machines 1
ACM Transactions on Architecture and Code Optimization (TACO)
Proceedings of the 19th international conference on Architectural support for programming languages and operating systems
Hi-index | 0.01 |
Dynamic or Just-in-Time (JIT) compilation is crucial to achieve acceptable performance for applications (written in managed languages, such as Java and C#) distributed as intermediate language binary codes for a virtual machine (VM) architecture. Since it occurs at runtime, JIT compilation needs to carefully tune its compilation policy to make effective decisions regarding 'if' and 'when' to compile different program regions to achieve the best overall program performance. Past research has extensively tuned JIT compilation policies, but mainly for VMs with a single compiler thread and for execution on single-processor machines. This work is driven by the need to explore the most effective JIT compilation strategies in their modern operational environment, where (a) processors have evolved from single to multi/many cores, and (b) VMs provide support for multiple concurrent compiler threads. Our results confirm that changing 'if' and 'when' methods are compiled have significant performance impacts. We construct several novel configurations in the HotSpot JVM to facilitate this study. The new configurations are necessitated by modern Java benchmarks that impede traditional static whole-program discovery, analysis and annotation, and are required for simulating future many-core hardware that is not yet widely available. We study the effects on performance of increasing compiler aggressiveness for VMs with multiple compiler threads running on existing single/multi-core and future many-core machines. Our results indicate that although more aggressive JIT compilation policies show no benefits on single-core machines, these can often improve program performance for multi/many-core machines. However, accurately prioritizing JIT method compilations is crucial to realize such benefits.