Heap Walker Reference View - Tree of Incoming References

The tree of incoming references is one of the view modes in the reference view of the heap walker. For following long chains of references, the tree of incoming references can be preferable to the reference graph.

There is always one instance visible at a time whose class name or array type is given above the field table. Above the upper right corner of the table, navigation controls allow to move back and forth through all the instances or arrays in the current object set.
The instance navigation is linked among the following views of the heap walker:
This allows you to easily switch back and forth between these views while keeping the focus on the same object.

The order of the instances in the object set can be adjusted to
- unsorted
  The objects are in a random order. This is the default setting.
- sorted by shallow size
  Objects with a larger shallow size are displayed first.
- sorted by retained size
  Objects with a larger retained size are displayed first.
- sorted by allocation time (oldest first)
  Objects with a greater age are displayed first. The "Record object allocation times" feature has to be activated on the "Memory Profiling" tab of the profiling settings dialog, otherwise this sort mode is not available and a warning message is displayed. This sorting only works for recorded objects. Unrecorded objects are appended to the end of the sorted set.
- sorted by allocation time (newest first)
  Like the above sort mode, only that objects with a smaller age are displayed first.
Please see the key concepts of the heap walker for an explanation of the different size types.

Sorting can take a few seconds, depending on the size of the heap. A progress dialog is shown while the objects are sorted.

After changing the sort order, the displayed index is set to one.

Above the main view, the the following additional information is displayed:
- shallow size
- retained size
- allocation time, if the "Record object allocation times" feature is activated on the "Memory Profiling" tab of the profiling settings dialog
Please see the key concepts of the heap walker for an explanation of the different size types.

Each reference node has one or two icons. The first icon is one of
- a regular reference.
- a reference expanded by the search to garbage collector root (see below).
- a reference from an object that is already present as an ancestor node. This indicates a reference cycle. Cycles are more convenienrly analyzed in the reference graph
The second icon is either not present or one of
- a reference from a class. In most circumstances, classes are the last step on the path to the GC root that you are interested in. Classes are not garbage collector roots, but in all situations where no custom classloaders are used it is appropriate and easier to treat them as such. This is JProfiler's default mode when searching for garbage collector roots, you can change this in the path to root options dialog.
  
  Class objects have references to
  - all implemented interfaces
  - their classloader unless they were loaded by the bootstrap classloader
  - all references in their constant pool
  Note that class objects have no reference to their super class.
  
  Classes are not garbage collected together with their classloader when
  - there is no class loaded by that classloader that has any live instances
  - the classloader is unreferenced except by its classes (this is a JVM level reference and not visible in the source of java.lang.Class).
  - None of the java.lang.Class objects is referenced except by the classloader and other classes of that classloader.
- a garbage collector root. A garbage collector root is an entity in the JVM that itself is not garbage collected and pins other objects or classes. There are the following types of garbage collector roots:
  - JNI references
    Native code can request references from the JNI (local or global)
  - stack
    Local variables all current stack frames
  - sticky class
    The JVM itself can flag certain classes as non-garbage collectable
  - thread block
    Live threads are not garbage collected
  - monitor used
    A monitor that is held by someone cannot be garbage collected
  - other GC root
    The JVM can pin objects by attaching this unspecified GC root to them
  For classes there is a special condition that prevents garbage collection: Since each instance has an implicit reference to its class, any live instance prevents a class from being garbage collected. This construct groups all such instances for reasons of conciseness. In this way you can also select all instances of a specific class (rather than a specific class name).

To check why an instance is not garbage collected, you can select it and use the Show paths to GC root button in the view-specific toolbar or the corresponding entry in the context menu.

A dialog will ask you whether to search for a single garbage collector root or for all roots. After that, the paths to root are searched. A progress dialog is shown while the paths to root are calculated.
- If the object is not referenced by a garbage collector root, a message box will be displayed. Note that this case is only possible if the "Remove unreferenced and weakly referenced objects" option in the heap walker option dialog is unchecked.
- Otherwise the tree is then expanded up to the garbage collector roots that were found.
Newly expanded nodes on the path to the GC root have a red reference icon. To highlight the found path without any distractions, no sibling references are shown on that level. To show all sibling references, you can either choose the Show all incoming references action from the context menu or View menu or collapse and expand the parent node.

Each object is optionally annotate with an object ID. With this ID, you can check whether two objects are the same or not. The display of IDs can be switched of the the context menu, the View menu and the view settings of the heap walker.

To add a selection step from this view you can select one or multiple objects and click the [Use ...] button above the graph and choose in the popup menu. There is a corresponding entry in the context menu. Multiple objects are selected by keeping the SHIFT key pressed during selection. The following selection modes are available:
- Selected Objects
  A new object set will be created that contains only the selected instances.
- Exclusively Referenced Objects
  A new object set will be created that contains all objects that would be garbage collected if the selected objects did not exist.
- Items in Selected Collection
  This option is only enabled if you select an array of objects or a standard collection from the java.util package. A new object set will be created that contains the objects in the array or collection. If you select a map collection, you are prompted whether you want to include the key objects as well.
After your selection, the view helper dialog will assist you in choosing the appropriate view for the new object set.