Analyzing your profiled data can be a little overwhelming for the first time. In this documentation you can find all the necessary knowledge to understand what's going on:
This view shows you a performance tree, split up per thread (and process if child processes were traced)
By clicking on 'Per thread' or 'Combined' you can switch between the two. The tree items are ordered by duration.
If you click on an item it will automatically expand all items below recursively for as long as they don't have any sibling nodes.This allows you to locate a bottle neck very fast.
The flame graph shows you the same information as the Tree view but in a graphical way. From bottom to
top are the different call stacks. The wider the boxes are, the longer the (sum of the) calls took.
The colors range from yellow (lowest call count) to dark red (highest call count). You can zoom in
on the graph by using CTRL + mousewheel up (or down to zoom out). If you hover over the boxes you
get some more information forthat particular call. If you click on a method, this will get selected
(so if you then move to the treeview you will automatically be at the right spot). Just as with the
Tree, you can also switch between 'Per thread' and 'Combined'. If you rescoped to a certain period
in time, there might be some white colored methods, this means these calls are not completely within
the time frame you selected (and thus have call count 0). Threads are also shown in white at the
start of your stack.
This shows you a list view of all method calls organized by assembly, namespace and type. You can order
the calls by clicking on the column headers.
There are two kind of list views:
Depending on your trace configuration, your timeline might look a little different. Methods that are DeepTraced (see
Profiling modes) appear in blue, all others (sampling and regular tracing) appear in orange.
From left to right is the time axis, and from top to bottom you go deeper in the call stack. Threads are stacked upon each other vertically, the thread names are shown at the front of each thread.
If you move your mouse over an item you will see an info tooltip. If you click on an item it will be selected and you will get the properties for that specific call in the properties tab (you can also select multiple items by using shift and/or control click). If you had enabled parameters, you will find them in the properties window. If object tracking was on, every object will have it's unique id between square brackets (as well in the instance, as in all arguments).
On the right you'll find the assembly tree to browse and find all method calls by assembly,namespace and type.
Bellow the assembly tree, is the heli(copter) view. You can use this to select the viewport for the timeline and/or move it around. If a particular method is selected, all calls of this method will be highlighted in the heliview (little blue dots). You can simply click once on an instance to select it. If you doubleclick that instance will be selected AND the view will be zoomed in on that item. Navigating in the timeline can also be done by using the buttons in the toolbar (Zoom to fit, Zoom, Drag). You can also use ctrl+scroll to zoom in and out on particular piece in the view.
If you hold the left mouse button while dragging the mouse you get a measurement tool overlay to find out how long any piece of the timeline takes.
Depending on your tracing settings, some plugins might be enabled. If you write your own plugins they will also be shown here if available. CodeTrack comes with 2 plugins :
The toolbar at the top provides all necessary tools to navigate and analyze your profiling session:
By clicking the "show/hide graph" button, you can display the extra metrics that are measured during your profiling session.
These metrics contain: Heap sizes (GC), processor usage by your process (CPU), memory usage by your process
(RAM), disk io by your process (IO).
Not that the heap sizes are collected from WMI, sometimes this doesn't work and these metrics are not
available. The first measurement can only occur AFTER the first garbage collect.
By hovering over the graph you can get the values of the metrics.
By clicking the "Filter & Order Threads" button in the toolbar, you get a dialog where you can reorder the treads by dragging them around. You can choose which threads to include in the views (this affect all views: "timeline" , "per thread", "all threads", "list", "exceptions",...)
Depending on the settings you choose before collecting your profiling data (Under the 'advanced' expander in your tracing
options), you can select the kind of timings you want to see in all the previous views by clicking the gear
icon in the upper right corner (timeline is always in Walltime mode).
Selecting calls will be effective over all sections. So eg. if you make a selection in the timeline, the call
will also be selected and highlighted in the tree views and vice versa.
You can use the navigator in the topright corner of the treeviews to navigate to previous and next instances if available.
Use Ctrl+F or press the magnify icon in the toolbar to search anything by name. This will allow you to find assemblies,
namespaces, types and methods.
Note that codetrack takes in account the generics of a class and/or method. Eg. the Add method of List
You can right click on a method in the assembly tree to mark or unmark all instance of a certain method.These markers will also be visible in the timeline.
Exceptions will be marked red (as well in the timeline view as in the assembly tree). If an exception is caught,
all methods where this exceptions passes in the stack will also be marked red.
Move your mouse over the stack tree, you'll find more info about the exception in the deepest red item. (this is only the case for non virtualized timelines)
In the exception overview ("Exceptions overview" button in the toolbar) you can browse through all exceptions that occured. This can be done by thread, exception class or just a flat list. If you select an exception you get more information and you can goto the location in the timeline where the exception occured. You will also find a red marker in the ticks header. By hovering over the tick you also get more information about the exception.
Whenever a managed thread is suspended, this is also traced. If you zoom in in the timeline, suspensions will
be marked with a red hatch pattern. If the reason for the suspension is known, it will also be shown:
Garbage collects are shown as orange markers in the tickheader at the top of the timeline. If GC info was enabled
under the advanced expander (Collect window), hovering over the marker will also tell you which generations
In the properties tab, you'll find everything there is to know about a certain method call, or the selected namespace,
type, method, ...
If you enabled argument tracing, you'll find the values for the parameters and return value in the property grid.
When no session has been opened for analysis yet, you get an overview of all previously traced and/or opened
If you already opened a session you can still get this list by clicking the history (clock) icon on the right of your tab titles. You can then open a file from here too.
By clicking the info button in the toolbar, you get a dialog showing you the settings you used for tracing and
som extra info about the process(es) in the current session.
In the code window you can see the decompiled code of the currently selected method. You can select the decompilation
target language by clicking on the links.
Note that this will only work if the assembly can be found on the location were it's traced. If an assembly is missing, you can specify its location on the current machine by typing it in the textbox on the right and clicking retry. Most of the time, all other missing assemblies will be in the same location, click the automap link to try and find other missing assemblies based on the one you already entered.
If pdbs where available at the time of tracing and they can be found at the expected location, you can also show the original source code in this window.