|

# How much memory do I need (part 2) – What is shallow heap?

August 27, 2012 by Filed under: Memory Leaks

What is the size of a particular data structure?
“Can I fit all these objects into my ehCache?”

This article is the second post in the series where we try to answer those questions. The last post explained the difference between retained and shallow sizes of an object. In the article we also offered an example of how to calculate retained heap size of a data structure. In today’s article we will expand on what we called “simple” in the previous post. Namely – what is and how to measure shallow heap used by an object.

In the first post we pushed a whole lot of complexity away by stating that calculating shallow heap size is easy – it consists of only the heap occupied by the object itself. But how do you calculate how much memory does the object “itself” require?  Apparently there is a formula for it:

Shallow Heap Size = [reference to the class definition] + space for superclass fields + space for instance fields + [alignment]

Does not seem too helpful, eh? Let’s try to apply the formula using the following sample code:

``````class X {
int a;
byte b;
java.lang.Integer c = new java.lang.Integer();
}``````
``````class Y extends X {
java.util.List d;
java.util.Date e;
}``````

Now, the question we strive to answer is – how much shallow heap size does an instance of a Y require? Lets start calculating it, assuming that we are on a 32-bit x86 architecture:

As a starting point – Y is a subclass of X, so its size includes “something” from the superclass. Thus, before calculating the size of Y, we look into calculating the shallow size of X.

Jumping into the calculations on X, first 8 bytes are used to refer its class definition. This reference is always present in all Java objects and is used by JVM to define the memory layout of the following state. It also has three instance variables – an int, an Integer and a byte. Those instance variables require heap as follows:

• a byte is what it is supposed to be. 1 byte in a memory.
• an int in our 32bit architecture requires 4 bytes.
• a reference to the Integer requires also 4 bytes. Note that when calculating retained heap, we should also take into account the size of a primitive wrapped into the Integer object, but as we are calculating shallow heap here, we only use the reference size of 4 bytes in our calculations.

So – is that it? Shallow heap of X = 8 bytes from reference to the class definition + 1 byte (the byte) + 4 bytes (the int) + 4 bytes (reference to the Integer) = 17 bytes? In fact – no. What now comes into play is called alignment (also called padding). It means that the JVM allocates the memory in multiples of 8 bytes, so instead of 17 bytes we would allocate 24 bytes if we would create an instance of X.

Did you know that 20% of Java applications have memory leaks? Don’t kill your application – instead find and fix leaks with Plumbr in minutes.

If you could follow us until here, good, but now we try to get things even more complex. We are NOT creating an instance of X, but an instance of Y. What this means is – we can deduct the 8 bytes from the reference to the class definition and the alignment. It might not be too obvious at first place but – did you note that while calculating the shallow size of X we did not take into account that it also extends java.lang.Object as all classes do even if you do not explicitly state it in your source code? We do not have to take into account the header sizes of superclasses, because JVM is smart enough to check it from the class definitions itself, instead of having to copy it into the object headers all the time.

The same goes for alignment – when creating an object you only align once, not at the boundaries of superclass/subclass definitions. So we are safe to say that when creating a subclass to X you will only inherit 9 bytes from the instance variables.

Finally we can jump to the initial task and start calculating the size of Y. As we saw, we have already lost 9 bytes to the superclass fields. Let’s see what will be added when we actually construct an instance of Y.

• Y’s headers referring to its class definition consume 8 bytes. The same as with previous ones.
• The Date is a reference to an object. 4 bytes. Easy.
• The List is a reference to a collection. Again 4 bytes. Trivial.

So in addition to the 9 bytes from the superclass we have 8 bytes from the header, 2×4 bytes from the two references (the List and the Date). The total shallow size for the instance of Y would be 25 bytes, which get aligned to 32.

To make the calculations somewhat easier to follow, we have aggregated it on the following diagram:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
Align Align Align Align
X Object a b c
Y Object a b c d e

What can you do with this knowledge? Together with the skills to calculate the size of retained heap (covered in my recent post), you now possess the ultimate power to calculate how much memory your data structures actually require.

To make things even more interesting, we have created an utility that measures the sizes of both shallow and retained heap for your objects. In the very near future we will release the tool for free use. Stay tuned by subscribing to our Twitter feed!

PS. While writing this article, the following online resources were used for inspiration:

Nice post, straight to bookmarks!

Good post. I actually guess it most time rather than doing precise calculation. Anyway does this calculation changes on 32 bit and 64 bit JVM ?

Sure it does 🙂 First of all object header is 12 bytes on 64bit JVM. Secondly, object references can by either 4 bytes or 8 bytes, depending on JVM flags and the size of the heap. I will explain it in more detail in future post.nnSo X will be either 24 or 32 bytes, and Y 32 or 48 bytes 🙂

iNikem

Alignment is different on different architectures. On SPARC, for example, every field are aligned to its own alignment size. The alignment size is the lesser of the size of the object itself and 8. In other words, byte a; long b; char c; double d; takes up 32 bytes, not 16 as it would on x86.

Elias Mu00e5rtenson

Good point, specified that this is 32bit x86 architecture

iNikem

You should fix the class definition for Y in the code tags:nNow you are defining class B which extends Y, but according your description, it should be class Y extending X.nnOther than that, nice and easy to understand post. Thanks!

Ir Relevant

Thanks for feedback, fixed!

iNikem