[Dlese-tools-proj] CVS: dlese-tools-project/src/org/dlese/dpc/util MemoryCheck.java,NONE,1.1

[John W. <jwe...@us...>]

Update of /cvsroot/dlese/dlese-tools-project/src/org/dlese/dpc/util
In directory sc8-pr-cvs1:/tmp/cvs-serv21130/src/org/dlese/dpc/util

Added Files:
	MemoryCheck.java 
Log Message:
This class outputs the total memory used by the app. Useful for debugging and determining the size of objects


--- NEW FILE ---

package org.dlese.dpc.util;

/**
 *  This class provides a utility to determine how much memory your application
 *  is using at any given time. Useful for determining the memory requirements
 *  of a given Object and for debugging possible memory leaks. See <a
 *  href="http://www.javaworld.com/javaworld/javatips/jw-javatip130.html">
 *  JavaWorld article</a> for more info. Includes a sample main method that
 *  shows how it might be used. <p>
 *
 *  To get a snapshot of current memory first call <code>runGC()</code> and then
 *  call <code>getUsedMemory()</code>. <p>
 *
 *  Example code: <p>
 *
 *  <code>MemoryCheck.runGC();</code> <br>
 *  <code>Long currentMem = MemoryCheck.getUsedMemory();</code>
 *
 * @author    John Weatherley
 */
public class MemoryCheck
{
	/**
	 *  The main program for the MemoryCheck class
	 *
	 * @param  args           The command line arguments
	 * @exception  Exception  DESCRIPTION
	 */
	public static void main(String[] args) throws Exception {
		// Warm up all classes/methods we will use
		runGC();
		getUsedMemory();

		// Array to keep strong references to allocated objects
		final int count = 100000;
		Object[] objects = new Object[count];

		long heap1 = 0;

		// Allocate count+1 objects, discard the first one
		for (int i = -1; i < count; ++i) {
			Object object = null;

			// Instantiate your data here and assign it to object

			object = new Object();
			//object = new Integer (i);
			//object = new Long (i);
			//object = new String ();
			//object = new byte [128][1]

			if (i >= 0)
				objects[i] = object;
			else {
				object = null;// Discard the warm up object
				runGC();
				heap1 = getUsedMemory();// Take a before heap snapshot
			}
		}

		runGC();
		long heap2 = getUsedMemory();// Take an after heap snapshot:

		final int size = Math.round(((float) (heap2 - heap1)) / count);
		System.out.println("'before' heap: " + heap1 +
				", 'after' heap: " + heap2);
		System.out.println("heap delta: " + (heap2 - heap1) +
				", {" + objects[0].getClass() + "} size = " + size + " bytes");

		for (int i = 0; i < count; ++i)
			objects[i] = null;
		objects = null;
	}


	/**
	 *  Gets the current amount of memory being used by the JVM. For best accuracy
	 *  you should call <code>runGC()</code> prior to calling this method.
	 *
	 * @return    The current amount of memory being used by the JVM.
	 */
	public static long getUsedMemory() {
		return s_runtime.totalMemory() - s_runtime.freeMemory();
	}


	/**
	 *  Runs object finization and the garbage collector several times. This tends
	 *  to be more effective than juse calling garbage collection once.
	 */
	public static void runGC() {
		try {
			// It helps to call Runtime.gc()
			// using several method calls:
			for (int r = 0; r < 4; ++r)
				_runGC();
		} catch (Exception e) {
			System.err.println("MemoryCheck.runGC() threw exception: " + e);
		}
	}


	/**
	 *  DESCRIPTION
	 *
	 * @exception  Exception  DESCRIPTION
	 */
	private static void _runGC() throws Exception {
		long usedMem1 = getUsedMemory();
		long usedMem2 = Long.MAX_VALUE;
		for (int i = 0; (usedMem1 < usedMem2) && (i < 500); ++i) {
			s_runtime.runFinalization();
			s_runtime.gc();
			Thread.currentThread().yield();

			usedMem2 = usedMem1;
			usedMem1 = getUsedMemory();
		}
	}


	private final static Runtime s_runtime = Runtime.getRuntime();

}