In Java what is the best way to determine the size of an object

Question

I have an application that reads a CSV file with piles of data rows. I give the user a summary of the number of rows based on types of data, but I want to make sure that I don't read in too many rows of data and cause OutOfMemoryErrors. Each row translates into an object. Is there an easy way to find out the size of that object programmatically? Is there a reference that defines how large primitive types and object references are for a VM?

Right now, I have code that says read up to 32,000 rows, but I'd also like to have code that says read as many rows as possible until I've used 32MB of memory. Maybe that is a different question, but I'd still like to know.

User · Answer

You should use jol  a tool developed as part of the OpenJDK project      JOL  Java Object Layout  is the tiny toolbox to analyze object layout schemes in JVMs  These tools are using Unsafe  JVMTI  and Serviceability Agent  SA  heavily to decoder the actual object layout  footprint  and references  This makes JOL much more accurate than other tools relying on heap dumps  specification assumptions  etc    To get the sizes of primitives  references and array elements  use VMSupport vmDetails     On Oracle JDK 1 8 0 40 running on 64-bit Windows  used for all following examples   this method returns  Running 64-bit HotSpot VM  Using compressed oop with 0-bit shift  Using compressed klass with 3-bit shift  Objects are 8 bytes aligned  Field sizes by type  4  1  1  2  2  4  4  8  8  bytes  Array element sizes  4  1  1  2  2  4  4  8  8  bytes    You can get the shallow size of an object instance using ClassLayout parseClass Foo class  toPrintable    optionally passing an instance to toPrintable    This is only the space consumed by a single instance of that class  it does not include any other objects referenced by that class   It does include VM overhead for the object header  field alignment and padding   For java util regex Pattern   java util regex Pattern object internals   OFFSET  SIZE        TYPE DESCRIPTION                    VALUE       0     4              object header                 01 00 00 00  0000 0001 0000 0000 0000 0000 0000 0000        4     4              object header                 00 00 00 00  0000 0000 0000 0000 0000 0000 0000 0000        8     4              object header                 cb cf 00 20  1100 1011 1100 1111 0000 0000 0010 0000       12     4         int Pattern flags                  0      16     4         int Pattern capturingGroupCount    1      20     4         int Pattern localCount             0      24     4         int Pattern cursor                 48      28     4         int Pattern patternLength          0      32     1     boolean Pattern compiled               true      33     1     boolean Pattern hasSupplementary       false      34     2              alignment padding gap         N A      36     4      String Pattern pattern                 object       40     4      String Pattern normalizedPattern       object       44     4        Node Pattern root                    object       48     4        Node Pattern matchRoot               object       52     4       int   Pattern buffer                 null      56     4         Map Pattern namedGroups            null      60     4 GroupHead   Pattern groupNodes             null      64     4       int   Pattern temp                   null      68     4              loss due to the next object alignment  Instance size  72 bytes  reported by Instrumentation API  Space losses  2 bytes internal   4 bytes external   6 bytes total   You can get a summary view of the deep size of an object instance using GraphLayout parseInstance obj  toFootprint     Of course  some objects in the footprint might be shared  also referenced from other objects   so it is an overapproximation of the space that could be reclaimed when that object is garbage collected   For the result of Pattern compile    a-zA-Z0-9   -    a-zA-Z0-9-      a-zA-Z0-9-        taken from this answer   jol reports a total footprint of 1840 bytes  of which only 72 are the Pattern instance itself   java util regex Pattern instance footprint       COUNT       AVG       SUM   DESCRIPTION          1       112       112    C          3       272       816    Z          1        24        24   java lang String          1        72        72   java util regex Pattern          9        24       216   java util regex Pattern 1         13        24       312   java util regex Pattern 5          1        16        16   java util regex Pattern Begin          3        24        72   java util regex Pattern BitClass          3        32        96   java util regex Pattern Curly          1        24        24   java util regex Pattern Dollar          1        16        16   java util regex Pattern LastNode          1        16        16   java util regex Pattern Node          2        24        48   java util regex Pattern Single         40                1840    total    If you instead use GraphLayout parseInstance obj  toPrintable    jol will tell you the address  size  type  value and path of field dereferences to each referenced object  though that s usually too much detail to be useful   For the ongoing pattern example  you might get the following    Addresses will likely change between runs    java util regex Pattern object externals            ADDRESS       SIZE TYPE                             PATH                           VALUE          d5e5f290         16 java util regex Pattern Node      root next atom next            object           d5e5f2a0        120  something else                   somewhere else                 something else           d5e5f318         16 java util regex Pattern LastNode  root next next next next next next next  object           d5e5f328      21664  something else                   somewhere else                 something else           d5e647c8         24 java lang String                  pattern                        object           d5e647e0        112  C                                pattern value                        a  -  z  A  -  Z  0  -  9           -              a  -  z  A  -  Z  0  -  9  -                 a  -  z  A  -  Z  0  -  9  -                       d5e64850        448  something else                   somewhere else                 something else           d5e64a10         72 java util regex Pattern                                          object           d5e64a58        416  something else                   somewhere else                 something else           d5e64bf8         16 java util regex Pattern Begin     root                           object           d5e64c08         24 java util regex Pattern BitClass  root next atom val rhs         object           d5e64c20        272  Z                                root next atom val rhs bits    false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  true  false  true  true  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  true  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false           d5e64d30         24 java util regex Pattern 1         root next atom val lhs val lhs val lhs val lhs val lhs val lhs  object           d5e64d48         24 java util regex Pattern 1         root next atom val lhs val lhs val lhs val lhs val lhs val rhs  object           d5e64d60         24 java util regex Pattern 5         root next atom val lhs val lhs val lhs val lhs val lhs  object           d5e64d78         24 java util regex Pattern 1         root next atom val lhs val lhs val lhs val lhs val rhs  object           d5e64d90         24 java util regex Pattern 5         root next atom val lhs val lhs val lhs val lhs  object           d5e64da8         24 java util regex Pattern 5         root next atom val lhs val lhs val lhs  object           d5e64dc0         24 java util regex Pattern 5         root next atom val lhs val lhs  object           d5e64dd8         24 java util regex Pattern 5         root next atom val lhs         object           d5e64df0         24 java util regex Pattern 5         root next atom                 object           d5e64e08         32 java util regex Pattern Curly     root next                      object           d5e64e28         24 java util regex Pattern Single    root next next                 object           d5e64e40         24 java util regex Pattern BitClass  root next next next atom val rhs  object           d5e64e58        272  Z                                root next next next atom val rhs bits  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  true  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false           d5e64f68         24 java util regex Pattern 1         root next next next atom val lhs val lhs val lhs  object           d5e64f80         24 java util regex Pattern 1         root next next next atom val lhs val lhs val rhs  object           d5e64f98         24 java util regex Pattern 5         root next next next atom val lhs val lhs  object           d5e64fb0         24 java util regex Pattern 1         root next next next atom val lhs val rhs  object           d5e64fc8         24 java util regex Pattern 5         root next next next atom val lhs  object           d5e64fe0         24 java util regex Pattern 5         root next next next atom       object           d5e64ff8         32 java util regex Pattern Curly     root next next next            object           d5e65018         24 java util regex Pattern Single    root next next next next       object           d5e65030         24 java util regex Pattern BitClass  root next next next next next atom val rhs  object           d5e65048        272  Z                                root next next next next next atom val rhs bits  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  true  true  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false  false           d5e65158         24 java util regex Pattern 1         root next next next next next atom val lhs val lhs val lhs val lhs  object           d5e65170         24 java util regex Pattern 1         root next next next next next atom val lhs val lhs val lhs val rhs  object           d5e65188         24 java util regex Pattern 5         root next next next next next atom val lhs val lhs val lhs  object           d5e651a0         24 java util regex Pattern 1         root next next next next next atom val lhs val lhs val rhs  object           d5e651b8         24 java util regex Pattern 5         root next next next next next atom val lhs val lhs  object           d5e651d0         24 java util regex Pattern 5         root next next next next next atom val lhs  object           d5e651e8         24 java util regex Pattern 5         root next next next next next atom  object           d5e65200         32 java util regex Pattern Curly     root next next next next next  object           d5e65220        120  something else                   somewhere else                 something else           d5e65298         24 java util regex Pattern Dollar    root next next next next next next  object    The   something else   entries describe other objects in the heap that are not part of this object graph   The best jol documentation is the jol samples in the jol repository   The samples demonstrate common jol operations and show how you can use jol to analyze VM and garbage collector internals

