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

Hsieh, Chiao; Conte, Marisa; Johnson, T.L.; Gyllenhaal, John C.; Hwu, Wen mei

doi:10.1109/cmpcon.1997.584710

Cited by 21 publications

(15 citation statements)

References 4 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The BTB target prediction accuracy is quite poor on object-oriented programs. Hsieh et al [1997] studied the performance of Java code running in interpreter mode and observed that microarchitectural mechanisms, such as BTB, are not well utilized. However, their work does not provide an in-depth characterization on Java indirect branches.…”

Section: Access Latency and Power Consumptionmentioning

confidence: 99%

Adapting branch-target buffer to improve the target predictability of java code

Bhargava

John

2005

ACM Trans. Archit. Code Optim.

View full text Add to dashboard Cite

Java programs are increasing in popularity and prevalence on numerous platforms, including high-performance general-purpose processors. The success of Java technology largely depends on the efficiency in executing the portable Java bytecodes. However, the dynamic characteristics of the Java runtime system present unique performance challenges for several aspects of microarchitecture design. In this work, we focus on the effects of indirect branches on branch-target address prediction performance. Runtime bytecode translation, just-in-time (JIT) compilation, frequent calls to the native interface libraries, and dependence on virtual methods increase the frequency of polymorphic indirect branches. Therefore, accurate target address prediction for indirect branches is very important for Java code.This paper characterizes the indirect branch behavior in Java processing and proposes an adaptive branch-target buffer (BTB) design to enhance the predictability of the targets. Our characterization shows that a traditional BTB will frequently mispredict a few polymorphic indirect branches, significantly deteriorating predictor accuracy in Java processing. Therefore, we propose a rehashable branch-target buffer (R-BTB), which dynamically identifies polymorphic indirect branches and adapts branch-target storage to accommodate multiple targets for a branch.The R-BTB improves the target predictability of indirect branches without sacrificing overall target prediction accuracy. Simulations show that the R-BTB eliminates 61% of the indirect branch mispredictions suffered with a traditional BTB for Java programs running in interpreter mode (46% in JIT mode), which leads to a 57% decrease in overall target address misprediction rate (29% in JIT mode). With an equivalent number of entries, the R-BTB also outperforms the previously proposed

show abstract

Section: Access Latency and Power Consumptionmentioning

confidence: 99%

Adapting branch-target buffer to improve the target predictability of java code

Bhargava

John

2005

ACM Trans. Archit. Code Optim.

View full text Add to dashboard Cite

show abstract

“…Hsieh et al [15] compare the performance of the SUN JDK 1.0.2 Java interpreter, a bytecode to native code translator called Caffeine [16] and a compiled C/C++ version of the code. This is done based on simulations.…”

Section: Related Workmentioning

confidence: 99%

How java programs interact with virtual machines at the microarchitectural level

2003

View full text Add to dashboard Cite

Java workloads are becoming increasingly prominent on various platforms ranging from embedded systems, over generalpurpose computers to high-end servers. Understanding the implications of all the aspects involved when running Java workloads, is thus extremely important during the design of a system that will run such workloads. In other words, understanding the interaction between the Java application, its input and the virtual machine it runs on, is key to a succesful design. The goal of this paper is to study this complex interaction at the microarchitectural level, e.g., by analyzing the branch behavior, the cache behavior, etc. This is done by measuring a large number of performance characteristics using performance counters on an AMD K7 Duron microprocessor. These performance characteristics are measured for seven virtual machine configurations, and a collection of Java benchmarks with corresponding inputs coming from the SPECjvm98 benchmark suite, the SPECjbb2000 benchmark suite, the Java Grande Forum benchmark suite and an open-source raytracer, called Raja with 19 scene descriptions. This large amount of data is further analyzed using statistical data analysis techniques, namely principal components analysis and cluster analysis. These techniques provide useful insights in an understandable way.From our experiments, we conclude that (i) the behavior observed at the microarchitectural level is primarily determined by the virtual machine for small input sets, e.g., the SPECjvm98 s1 input set; (ii) the behavior can be quite different for various input sets, e.g., short-running versus longrunning benchmarks; (iii) for long-running benchmarks with few hot spots, the behavior can be primarily determined by the Java program and not the virtual machine, i.e., all the virtual machines optimize the hot spots to similarly behaving native code; (iv) in general, the behavior of a Java application running on one virtual machine can be significantly different from running on another virtual machine. These conclusions warn researchers working on Java workloads to be careful when using a limited number of Java benchmarks

show abstract

“…Romer et al [17] and Hsieh et al [8] evaluate the performance of Java programs, but their studies are limited to the interpreted Java programs and/or static executable images generated by a bytecode to native code translator. Radhakrishnan et al [15] compare the characteristics of both the JIT and the interpreter and their interaction with the architectural features such as the cache and branch prediction hardware.…”

Section: R E L a T E D W O R Kmentioning

confidence: 99%

Memory system behavior of Java programs

Hsu

2000

Proceedings of the 2000 ACM SIGMETRICS International Conference on Measurement and Modeling of Computer Systems

View full text Add to dashboard Cite

This paper studies the memory system behavior of Java programs by analyzing memory reference traces of several SPECjvm98 applications running with a Just-In-Time (JIT) compiler. Trace information is collected by an exceptionbased tracing tool called JTRAeE, without any instrumentation to the Java programs or the JIT compiler.First, we find that the overall cache miss ratio is increased due to garbage collection, which suffers from higher cache misses compared to the application. We also note that going beyond 2-way cache associativity improves the cache miss ratio marginally. Second, we observe that Java programs generate a substantial amount of short-lived objects. However, the size of frequently-referenced long-lived objects is more important to the cache performance, because it tends to determine the application's working set size. Finally, we note that the default heap configuration which starts from a small initial heap size is very inefficient since it invokes a garbage collector frequently. Although the direct costs of garbage collection decrease as we increase the available heap size, there exists an optimal heap size which minimizes the total execution time due to the interaction with the virtual memory performarLce.

show abstract

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

Cited by 21 publications

References 4 publications

Adapting branch-target buffer to improve the target predictability of java code

Adapting branch-target buffer to improve the target predictability of java code

How java programs interact with virtual machines at the microarchitectural level

Memory system behavior of Java programs

Contact Info

Product

Resources

About