Can I measure the size of a List in the memory including elements using Instrumentation.getObjectSize?

Question

As far as I can see java.lang.instrument.Instrumentation.getSize returns the size without elements (as the size doesn't depend on the number of the list. It is 24 bytes). Looks strange. Is that correct that list items are not measured?

Answer 1

The size of objects in Java is fixed, because Java, like C++, is a statically-typed language. The size basically corresponds to whatever is written inside the class file. Since a class file layout is fixed, so is its size.

An ArrayList for example, looks roughly like this:

public class ArrayList implements List
{
    Object[] elementData;
    private int size;
}

The size of any ArrayList instance would be the size of elementData (a pointer to Object[]), size (an int), and overhead. So 24 sounds about right.

That is often referred to as a shallow size.

It sounds like what you want instead is the deep size, i.e. the size of the List + all of the objects it refers to + all the objects those objects refer to, etc.

That's not directly possible using instrumentation API, but with some hacky reflection + instrumentation you might be able to get it. The basic idea is to reflect the object and recursively call getObjectSize() on all referred objects, skipping circular references.

Something along the lines:

public class DeepSizeCounter {
    private HashSet<Object> counted = new HashSet<>();
    private long size = 0;

    public long getSizeDeep(Object x) throws Exception {
        counted.clear();
        size = 0;
        computeSizeDeep(x);
        return size;
    }

    private void computeSizeDeep(Object x) throws Exception {
        if (x != null && !counted.contains(x)) {
            counted.add(x);
            size += instrumentation.getObjectSize(x);
            if (x.getClass().isArray()) {
                if (!x.getClass().getComponentType().isPrimitive())
                    for (Object y : (Object[]) x)
                        computeSizeDeep(y);
            } else {
                for (Field f : x.getClass().getDeclaredFields()) {
                    if (!f.getType().isPrimitive() && (f.getModifiers() & Modifier.STATIC) == 0) {
                        f.setAccessible(true);
                        computeSizeDeep(f.get(x));
                    }
                }
            }
        }
    }
}

Use as:

long totalSize = new DeepSizeCounter().getSizeDeep(myList);

Beware that this approach is unreliable because objects can have backreferences to some global state which you can't distinguish automatically, so can end up counting way too many objects. Also if access control is on, the Field.setAccessible() hack won't work and you won't be able to count any non-public members.