User · Answer

Here is a utility I made using some of the linked examples to handle 32-bit, 64-bit and 64-bit with compressed OOP. It uses sun.misc.Unsafe.

It uses Unsafe.addressSize() to get the size of a native pointer and Unsafe.arrayIndexScale( Object[].class ) for the size of a Java reference.

It uses the field offset of a known class to work out the base size of an object.

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.IdentityHashMap;
import java.util.Stack;
import sun.misc.Unsafe;

/** Usage: 
 * MemoryUtil.sizeOf( object )
 * MemoryUtil.deepSizeOf( object )
 * MemoryUtil.ADDRESS_MODE
 */
public class MemoryUtil
{
    private MemoryUtil()
    {
    }

    public static enum AddressMode
    {
        /** Unknown address mode. Size calculations may be unreliable. */
        UNKNOWN,
        /** 32-bit address mode using 32-bit references. */
        MEM_32BIT,
        /** 64-bit address mode using 64-bit references. */
        MEM_64BIT,
        /** 64-bit address mode using 32-bit compressed references. */
        MEM_64BIT_COMPRESSED_OOPS
    }

    /** The detected runtime address mode. */
    public static final AddressMode ADDRESS_MODE;

    private static final Unsafe UNSAFE;

    private static final long ADDRESS_SIZE; // The size in bytes of a native pointer: 4 for 32 bit, 8 for 64 bit
    private static final long REFERENCE_SIZE; // The size of a Java reference: 4 for 32 bit, 4 for 64 bit compressed oops, 8 for 64 bit
    private static final long OBJECT_BASE_SIZE; // The minimum size of an Object: 8 for 32 bit, 12 for 64 bit compressed oops, 16 for 64 bit
    private static final long OBJECT_ALIGNMENT = 8;

