Check validity of allocation index when parsing data file.

Never divide by zero.

Intern caller/callee data by location data.

Add caller/callee table view of data.

Reuse common AllocationData class, with operator+=, operator+.

Simplifies the code in some areas.

Make it possible to select different cost sources for the flame graph.

Also put the bottom-down action into the new control toolbar.

Don't print unknown file/line location in tooltip.

Colorize model cost cells background based on relative cost to total.

Maniphest Task: https://phabricator.kde.org/T1709

Properly skip 32bit versions of operator new.

Fix compile warnings on 32bit machines

Update libbacktrace from GCC trunk@234085.

Don't show functions that triggered no temporary allocations in top list.

Add executable to measure malloc overhead.

Filter rows that did not leak anything in TopProxy.

Include total system memory and peak RSS usage in output.

We now track the RSS by parsing /proc/self/statm on every timestamp.
The total system memory is taken from sysconf.

The RSS may potentially miss its true peaks, which can be handled in
the future via getrusage(). Still, this is a nice and useful addition
I think.

Show minimal statistics directly after heaptrack finished.

Pass correct data to dl_iterate_phdr.

I wonder why this didn't crash before...

Don't access invalid memory for tiny or broken input files.

Put summary text into three columns to save vertical space.

Display the time when the memory peak was encountered.

Remove resize-to-contents call.

Add summary tab and display all top functions there.

Show error when we failed to parse an input file.

Use monospace font family in tooltips.

Bug got fixed upstream in Qt but for older Qt this improves
readability significantly.

Don't show 'backtrace: ' without a backtrace in the tooltip.

Add stacks model to display full backtrace for selection.

Display shorter basename for files in tables by default.

Don't descend into children of invisible flamegraph items.

Optimize TreeModel: cache KFormat to prevent repeated allocations.

Let KDE*CompilerSettings change the policies in the project

As suggested in ECM documentation.

Decrease indentation which allows us to show deeper backtraces with less space to the left.

There is still work left to be done to have a nice GUI for
deep backtraces, potentially by not increasing the indentation
depth when the merged backtrace has no forks.

Make chart tooltips better readable.

Use std::tie instead of std::make_tuple for lexicographical ordering.

std::tie takes the arguments by reference, whereas make_tuple copies
them. We want the former.

See also: http://www.cppsamples.com/common-tasks/lexicographic-ordering.html

Show data as soon as it is available.

This way one can investigate the data table while waiting for the
charts to be built up, which can take some time for large data
files.

Sort cost columns initially in descending order.

Add some indication on the file load process.

Display pretty-printed byte sizes in tree model.

Set proper axis type for temporary allocation plot.

Don't duplicate allocation infos when reparsing.

Reuse PointerMap for backwards compatibility.

This also makes the size histogram work with older data files.

Add size histogram to heaptrack_gui.

This tracks the number of times allocations of a certain size are
requested and displays the data in a histogram. Note that the sizes
are binned in the following byte ranges:

0-8
9-16
17-32
33-64
65-128
129-256
257-512
513-1024
>1024

Reject data files of newer heaptrack versions.

Optimize tracking of active allocations.

Instead of mapping the pointer to a pair of allocated size and
trace index, we intern the pair and map the pointer to a 32bit index.
This assumes that not more than 4.294.967.295 different pairs occur,
which could theoretically be broken by allocating different sizes
in a loop. Practically, I've never seen this happen. If it really
breaks we can always bump it to a 64bit index later.

Furthermore, this patch introduces a new PointerMap, which drastically
reduces the memory overhead of tracking the allocations. The benchmark
which also gets added here, shows that its overhead is only ~20%
compared to the 100% overhead of a simple hash map. Also note that
even google's sparse_hash_map only gets down to 50% overhead.
Even better, the PointerMap implementation is faster than google's
sparse_hash_map. This is possible by leveraging some information about
memory allocations, which return pointers to pages. Thus the pointers
are clustered and we can shrink a 64bit pointer to an common shared
base pointer and a small 16bit offset.

On my machine, the runtime performance is close to that of the simple
hash map. As such, I decided to move this allocation tracking into
heaptrack_interpret itself. This drastically reduces the file size
of heaptrack data files, sometimes cutting the size into half. Even
better, this speeds some heaptrack benchmarks, as less data is written
to disk. And of course all of this leads to an much improved
performance of heaptrack_gui and heaptrack_print.

Also make the number of sub traces of peaks configurable.

Make number of reported peaks configurable

Make it possible to control number of reported peaks in heaptrack_print

REVIEW: 126282

From 98a061bee3879fcb5c01728d63c39b6773705108 Mon Sep 17 00:00:00 2001
From: David Landell <david.landell.dl@gmail.com>
Date: Wed, 2 Dec 2015 19:04:59 +0100
Subject: [PATCH] Make number of reported peaks configurable

Add .reviewboardrc file for rbt integration.

Add version to heaptrack data files.

Don't check module map sanity in non-debug builds of heaptrack.

Show temporary allocations in heaptrack_gui.

Find temporary allocations in heaptrack_print.

Fix regression: the pointer index is still 64bit.

Fix compiler warning

Optimize: Reduce memory cost for tracking active allocations.

