Evaluation of trace inlining heuristics for Java

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

doi:10.1145/2245276.2232084

Cited by 7 publications

(10 citation statements)

References 14 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…In previous work [Häubl and Mössenböck 2011;Häubl et al 2012Häubl et al , 2013, we implemented a trace recording infrastructure and a simple trace-based JIT compiler for Java based on the production-quality Java HotSpot VM. Our implementation supports two different kinds of traces: loop traces anchored at loop headers, and method traces anchored at method entries.…”

Section: Previous Workmentioning

confidence: 99%

“…Trace inlining is our most profitable optimization. It is more powerful than method inlining because traces contain context-sensitive information, which helps us to avoid inlining unnecessary method parts [Häubl et al 2012[Häubl et al , 2013. This is shown in Figure 4, where two different callers invoke the same method.…”

Section: Compilationmentioning

confidence: 99%

“…Unlike other trace-based compilers Bebenita et al 2010b;Bolz et al 2009], we do trace inlining during JIT compilation instead of during trace recording [Häubl et al 2012]. This allows using sophisticated inlining heuristics to avoid unnecessary code bloat as more information is available during JIT compilation.…”

Section: Trace Transitioningmentioning

confidence: 99%

“…In previous work [Häubl and Mössenböck 2011;Häubl et al 2012Häubl et al , 2013, we implemented a trace recording infrastructure and a simple trace-based JIT compiler by modifying Oracle's Java HotSpot Virtual Machine (VM). This article contributes the following new aspects:…”

Section: Introductionmentioning

confidence: 99%

See 3 more Smart Citations

Trace transitioning and exception handling in a trace-based JIT compiler for java

Häubl

Wimmer

Mössenböck

2014

ACM Trans. Archit. Code Optim.

Self Cite

View full text Add to dashboard Cite

Trace-based Just-In-Time (JIT) compilation generates machine code for frequently executed paths (so-called traces) instead of whole methods. While this has several advantages, it complicates invocation of compiled traces as well as exception handling, so that previous trace-based compilers limited the way in which traces could be invoked.We present a significantly enhanced trace-based compiler where arbitrary transitions between interpreted and compiled traces are possible. For that, we introduce suitable trace calling conventions and extend exception handling to work both within traces and across trace boundaries. Furthermore, we use the recorded trace information for optimizations and combine the tracing ideas with ideas from partial-method compilation to avoid code bloat.An extensive evaluation with the benchmark suites DaCapo 9.12 Bach and SPECjvm2008 shows that our trace-based compiler achieves up to 59% higher peak performance than the method-based Java HotSpot client compiler. On a few benchmarks, our fairly simple trace-based compiler shows a higher peak performance than the Java HotSpot server compiler, which is one of today's best optimizing JIT compilers for Java.

show abstract

Section: Previous Workmentioning

confidence: 99%

Section: Compilationmentioning

confidence: 99%

Section: Trace Transitioningmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Trace transitioning and exception handling in a trace-based JIT compiler for java

Häubl

Wimmer

Mössenböck

2014

ACM Trans. Archit. Code Optim.

Self Cite

View full text Add to dashboard Cite

show abstract

“…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

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

Evaluation of trace inlining heuristics for Java

Cited by 7 publications

References 14 publications

Trace transitioning and exception handling in a trace-based JIT compiler for java

Trace transitioning and exception handling in a trace-based JIT compiler for java

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

Context-sensitive trace inlining for Java

Contact Info

Product

Resources

About