    /** Use the offset of a known field to determine the minimum size of an object. */
    private static final Object HELPER_OBJECT = new Object() { byte b; };


    static
    {
        try
        {
            // Use reflection to get a reference to the 'Unsafe' object.
            Field f = Unsafe.class.getDeclaredField( "theUnsafe" );
            f.setAccessible( true );
            UNSAFE = (Unsafe) f.get( null );

            OBJECT_BASE_SIZE = UNSAFE.objectFieldOffset( HELPER_OBJECT.getClass().getDeclaredField( "b" ) );

            ADDRESS_SIZE = UNSAFE.addressSize();
            REFERENCE_SIZE = UNSAFE.arrayIndexScale( Object[].class );

            if( ADDRESS_SIZE == 4 )
            {
                ADDRESS_MODE = AddressMode.MEM_32BIT;
            }
            else if( ADDRESS_SIZE == 8 && REFERENCE_SIZE == 8 )
            {
                ADDRESS_MODE = AddressMode.MEM_64BIT;
            }
            else if( ADDRESS_SIZE == 8 && REFERENCE_SIZE == 4 )
            {
                ADDRESS_MODE = AddressMode.MEM_64BIT_COMPRESSED_OOPS;
            }
            else
            {
                ADDRESS_MODE = AddressMode.UNKNOWN;
            }
        }
        catch( Exception e )
        {
            throw new Error( e );
        }
    }


    /** Return the size of the object excluding any referenced objects. */
    public static long shallowSizeOf( final Object object )
    {
        Class<?> objectClass = object.getClass();
        if( objectClass.isArray() )
        {
            // Array size is base offset + length * element size
            long size = UNSAFE.arrayBaseOffset( objectClass )
                    + UNSAFE.arrayIndexScale( objectClass ) * Array.getLength( object );
            return padSize( size );
        }
        else
        {
            // Object size is the largest field offset padded out to 8 bytes
            long size = OBJECT_BASE_SIZE;
            do
            {
                for( Field field : objectClass.getDeclaredFields() )
                {
                    if( (field.getModifiers() & Modifier.STATIC) == 0 )
                    {
                        long offset = UNSAFE.objectFieldOffset( field );
                        if( offset >= size )
                        {
                            size = offset + 1; // Field size is between 1 and PAD_SIZE bytes. Padding will round up to padding size.
                        }
                    }
                }
                objectClass = objectClass.getSuperclass();
            }
            while( objectClass != null );

            return padSize( size );
        }
    }


