|Project Name||Stars||Downloads||Repos Using This||Packages Using This||Most Recent Commit||Total Releases||Latest Release||Open Issues||License||Language|
|Hotspot||3,581||2 days ago||58||C++|
|The Linux perf GUI for performance analysis.|
|Goldencheetah||1,673||2 days ago||171||gpl-2.0||Standard ML|
|Performance Software for Cyclists, Runners, Triathletes and Coaches|
|Galry||187||8 years ago||5||March 19, 2016||3||other||Python|
|[deprecated] High-performance interactive visualization in Python|
|high performance access to `wkhtmltopdf` and `wkhtmltoimage` from node.js.|
|Hands On High Performance With Qt||30||3 years ago||mit||C++|
|Hands-On-High-performance-with-QT, published by Packt|
|Performancewidget||26||8 years ago||1||mit||Makefile|
|A series of classes to create Qt Widgets to plot computer performance like ram and cpu usage|
|Jqsentry||17||2 years ago||1||C++|
|Tuned Switcher||12||8 months ago||3||gpl-3.0||C++|
|Simple utility to manipulate the Tuned service|
|Qmake Unity||10||5 years ago||mit||C++|
|QMake-unity is a standalone tool to speed up the compilation of qmake based C++ projects.|
|Qtperf||7||11 years ago||gpl-3.0||C++|
|A small tool to benchmark Qt graphics performance.|
This project is a KDAB R&D effort to create a standalone GUI for performance data. As the first goal, we want to provide a UI like KCachegrind around Linux perf. Looking ahead, we intend to support various other performance data formats under this umbrella.
Here are some screenshots showing the most important features of hotspot in action:
The main feature of hotspot is visualizing a
perf.data file graphically.
The time line allows filtering the results by time, process or thread. The data views will update accordingly.
You can also launch
perf from hotspot, to profile a newly started application
or to attach to already running process(es). Do take the
caveats below into account though.
Note: Hotspot is not yet packaged on all Linux distributions. In such cases, or when you want to use the latest version, please use the AppImage which will work on any recent Linux distro just fine.
hotspot is available in AUR (https://aur.archlinux.org/packages/hotspot).
hotspot ebuilds are available from our overlay (KDAB/kdab-overlay).
hotspot is available in Fedora (https://packages.fedoraproject.org/pkgs/hotspot/hotspot/).
Head over to our list of AppImage build jobs. When you click on a job, you'll see a page with an "Artifacts" section that contains an "appimage" binary you can then download. Unzip the AppImage file and make it executable, then run it.
Please use the latest build to get the most recent version. If it doesn't work, please report a bug and test the latest stable version.
Note: Your system libraries or preferences are not altered. In case you'd like to remove Hotspot again, simply delete the downloaded file. Learn more about AppImage here.
To find out how to debug the Appimage, see HACKING.
Building hotspot from source gives you the latest and greatest, but you'll have to make sure all its dependencies are available. Most users should probably install hotspot from the distro package manager or as an AppImage.
For everyone that wants to contribute to Hotspot or use the newest version without the Appimage detailed notes are found at HACKING.
First of all, record some data with
perf. To get backtraces, you will need to enable the dwarf callgraph
perf record --call-graph dwarf <your application> ... [ perf record: Woken up 58 times to write data ] [ perf record: Captured and wrote 14.874 MB perf.data (1865 samples) ]
Now, if you have hotspot available on the same machine, all you need to do is launch it.
It will automatically open the
perf.data file in the current directory (similar to
Alternatively, you can specify the path to the data file on the console:
Depending on your needs you may want to pass additional command line options to hotspot.
This allows to one-time set configuration options that are found in the GUI under "Settings"
and also allows to convert Linux perf data files into the smaller and portable perfdata format
(see Import / Export for details on that).
All command line options are shown with
Usage: hotspot [options] [files...] Linux perf GUI for performance analysis. Options: -h, --help Displays help on commandline options. --help-all Displays help including Qt specific options. -v, --version Displays version information. --sysroot <path> Path to sysroot which is used to find libraries. --kallsyms <path> Path to kallsyms file which is used to resolve kernel symbols. --debugPaths <paths> Colon separated list of paths that contain debug information. These paths are relative to the executable and not to the current working directory. --extraLibPaths <paths> Colon separated list of extra paths to find libraries. --appPath <path> Path to folder containing the application executable and libraries. --sourcePaths <paths> Colon separated list of extra paths to the source code. --arch <path> Architecture to use for unwinding. --exportTo <path> Path to .perfparser output file to which the input data should be exported. A single input file has to be given too. Arguments: files Optional input files to open on startup, i.e. perf.data files.
Hotspot supports a very powerful way of doing wait-time analysis, or off-CPU profiling. This analysis is based on kernel tracepoints in the linux scheduler. By recording that data, we can find the time delta during which a thread was not running on the CPU, but instead was off-CPU. There can be multiple reasons for that, all of which can be found using this technique:
mmap()'ed file data
By leveraging kernel trace points in the scheduler, the overhead is pretty manageable and we only pay a price, when the process is actually getting switched out. Most notably we do not pay a price when e.g. a mutex lock operation can be handled directly in user-space.
To do off-CPU analysis with hotspot, you need to record the data with a very specific command:
perf record \ -e cycles \ # on-CPU profiling -e sched:sched_switch --switch-events \ # off-CPU profiling --sample-cpu \ # track on which core code is executed -m 8M \ # reduce chance of event loss --aio -z \ # reduce disk-I/O overhead and data size --call-graph dwarf \ # we definitely want backtraces <your application>
Alternatively, you can use the off-CPU check box in hotspot's integrated record page.
During the analysis, you can then switch between the "cycles" cost view for on-CPU data to the "off-CPU time" cost view for wait-time analysis. Often, you will want to change between both, e.g. to find places in your code which may require further parallelization (see also Amdahl's law).
The "sched:sched_switch" cost will also be shown to you. But in my opinion that is less useful, as it only indicates the number of scheduler switches. The length of the time inbetween is often way more interesting to me - and that's what is shown to you in the "off-CPU time" metric.
If you are recording on an embedded system, you will want to analyze the data on your development machine with hotspot. To do so, make sure your sysroot contains the debug information required for unwinding (see below). Then record the data on your embedded system:
embedded$ perf record --call-graph dwarf <your application> ... [ perf record: Woken up 58 times to write data ] [ perf record: Captured and wrote 14.874 MB perf.data (1865 samples) ] embedded$ cp /proc/kallsyms /tmp/kallsyms # make pseudo-file a real file
It's OK if your embedded machine is using a different platform than your host. On your host, do the following steps then to analyze the data:
host$ scp embedded:perf.data embedded:/tmp/kallsyms . host$ hotspot --sysroot /path/to/sysroot --kallsyms kallsyms \ perf.data
If you manually deployed an application from a path outside your sysroot, do this instead:
host$ hotspot --sysroot /path/to/sysroot --kallsyms kallsyms --appPath /path/to/app \ perf.data
If your application is also using libraries outside your sysroot and the appPath, do this:
host$ hotspot --sysroot /path/to/sysroot --kallsyms kallsyms --appPath /path/to/app \ --extraLibPaths /path/to/lib1:/path/to/lib2:... \ perf.data
And, worst-case, if you also use split debug files in non-standard locations, do this:
host$ hotspot --sysroot /path/to/sysroot --kallsyms kallsyms --appPath /path/to/app \ --extraLibPaths /path/to/lib1:/path/to/lib2:... \ --debugPaths /path/to/debug1:/path/to/debug2:... \ perf.data
perf.data file format is not self-contained. To analyze it, you need access
to the executables and libraries of the profiled process, together with debug symbols.
This makes it unwieldy to share such files across machines, e.g. to get the help from
a colleague to investigate a performance issue, or for bug reporting purposes.
Hotspot allows you to export the analyzed data, which is then fully self-contained.
This feature is accessible via the "File > Save As" menu action. The data is then
saved in a self-contained
*.perfparser file. To import the data into hotspot again,
just open that file directly in place of the original
Note: The file format is not yet stable. Meaning data exported by one version of hotspot can only be read back in by the same version. This problem will be resolved in the future, as time permits.
hotspot currently only shows the name of the tracepoints in the timeline.
Hotspot includes an disassembler, which can show you the cost per instruction. The disassembler uses colors to indicate which assembly lines correspond to which source code line. For easier navigation, you can simply click on a line and the other view will jump to it. You can follow function calls with a double click. In the sourcecode view you can press ctrl+f or press the search icon to open a search window.
If you have the sources in different directory, you can use
--sourcePaths or the settings to
select tell the disassembler to search there for the source code.
If anything breaks in the above and the output is less usable than
perf report, please
report an issue on GitHub.
That said, there are some known issues that people may trip over:
Unwinding the stack to produce a backtrace is a dark art and can go wrong in many ways.
Hotspot relies on
perfparser (see below), which in turn relies on
libdw from elfutils
to unwind the stack. This works quite well most of the time, but still can go wrong. Most
notably, unwinding will fail when:
perf.datafile is missing
--debugPaths <paths>: Use this when you have split debug files in non-standard locations
--extraLibPaths <paths>: Use this when you have moved libraries to some other location since recording
--appPath <paths>: This is kind of a combination of the above two fields. The path is traversed recursively, looking for debug files and libraries.
--sysroot <path>: Use this when you try to inspect a data file recorded on an embedded platform
-O2 -g. You will have to repeat the
perf record only copies a part of the stack to the data file. This can lead to issues with
very deep call stacks, which will be cut off at some point. This issue will break the top-down call trees
in hotspot, as visualized in the Top-Down view or the Flame Graph. To fix this, you can try to increase
the stack dump size, i.e.:
perf record --call-graph dwarf,32768
Note that this can dramatically increase the size of the
perf.data files - use it with care. Also have a
man perf record.
For some scenarios, recursive function calls simply fail to be unwound. See also https://github.com/KDAB/hotspot/issues/93
hotspot supports downloading debug symbols via debuginfod.
This can be enabled by either adding download urls in the settings or launching hotspot with
defined in the environment.
perf report, hotspot misses a lot of features. Some of these are planned to be resolved
in the future. Others may potentially never get implemented. But be aware that the following features
are not available in hotspot currently:
--branch-history, are unsupported
But without superuser rights, you may see error messages such as the following when using hotspot's record feature:
You may not have permission to collect stats. Consider tweaking /proc/sys/kernel/perf_event_paranoid: -1 - Not paranoid at all 0 - Disallow raw tracepoint access for unpriv 1 - Disallow cpu events for unpriv 2 - Disallow kernel profiling for unpriv
To workaround this limitation, hotspot can run perf itself with elevated privileges.
The current data export is limited to a format that can only be read back by hotspot of the same version. This makes interop with other visualization tools quasi impossible. This is known and will get improved in the future. Most notably support for export to web viewers such as perfetto or the Mozilla profiler is planned but not yet implemented. Patches welcome!
This project leverages the excellent
perfparser utility created by The Qt Company
for their Qt Creator IDE. If you are already using Qt Creator, consider leveraging
its integrated CPU Usage Analyzer.