Trace-based compilation for the Java HotSpot virtual machine

Häubl, Christian; Mössenböck, Hanspeter

doi:10.1145/2093157.2093176

Cited by 24 publications

(28 citation statements)

References 27 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…In [18][19][20], a trace that is aborted from the compiled code into the interpreted execution too frequently may be recompiled to include a trace starting from the side exit point in the compilation scope. Such recompilation is used to limit the penalty of a badly formed trace by extending the coverage by the compiled code, not for upgrading compilation for really hot traces.…”

Section: Related Workmentioning

confidence: 99%

Adaptive multi-level compilation in a trace-based Java JIT compiler

Inoue

Hayashizaki

et al. 2012

Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications

View full text Add to dashboard Cite

This paper describes our multi-level compilation techniques implemented in a trace-based Java JIT compiler (trace-JIT). Like existing multi-level compilation for method-based compilers, we start JIT compilation with a small compilation scope and a low optimization level so the program can start running quickly. Then we identify hot paths with a timer-based sampling profiler, generate long traces that capture the hot paths, and recompile them with a high optimization level to improve the peak performance. A key to high performance is selecting long traces that effectively capture the entire hot paths for upgrade recompilations. To do this, we introduce a new technique to generate a directed graph representing the control flow, a TTgraph, and use the TTgraph in the trace selection engine to efficiently select long traces. We show that our multilevel compilation improves the peak performance of programs by up to 58.5% and 22.2% on average compared to compiling all of the traces only at a low optimization level. Comparing the performance with our multi-level compilation to the performance when compiling all of the traces at a high optimization level, our technique can reduce the startup times of programs by up to 61.1% and 31.3% on average without significant reduction in the peak performance. Our results show that our adaptive multilevel compilation can balance the peak performance and startup time by taking advantage of different optimization levels.

show abstract

Section: Related Workmentioning

confidence: 99%

Adaptive multi-level compilation in a trace-based Java JIT compiler

Inoue

Hayashizaki

et al. 2012

Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications

View full text Add to dashboard Cite

show abstract

“…loop header, method entry) [2,15,17,19,36], or always enabled when interpreting code [4]. Various backbone data structures have been suggested to capture recorded traces such as trace-trees [14], control-flow-graphs (CFG) of traced basic blocks [4], or hybrids between trace-trees and CFGs called trace-regions [2] or trace-graphs [18]. In general, recording approaches for multi-threaded applications can be categorized based on how CFG recordings are accessed and constructed:…”

Section: Region-recording For Multi-threaded Applicationsmentioning

confidence: 99%

“…• Global Recording Structure -Most [2,14,15,[17][18][19]36] JIT compilation systems use one shared global recording structure ( 1 in Figure 1) to incrementally build CFG sections. This scheme works well for single-threaded execution environments but does not scale to multi-threaded applications as additional synchronisation is required when recording in parallel for multiple threads.…”

Section: Region-recording For Multi-threaded Applicationsmentioning

confidence: 99%

“…Only one background compilation thread is used. A similar global trace cache is used by Häubl [18] for the Hotspot JVM. Wimmer et al [36] note that tracing enables simple phase change detection by comparing the ratio of side exits taken to the time spent in the trace itself.…”

Section: Tracing Parallel Jit Compilationmentioning

confidence: 99%

“…[19]. An alternative approach that avoids this problem is to maintain thread-private traces [13,18], i.e. for each application thread a separate trace data structure is maintained.…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Efficiently parallelizing instruction set simulation of embedded multi-core processors using region-based just-in-time dynamic binary translation

Kyle

Böhm

Franke

et al. 2012

Proceedings of the 13th ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, Tools and Theory for Embedded Syst

View full text Add to dashboard Cite

Embedded systems, as typified by modern mobile phones, are already seeing a drive toward using multi-core processors. The number of cores will likely increase rapidly in the future. Engineers and researchers need to be able to simulate systems, as they are expected to be in a few generations time, running simulations of many-core devices on today's multi-core machines. These requirements place heavy demands on the scalability of simulation engines, the fastest of which have typically evolved from just-in-time (JIT) dynamic binary translators (DBT).Existing work aimed at parallelizing DBT simulators has focused exclusively on trace-based DBT, wherein linear execution traces or perhaps trees thereof are the units of translation. Regionbased DBT simulators have not received the same attention and require different techniques than their trace-based cousins.In this paper we develop an innovative approach to scaling multi-core, embedded simulation through region-based DBT. We initially modify the JIT code generator of such a simulator to emit code that does not depend on a particular thread with its threadspecific context and is, therefore, thread-agnostic. We then demonstrate that this thread-agnostic code generation is comparable to thread-specific code with respect to performance, but also enables the sharing of JIT-compiled regions between different threads. This sharing optimisation, in turn, leads to significant performance improvements for multi-threaded applications. In fact, our results confirm that an average of 76% of all JIT-compiled regions can be shared between 128 threads in representative, parallel workloads. We demonstrate that this translates into an overall performance improvement by 1.44x on average and up to 2.40x across 12 multithreaded benchmarks taken from the SPLASH-2 benchmark suite, targeting our high-performance multi-core DBT simulator for embedded ARC processors running on a 4-core Intel host machine.

show abstract

Context-sensitive trace inlining for Java

Häubl¹,

Wimmer²,

Mössenböck³

2013

Computer Languages, Systems & Structures

Self Cite

View full text Add to dashboard Cite

Method inlining is one of the most important optimizations in method-based just-in-time (JIT) compilers. It widens the compilation scope and therefore allows optimizing multiple methods as a whole, which increases the performance. However, if method inlining is used too frequently, the compilation time increases and too much machine code is generated. This has negative effects on the performance.Trace-based JIT compilers only compile frequently executed paths, so-called traces, instead of whole methods. This may result in faster compilation, less generated machine code, and better optimized machine code. In the previous work, we implemented a trace recording infrastructure and a trace-based compiler for JavaTM, by modifying the Java HotSpot VM. Based on this work, we evaluate the effect of trace inlining on the performance and the amount of generated machine code.Trace inlining has several major advantages when compared to method inlining. First, trace inlining is more selective than method inlining, because only frequently executed paths are inlined. Second, the recorded traces may capture information about virtual calls, which simplify inlining. A third advantage is that trace information is context sensitive so that different method parts can be inlined depending on the specific call site. These advantages allow more aggressive inlining while the amount of generated machine code is still reasonable.We evaluate several inlining heuristics on the benchmark suites DaCapo 9.12 Bach, SPECjbb2005, and SPECjvm2008 and show that our trace-based compiler achieves an up to 51% higher peak performance than the method-based Java HotSpot client compiler. Furthermore, we show that the large compilation scope of our trace-based compiler has a positive effect on other compiler optimizations such as constant folding or null check elimination.

show abstract

Trace-based compilation for the Java HotSpot virtual machine

Cited by 24 publications

References 27 publications

Adaptive multi-level compilation in a trace-based Java JIT compiler

Adaptive multi-level compilation in a trace-based Java JIT compiler

Efficiently parallelizing instruction set simulation of embedded multi-core processors using region-based just-in-time dynamic binary translation

Context-sensitive trace inlining for Java

Contact Info

Product

Resources

About