    private static final long padSize( final long size )
    {
        return (size + (OBJECT_ALIGNMENT - 1)) & ~(OBJECT_ALIGNMENT - 1);
    }


    /** Return the size of the object including any referenced objects. */
    public static long deepSizeOf( final Object object )
    {
        IdentityHashMap<Object,Object> visited = new IdentityHashMap<Object,Object>();
        Stack<Object> stack = new Stack<Object>();
        if( object != null ) stack.push( object );

        long size = 0;
        while( !stack.isEmpty() )
        {
            size += internalSizeOf( stack.pop(), stack, visited );
        }
        return size;
    }


    private static long internalSizeOf( final Object object, final Stack<Object> stack, final IdentityHashMap<Object,Object> visited )
    {
        // Scan for object references and add to stack
        Class<?> c = object.getClass();
        if( c.isArray() && !c.getComponentType().isPrimitive() )
        {
            // Add unseen array elements to stack
            for( int i = Array.getLength( object ) - 1; i >= 0; i-- )
            {
                Object val = Array.get( object, i );
                if( val != null && visited.put( val, val ) == null )
                {
                    stack.add( val );
                }
            }
        }
        else
        {
            // Add unseen object references to the stack
            for( ; c != null; c = c.getSuperclass() )
            {
                for( Field field : c.getDeclaredFields() )
                {
                    if( (field.getModifiers() & Modifier.STATIC) == 0 
                            && !field.getType().isPrimitive() )
                    {
                        field.setAccessible( true );
                        try
                        {
                            Object val = field.get( object );
                            if( val != null && visited.put( val, val ) == null )
                            {
                                stack.add( val );
                            }
                        }
                        catch( IllegalArgumentException e )
                        {
                            throw new RuntimeException( e );
                        }
                        catch( IllegalAccessException e )
                        {
                            throw new RuntimeException( e );
                        }
                    }
                }
            }
        }

        return shallowSizeOf( object );
    }
}

User · Answer

This answer is not related to Object size, but when you are using array to accommodate the objects; how much memory size it will allocate for the object.

So arrays, list, or map all those collection won't be going to store objects really (only at the time of primitives, real object memory size is needed), it will store only references for those objects.

Now the Used heap memory = sizeOfObj + sizeOfRef (* 4 bytes) in collection

(4/8 bytes) depends on (32/64 bit) OS

PRIMITIVES

int   [] intArray    = new int   [1]; will require 4 bytes.
long  [] longArray   = new long  [1]; will require 8 bytes.

OBJECTS

Object[] objectArray = new Object[1]; will require 4 bytes. The object can be any user defined Object.
Long  [] longArray   = new Long  [1]; will require 4 bytes.

I mean to say all the object REFERENCE needs only 4 bytes of memory. It may be String reference OR Double object reference, But depends on object creation the memory needed will vary.

e.g) If i create object for the below class ReferenceMemoryTest then 4 + 4 + 4 = 12 bytes of memory will be created. The memory may differ when you are trying to initialize the references.

 class ReferenceMemoryTest {
    public String refStr;
    public Object refObj;
    public Double refDoub; 
}

So when are creating object/reference array, all its contents will be occupied with NULL references. And we know each reference requires 4 bytes.

And finally, memory allocation for the below code is 20 bytes.

ReferenceMemoryTest ref1 = new ReferenceMemoryTest(); ( 4(ref1) + 12 = 16 bytes) ReferenceMemoryTest ref2 = ref1; ( 4(ref2) + 16 = 20 bytes)

User · Answer

