Java client ahead-of-time compiler for embedded systems

  • Authors:

  • SungHyun Hong;Jin-Chul Kim;Jin Woo Shin;Soo-Mook Moon;Hyeong-Seok Oh;Jaemok Lee;Hyung-Kyu Choi

  • Affiliations:

  • Seoul National University, Seoul, South Korea;Seoul National University, Seoul, South Korea;Seoul National University, Seoul, South Korea;Seoul National University, Seoul, South Korea;Seoul National University, Seoul, South Korea;Seoul National University, Seoul, South Korea;Seoul National University, Seoul, South Korea

  • Venue:
  • Proceedings of the 2007 ACM SIGPLAN/SIGBED conference on Languages, compilers, and tools for embedded systems
  • Year:
  • 2007

Quantified Score

Hi-index 0.00

Visualization

Abstract

The performance of embedded Java virtual machine can be improved by ahead-of-time compiler (AOTC), which translates bytecode into machine code in the server and installs the machine code on the client device. Although AOTC is more advantageous than just-in-time compiler (JITC) due to its absence of the translation overhead, AOTC cannot be applicable to dynamically downloaded classes at runtime. This paper proposes client-AOTC (c-AOTC) which performs AOTC on the client device using the JITC module installed on the device, complementing the server-AOTC. The machine code of a method translated by JITC is cached on a persistent memory of the device, and when the method is invoked again in a later run of the program, the machine code is loaded and executed directly without the translation and interpretation overhead. One of major issues in c-AOTC is relocation because some of the addresses used by the cached machine code are not correct when the machine code is loaded and used in a different run; those addresses should be corrected before they are used. Constant pool resolution and inlining complicate the relocation problem and we propose our solutions. We developed a c-AOTC on Sun's CDC VM reference implementation (RI) and our evaluation results indicate that c-AOTC can improve the performance significantly, as much as an average of 12%. We also experiment with the issue of reducing the number of c-AOTC methods to be cached when the persistent space is tight, with a graceful degradation of performance.