HP

HPjmeter 4.1 User's Guide

English
  HPjmeter 4.1 User's Guide > Chapter 5 Profiling Applications   

Using Call Graph Trees

The call graph trees are used to represent metrics based on graphs. There are four metrics based on the method call graph (showing CPU Time, Clock Time, Call Count, and Lock Delay), and two based on object references (Reference Graph and Reference Sub-Trees by Size).

You can expand or collapse any non-leaf node by clicking on the small square on the left side of each node.

A consequence of representing a graph in the tree form is that the same graph node can be displayed many times within the tree (showing different paths in the graph). Special color coding of the nodes helps you to navigate the tree. Five colors are used:

Table 5-6 Key to Color Coding of Call Graph Nodes

Leaf node in black text
Leaf. Leaf nodes, written in black, represent methods that did not call any other methods or objects that do not keep any references to other objects. Leaf nodes cannot be expanded or collapsed.
Expanded node in gray
text
Expanded. After expansion the node will be shown using gray.
Node expanded elsewhere
in red text
Expanded Elsewhere. A tree node that is already expanded elsewhere in the tree will be shown in red.It is possible to expand this node if you want to do so. The information shown will be identical to that already displayed where the node is expanded. You may find that expanding the same graph node in more than one place makes the tree less manageable.
Visited node in purple
text
Visited. A node that you have expanded and then collapsed is called a visited node. It is shown in a different color (purple) to remind you that you have already looked at the contents of this node.
All other non-leaf nodes
in blue text
Regular. All other non-leaf nodes that have not been visited are presented in blue.

 

See the figure below for examples.

Interpreting Call Graph Data

In the trees that are based on the call graph, the nodes represent methods and the arcs represent cumulative calls from the preceding node.

  • For CPU and Clock trees, the numerical values represent the time used by the arc. That is, the numerical values represent the inclusive time used by all invocations represented by the arc. The numbers in parentheses indicate what percentage of the total inclusive time used by the method was caused by the calls from the preceding node. By default, the arcs with numerical values less than 50 are not shown.

  • For a Call Count tree, the numerical values represent the number of calls made to the method from the preceding node (the caller). The percentage numbers represent the ratio of calls from the caller to the number of all calls to this method from all callers. It may be non-intuitive to traverse this graph if you get used to the call graphs representing time. This is because below a low number of calls—for example, 1—a very large number of further calls can be hidden.

In cases when there is more than one caller of a method, the number of other callers is also given.

Example of Node Color Display

It is best to explain the meaning of the numbers in a tree in an example. Here's a snippet from a Call Graph Tree with times:

Figure 5-2 Multiple Nodes Exposed in Call Graph Tree Display Showing Visitation Color Coding

Multiple Nodes Exposed in Call Graph Tree Display Showing Visitation Color Coding

In the picture above, you can see that run was the only caller of sleepPerTab. The inclusive time for all calls to sleepPerTab was 6,883,833 time units. Lower down, you can see that sleepPerTab used 2,966 time units on calls to setValue , which represents 97% of the total inclusive time used by this method. The remaining 3% of time used by setValue was caused by calls from the remaining callers (three other callers in this case).

NOTE: Inclusive times include the time spent in called methods. Therefore, for recursive calls, the same time is accumulated many times, depending on the depth of the recursion. When this happens, a recursive method may show an inclusive time that is greater than the inclusive time shown for its parent method.
TIP: To see the list of all callers of a given method, double-click on the method name.

The line showing repaint is marked in red. This is because a node showing this method is already expanded elsewhere in the tree. Note that all recursive calls will appear in red (unless you expand the red node), but not all red nodes indicate a recursive call!

Options for Manipulating the Call Tree Display

You have several options for adjusting the display to better reveal the data that you want to see.

Tree Pruning

For the trees showing time, arcs with values of less than 50 are not shown by default to avoid cluttering the display with arcs that are not essential for locating performance bottleneck. However, because the time units are generally abstract, and because your application may have run exceptionally long (or briefly), this threshold (cut-off value) can be modified. Use Tree->Prune to change the cut-off value.

You'll have a choice of changing the value just for the current tree, or changing the default. The latter will be valid for all windows, but will not affect the trees which are already displayed.

Another form of pruning is available for the Object Reference Graph. To keep the size of the displayed data manageable, arrays of references can be only partially represented on the screen. The pruning mechanism controls the maximum number of elements from each reference array that will be shown.

Auto-Expanding the Call Tree

Quite often the tree nodes that you would like to work with are deep in the tree. To see them, you need to expand the entire call chain leading from the root to the nodes of interest. To assist in this task, and to help locate the nodes that are good candidates for analysis in the top-down approach, use the Tree->Auto Expand function that automatically expands the tree and selects the nodes which seem to correspond to complex high-level operations.

Naturally, the tool's choice may be incorrect. In any case, your analysis should not end at the nodes selected for you by HPjmeter.

Using Sub-Trees

Excessive expansion of the tree makes the display hard to navigate. It also slows down scrolling.

You can get rid of the usually uninteresting, higher layers of the tree by selecting one or more nodes and then executing Tree->Set As Root(s). This will replace the current roots of the displayed tree with the selected nodes. You can repeat this command more than once, if necessary.

To restore the original tree, use Tree->Restore Roots.

Searching the Trees

The search functions work in trees basically the same way they work for other metrics, but there are a few special considerations for searching call graph trees.

  • Occasionally, not all nodes found in a search will be accessible (visible). You'll be notified about such situations in the status bar at the bottom of the window. A node will be inaccessible:

    • if no path exists from the root to the node using only arcs with values above the current cut-off value (see Tree Pruning), or

    • if no path exists from the root to the node at all. This can happen when you change the roots of the tree (see Using Sub-Trees).

  • After a search, all found accessible nodes can be made visible by expanding the tree to show the nodes. Occasionally, if the search yielded many results, this creates a tree that is too large to be conveniently navigated, even if you use the Find Next Selected command.

    You may then want to use Tree->Collapse All to fold down the tree alternately with Find Next Selected. This will expand the tree to show only the current node, rather than all selected nodes.

    • The trees showing different metrics may expand differently, even if the same node is found.

    • For trees with time, the tree expands along the path from the root that shows the maximum time (more precisely, the path that maximizes the minimum arc time existing in the path).

    • The tree with call counts expands showing the callers that made the most calls to the found node and, recursively, its selected caller.

    • Finally, the object reference tree expands showing the shortest path from the root to the found node.