long heapSizeBefore   Runtime getRuntime   totalMemory        Code for object construction     long heapSizeAfter   Runtime getRuntime   totalMemory    long size   heapSizeAfter - heapSizeBefore    size gives you the increase in memory usage of the jvm due to object creation and that typically is the size of the object

User · Answer

My answer is based on the code supplied by Nick. That code measures total amount of bytes which are occupied by the serialized object. So this actually measures serialization stuff + plain object memory footprint (just serialize for example int and you will see that total amount of serialized bytes is not 4). So if you want to get raw byte number used exactly for your object - you need to modify that code a bit. Like so:

import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ObjectSizeCalculator {
    private Object getFirstObjectReference(Object o) {
        String objectType = o.getClass().getTypeName();

        if (objectType.substring(objectType.length()-2).equals("[]")) {
            try {
                if (objectType.equals("java.lang.Object[]"))
                    return ((Object[])o)[0];
                else if (objectType.equals("int[]"))
                    return ((int[])o)[0];
                else
                    throw new RuntimeException("Not Implemented !");
            } catch (IndexOutOfBoundsException e) {
                return null;
            }
        }

        return o;
    } 

    public int getObjectSizeInBytes(Object o) {
        final String STRING_JAVA_TYPE_NAME = "java.lang.String";

        if (o == null)
            return 0;

        String objectType = o.getClass().getTypeName();
        boolean isArray = objectType.substring(objectType.length()-2).equals("[]");

        Object objRef = getFirstObjectReference(o);
        if (objRef != null && !(objRef instanceof Serializable))
            throw new RuntimeException("Object must be serializable for measuring it's memory footprint using this method !");

        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(o);
            oos.close();
            byte[] bytes = baos.toByteArray();

            for (int i = bytes.length - 1, j = 0; i != 0; i--, j++) {
                if (objectType != STRING_JAVA_TYPE_NAME) {
                    if (bytes[i] == 112)
                        if (isArray)
                            return j - 4;
                        else
                            return j;
                } else {
                    if (bytes[i] == 0)
                        return j - 1;
                }
            }
        } catch (Exception e) {
            return -1;
        }

        return -1;
    }    

}

I've tested this solution with primitive types, String, and on some trivial classes. There may be not covered cases also.

UPDATE: Example modified to support memory footprint calculation of array objects.

User · Answer

You have to walk the objects using reflection. Be careful as you do:

Just allocating an object has some overhead in the JVM. The amount varies by JVM so you might make this value a parameter. At least make it a constant (8 bytes?) and apply to anything allocated.
Just because byte is theoretically 1 byte doesn't mean it takes just one in memory.
There will be loops in object references, so you'll need to keep a HashMap or somesuch using object-equals as the comparator to eliminate infinite loops.

@jodonnell: I like the simplicity of your solution, but many objects aren't Serializable (so this would throw an exception), fields can be transient, and objects can override the standard methods.

User · Answer

I was looking for a runtime calculation of an object size that met the following requirements:

Available at runtime with no need to include instrumentation.
Works with Java 9+ without access to Unsafe.
Is based on the Class only. Not a deep sizeOf that takes into consideration string lengths, array lengths, etc.

The following is based on the core code of the original java specialists article (https://www.javaspecialists.eu/archive/Issue078.html) and a few bits from the Unsafe version in another answer to this question.

I hope someone finds it useful.

public class JavaSize {

private static final int NR_BITS = Integer.valueOf(System.getProperty("sun.arch.data.model"));
private static final int BYTE = 8;
private static final int WORD = NR_BITS / BYTE;
private static final int HEADER_SIZE = 8;

public static int sizeOf(Class<?> clazz) {
    int result = 0;

    while (clazz != null) {
        Field[] fields = clazz.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            if (!Modifier.isStatic(fields[i].getModifiers())) {
                if (fields[i].getType().isPrimitive()) {
                    Class<?> primitiveClass = fields[i].getType();
                    if (primitiveClass == boolean.class || primitiveClass == byte.class) {
                        result += 1;
                    } else if (primitiveClass == short.class) {
                        result += 2;
                    } else if (primitiveClass == int.class || primitiveClass == float.class) {
                        result += 4;
                    } else if (primitiveClass == double.class || primitiveClass == long.class) {
                        result += 8;
                    }

                } else {
                    // assume compressed references.
                    result += 4;
                }
            }
        }

        clazz = clazz.getSuperclass();

        // round up to the nearest WORD length.
        if ((result % WORD) != 0) {
            result += WORD - (result % WORD);
        }
    }

    result += HEADER_SIZE;

    return result;
}

}

