Admin: Memory
From Resin 3.0
Contents |
Memory Pools
Java organizes its memory into pools, depending on the memory use. The main long-term heap memory is the Tenured memory. Other memory are optimizations of the Tenured memory. Eden is new, short-term memory. Survivor new memory that has survived a short garbage collection.
CodeCache
The CodeCache is the JVM's non-heap memory pool containing the JNI compiled Java class code.
Eden
The Eden memory pool is used by the JVM for new, short-lived memory. Free memory in the Eden can be collected in fast garbage collections. If an object survives a short GC from the Eden space, it moves to the Survivor pool.
Typically, objects specific to a single HTTP request will be in the Eden pool and will freed on the first garbage collection after the request completes.
The Eden memory size is configured with -Xmn128m. In general, the JVM's defaults are fine.
PermGen
The PermGen pool is an important memory heap pool used for classes and other permanent memory. If an application has a lot of classes, it's possible for this memory to be used up.
For restarts, the PermGen can have important memory leaks, where a restarted WebApp might not release its classes and the PermGen memory can increase. The PermGen leaks tend to be application or framework errors where a class is either stored in an incorrect environment, like saving a servlet class in a ThreadLocal or in a system object.
Survivor
The Survivor pool contains objects that are older than Eden objects, but have survived a short GC. It's a medium pool between Eden and Tenured. If the Survivor objects survive further garbage collections, they are moved to the Tenured space.
Tenured
The Tenured pool is the main memory heap for long-lived objects. For a servlet container, the tenured pool contains long-lived objects like Servlets, Application-scoped CDI beans, and Sessions.
If a memory leak exists, the tenured memory will gradually be used up until the JDK runs out of memory.
Memory Usage
In the Admin display, the state of a memory pool is broken into three main groups: free, used and max.
free
The free memory is the amount of memory in a pool available for new allocations. In general, this is the most critical number, because when it goes to 0, you have run out of memory.
Small values of free memory will cause the garbage collector to run steadily, so you will generally want to have a solid buffer of free memory.
used
The used memory for a pool is the amount of memory actually being used.
max
The maximum memory for the pool is the total amount of memory allocated to that pool. Note, this number does not always match up with the configured maximum.
