Study of the cache and branch performance issues with running Java on current hardware platforms

Cheng Hseueh A Hsieh, Marie T. Conte, Teresa L. Johnson, John C. Gyllenhaal, Wen-Mei W Hwu

Research output: Chapter in Book/Report/Conference proceedingConference contribution

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, Java bytecode programs 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. However, Java interpreters cause performance problems with microarchitectural features such as the caches and the Branch Target Buffer. Some of these problems can be solved by translating Java bytecode to native code. In this paper we compare the performance of code run through the SUN Java interpreter to code compiled through Caffeine, a bytecode to native code translator, as well as to compiled C/C++ versions of the code, using large applications and common benchmarks. We discuss the reasons for several performance problems incurred by both approaches to running Java code, and examine possible solutions.

Original languageEnglish (US)
Title of host publicationDigest of Papers - COMPCON - IEEE Computer Society International Conference
Editors Anon
PublisherIEEE
Pages211-216
Number of pages6
StatePublished - 1997
EventProceedings of the 1997 IEEE COMPCON Conference - San Jose, CA, USA
Duration: Feb 23 1997Feb 26 1997

Other

OtherProceedings of the 1997 IEEE COMPCON Conference
CitySan Jose, CA, USA
Period2/23/972/26/97

Fingerprint

Caffeine
Hardware

ASJC Scopus subject areas

  • Hardware and Architecture

Cite this

Hsieh, C. H. A., Conte, M. T., Johnson, T. L., Gyllenhaal, J. C., & Hwu, W-M. W. (1997). Study of the cache and branch performance issues with running Java on current hardware platforms. In Anon (Ed.), Digest of Papers - COMPCON - IEEE Computer Society International Conference (pp. 211-216). IEEE.

Study of the cache and branch performance issues with running Java on current hardware platforms. / Hsieh, Cheng Hseueh A; Conte, Marie T.; Johnson, Teresa L.; Gyllenhaal, John C.; Hwu, Wen-Mei W.

Digest of Papers - COMPCON - IEEE Computer Society International Conference. ed. / Anon. IEEE, 1997. p. 211-216.

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Hsieh, CHA, Conte, MT, Johnson, TL, Gyllenhaal, JC & Hwu, W-MW 1997, Study of the cache and branch performance issues with running Java on current hardware platforms. in Anon (ed.), Digest of Papers - COMPCON - IEEE Computer Society International Conference. IEEE, pp. 211-216, Proceedings of the 1997 IEEE COMPCON Conference, San Jose, CA, USA, 2/23/97.
Hsieh CHA, Conte MT, Johnson TL, Gyllenhaal JC, Hwu W-MW. Study of the cache and branch performance issues with running Java on current hardware platforms. In Anon, editor, Digest of Papers - COMPCON - IEEE Computer Society International Conference. IEEE. 1997. p. 211-216
Hsieh, Cheng Hseueh A ; Conte, Marie T. ; Johnson, Teresa L. ; Gyllenhaal, John C. ; Hwu, Wen-Mei W. / Study of the cache and branch performance issues with running Java on current hardware platforms. Digest of Papers - COMPCON - IEEE Computer Society International Conference. editor / Anon. IEEE, 1997. pp. 211-216
@inproceedings{aa720bd0f9044f459316f833323597ec,
title = "Study of the cache and branch performance issues with running Java on current hardware platforms",
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, Java bytecode programs 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. However, Java interpreters cause performance problems with microarchitectural features such as the caches and the Branch Target Buffer. Some of these problems can be solved by translating Java bytecode to native code. In this paper we compare the performance of code run through the SUN Java interpreter to code compiled through Caffeine, a bytecode to native code translator, as well as to compiled C/C++ versions of the code, using large applications and common benchmarks. We discuss the reasons for several performance problems incurred by both approaches to running Java code, and examine possible solutions.",
author = "Hsieh, {Cheng Hseueh A} and Conte, {Marie T.} and Johnson, {Teresa L.} and Gyllenhaal, {John C.} and Hwu, {Wen-Mei W}",
year = "1997",
language = "English (US)",
pages = "211--216",
editor = "Anon",
booktitle = "Digest of Papers - COMPCON - IEEE Computer Society International Conference",
publisher = "IEEE",

}

TY - GEN

T1 - Study of the cache and branch performance issues with running Java on current hardware platforms

AU - Hsieh, Cheng Hseueh A

AU - Conte, Marie T.

AU - Johnson, Teresa L.

AU - Gyllenhaal, John C.

AU - Hwu, Wen-Mei W

PY - 1997

Y1 - 1997

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, Java bytecode programs 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. However, Java interpreters cause performance problems with microarchitectural features such as the caches and the Branch Target Buffer. Some of these problems can be solved by translating Java bytecode to native code. In this paper we compare the performance of code run through the SUN Java interpreter to code compiled through Caffeine, a bytecode to native code translator, as well as to compiled C/C++ versions of the code, using large applications and common benchmarks. We discuss the reasons for several performance problems incurred by both approaches to running Java code, and examine possible solutions.

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, Java bytecode programs 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. However, Java interpreters cause performance problems with microarchitectural features such as the caches and the Branch Target Buffer. Some of these problems can be solved by translating Java bytecode to native code. In this paper we compare the performance of code run through the SUN Java interpreter to code compiled through Caffeine, a bytecode to native code translator, as well as to compiled C/C++ versions of the code, using large applications and common benchmarks. We discuss the reasons for several performance problems incurred by both approaches to running Java code, and examine possible solutions.

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

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

M3 - Conference contribution

AN - SCOPUS:0030676646

SP - 211

EP - 216

BT - Digest of Papers - COMPCON - IEEE Computer Society International Conference

A2 - Anon, null

PB - IEEE

ER -