User · Answer

Back when I worked at Twitter  I wrote a utility for calculating deep object size  It takes into account different memory models  32-bit  compressed oops  64-bit   padding  subclass padding  works correctly on circular data structures and arrays  You can just compile this one  java file  it has no external dependencies   https   github com twitter commons blob master src java com twitter common objectsize ObjectSizeCalculator java

User · Answer

Suppose I declare a class named Complex like   public class Complex        private final long real      private final long imaginary          omitted      In order to see how much memory is allocated to live instances of this class     jmap -histo live  lt pid gt    grep Complex   num      instances          bytes  class name  module  -------------------------------------------------------  327              1             32  Complex

User · Answer

There isn t a method call  if that s what you re asking for  With a little research  I suppose you could write your own  A particular instance has a fixed sized derived from the number of references and primitive values plus instance bookkeeping data  You would simply walk the object graph  The less varied the row types  the easier   If that s too slow or just more trouble than it s worth  there s always good old-fashioned  row counting rule-of-thumbs

User · Answer

I wrote a quick test once to estimate on the fly:

public class Test1 {

    // non-static nested
    class Nested { }

    // static nested
    static class StaticNested { }

    static long getFreeMemory () {
        // waits for free memory measurement to stabilize
        long init = Runtime.getRuntime().freeMemory(), init2;
        int count = 0;
        do {
            System.out.println("waiting..." + init);
            System.gc();
            try { Thread.sleep(250); } catch (Exception x) { }
            init2 = init;
            init = Runtime.getRuntime().freeMemory();
            if (init == init2) ++ count; else count = 0;
        } while (count < 5);
        System.out.println("ok..." + init);
        return init;
    }

    Test1 () throws InterruptedException {

        Object[] s = new Object[10000];
        Object[] n = new Object[10000];
        Object[] t = new Object[10000];

        long init = getFreeMemory();

        //for (int j = 0; j < 10000; ++ j)
        //    s[j] = new Separate();

        long afters = getFreeMemory();

        for (int j = 0; j < 10000; ++ j)
            n[j] = new Nested();

        long aftersn = getFreeMemory();

        for (int j = 0; j < 10000; ++ j)
            t[j] = new StaticNested();

        long aftersnt = getFreeMemory();

        System.out.println("separate:      " + -(afters - init) + " each=" + -(afters - init) / 10000);
        System.out.println("nested:        " + -(aftersn - afters) + " each=" + -(aftersn - afters) / 10000);
        System.out.println("static nested: " + -(aftersnt - aftersn) + " each=" + -(aftersnt - aftersn) / 10000);

    }

    public static void main (String[] args) throws InterruptedException {
        new Test1();
    }

}

General concept is allocate objects and measure change in free heap space. The key being getFreeMemory(), which requests GC runs and waits for the reported free heap size to stabilize. The output of the above is:

nested:        160000 each=16
static nested: 160000 each=16

Which is what we expect, given alignment behavior and possible heap block header overhead.

The instrumentation method detailed in the accepted answer here the most accurate. The method I described is accurate but only under controlled conditions where no other threads are creating/discarding objects.

User · Answer

Without having to mess with instrumentation and so on, and if you don't need to know the byte-exact size of an object, you could go with the following approach:

System.gc();
Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();

do your job here

System.gc();
Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();

This way you read the used memory before and after, and calling the GC just before getting the used memory you lower the "noise" almost to 0.

For a more reliable result you can run your job n times, and then divide the used memory by n, obtaining how much memory one run takes. Even more, you can run the whole thing more times and make an average.

User · Answer

Just use java visual VM    It has everything you need to profile and debug memory problems    It also has a OQL  Object Query Language  console which allows you to do many useful things  one of which being sizeof o

User · Answer

