Efficient JavaVM just-in-time compilation

Krall, Andreas

doi:10.1109/pact.1998.727250

Cited by 38 publications

(23 citation statements)

References 9 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…However, for such systems, the time constraints for the compiler are very strict. For instance, the CACAO VM [Krall, 1998], performs optimizations only on a local scope. Later systems such as the Jalapeño VM [Arnold et al, 2000] or the HotSpot VM [Paleczny et al, 2001], introduce adaptive compilation, i.e., dynamic compilation of the most relevant parts based on the current execution pro le.…”

Section: Dynamic and Adaptive Compilationmentioning

confidence: 99%

Trace Register Allocation Policies

Eisl

Marr

Würthinger³

et al. 2017

Proceedings of the 14th International Conference on Managed Languages and Runtimes

View full text Add to dashboard Cite

Register allocation is an integral part of compilation, regardless of whether a compiler aims for fast compilation or optimal code quality. State-of-the-art dynamic compilers often use global register allocation approaches such as linear scan. Recent results suggest that non-global trace-based register allocation approaches can compete with global approaches in terms of allocation quality. Instead of processing the whole compilation unit (i.e., method) at once, a trace-based register allocator divides the problem into linear code segments, called traces.In this work, we present a register allocation framework that can exploit the additional exibility of traces to select di erent allocation strategies based on the characteristics of a trace. This provides us with ne-grained control over the trade-o between compile time and peak performance in a just-in-time compiler.Our framework features three allocation strategies: a linearscan-based approach that achieves good code quality, a single-pass bottom-up strategy that aims for short allocation times, and an allocator for trivial traces.To demonstrate the exibility of the framework, we select 8 allocation policies and show their impact on compile time and peak performance. This approach can reduce allocation time by 7%-43% at a peak performance penalty of about 1%-11% on average.For systems that do not focus on peak performance, our approach allows to adjust the time spent for register allocation, and therefore the overall compilation time, thus nding the optimal balance between compile time and peak performance according to an application's requirements.

show abstract

Section: Dynamic and Adaptive Compilationmentioning

confidence: 99%

Trace Register Allocation Policies

Eisl

Marr

Würthinger³

et al. 2017

Proceedings of the 14th International Conference on Managed Languages and Runtimes

View full text Add to dashboard Cite

show abstract

“…JIT compilation has proved to be much more efficient than interpretation especially in execution intensive applications [11,12,22,24]. In the Microsoft .NET Framework, a method is compiled prior to its first use.…”

Section: Introductionmentioning

confidence: 99%

An Empirical Study of the Code Pitching Mechanism in the .NET Framework.

Anthony¹,

Srisa-an²,

Leung³

2006

JOT

View full text Add to dashboard Cite

The .NET Compact Framework is designed to be a high-performance virtual machine for mobile and embedded devices that operate on Windows CE (version 4.1 and later). It achieves fast execution time by compiling methods dynamically instead of using interpretation. Once compiled, these methods are stored in a portion of the heap called the code cache and can be quickly reused to satisfy future method calls. While the code cache provides a high-level of reusability, it can also use a large amount of memory. As a result, the Compact Framework provides a "code pitching" mechanism that can be used to discard the previously compiled methods as needed. In this paper, we study the effect of code pitching on the overall performance and memory utilization of .NET applications. We conduct our experiments using Microsoft's Shared-Source Common Language Infrastructure (SSCLI). We profile the access behavior of the compiled methods. We also experiment with various code cache configurations to perform pitching. We find that programs can operate efficiently with a small code cache without incurring substantial recompilation and execution overheads.

show abstract

“…Dynamic compilation enlarges the JVM memory footprint in three primary ways: The extra code base introduced by the JIT engine, the intermediate data structures generated by the compiler during compilation, and the compiled code stored for reuse. Significant engineering effort and research [Adl-Tabatabai et al 1998;Krall 1998;Bruening and Duesterwald 2000] have been performed to address the first two problems by making the JIT compiler more lightweight while still enabling generation of high quality code. In this paper, we present a technique that attacks the third issue: reducing the memory requirements introduced by compiled code.…”

Section: Introductionmentioning

confidence: 99%

The design, implementation, and evaluation of adaptive code unloading for resource-constrained devices

Zhang

Krintz

2005

ACM Trans. Archit. Code Optim.

View full text Add to dashboard Cite

Java Virtual Machines (JVMs) for resource-constrained devices, e.g., hand-helds and cell phones, commonly employ interpretation for program translation. However, compilers are able to produce significantly better code quality, and hence, use device resources more efficiently than interpreters, since compilers can consider large sections of code concurrently and exploit optimization opportunities. Moreover, compilation-based systems store code for reuse by future invocations obviating the redundant computation required for re-interpretation of repeatedly executed code.However, code storage required for compilation can increase the memory footprint of the VM significantly. As a result, for devices with limited memory resources, this additional code storage may preclude some programs from executing, significantly increase memory management overhead, and substantially reduce the amount of memory available for use by the application.To address the limitations of native code storage, we present the design, implementation, and empirical evaluation of a compiled-code management system that can be integrated into any compilation-based JVM. The system unloads compiled code to reduce the memory footprint of the VM. It does so by dynamically identifying and unloading dead or infrequently used code; if the code is later reused, it is recompiled by the system. As such, our system adaptively trades off memory footprint and its associated memory management costs, with recompilation overhead. Our empirical evaluation shows that our code management system significantly reduces the memory requirements of a compile-only JVM, while maintaining the performance benefits enabled by compilation.We investigate a number of implementation alternatives that use dynamic program behavior and system resource availability to determine when to unload as well as what code to unload. From our empirical evaluation of these alternatives, we identify a set of strategies that enable significant reductions in the memory overhead required for application code. Our system reduces code size by 36%-62% on average which translates into significant execution time benefits for the benchmarks and JVM configurations that we studied.

show abstract

Efficient JavaVM just-in-time compilation

Cited by 38 publications

References 9 publications

Trace Register Allocation Policies

Trace Register Allocation Policies

An Empirical Study of the Code Pitching Mechanism in the .NET Framework.

The design, implementation, and evaluation of adaptive code unloading for resource-constrained devices

Contact Info

Product

Resources

About