JIT Compilation Policy on Single-Core and Multi-core Machines

Authors:
Prasad A. Kulkarni;Jay Fuller
Affiliations:
-;-
Venue:
INTERACT '11 Proceedings of the 2011 15th Workshop on Interaction between Compilers and Computer Architectures
Year:
2011

Citing 0
Cited 3

JIT compilation policy for modern machines

Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
Efficiently parallelizing instruction set simulation of embedded multi-core processors using region-based just-in-time dynamic binary translation

Proceedings of the 13th ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, Tools and Theory for Embedded Systems
Exploring single and multilevel JIT compilation policy for modern machines 1

ACM Transactions on Architecture and Code Optimization (TACO)

Quantified Score

Hi-index	0.01

Visualization

Abstract

Dynamic or Just-in-Time (JIT) compilation is crucial to achieve acceptable performance for applications written in traditionally interpreted languages, such as Java and C#. Such languages enable the generation of portable applications that are written and compiled once, and can be executed by a virtual machine on any supported architecture. However, by virtue of occurring at runtime, dynamic compilation adds to the overall execution time of the application, and can potentially slow down program execution if performed injudiciously. Selective compilation is a technique that was developed for single-core architectures to manage the compilation overhead by dynamically determining and compiling only the most critical program regions. Current processors have evolved from single-core machines to those supporting multiple tightly-integrated cores. Consequently, research is needed to explore the best JIT compilation policy on multi-core machines with several concurrent compiler threads. In this paper, we present novel experimental configurations to understand the benefits of dynamic compilation, and find the best JIT compilation policies on single and multi-core machines. Our results validate earlier claims that compiling a small percentage of methods has an inordinately large impact on performance. We show that spawning a greater number of simultaneous compiler threads can achieve better program performance on single-core machines. Our results also reveal that more than an increase in compiler aggressiveness, a small increase in the number of compiler threads achieves the best application performance on multi-core machines.