I accidentally found a java class  jdk nashorn internal ir debug ObjectSizeCalculator   already in jdk   which is easy to use and seems quite useful for determining the size of an object   System out println ObjectSizeCalculator getObjectSize new gnu trove map hash TObjectIntHashMap lt String gt  12000  0 6f  -1     System out println ObjectSizeCalculator getObjectSize new HashMap lt String  Integer gt  100000     System out println ObjectSizeCalculator getObjectSize 3    System out println ObjectSizeCalculator getObjectSize new int   1  2  3  4  5  6  7      System out println ObjectSizeCalculator getObjectSize new int 100       results   164192 48 16 48 416

User · Answer

Firstly  the size of an object  isn t a well-defined concept in Java  You could mean the object itself  with just its members  the Object and all objects it refers to  the reference graph   You could mean the size in memory or the size on disk  And the JVM is allowed to optimise things like Strings   So the only correct way is to ask the JVM  with a good profiler  I use YourKit   which probably isn t what you want   However  from the description above it sounds like each row will be self-contained  and not have a big dependency tree  so the serialization method will probably be a good approximation on most JVMs  The easiest way to do this is as follows    Serializable ser   ByteArrayOutputStream baos   new ByteArrayOutputStream     ObjectOutputStream oos   new ObjectOutputStream baos    oos writeObject ser    oos close     return baos size      Remember that if you have objects with common references this will not give the correct result  and size of serialization will not always match size in memory  but it is a good approximation  The code will be a bit more efficient if you initialise the ByteArrayOutputStream size to a sensible value

User · Answer

You can use the java lang instrument package  Compile and put this class in a JAR   import java lang instrument Instrumentation   public class ObjectSizeFetcher       private static Instrumentation instrumentation       public static void premain String args  Instrumentation inst            instrumentation   inst             public static long getObjectSize Object o            return instrumentation getObjectSize o             Add the following to your MANIFEST MF   Premain-Class  ObjectSizeFetcher   Use getObjectSize   public class C       private int x      private int y       public static void main String    args            System out println ObjectSizeFetcher getObjectSize new C                Invoke with   java -javaagent ObjectSizeFetcherAgent jar C

User · Answer

For JSONObject the below code can help you.

`JSONObject.toString().getBytes("UTF-8").length`

returns size in bytes

I checked it with my JSONArray object by writing it to a file. It is giving object size.

User · Answer

I doubt you want to do it programmatically unless you just want to do it once and store it for future use. It's a costly thing to do. There's no sizeof() operator in Java, and even if there was, it would only count the cost of the references to other objects and the size of the primitives.

One way you could do it is to serialize the thing to a File and look at the size of the file, like this:

Serializable myObject;
ObjectOutputStream oos = new ObjectOutputStream (new FileOutputStream ("obj.ser"));
oos.write (myObject);
oos.close ();

Of course, this assumes that each object is distinct and doesn't contain non-transient references to anything else.

Another strategy would be to take each object and examine its members by reflection and add up the sizes (boolean & byte = 1 byte, short & char = 2 bytes, etc.), working your way down the membership hierarchy. But that's tedious and expensive and ends up doing the same thing the serialization strategy would do.

User · Answer

The java lang instrument Instrumentation class provides a nice way to get the size of a Java Object  but it requires you to define a premain and run your program with a java agent  This is very boring when you do not need any agent and then you have to provide a dummy Jar agent to your application   So I got an alternative solution using the Unsafe class from the sun misc  So  considering the objects heap alignment according to the processor architecture and calculating the maximum field offset  you can measure the size of a Java Object  In the example below I use an auxiliary class UtilUnsafe to get a reference to the sun misc Unsafe object   private static final int NR BITS   Integer valueOf System getProperty  sun arch data model     private static final int BYTE   8  private static final int WORD   NR BITS BYTE  private static final int MIN SIZE   16    public static int sizeOf Class src                 Get the instance fields of src class             List lt Field gt  instanceFields   new LinkedList lt Field gt         do          if src    Object class  return MIN SIZE          for  Field f   src getDeclaredFields                  if  f getModifiers    amp  Modifier STATIC     0                   instanceFields add f                                   src   src getSuperclass         while instanceFields isEmpty                   Get the field with the maximum offset              long maxOffset   0      for  Field f   instanceFields            long offset   UtilUnsafe UNSAFE objectFieldOffset f           if offset  gt  maxOffset  maxOffset   offset             return     int maxOffset WORD    1  WORD     class UtilUnsafe       public static final sun misc Unsafe UNSAFE       static           Object theUnsafe   null          Exception exception   null          try               Class lt   gt  uc   Class forName  sun misc Unsafe                Field f   uc getDeclaredField  theUnsafe                f setAccessible true               theUnsafe   f get uc             catch  Exception e    exception   e            UNSAFE    sun misc Unsafe  theUnsafe          if  UNSAFE    null  throw new Error  Could not obtain access to sun misc Unsafe   exception             private UtilUnsafe

