On-line Java^TM Data Traces

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

Java interpreter patch now publicly available

Trace Details

We produced address traces for 9 different Java programs. In addition for 6 of these programs, we produced traces of C++ versions of the programs.

Java Trace Format

Java data references can be of three types: operand stack references, references to local variables and references to heap-allocated objects. Our methods generate traces for all three types of references. However, due to the sheer number and high locality of the stack references (which suggests the use of registers or dribbling stack cache of some type in any practical implementation), the traces we have placed on-line include only local variables and heap references. The motivation for separating the heap from the local memory references comes from the large amount of locality observed in the local reference stream. One possible way to exploit this locality is to have a separate cache for each type of reference. Please see our project for results and further discussion.

We use the Dinero trace format used by the DineroIII (download) cache simulator, which has been written by Prof. Mark D. Hill. The format is clean and simple: one reference per line. Each line consists of a small non-negative integer (indicating the type of the memory reference) followed by a hexadecimal address. The reference types used are 0 & 1 for reads and writes of local variable and 5 & 6 for reads and writes of heap-allocated objects. The Dinero cache simulator, by default, treats reference types 5 and 6 as reads, not writes, so for total accuracy, these types should be changed to 0 and 1 when simulating a cache which caches both local and heap accesses.

We obtained the Java traces by modifying the Java interpreter supplied with Sun's Java^tm Developers Kit (JDK) Version 1.0.2 to generate a trace of the memory references of an executing Java program. We have made the modifications publicly available as a patch to the original source code of Sun's Java interpreter. To apply the modifications you will need to obtain the JDK source code from Sun. Our modifications do not provide traces of garbage collection, exception handling, multi-threaded code or native code methods.

All the Java benchmarks were compiled using the -O option of the Java bytecode compiler from Sun Microsystems' Java Development Kit Version 1.0.2. (except for JavaCC and Kawa for which we obtained binary distributions directly).

C++ Trace Format

The C++ traces were collected using the profiling tool QPT2 developed by Prof. James R. Larus. The programs were compiled on a Sun SPARCStation 20 running Solaris 2.5 using Gnu C++ version 2.7.2 with -O2 optimization level and static linking. We did not separate the different kinds of data references in C++ so all data references are stored together in standard Dinero format (tags 0 and 1 for read and write respectively).

Reference Summary

Notice that Java has a larger number of references compared to C++, and thus it is not suggested that absolute misses are used over miss ratios when comparing Java and C++ cache behavior.

Trace References (in millions)
	Java							C++
	Locals			Heap			Total	C++
Benchmark	Reads	Writes	Total	Reads	Writes	Total	Total	Reads	Writes	Total
N-queens	2.43	0.49	2.92	3.03	0.34	3.37	6.29	2.41	0.39	2.80
MatMult	4.12	0.34	4.46	4.17	0.39	4.56	8.68	3.27	1.02	4.29
CellAuto	5.91	0.70	6.61	4.51	0.80	5.31	11.92	3.58	0.92	4.50
WordFreq	6.12	2.36	8.48	2.99	0.38	3.37	11.82	3.08	0.69	3.77
QuickSort	9.26	1.33	10.59	3.36	0.49	3.85	14.44	1.43	0.49	1.92
Linpack	4.17	0.51	4.68	2.13	0.40	2.53	7.21	1.16	0.46	1.62
JavaC	4.53	1.06	4.59	2.41	0.50	2.91	7.50	C++ versions not available
JavaCC	4.77	0.95	5.72	9.00	2.61	11.61	17.33
Kawa	8.16	2.94	11.10	3.88	0.25	4.13	15.23