gcbench.java

Java Op Processor java vhdl processor

// This is adapted from a benchmark written by John Ellis and Pete Kovac
// of Post Communications.
// It was modified by Hans Boehm of Silicon Graphics.
//
// 	This is no substitute for real applications.  No actual application
//	is likely to behave in exactly this way.  However, this benchmark was
//	designed to be more representative of real applications than other
//	Java GC benchmarks of which we are aware.
//	It attempts to model those properties of allocation requests that
//	are important to current GC techniques.
//	It is designed to be used either to obtain a single overall performance
//	number, or to give a more detailed estimate of how collector
//	performance varies with object lifetimes.  It prints the time
//	required to allocate and collect balanced binary trees of various
//	sizes.  Smaller trees result in shorter object lifetimes.  Each cycle
//	allocates roughly the same amount of memory.
//	Two data structures are kept around during the entire process, so
//	that the measured performance is representative of applications
//	that maintain some live in-memory data.  One of these is a tree
//	containing many pointers.  The other is a large array containing
//	double precision floating point numbers.  Both should be of comparable
//	size.
//
//	The results are only really meaningful together with a specification
//	of how much memory was used.  It is possible to trade memory for
//	better time performance.  This benchmark should be run in a 32 MB
//	heap, though we don't currently know how to enforce that uniformly.
//
//	Unlike the original Ellis and Kovac benchmark, we do not attempt
// 	measure pause times.  This facility should eventually be added back
//	in.  There are several reasons for omitting it for now.  The original
//	implementation depended on assumptions about the thread scheduler
//	that don't hold uniformly.  The results really measure both the
//	scheduler and GC.  Pause time measurements tend to not fit well with
//	current benchmark suites.  As far as we know, none of the current
//	commercial Java implementations seriously attempt to minimize GC pause
//	times.
//
//	Known deficiencies:
//		- No way to check on memory use
//		- No cyclic data structures
//		- No attempt to measure variation with object size
//		- Results are sensitive to locking cost, but we dont
//		  check for proper locking

package gctest;

import com.jopdesign.sys.GC;

class Node {
	Node left, right;
	int i, j;
	Node(Node l, Node r) { left = l; right = r; }
	Node() { }
}

public class GCBench {

	public static final int kStretchTreeDepth    = 5; //18;	// about 16Mb
	public static final int kLongLivedTreeDepth  = 5; //16;  // about 4Mb
	public static final int kArraySize  = 500; // 500000;  // about 4Mb
	public static final int kMinTreeDepth = 4;
	public static final int kMaxTreeDepth = 16;

	// Nodes used by a tree of a given size
	static int TreeSize(int i) {
	    	return ((1 << (i + 1)) - 1);
	}

	// Number of iterations to use for a given tree depth
	static int NumIters(int i) {
	    		int b = TreeSize(kStretchTreeDepth);
                return (b+b) / TreeSize(i);
        }

	// Build tree top down, assigning to older objects. 
	static void Populate(int iDepth, Node thisNode) {
		if (iDepth<=0) {
			return;
		} else {
			iDepth--;
			thisNode.left  = new Node();
			thisNode.right = new Node();
			Populate (iDepth, thisNode.left);
			Populate (iDepth, thisNode.right);
		}
	}

	// Build tree bottom-up
	static Node MakeTree(int iDepth) {
		if (iDepth<=0) {
			return new Node();
		} else {
			return new Node(MakeTree(iDepth-1),
					MakeTree(iDepth-1));
		}
	}

	static void PrintDiagnostics() {
		int lFreeMemory = GC.freeMemory();
		int lTotalMemory = GC.totalMemory();

		// System.out.print(" Total memory available="+ lTotalMemory + " bytes");
		// System.out.println("  Free memory=" + lFreeMemory + " bytes");
		System.out.print("Total Memory: ");
		System.out.println(lTotalMemory);
		System.out.print("Free Memory: ");
		System.out.println(lFreeMemory);
	}

	static void TimeConstruction(int depth) {
		Node    root;
		int    tStart, tFinish;
		int 	iNumIters = NumIters(depth);
		Node	tempTree;

		// System.out.println("Creating " + iNumIters + " trees of depth " + depth);
		System.out.print("Creating "); 
		System.out.print(iNumIters);
		System.out.print(' ');
		System.out.print("trees of depth "); 
		System.out.println(depth);
		tStart = (int) System.currentTimeMillis();
		for (int i = 0; i < iNumIters; ++i) {
			tempTree = new Node();
			Populate(depth, tempTree);
			tempTree = null;
		}
		tFinish = (int) System.currentTimeMillis();
		// System.out.println("\tTop down construction took "+ (tFinish - tStart) + "msecs");
		System.out.print("\tTop down construction took (msec): ");
		System.out.println(tFinish - tStart);
		tStart = (int) System.currentTimeMillis();
        for (int i = 0; i < iNumIters; ++i) {
                        tempTree = MakeTree(depth);
                        tempTree = null;
        }
        tFinish = (int) System.currentTimeMillis();
                // System.out.println("\tBottom up construction took "+ (tFinish - tStart) + "msecs");
		System.out.print("\tBottom up construction took (msec): ");
		System.out.println(tFinish - tStart);
	}

	public static void main(String args[]) {
		Node	root;
		Node	longLivedTree;
		Node	tempTree;
		int	tStart, tFinish;
		int	tElapsed;


		// System.out.println("Garbage Collector Test");
		// System.out.println(" Stretching memory with a binary tree of depth "+ kStretchTreeDepth);
		System.out.print(" Stretching memory with a binary tree of depth ");
		System.out.println(kStretchTreeDepth);
	
		PrintDiagnostics();
		tStart = (int) System.currentTimeMillis();

		// Stretch the memory space quickly
		tempTree = MakeTree(kStretchTreeDepth);
		tempTree = null;

		// Create a long lived object
		System.out.print(" Creating a long-lived binary tree of depth ");
		System.out.println(kLongLivedTreeDepth);
		// System.out.println(" Creating a long-lived binary tree of depth " +kLongLivedTreeDepth);
		longLivedTree = new Node();
		Populate(kLongLivedTreeDepth, longLivedTree);
//		GC.gc();
//		PrintDiagnostics();

		// Create long-lived array, filling half of it
		// System.out.println(" Creating a long-lived array of "+ kArraySize + " doubles");
		System.out.print(" Creating a long-lived array of ints ");
		System.out.println(kArraySize);
		int array[] = new int[kArraySize];
		for (int i = 0; i < kArraySize/2; ++i) {
			array[i] = i; //1.0/i;
		}
		PrintDiagnostics();

		for (int d = kMinTreeDepth; d <= kMaxTreeDepth; d += 2) {
			TimeConstruction(d);
		}

		if (longLivedTree == null) { // || array[1000] != 1.0/1000) {
			System.out.print("Failed!\n");
		    // System.out.println("Failed");
					// fake reference to LongLivedTree
					// and array
					// to keep them from being optimized away
		}
		tFinish = (int) System.currentTimeMillis();
		tElapsed = tFinish-tStart;
		PrintDiagnostics();
		// System.out.println("Completed in " + tElapsed + "ms.");
		System.out.print("Completed in (msec): ");
		System.out.println(tElapsed);
	}
} // class JavaGC