Quickly find which OS X versions are compatible with your Mac model and year. Guide includes OS X 10.7.x (Lion) through OS X 10.14.x (Mojave). 1.800.275.4576 or +1.815.338.8685.
Trace Compass User Guide - LTTng-UST Analyses LTTng-UST Analyses LTTng Kernel Analysis Trace synchronization LTTng-UST Analyses The Userspace traces are taken on an application level. With kernel traces, you know what events you will have as the domain is known and cloistered.
Userspace traces can contain pretty much anything. Some analyses are offered if certain events are enabled.
Call Stack View The Call Stack view allows the user to visualize the call stack per thread over time, if the application and trace provide this information. To open this view go in Window - Show View - Other. And select Tracing/Call Stack in the list. The view shows the call stack information for the currently selected trace. Conversely, you can select a trace and expand it in the Project Explorer then expand LTTng-UST CallStack Analysis (the trace must be loaded) and open Call Stack.
The table on the left-hand side of the view shows the threads and call stack. The function name, depth, entry and exit time and duration are shown for the call stack at the selected time. Double-clicking on a function entry in the table will zoom the time graph to the selected function's range of execution. The time graph on the right-hand side of the view shows the call stack state graphically over time. The function name is visible on each call stack event if size permits.
The color of each call stack event is randomly assigned based on the function name, allowing for easy identification of repeated calls to the same function. Clicking on the time graph will set the current time and consequently update the table with the current call stack information. Shift-clicking on the time graph will select a time range. When the selection is a time range, the begin time is used to update the stack information. Double-clicking on a call stack event will zoom the time graph to the selected function's range of execution.
Tracecompass-dev Trace Compass 1.0.0 Rebuilt For Mac Free
Clicking the Select Next State Change or Select Previous State Change or using the left and right arrows will navigate to the next or previous call stack event, and select the function currently at the top of the call stack. Note that pressing the Shift key at the same time will update the selection end time of the current selection. Clicking the Configure how addresses are mapped to function names ( ) icon will open the symbol providers dialog. Depending on the available symbol providers for the given trace, you can specify: 1) a text or binary file containing mappings from function addresses to function names or 2) the root location of the binaries of the trace target.
If the call stack provider for the current trace type only provides function addresses, a mapping file will be required to get the function names in the view. See the following sections for an example with LTTng-UST traces. Using the Callstack View with LTTng-UST traces There is support in the LTTng-UST integration plugin to display the callstack of applications traced with the liblttng-ust-cyg-profile.so library (see the liblttng-ust-cyg-profile man page for additional information). To do so, you need to:. Recompile your application with ' -g -finstrument-functions'. Set up a tracing session with the the vpid, vtid and procname contexts. See the and sections.
Or if using the command-line:. lttng enable-event -u -a. lttng add-context -u -t vpid -t vtid -t procname.
Preload the liblttng-ust-cyg-profile library when running your program:. LDPRELOAD=/usr/lib/liblttng-ust-cyg-profile.so./myprogram Once you load the resulting trace, the Callstack View should be populated with the relevant information. Note that for non-trivial applications, liblttng-ust-cyg-profile generates a lot of events! You may need to increase the channel's subbuffer size to avoid lost events.
Refer to the. For traces taken with LTTng-UST 2.8 or later, the Callstack View should show the function names automatically, since it will make use of the debug information statedump events (which are enabled when using enable-event -u -a). For traces taken with prior versions of UST, you would need to set the path to the binary file or mapping manually: Importing a binary or function name mapping file (for LTTng-UST mapping.txt.
Select the mapping.txt file that was just created. If you are dealing with C executables, you may want to use nm -demangle instead to get readable function names. The view should now update to display the function names instead. Make sure the binary used for taking the trace is the one used for this step too (otherwise, there is a good chance of the addresses not being the same).
Lastly, the basic symbol provider introduces the notion of priorities between the mapping files. The resolved symbols from the file at the top of the list will have a higher priority than the files listed below. The files can be moved using the Up and Down buttons. Navigation See Control Flow View's,. Marker Axis See Control Flow View's.
Flame Graph View This is an aggregate view of the function calls from the Call Stack View. This shows a bird's eye view of what are the main time sinks in the traced applications.
Each entry in the Flame Graph represents an aggregation of all the calls to a function in a certain depth of the call stack having the same caller. So, functions in the Flame Graph are aggregated by depth and caller. This enables the user to find the most executed code path easily.
In a Flame Graph, each entry (box) represents a function in the stack. If one takes a single vertical line in the view, it represents a full call stack with parents calling children. The x-axis represents total duration (execution time) and not absolute time, so it is not aligned with the other views. The width of an entry is the total time spent in that function, including time spent calling the children. The total time can exceed the longest duration, if the program is pre-empted and not running during its trace time.
Each thread traced makes its own flame graph. The function name is visible on each Flame graph event if the size permits. Each box in the Flame Graph has the same color as the box representing the same function in the Call Stack.
To open this view, select a trace, expand it in the Project Explorer, then expand the Call Graph Analysis (the trace must be loaded) and open the Flame Graph. It's also possible to go in Window - Show View - Tracing then select Flame Graph in the list. To use the Flame graph, one can navigate it and find which function is consuming the most self-time.
This can be seen as a large plateau. Then the entry can be inspected. At this point, the worst offender in terms of CPU usage will be highlighted, however, it is not a single call to investigate, but rather the aggregation of all the calls. Right mouse-clicking on that entry will open a context sensitive menu. Selecting Go to minimum or Go to maximum will take the user to the minimum or maximum recorded times in the trace. This is interesting to compare and contrast the two.
Hovering over a function will show a tooltip with the statistics on a per-function basis. One can see the total and self times ( worst-case, best-case, average, total time, standard deviation, number of calls) for that function. If one wishes to explore at a medium detail level between the 'classic' flame graph view and the call stack view, a per-thread flame graph view is available by selecting the coarser menu and clicking on Content Presentation then Per-thread. To return to the default mode, return to that menu and click on Aggregate Threads. How to use a Flame Graph Observing the time spent in each function can show where most of the time is spent and where one could optimize. An example in the image above: one can see that mpsort is a recursive sort function, it takes approximately 40% of the execution time of the program.
That means that perfectly parallelizing it can yield a gain of 20% for 2 threads, 33% for 3 and so forth. Looking at the function printcurrentfiles, it takes about 30% of the time, and it has a child printmanyperline that has a large self time (above 10%). This could be another area that can be targeted for optimization. Knowing this in advance helps developers know where to aim their efforts.
It is recommended to have a kernel trace as well as a user space trace in an experiment while using the Flame Graph as it will show what is causing the largest delays. When using the Flame Graph together with a call stack and a kernel trace, an example work flow would be to find the worst offender in terms of time taken for a function that seems to be taking too long. Then, using the context menu Go to maximum, one can navigate to the maximum duration and see if the OS is, for example, preempting the function for too long, or if the issue is in the code being executed. Function Duration Statistics This displays the descriptive statistics of the 'wall time' durations of given functions.
It gives an overview of how often a function is called, how much total time it took, its mean duration as well as its maximum, minimum times and the standard deviation. If a time range is selected it will display the local statistics too. This analysis is available if the Flame Graph is available.
Using the mouse. Double-click on the duration ruler will zoom the graph to the selected duration range.