|
import java.io.IOException;
|
import java.io.OutputStream;
|
import java.lang.instrument.*;
|
import java.lang.reflect.Field;
|
import java.lang.reflect.Modifier;
|
import java.util.*;
|
|
/**
|
* A simple implementation of C++ keyword sizeof for Java 5+
|
*
|
* @author Nicola Santi
|
* @author Marco Rosi
|
*
|
* @see java#lang#instrument#Instrument
|
*
|
* @version 0.6
|
*/
|
public class SizeOf
|
{
|
private static OutputStream out = System.out;
|
|
/**
|
* Instance of java.lang.instrument.Instrument injected by the Java VM
|
* @see premain(String options, Instrumentation inst)
|
*/
|
private static Instrumentation inst;
|
|
private static long MIN_CLASS_SIZE_TO_LOG = 1024 * 1024;
|
private static boolean SKIP_STATIC_FIELD = false;
|
private static boolean SKIP_FINAL_FIELD = false;
|
private static boolean SKIP_FLYWEIGHT_FIELD = false;
|
private static boolean debug = false;
|
|
/**
|
* Callback method used by the Java VM to inject the java.lang.instrument.Instrument
|
* instance
|
*/
|
public static void premain(String options, Instrumentation inst)
|
{
|
SizeOf.inst = inst;
|
|
System.out.println("JAVAGENT: call premain instrumentation for class SizeOf");
|
}
|
|
/**
|
* Calls java.lang.instrument.Instrument.getObjectSize(object).
|
*
|
* @param object the object to size
|
* @return an implementation-specific approximation of the amount of storage consumed
|
* by the specified object.
|
*
|
* @see java#lang#instrument#Instrument#Instrumentation#getObjectSize(Object objectToSize)
|
*/
|
public static long sizeOf(Object object)
|
{
|
if (inst == null)
|
throw new IllegalStateException("Instrumentation is null");
|
|
if (SKIP_FLYWEIGHT_FIELD && isSharedFlyweight(object))
|
return 0;
|
|
return inst.getObjectSize(object);
|
}
|
|
private static String[] unit = { "b", "Kb", "Mb" };
|
|
/**
|
* Format size in a human readable format
|
*
|
* @param size
|
* @return a string representation of the size argument followed by
|
* b for byte, Kb for kilobyte or Mb for megabyte
|
*/
|
public static String humanReadable(long size)
|
{
|
int i;
|
double dSize = size;
|
for (i = 0; i < 3; ++i)
|
{
|
if (dSize < 1024)
|
break;
|
dSize /= 1024;
|
}
|
|
return dSize + unit[i];
|
}
|
|
/**
|
* Compute an implementation-specific approximation of the amount of storage consumed
|
* by objectToSize and by all the objects reachable from it
|
*
|
* @param objectToSize
|
* @return an implementation-specific approximation of the amount of storage consumed
|
* by objectToSize and by all the objects reachable from it
|
*/
|
public static long deepSizeOf(Object objectToSize)
|
{
|
//Set<Integer> doneObj = new HashSet<Integer>();
|
Map<Object,Object> doneObj = new IdentityHashMap<Object,Object>();
|
return deepSizeOf(objectToSize, doneObj, objectToSize.getClass(), 0);
|
}
|
|
/**
|
* @deprecated use deepSizeOf
|
*/
|
public static long iterativeSizeOf(Object objectToSize) throws IllegalArgumentException,
|
IllegalAccessException, IOException
|
{
|
return deepSizeOf(objectToSize);
|
}
|
|
private static String indent(int depth)
|
{
|
StringBuilder builder = new StringBuilder();
|
for (int i = 0; i < depth; i++)
|
builder.append(" ");
|
|
return builder.toString();
|
}
|
|
private static long deepSizeOf(Object o, Map<Object,Object> doneObj, Class dsect, int depth)
|
{
|
if (o == null)
|
{
|
if (debug)
|
print("null\n");
|
return 0;
|
}
|
|
long size = 0;
|
|
boolean root = dsect == o.getClass();
|
|
if (doneObj.containsKey(o) && root)
|
{
|
if (debug)
|
print("\n%s{ yet computed }\n", indent(depth));
|
return 0;
|
}
|
|
|
if (debug)
|
print("\n%s{ %s\n", indent(depth), o.getClass().getName());
|
|
if(root)
|
{
|
doneObj.put(o,null);
|
size = sizeOf(o);
|
}
|
|
if (dsect.getName().equals("java.lang.Object"))
|
return size;
|
|
//Applet3D.tracein(o.getClass());
|
//Applet3D.trace(size);
|
|
if (o instanceof Object[])
|
{
|
int i = 0;
|
for (Object obj : (Object[]) o)
|
{
|
size += 4;
|
if (obj == null)
|
{
|
//size += 4;
|
continue;
|
}
|
if (debug)
|
print("%s [%d] = ", indent(depth), i++);
|
size += deepSizeOf(obj, doneObj, obj.getClass(), depth + 1);
|
//Applet3D.trace(size);
|
}
|
} else
|
{
|
|
//Field[] fields = o.getClass().getSuperclass().getDeclaredFields();
|
Field[] fields = dsect.getDeclaredFields();
|
|
for (Field field : fields)
|
{
|
//System.out.println("FIELD = " + field);
|
if(field.toString().equals("Composite Object3D.parent"))
|
continue;
|
|
field.setAccessible(true);
|
Object obj;
|
try
|
{
|
obj = field.get(o);
|
if(obj == null)
|
{
|
//size += 4;
|
continue;
|
}
|
//Applet3D.trace(":" + (obj==null?"NULL":"OK"));
|
} catch (IllegalArgumentException e)
|
{
|
throw new RuntimeException(e);
|
} catch (IllegalAccessException e)
|
{
|
throw new RuntimeException(e);
|
}
|
|
if (isComputable(field))
|
{
|
if (debug)
|
print("%s %s = ", indent(depth), field.getName());
|
//Applet3D.trace(field);
|
size += deepSizeOf(obj, doneObj, obj.getClass(), depth + 1);
|
} else
|
{
|
//if (debug)
|
// print("%s %s = %s\n", indent(depth), field.getName(), obj);
|
}
|
}
|
|
// Base class
|
//Applet3D.trace("BASE CLASS = " + dsect.getSuperclass());
|
size += deepSizeOf(o, doneObj, dsect.getSuperclass(), depth);
|
}
|
|
if (debug)
|
print("%s} size = %s\n", indent(depth), humanReadable(size));
|
|
//if (MIN_CLASS_SIZE_TO_LOG > 0 && size >= MIN_CLASS_SIZE_TO_LOG)
|
// print("Found big object: %s%s@%s size: %s\n", indent(depth), o.getClass().getName(), System.identityHashCode(o), humanReadable(size));
|
|
//Applet3D.traceout(o.getClass(), size);
|
|
return size;
|
}
|
|
/**
|
* Return true if the specified class is a primitive type
|
*/
|
private static boolean isAPrimitiveType(Class clazz)
|
{
|
if (clazz == java.lang.Boolean.TYPE)
|
return true;
|
|
if (clazz == java.lang.Character.TYPE)
|
return true;
|
|
if (clazz == java.lang.Byte.TYPE)
|
return true;
|
|
if (clazz == java.lang.Short.TYPE)
|
return true;
|
|
if (clazz == java.lang.Integer.TYPE)
|
return true;
|
|
if (clazz == java.lang.Long.TYPE)
|
return true;
|
|
if (clazz == java.lang.Float.TYPE)
|
return true;
|
|
if (clazz == java.lang.Double.TYPE)
|
return true;
|
|
if (clazz == java.lang.Void.TYPE)
|
return true;
|
|
return false;
|
}
|
|
/**
|
* @param field
|
* @param obj
|
* @return true if the field must be computed
|
*/
|
private static boolean isComputable(Field field)
|
{
|
int modificatori = field.getModifiers();
|
|
if (isAPrimitiveType(field.getType()) || Modifier.isTransient(modificatori))
|
return false;
|
else if (SKIP_STATIC_FIELD && Modifier.isStatic(modificatori))
|
return false;
|
else if (SKIP_FINAL_FIELD && Modifier.isFinal(modificatori))
|
return false;
|
else
|
return true;
|
}
|
|
/**
|
* Returns true if this is a well-known shared flyweight.
|
* For example, interned Strings, Booleans and Number objects.
|
*
|
* thanks to Dr. Heinz Kabutz
|
* see http://www.javaspecialists.co.za/archive/Issue142.html
|
*/
|
private static boolean isSharedFlyweight(Object obj)
|
{
|
// optimization - all of our flyweights are Comparable
|
if (obj instanceof Comparable)
|
{
|
if (obj instanceof Enum)
|
{
|
return true;
|
} else if (obj instanceof String)
|
{
|
return (obj == ((String) obj).intern());
|
} else if (obj instanceof Boolean)
|
{
|
return (obj == Boolean.TRUE || obj == Boolean.FALSE);
|
} else if (obj instanceof Integer)
|
{
|
return (obj == Integer.valueOf((Integer) obj));
|
} else if (obj instanceof Short)
|
{
|
return (obj == Short.valueOf((Short) obj));
|
} else if (obj instanceof Byte)
|
{
|
return (obj == Byte.valueOf((Byte) obj));
|
} else if (obj instanceof Long)
|
{
|
return (obj == Long.valueOf((Long) obj));
|
} else if (obj instanceof Character)
|
{
|
return (obj == Character.valueOf((Character) obj));
|
}
|
}
|
return false;
|
}
|
|
/**
|
* The objects processed by deepSizeOf are logged to the log output stream if
|
* their size (in byte) is greater than this value.
|
* The default value is 1024*1024 (1 megabyte), 0 turn off logging
|
*/
|
public static void setMinSizeToLog(long min_class_size_to_log)
|
{
|
MIN_CLASS_SIZE_TO_LOG = min_class_size_to_log;
|
}
|
|
/**
|
* If true deepSizeOf() doesn't compute the final fields of an object.
|
* Default value is false.
|
*/
|
public static void skipFinalField(boolean skip_final_field)
|
{
|
SKIP_FINAL_FIELD = skip_final_field;
|
}
|
|
/**
|
* If true deepSizeOf() doesn't compute the static fields of an object.
|
* Default value is false.
|
*/
|
public static void skipStaticField(boolean skip_static_field)
|
{
|
SKIP_STATIC_FIELD = skip_static_field;
|
}
|
|
/**
|
* If true flyweight objects has a size of 0.
|
* Default value is false.
|
*/
|
public static void skipFlyweightObject(boolean skip)
|
{
|
SKIP_FLYWEIGHT_FIELD = skip;
|
}
|
|
private static void print(String s)
|
{
|
try
|
{
|
out.write(s.getBytes());
|
} catch (IOException e)
|
{
|
throw new RuntimeException(e);
|
}
|
}
|
|
private static void print(String s, Object... args)
|
{
|
try
|
{
|
out.write(String.format(s, args).getBytes());
|
} catch (IOException e)
|
{
|
throw new RuntimeException(e);
|
}
|
}
|
|
/**
|
* Sets the OutputStream to use for logging.
|
* The default OutputStream is System.out
|
* @param o
|
*/
|
public static void setLogOutputStream(OutputStream o)
|
{
|
if (o == null)
|
throw new IllegalArgumentException("Can't use a null OutputStream");
|
|
out = o;
|
}
|
|
/**
|
* Turn on debugging information
|
*/
|
public static void turnOnDebug()
|
{
|
debug = true;
|
}
|
|
/**
|
* Turn off debugging information
|
*/
|
public static void turnOffDebug()
|
{
|
debug = true;
|
}
|
}
|