User · Answer

When using JetBrains IntelliJ  first enable  Attach memory agent  in File   Settings   Build  Execution  Deployment   Debugger   When debugging  right-click a variable of interest and choose  Calculate Retained Size

User · Answer

Some years back Javaworld had an article on determining the size of composite and potentially nested Java objects, they basically walk through creating a sizeof() implementation in Java. The approach basically builds on other work where people experimentally identified the size of primitives and typical Java objects and then apply that knowledge to a method that recursively walks an object graph to tally the total size.

It is always going to be somewhat less accurate than a native C implementation simply because of the things going on behind the scenes of a class but it should be a good indicator.

Alternatively a SourceForge project appropriately called sizeof that offers a Java5 library with a sizeof() implementation.

P.S. Do not use the serialization approach, there is no correlation between the size of a serialized object and the amount of memory it consumes when live.

User · Answer

There is also the Memory Measurer tool  formerly at Google Code  now on GitHub   which is simple and published under the commercial-friendly Apache 2 0 license  as discussed in a similar question   It  too  requires a command-line argument to the java interpreter if you want to measure memory byte consumption  but otherwise seems to work just fine  at least in the scenarios I have used it

User · Answer

If you would just like to know how much memory is being used in your JVM, and how much is free, you could try something like this:

// Get current size of heap in bytes
long heapSize = Runtime.getRuntime().totalMemory();

// Get maximum size of heap in bytes. The heap cannot grow beyond this size.
// Any attempt will result in an OutOfMemoryException.
long heapMaxSize = Runtime.getRuntime().maxMemory();

// Get amount of free memory within the heap in bytes. This size will increase
// after garbage collection and decrease as new objects are created.
long heapFreeSize = Runtime.getRuntime().freeMemory();

edit: I thought this might be helpful as the question author also stated he would like to have logic that handles "read as many rows as possible until I've used 32MB of memory."

User · Answer

Much of the other answers provide shallow sizes - e.g. the size of a HashMap without any of the keys or values, which isn't likely what you want.

The jamm project uses the java.lang.instrumentation package above but walks the tree and so can give you the deep memory use.

new MemoryMeter().measureDeep(myHashMap);

https://github.com/jbellis/jamm

To use MemoryMeter, start the JVM with "-javaagent:/jamm.jar"

User · Answer

You have to measure it with a tool  or estimate it by hand  and it depends on the JVM you are using   There is some fixed overhead per object  It s JVM-specific  but I usually estimate 40 bytes  Then you have to look at the members of the class  Object references are 4  8  bytes in a 32-bit  64-bit  JVM  Primitive types are     boolean and byte  1 byte char and short  2 bytes int and float  4 bytes long and double  8 bytes   Arrays follow the same rules  that is  it s an object reference so that takes 4  or 8  bytes in your object  and then its length multiplied by the size of its element   Trying to do it programmatically with calls to Runtime freeMemory   just doesn t give you much accuracy  because of asynchronous calls to the garbage collector  etc  Profiling the heap with -Xrunhprof or other tools will give you the most accurate results

User · Answer

You could generate a heap dump  with jmap  for example  and then analyze the output to find object sizes   This is an offline solution  but you can examine shallow and deep sizes  etc

[java] In Java, what is the best way to determine the size of an object?

The answer is

Examples related to java

Examples related to memory

Tags