Verbose garbage collection data items
The IBM® Monitoring and Diagnostic Tools - Garbage Collection and Memory Visualizer can display many types of garbage collection data. You can control which types are displayed by selecting the corresponding items, such as heap size or compact time, in the Data selector view.
When you open a verbose garbage collection
log file, the Data selector view is displayed.
The view shows a number of data categories, such as VGC
pause, and the data items that are available in each category.
Select a data item to display the data in the Data set tab.
The available items are explained in the following table.
Note: The
categories and lists of available items can vary depending on the
type of log file and the information that it contains.
| Data item | Meaning |
|---|---|
| Action | The action code. |
| Actual Concurrent Trace Kickoff | The actual kick-off point for concurrent collections. |
| Allocation per cycle | The number of allocations made for each cycle. |
| Amount compacted | The amount of data compacted in a collection. |
| Amount copied from eden | The number of bytes copied from eden regions during partial garbage collect. |
| Amount copied from other regions | The number of bytes copied from regions other than eden regions, during partial garbage collect. |
| Amount failed flipped | The amount of data that failed to be flipped during the scavenger collection. |
| Amount failed tenured | The amount of data that failed to be tenured during the scavenger collection |
| Amount flipped | The amount of data flipped during the scavenger collection. |
| Amount freed | The amount of data freed during the scavenger collection. |
| Amount tenured | The amount of data tenured in a collection. |
| CMS Abortable Preclean CPU Time | The processor time used by CMS during its abortable precleaning phase. |
| CMS Abortable Preclean Real Time | The "real" (elapsed) time taken by CMS to perform its abortable precleaning phase |
| CMS Heap Size At Mark Start | The size of the heap managed by CMS when the mark phase was triggered |
| CMS Heap Size At Re-mark Start | The size of the heap managed by CMS when the remark phase was triggered |
| CMS Heap Used At Mark Start | The amount of the heap managed by CMS that was in use when the mark phase was triggered |
| CMS Heap Used At Re-mark Start | The amount of the heap managed by CMS that was in use when the remark phase was triggered |
| CMS Mark CPU Time | The processor time used by Concurrent Mark Sweep (CMS) during its marking phase |
| CMS Mark Real Time | The "real" (elapsed) time taken by CMS to perform its marking phase |
| CMS Preclean CPU Time | The processor time used by CMS during its precleaning phase |
| CMS Preclean Real Time | The "real" (elapsed) time taken by CMS to perform its precleaning phase |
| CMS Reset CPU Time | The processor time used by CMS during its reset phase. |
| CMS Reset Real Time | The "real" (elapsed) time taken by CMS to perform its reset phase |
| CMS Sweep CPU Time | The processor time used by CMS during its sweep phase |
| CMS Sweep Real Time | The "real" (elapsed) time taken by CMS to perform its sweep phase |
| Card cleaning times | The card-cleaning times. |
| Cards cleaned | The number of cards cleaned in a concurrent collection. |
| Cards traced | The number of cards traced in a concurrent collection. |
| Class loaders unloaded | The number of class loaders unloaded. |
| Classes unloaded | The number of classes unloaded. |
| Common NUMA memory at gc start | Common non-uniform memory architecture (NUMA) value at the start of garbage collection. |
| Common NUMA memory at gc end | Common non-uniform memory architecture value at the end of garbage collection. |
| Compact times | The time spent compacting. |
| Copy forward time | The time spent copying memory. |
| Dynamic SoftReference Threshold | Dynamic age threshold used to clear soft references. |
| Eden size | The size of the eden area. |
| Exclusive access times | The exclusive access time. This time might include time spent waiting for earlier collections to complete. |
| Final references cleared | The number of references to objects which will require finalization cleared. See the Diagnostics Guide for more details. |
| Final references queued | The number of pending references to objects which will require finalization. See the Diagnostics Guide for more details. |
| Fragmentation index | The number of objects of the requested size that could not be allocated due to fragmentation. |
| Free LOA (after collection) | The free large object area after garbage collection occurs. (The large object area is also known as the wilderness). |
| Free LOA (before collection) | The free large object area before garbage collection occurs. (The large object area is also known as the wilderness). |
| Free SOA (after collection) | The free small object area after collection. |
| Free SOA (before collection) | The free small object area before collection. |
| Free eden heap | The amount of free space in the eden area. |
| Free heap (after all collections in event) | The amount free in the total heap. |
| Free heap (after collection) | The amount free in the total heap after a garbage collection. |
| Free heap (before collection) | The amount free in the total heap before collection. |
| Free nursery heap (after all collections in event) | The free nursery after enough garbage collections have occurred to satisfy an allocation request. |
| Free nursery heap (after collection) | The free nursery after garbage collection. |
| Free nursery heap (before collection) | The free nursery before a garbage collection. This quantity is expected to be near zero. |
| Free remembered set | The amount of free space in the remembered set. |
| Free tenured heap (after all collections in event) | The amount free in the tenured heap after all the collections in an event. |
| Free tenured heap (after collection) | The amount free in the tenured heap after collection. |
| Free tenured heap (before collection) | The amount free in the tenured heap before garbage collection. |
| Free permanent heap (after collection) | The free permanent heap after a garbage collection. |
| Free permanent heap (before collection) | The free permanent heap before a garbage collection. |
| GC rate (per ms) | The amount of heap freed by garbage collection, over time. The time that is used in the calculation is the "Interval between garbage collections (mark-sweep, nursery, or global)", in milliseconds. |
| GC reasons | A record of the reasons for all the collections which occurred. For example, AF or SYS. |
| GC types | A record of the type of all the collections that occurred. |
| Heap size | The total size of the total heap. |
| Intended Concurrent Trace Kickoff | The target kick-off point for concurrent collections. |
| Interval between allocation failure garbage collections | Garbage collection intervals for allocation failure trigger types only. |
| Interval between allocation taxation garbage collections | Garbage collection intervals for allocation tax trigger types only. |
| Interval between concurrent garbage collections | Garbage collection intervals for concurrent trigger types only. |
| Interval between garbage collection triggers | Garbage collection intervals for all trigger types (allocation, system, and concurrent). |
| Interval between garbage collections (mark-sweep, nursery, or global) | Garbage collection intervals for subcollections (nested garbage collection clauses). |
| Interval between system garbage collections | Garbage collection intervals for system trigger types only. |
| JNI references cleared | The number of JNI weak references cleared (iSeries operating systems only). JNI weak references provide the same capability as WeakReference objects do, but the processing is different. A JNI routine can create a JNI Weak reference to an object and later delete that reference. The Garbage Collector clears any weak reference where the referent is unmarked, but no equivalent of the queuing mechanism exists. Failure to delete a JNI Weak reference causes a memory leak in the table and performance problems. This behavior is also true for JNI global references. The processing of JNI weak references is handled last in the reference handling process. The result is that a JNI weak reference can exist for an object that has already been finalized and had a phantom reference queued and processed. |
| JNI references queued | The number of JNI weak references queued (iSeries operating systems only). JNI weak references provide the same capability as WeakReference objects do, but the processing is different. A JNI routine can create a JNI Weak reference to an object and later delete that reference. The Garbage Collector clears any weak reference where the referent is unmarked, but no equivalent of the queuing mechanism exists. Failure to delete a JNI Weak reference causes a memory leak in the table and performance problems. This behavior is also true for JNI global references. The processing of JNI weak references is handled last in the reference handling process. The result is that a JNI weak reference can exist for an object that has already been finalized and had a phantom reference queued and processed. |
| JVM restarts | The label for unstructured data indicating the VM was restarted. |
| Largest primitive arraylet object | The largest number of leaves for a single arraylet object that has an element type of primitive. |
| Largest reference arraylet object | The largest number of leaves for a single arraylet object that has an element type of reference. |
| Local NUMA memory at gc start | Local non-uniform memory architecture value at the start of garbage collection. |
| Local NUMA memory at gc end | Local non-uniform memory architecture value at the end of garbage collection. |
| Mark times | The time spent marking the heap. |
| Maximum SoftReference Threshold | Maximum age threshold used to clear soft references. |
| Multiple invocations | Unstructured data indicating that a log includes multiple invocations of a Java™ VM. |
| Non-local NUMA memory at gc start | Non-local non-uniform memory architecture value at the start of garbage collection. |
| Non-local NUMA memory at gc end | Non-local non-uniform memory architecture value at the end of garbage collection. |
| Number of GMP collections per cycle | The number of collections per global mark phase (GMP). |
| Nursery size | The total size of the nursery. |
| Nursery size before collection | The total size of the nursery before a collection |
| Objects compacted | The number of objects moved in a collection. |
| Objects failed flipped | |
| Objects failed tenured | The number of objects that failed to be tenured during the scavenger collection |
| Objects flipped | |
| Objects queued for finalization | The number of objects queued for finalization. |
| Objects tenured | The number of objects tenured in a collection. |
| Pause time (mark, sweep, compact) | The total pause times, for each collection. Multiple collections might occur after a single trigger (such as an allocation failure, or concurrent collection kickoff). This time is not reported for scavenger collections, so gencon logs do not contain many pause times. |
| Permanent heap size | The total size of the permanent heap. |
| Phantom references cleared | The number of phantom references cleared. |
| Phantom references queued | The number of phantom references queued. |
| PhantomReference count (after collection) | The number of phantom references on the heap after the collection. |
| PhantomReference count (before collection) | The number of phantom references on the heap before the collection. |
| Pinned classes | The number of pinned classes. |
| Primitive arraylet leaves | The total number of leaves used for arraylet objects that have an element type of primitive. |
| Real Time | The "real" time taken to perform garbage collection |
| Reference arraylet leaves | The total number of leaves used for arraylet objects that have an element type of reference. |
| Reference arraylet object count | The number of arraylet objects that have an element type of reference. |
| Requested object sizes triggering allocation failures | The number of bytes which were requested but could not be allocated, triggering an allocation failure. |
| Remembered set | The size of the remembered set. |
| Scavenge time | The time spent performing the scavenge. |
| Soft references cleared | The number of soft references cleared during
this collection. For more information about soft references, see the developerWorks® article  Java theory
and practice: Plugging memory leaks with soft references. |
| Soft references queued | The number of soft references queued. For
more information about soft references, see the developerWorks article Java theory
and practice: Plugging memory leaks with soft references. |
| SoftReference count (after collection) | The number of soft references on the heap after the collection. |
| SoftReference count (before collection) | The number of soft references on the heap before the collection. |
| Sweep times | The time spent sweeping the heap. |
| System information | Initialization system attributes. |
| System Time | The "system" time taken to perform garbage collection |
| Tenure rate (per ms) | The amount of heap tenured, over time. The time that is used in the calculation is the "Interval between garbage collections (mark-sweep, nursery, or global)", in milliseconds. |
| Thread Start Times | The time taken to start running threads after garbage collection finishes. |
| Thread Stop Times | The time taken to stop running threads before garbage collection could begin. |
| Tenure age | The target tenure age in generational collection. |
| Tenured heap size | The total size of the tenured heap. |
| Tilt ratio | The proportion of the nursery which is available for allocation and existing objects. The size of the allocate space in the new area is maximized by a technique called tilting. Tilting controls the relative sizes of the allocate and survivor spaces. Because not all objects typically survive a collection, the survivor space can be less than half the nursery. The tilt ratio is only relevant for generational policies with a semi-space nursery. The garbage collector automatically tunes the tilt ratio. |
| Time taken to scan roots | The time taken to scan the roots. |
| Time spent unloading class loaders | The amount of time spent unloading class loaders. |
| Time spent unloading classes | The amount of time spent unloading classes. |
| Total LOA (after collection) | The total size of the large object area (also known as wilderness). |
| Total LOA (before collection) | The total size of the large object area (also known as wilderness). |
| Total NUMA memory at gc start | Total non-uniform memory architecture value at the start of garbage collection. |
| Total NUMA memory at gc end | Total non-uniform memory architecture value at the end of garbage collection. |
| Total SOA (after collection) | The total size of the small object area after collection. |
| Total SOA (before collection) | The total size of the small object area before collection. |
| Total heap (after all collections in event) | The amount free in the total heap at the end of garbage collection. |
| Total heap (before collection) | The total heap before collection. |
| Total nursery heap (after all collections in event) | The nursery size after enough garbage collections have occurred to satisfy an allocation request. |
| Total pause time | The total pause times, per collection trigger (such as an allocation failure or exclusive access). This time might include time spent waiting for earlier collections to complete. |
| Total tenured heap (before collection) | The tenured heap size before garbage collection. |
| Trace rate | The trace rate for concurrent collections. |
| Trace Target | The target end point for concurrent collections. |
| Unusable heap (due to fragmentation) | The amount of heap which was free before garbage collection but could not be used to allocate the requested object that triggered garbage collection because it contained no contiguous section large enough for the requested object. |
| Unusable heap (due to fragmentation, excluding LOA) | The amount of small object area heap which was free before garbage collection but could not be used to allocate the requested object that triggered garbage collection because it contained no contiguous section large enough for the requested object. |
| Unusable tenured area (due to fragmentation) | The amount of tenured heap which was free before garbage collection but could not be used to allocate the requested object that triggered garbage collection because it contained no contiguous section large enough for the requested object. |
| Used LOA (after collection) | The used large object area after garbage collection occurs. (The large object area is also known as the wilderness). |
| Used LOA (before collection) | The used large object area before garbage collection occurs. (The large object area is also known as the wilderness). |
| Used SOA (after collection) | The used small object area after collection. |
| Used SOA (before collection) | The used small object area before collection. |
| Used heap (after collection) | The amount used in the flat heap. |
| Used heap (after global collection) | The amount used in the heap after each garbage collection on the entire heap |
| Used heap (before collection) | The amount used in the tenured heap (or total heap, in the case of flat heaps). |
| Used nursery heap (after collection) | The used nursery after a garbage collection. |
| Used nursery heap (before collection) | The used nursery before a garbage collection. This value is expected to be near the nursery size. |
| Used permanent heap (after collection) | The used permanent heap after a collection. |
| Used permanent heap (before collection) | The used permanent heap before a collection. |
| Used tenured heap (after collection) | The amount of used space in the tenured heap after a garbage collection. |
| Used tenured heap (after global collection) | The amount of used space in the tenured heap after a garbage collection on the entire heap. |
| Used tenured heap (before collection) | The amount of used space in the tenured heap before a garbage collection. |
| User Time | The "user" time taken to perform garbage collection |
| Weak references cleared | The number of weak references cleared during
this collection. For more information about weak references, see the developerWorks article Java theory
and practice: Plugging memory leaks with weak references. |
| Weak references queued | The number of weak references queued. For
more information about weak references, see the developerWorks article Java theory
and practice: Plugging memory leaks with weak references. |
| WeakReference count (after collection) | The number of weak references objects on the heap after the collection. |
| WeakReference count (before collection) | The number of weak references on the heap before the collection. |
| Version | The version of the VM used to produce the log. |
| VM settings | Initialization garbage collection attributes. |