Yet Another Post About Java Heap Space

Generational Garbage Collectors JVM heap is divided into two different Generations. One is called Young and the second one is the Old (sometimes referred to as Tenured). The Young Generation is further separated into two main logical sections: Eden and Survivor spaces. There are also Virtual spaces for both Young and the Old Generations which…

What Causes OutOfMemoryError?

OutOfMemoryError might be thrown when one of the following circumstances occurs: JVM has run out of native memory Java heap is out of memory PermGen or Metaspace has run out of memory JVM spent too much time trying to collect the garbage The root cause of OutOfMemoryError can be usually deducted from the error message. Let’s…

Shallow, Retained and Deep Size

If you ever worked with heap analysis, you might have encountered terms such as shallow, retained and deep size of an object. It doesn’t really matter if we’re talking about analyzing JVM heap dump with VisualVM or JavaScript heap snapshot with Chrome DevTools – the terms are the same. The difference between shallow, retained and…

When Application Threads Can Be Stopped: Safepoints

There are two logical groups of threads in Java application: application threads performing application logic threads performing GC When performing operations such as heap compaction, GC threads move some objects around and those objects cannot be used by any of the application thread, because their physical location may change. This leads to so called…

PermGen and Metaspace

PermGen is an abbreviation for Permanent Generation and it’s a special heap space which is separate from the main Java heap where JVM keeps track of metadata of the classes which have been loaded. In Java 8 PermGen has been renamed to Metaspace – with some subtle differences. From our perspective, it is important to…

Deoptimization

When looking at the output of -XX:+PrintCompilation JVM flag, it’s easy to spot some entries with “made not entrant” and “made zombie”. This indicates so called deoptimization. What it basically means is that the code which was previously compiled, has to be backed out. Not entrant code Code can be made not entrant in…

Tiered Compilation

Even though there are only two basic compilers (+ interpreter) in Java, there are five levels of executions, because the client (C1) compiler has three different levels of compilation. The server compiler (C2) has only one. Level 0 – interpreted code Level 1 – simple C1 compiled code (with no profiling) Level 2 –…

What’s So Hot in HotSpot?

HotSpot JVM is the primary reference Java Virtual Machine implementation. The name comes from the approach it takes toward compiling the code. Hot spot is the code which is executed frequently. The more frequently code is executed, the hotter it becomes. If HotSpot JVM finds that kind of code, it will compile it to make…

Client, Server and Tiered Compilation

Client and Server Compilers There are two basic types of Just-In-Time Java compilers: Client and Server. Traditionally, the Client and the Server compilers are called C1 and C2 respectively. The main difference between the Client and the Server compilers is the aggressiveness in a way they compile code. The Client compiler is optimised to…

Escape Analysis

Escape Analysis (EA) is another very important technique which Just-In-Time Java compiler can use to analyze the scope of a new object and decide whether it might not be allocated on Java heap space. Many resources available on the internet say that EA allows objects to be allocated on the method stack. While technically…