On-line Java^TM Data Traces

By Milo M. Martin and Manoj Plakal

[ Overview  |  Trace Details  |  Benchmark Descriptions  |  Download Traces  |  Our Project ]

Java interpreter patch now publicly available

Our Project:

Top-Level Data Memory Hierarchy: Java vs C++

by Milo Martin, Manoj Plakal, and Venkatesh Iyengar

Abstract

Using memory reference trace based cache simulation, we studied the data cache behavior of Java bytecode programs (not the cache behavior of the Java interpreter).  In addition, we compare this behavior to the data cache behavior of equivalent C++ programs.  Our results suggest that caching each type of different memory access in Java (operand stack, locals, and heap references) is advantageous to exploit the high locality of the operand stack and locals.  The Java programs tested performed more memory accesses and on average had more cache misses than the equivalent C++ program.  This result suggest that Java might require a more aggressive memory system to achieve equivalent performance.

Documents

Presentation slides (gzipped Postscript, 38K)

Project report (gzipped Postscript, 36K)

Differences between on-line traces and traces used for data in the project

The traces placed on-line are not identical to the traces used for the project data.  After completing the project we regenerated the traces to reflect a number of improvement.  Some of these improvements include using large problem sizes, newer versions of some of the programs, using optimization (-O2) when compiling the C++ programs, and using the -O javac optimization parameter for the Java programs.  We believe these traces we have made available on-line are an improvement from what we used for our project.

Disclaimer

This work was for a class project, and thus the work was performed over a one month period. Due to the lack of a reasonable benchmark suite for Java at this time, the benchmarks used are mostly ``toy'' programs.  In addition the C++ programs that were traced were compiled with no optimization flags set. This appears to have inflated the number of C++ memory references. Furthermore, we did not consider garbage collection, multi-threading, exception handling, native code methods (e.g.the AWT graphics libraries). However, we do believe that the general trend of the data is correct and that the conclusions we drew are valid.

Related Work

• [UC Berkeley] Java Cache Behavior - Cache Performance of Java Interpreters and JIT Compilers by Jeff Foster and Charles Zapata

• [UC Berkeley] Study of the Java Instruction Set Architecture by Amar Chaudhary, Yatin Chawathe and Tina Wong

[ Overview  |  Trace Details  |  Benchmark Descriptions  |  Download Traces  |  Our Project ]

Last updated on