Java bytecode to native code translation: The Caffeine prototype and preliminary results

Cheng Hsueh A Hsieh, John C. Gyllenhaal, Wen-Mei W Hwu

Research output: Contribution to journalArticle

Abstract

The Java bytecode language is emerging as a software distribution standard. With major vendors committed to porting the Java run-time environment to their platforms, programs in Java bytecode are expected to run without modification on multiple platforms. These first generation run-time environments rely on an interpreter to bridge the gap between the bytecode instructions and the native hardware. This interpreter approach is sufficient for specialized applications such as Internet browsers where application performance is often limited by network delays rather than processor speed. It is, however, not sufficient for executing general applications distributed in Java bytecode. This paper presents our initial prototyping experience with Caffeine, an optimizing translator from Java bytecode to native machine code. We discuss the major technical issues involved in stack to register mapping, run-time memory structure mapping, and exception handlers. Encouraging initial results based on our X86 port are presented.

Original languageEnglish (US)
Pages (from-to)90-97
Number of pages8
JournalProceedings of the Annual International Symposium on Microarchitecture
StatePublished - 1996

Fingerprint

Caffeine
Internet
Hardware
Data storage equipment

ASJC Scopus subject areas

  • Hardware and Architecture
  • Software

Cite this

Java bytecode to native code translation : The Caffeine prototype and preliminary results. / Hsieh, Cheng Hsueh A; Gyllenhaal, John C.; Hwu, Wen-Mei W.

In: Proceedings of the Annual International Symposium on Microarchitecture, 1996, p. 90-97.

Research output: Contribution to journalArticle

@article{8d819b9b3adf498a8ce61f8b408ac4e2,
title = "Java bytecode to native code translation: The Caffeine prototype and preliminary results",
abstract = "The Java bytecode language is emerging as a software distribution standard. With major vendors committed to porting the Java run-time environment to their platforms, programs in Java bytecode are expected to run without modification on multiple platforms. These first generation run-time environments rely on an interpreter to bridge the gap between the bytecode instructions and the native hardware. This interpreter approach is sufficient for specialized applications such as Internet browsers where application performance is often limited by network delays rather than processor speed. It is, however, not sufficient for executing general applications distributed in Java bytecode. This paper presents our initial prototyping experience with Caffeine, an optimizing translator from Java bytecode to native machine code. We discuss the major technical issues involved in stack to register mapping, run-time memory structure mapping, and exception handlers. Encouraging initial results based on our X86 port are presented.",
author = "Hsieh, {Cheng Hsueh A} and Gyllenhaal, {John C.} and Hwu, {Wen-Mei W}",
year = "1996",
language = "English (US)",
pages = "90--97",
journal = "Proceedings of the Annual International Symposium on Microarchitecture, MICRO",
issn = "1072-4451",

}

TY - JOUR

T1 - Java bytecode to native code translation

T2 - The Caffeine prototype and preliminary results

AU - Hsieh, Cheng Hsueh A

AU - Gyllenhaal, John C.

AU - Hwu, Wen-Mei W

PY - 1996

Y1 - 1996

N2 - The Java bytecode language is emerging as a software distribution standard. With major vendors committed to porting the Java run-time environment to their platforms, programs in Java bytecode are expected to run without modification on multiple platforms. These first generation run-time environments rely on an interpreter to bridge the gap between the bytecode instructions and the native hardware. This interpreter approach is sufficient for specialized applications such as Internet browsers where application performance is often limited by network delays rather than processor speed. It is, however, not sufficient for executing general applications distributed in Java bytecode. This paper presents our initial prototyping experience with Caffeine, an optimizing translator from Java bytecode to native machine code. We discuss the major technical issues involved in stack to register mapping, run-time memory structure mapping, and exception handlers. Encouraging initial results based on our X86 port are presented.

AB - The Java bytecode language is emerging as a software distribution standard. With major vendors committed to porting the Java run-time environment to their platforms, programs in Java bytecode are expected to run without modification on multiple platforms. These first generation run-time environments rely on an interpreter to bridge the gap between the bytecode instructions and the native hardware. This interpreter approach is sufficient for specialized applications such as Internet browsers where application performance is often limited by network delays rather than processor speed. It is, however, not sufficient for executing general applications distributed in Java bytecode. This paper presents our initial prototyping experience with Caffeine, an optimizing translator from Java bytecode to native machine code. We discuss the major technical issues involved in stack to register mapping, run-time memory structure mapping, and exception handlers. Encouraging initial results based on our X86 port are presented.

UR - http://www.scopus.com/inward/record.url?scp=0030401093&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=0030401093&partnerID=8YFLogxK

M3 - Article

AN - SCOPUS:0030401093

SP - 90

EP - 97

JO - Proceedings of the Annual International Symposium on Microarchitecture, MICRO

JF - Proceedings of the Annual International Symposium on Microarchitecture, MICRO

SN - 1072-4451

ER -