What is a Memory Graph?
A Memory Graph is a visual representation of memory over time. FusionReactor periodically checks to see what the current state of the memory is and it will store these values in it's history. The type of graph you choose to view then effects how much of this memory you will see.
Why would I be interested in memory?
Memory (or lack of it) is so often the cause of major issues in Java environments. It's important to understand the different memory spaces and how heap and non-heap play a role. FusionReactor's memory analysis is a great aid to helping you identify memory issues. Due to the visual nature, the memory graph can very quickly give you a good idea how the system is performing. Not only that but, because it can cover larger periods of time, it can warn you of trends which could become a problem in the future. This kind of trend is much more difficult to spot if you are only checking the system periodically and are only looking at the health of the system right at this point in time.
Which detail memory graphs are available?
- Heap/Non-Heap
- Code Cache (non-heap memory)
- PS Eden / Survivor / Old Gens (heap memory)
- PS PermGen Space (non-heap memory)
- PS Survivor Space (heap memory)
How do I view a Memory Graph?
Select "Resources / Memory Graphs" from the table of contents (Memory section) and you will see the various memory graph pages. It will look something like this: (Although it is unlikely that the actual graph will look like this one.)
From this graph you can see the amount of unallocated memory, the amount of allocated memory and the amount of memory actually being used. The Memory Graph shows the most recent memory activity over the period of stored history or since the JVM being monitored was started, up to a max of typically about 12 hours, as configurable in the Resource Settings, as discussed below..
How do I configure the Memory Graph?
From the FusionReactor Administrator, click "Resource Settings" from the table of contents (Resources section) and you will see the Resource Settings screen. It will look something like this:
From here you can change the way FusionReactor stores memory values:
Initial Delay: This is the number of milliseconds which FusionReactor will wait after a restart before collecting memory values. This wait is added so that you don't interfere with processes which must initialize after startup. It also avoids an unexpected spike at the start of the memory graph.
Sample Interval: This is the number of milliseconds which FusionReactor will wait between taking memory samples.
History Size: This is the maximum number of memory values which FusionReactor will keep in memory. Once the memory is full, the oldest value will be throw away every time a new one is taken.
The Current Memory Graph shows the last 300 memory samples. With a Sample Interval of 5000 milliseconds, the graph would show a time period of 25 minutes.
The Complete Memory Graph shows memory settings right through the history. With a History Size of 8640 and a Sample Interval of 5000 milliseconds, the graph would show a time period of 12 hours.
Memory Explained
Heap memory
The heap memory is the runtime data area from which the Java VM allocates memory for all class instances and arrays. The heap may be of a fixed or variable size. The garbage collector is an automatic memory management system that reclaims heap memory for objects.
- Eden Space: The pool from which memory is initially allocated for most objects.
- Survivor Space: The pool containing objects that have survived the garbage collection of the Eden space.
- Tenured Generation: The pool containing objects that have existed for some time in the survivor space.
Non-heap memory
Non-heap memory includes a method area shared among all threads and memory required for the internal processing or optimization for the Java VM. It stores per-class structures such as a runtime constant pool, field and method data, and the code for methods and constructors. The method area is logically part of the heap but, depending on the implementation, a Java VM may not garbage collect or compact it. Like the heap memory, the method area may be of a fixed or variable size.
- Permanent Generation: The pool containing all the reflective data of the virtual machine itself, such as class and method objects. With Java VMs that use class data sharing, this generation is divided into read-only and read-write areas.
- Code Cache: The HotSpot Java VM also includes a code cache, containing memory that is used for compilation and storage of native code.
