Why does newInstance use more memory then expected?

Question

In Java, I want to figure out the exact amount of memory a object uses while allocated.

Just calling the constructor and measure won't work, as it might allocate other object during the constructor. Also, I prefer to use a method that realtime calculate used memory in the given VM. This might not be the standard VM so counting fields and making a smart guess is not sufficient.

Anyway, so far I found that you can make a object with no other allocations with the newConstructorForSerialization found in sun.reflect.ReflectionFactory.

This works, but somehow the call to newInstance allocate 1 block of memory more then expected.

For example, the class

public class a {
    Integer a;
}

and

public class b {
    Integer b = new Integer(12345);
}

Should both give the same result. 16 bytes in this case using Java 7 in the default VM.

However, my code gives 32 bytes (always 16 more then expected). I can compensate for this by removing 16 from the result, but I need to be 100% sure it always allocate that additional block. It's more important for me to know the upped bound of memory usage then the exact amount. So it's only safe to subtract 16 from the result if I'm 100% sure this block is always added.

My code: (run with -XX:-UseTLAB VM arguments)

import java.lang.reflect.Constructor;

import sun.reflect.ReflectionFactory;

public class test {

    public static void main(String[] args) throws Exception {
        prepare(a.class, Object.class);
        System.out.println(memUse());
        System.out.println(memUseSimple());
    }

    private static long memUseSimple() {
        long start = Runtime.getRuntime().freeMemory();
        a a = new a();
        return start - Runtime.getRuntime().freeMemory();
    }

    private static long memUse() throws Exception {
        Object o0 = intConstr.newInstance();
        long start = Runtime.getRuntime().freeMemory();
        Object o1 = intConstr.newInstance();
        return start - Runtime.getRuntime().freeMemory() - 16;
    }

    private static Constructor<?> intConstr;

    private static void prepare(Class<?> clazz, Class<?> parent) throws Exception {
            intConstr = ReflectionFactory.getReflectionFactory()
                    .newConstructorForSerialization(clazz,
                            parent.getDeclaredConstructor());
            return;
    }
}

Edit: To clarify: I want to know why i need to subtract the 16 bytes overhead of the intConstr.newInstance() call, and if i can be 100% sure this overhead is always the same (or at least not less then 16 bytes).

Even if you replace a with b in the above code, it still gives 16 as the result for memUse(), but not memUseSimple(). I only care about memUse() but added the simple method as a comparison.

I know intConstr.newInstance() can have a different overhead on another VM. This is not important, what i need to know if that if it gives a overhead of 16 bytes on the current VM, will it always give 16 bytes overhead (during this runtime)? Also, where does this overhead come from compared to just new a()?

Answer 1

The thing is more or less simple. I used the following code to check if there's a difference between new and newInstance() and I could not find any (Java 7, 64 bit, -XX:-UseTLAB -verbose:gc):

public final static long usedMemory()
{
    return Runtime.getRuntime().totalMemory() 
               - Runtime.getRuntime().freeMemory();
}

public static void main(String[] args) throws Exception
{
    // we get the default ctor
    Constructor<?> ctor = ReflectionFactory
            .getReflectionFactory()
            .newConstructorForSerialization(
                    Main.class, Object.class.getDeclaredConstructor());
    // warm up newInstance
    Object d = ctor.newInstance();
    // warm up Runtime
    System.out.println(usedMemory());
    // warm up Main
    Object b = new Main();
    // force GC
    System.gc();
    // get currently used memory
    final long mem = usedMemory();
    Object a = new Main();
    System.out.println(usedMemory() - mem);
    Object c = ctor.newInstance();
    System.gc();
    System.out.println(usedMemory() - mem);
    System.out.println(a + ", " + b + ", " + c + ", " + d);
}

The code loks like this because we have to trick the compiler not to optimize away any portions of it and to let the system initialize some background stuff. The output I get is:

384024
[GC 381K->400K(249664K), 0.0006325 secs]
[Full GC 400K->264K(249664K), 0.0040675 secs]
16
[GC 264K->296K(249664K), 0.0002040 secs]
[Full GC 296K->264K(249664K), 0.0023534 secs]
32

... which is exactly what I had expected. One object of type 'Main' consumes 16 bytes and if I allocate another we're consuming 32 bytes. The second value is the difference to the used memory value before the first 'Main' allocation.

It also did not made any difference if the Main class contained a member variable or not. I tried it without, with Integer integer; and Integer integer = Integer.of(42);, the result was always the same.

The overhead you encounter comes from the stuff that's going on in the background of the newInstance call. In my example I compensated for this by enforcing the GC to run.

This may be a little cheating, but this example is just to show that there's now difference between new and newInstance except that the latter allocates some more stuff in the background. As these objects get allocated in eden space, and won't survive any GC cycle they can be neglected IMHO.