days
0
-99
-3
hours
0
-4
minutes
-5
-1
seconds
-5
0
Get ready to do some maths

# Shallow heap and retained heap calculation in Eclipse MAT

Confused about how you can calculate shallow heaps and retained heaps in Eclipse MAT? In this helpful explainer, Ram Lakshmanan goes over the basics of analyzing heap dumps and how developers can save memory space through garbage collection.

Eclipse MAT (Memory Analyzer Tool) is a powerful tool to analyze heap dumps. It comes quite handy when you are trying to debug memory related problems. Two different types of object sizes are reported in Eclipse MAT: shallow heap and retained heap.

In this article, we will explore the differences between them, focusing on how they are calculated.

Figure 1: Objects in memory

It’s easier to learn new concepts through examples. Let’s say your application has an object model similar to the one shown in Fig #1:

• Object A is holding reference to objects B and C.
• Object B is holding reference to objects D and E.
• Object C is holding reference to objects F and G.

Let’s say each object occupies 10 bytes of memory. With this context, let’s begin our study.

### How the 4 Pillars of Nonviolent Communication can Help Support Your Working Relationships

Casie Siekman (soona)

### Code Automation with Bitbucket

Michael Dowden (Andromeda Galactic Solutions)

### Modern Architecture in the Cloud of 2022

Marius Zaharia (Cloud Solution Architect, Société Générale)

### Shallow heap size

The shallow heap of an object is its size in the memory. Since in our example each object occupies 10 bytes, shallow heap size of each object is 10 bytes. Very simple.

### Retained heap size of B

Retained heap is the amount of memory that will be freed when the particular object is garbage collected.

From the Fig #1 you can notice that object B is holding reference to objects D and E. So, if object B is garbage collected from memory, there will be no more active references to object D and E. It means D & E can also be garbage collected. Thus, retained heap size of B can be calculated in the following fashion:

= B’s shallow heap size + D’s shallow heap size + E’s shallow heap size

= 10 bytes + 10 bytes + 10 bytes

= 30 bytes

Thus, retained heap size of B is 30 bytes.

### Retained heap size of C

Object C is holding reference to objects F and G. So, if object C is garbage collected from memory, there will be no more references to object F & G. It means F & G can also be garbage collected. Thus, retained heap size of C is:

= C’s shallow heap size + F’s shallow heap size + G’s shallow heap size

= 10 bytes + 10 bytes + 10 bytes

= 30 bytes

Thus, retained heap size of C is 30 bytes as well.

Fig 2: Objects Shallow and Retained Heap size.

### Retained heap size of A

Object A is holding reference to objects B and C, which in turn are holding references to objects D, E, F, G. Thus, if object A is garbage collected from memory, there will be no more reference to objects B, C, D, E, F and G. With this understanding let’s do retained heap size calculation of A.

Thus, retained heap size of A is:

= A’s shallow heap size + B’s shallow heap size + C’s shallow heap size + D’s shallow heap size + E’s shallow heap size + F’s shallow heap size + G’s shallow heap size

= 10 bytes + 10 bytes + 10 bytes + 10 bytes + 10 bytes + 10 bytes + 10 bytes

= 70 bytes

Thus, retained heap size of A is 70 bytes.

### Retained heap size of D, E, F and G

Retained heap size of D is 10 bytes only, i.e. their shallow size only. Because D don’t hold any active reference to any other objects. Thus, if D gets garbage collected no other objects will be removed from memory. As per the same explanation objects E, F and G’s retained heap size are also only 10 bytes.

### Let’s make things more interesting

Now let’s make our study little bit more interesting, so that you will gain thorough understanding of shallow heap and retained heap size. Let’s have object H starts to hold reference to B in the example. Note object B is already referenced by object A. Now two guys A and H are holding references to object B. In this circumstance lets study what will happen to our retained heap calculation.

Fig 3: New reference to Object B

In this circumstance, the retained heap size of object A will go down to 40 bytes. Surprised or puzzled? Keep reading!

If object A gets garbage collected, then there will be no more reference to objects C, F and G. Thus, only objects C, F and G will also be garbage collected. On the other hand, objects B, D and E will continue to live in memory, because H is holding active reference to B. Thus B, D and E will not be removed from memory even when A gets garbage collected.

Thus, retained heap size of A is:

= A’s shallow heap size + C’s shallow heap size + F’s shallow heap size + G’s shallow heap size

= 10 bytes + 10 bytes + 10 bytes + 10 bytes

= 40 bytes.

Thus, retained heap size of A will become 40 bytes. All other objects retained heap size will remain undisturbed, because there is no change in their references.

### In conclusion

I hope this article helped to clarify shallow heap size and retained heap size calculation in Eclipse MAT. You might also consider exploring HeapHero. HeapHero is another powerful heap dump analysis tool, which shows the amount of memory wasted due to inefficient programming practices such as duplication of objects, over-allocation and under-utilization of data structures, and sub optimal data type definitions.

Author

Ram Lakshmanan

Every single day, millions & millions of people in North America—bank, travel, and commerce—use the applications that Ram Lakshmanan has architected. Ram is an acclaimed speaker in major conferences on scalability, availability, and performance topics. Recently, he has founded a startup, which specializes in troubleshooting performance problems.