We split the hash into two, one for small allocations up to
numeric_limits<uint32_t>::max, and one for the bigger rest. This
allows us to reduce the cost by up to a factor of 2 for some apps.
A notable example here is heaptrack_gui itself, as it does tons of
small allocations for its lookup tables, which are long-lived.

In one test case this reduces the memory consumption of heaptrack by
up to 1GB for me.

Use uint32_t for indices.

This allows us to save some memory and opens up more possibilities
for future optimizations. And 4,294,967,295 should still be more
than enough space for our lists of traces, strings etc. pp.

Optimize: Reduce memory consumption of RowData for TreeModel by ~20%.

By interning the common LocationData we can save quite some memory
for large data sets. Still, the large tree is still easily hogging
up gigabytes of memory...

Generate flame graph in background thread.

Also add a temporary text that indicates we are generating the graph.

Make it possible to switch between bottom-up/top-down flame graph.

The context menu has a new action now to switch the view mode of
the flame graph.

Build flame graph on demand.

Reduces memory consumption when the flame graph is not being displayed.

Remove duplicate component

Default CMAKE_BUILD_TYPE to RelWithDebInfo.

We need compiler optimizations for the heaptrack code, as it
is otherwise really slow to run.

Always pass false for exe in elf_add call.

Basically, if you pass the isExe flag to elf_add, libbacktrace will
see that it's an ET_DYN executable which means that the sections
can be relocated on load so it will defer to dl_iterate_phdr to get
the real addresses. It will do that only when you call
backtrace_pcinfo which, behind the scenes, ends up calling
backtrace_initialize and that will do the dl_iterate_phdr for the
executable which is wrong since the executable we want to get the
symbols on is not the current one (which is heaptrack_interpret) and
we already get the base addresses correctly from the main process
through the pipe. So there's no need to ever pass isExe = true.

Reserve space for chart data.

Optimize: evaluate top-down data in parallel to chart data.

For a larger data file, this reduces the parse time from ~21s
to 15s on my machine.

Optimize: only do one hash lookup instead of three per IpIndex.

This is still one of the hotspots when parsing large data files,
but at least it makes it a bit faster.

Optimize: Replace QHash with std::array.

We now know that chart cost data is monotonously indexed and can
thus use a plain array over a QHash. This is much quicker to index
into in Parser::handleTimeStamp, and removes a hotspot found with
perf when analyzing a big data file.

Minor: move newline for readbility

Increase max chart datapoints to 500.

Only allocate 100 brushes for the flamegraph.

More colors are probably not discernible anyways. This way,
we can save a couple of megabytes of memory for large input
files.

Use two-pass over input data to speed up chart building.

This way, we can look at the top N hotspots after the first parse,
and then quickly iterate over the file again, discarding most lines.
Only the lines for (de-)allocations must be looked at, everything
else can be reused from the first parse.

Now, we won't spend minutes/hours to create chart data, as we can
look at the explicit hotspots which we found once before. No more
costly merging or sorting of the allocation data on every timestamp.

Only create one chart data per second.

This way we can run heaptrack on large data files.

In the future, this will be restructured to make it configurable.

Make sure the ChartMergeData is nothrow-move-assignable.

Cache ip addresses.

Fix wrong assertion

Disable modeltest.

I'll write a proper test soon and add the ModelTest there.

Restructure test code layout, import catch and use that.

Simplify CMakeLists.txt - we always use malloc now.

Use malloc within libbacktrace for the usecase of heaptrack.

This library is only being used from within the external interpret
process and never from a signal handler. Only there the mmap-approach
makes sense. Using malloc instead is significantly faster and makes
using heaptrack with clang++ and debug symbols usuable.

Cleanup and rename leaked in gui to consumed.

Fix chart model by splitting it up by type.

Since the number of columns can be different per type
we need separate models. This finally makes the stacked
charts work properly.

cleanup

Deduplicate code

Format tooltip cost and time.

Keep the chart data associated with a constant column.

This is neccessary to have the association with a color and
later a legend label make sense.

What's left to be done now is adding some sorting on top to
have the most costly column at the bottom of the model.

Merge entries for chart data and sort in descending order.

Fix tooltips and show stacked graph.

Use correct axis and labels in time charts.

Add basic tooltip functionality for stacked time charts

start with stacked time charts

Use the TopDownData as input to generate the FlameGraph.

Add Top-Down tree model.

Also sum up peaks.

The models have no temporal notation thus if two peaks happen
at a different time, you cannot say that this is the real
peak memory consumption of a merged allocation.

But taking the absolute peak of peaks is very confusing as
then the leaked number can be less than the peak.

Build tooltip ondemand which speeds initial parsing up tremendously.

We save thousands of allocations this way. And the tooltip becomes more
expressive as well. This does remove the number of allocations from the graph
iteself though, but often it's not visible there anyways and the width already
represents the same data.

Don't forget selection when resizing the flamegraph widget.

Cleanup the code and add some comments

Merge branch 'flamegraph'

Cleanup code

Implement zooming as done in original FlameGraph SVG.

Maximize parent frames, hide all siblings of these parents and relayout
the children to the available parent width.

This is much better from a usability POV imo and has proven itself in
in the SVG implementation. The previous take of mine was simply too
confusing.

Use mem color scheme from upstream FlameGraph.

Add hover effect.

Paint selected item differently.