Add first test to verify libunwind integration behaves sane.

Turns out that you must not build libunwind with the gold linker,
it completely breaks the stack unwinding functionality for me.

TODO: use a proper testing framework here.

Don't show an error when heaptrack_gui is not in PATH.

Make GUI/Chart optional.

Fix 'obvious' error on 32bit for injection, still doesn't work properly.

Also fix building of the gui on 32bit

Always assume 64bit input data in the printer.

Otherwise, we cannot print 64bit records on 32bit machines.

Fix compile warnings on 32bit

Use ki18n_wrap_ui

Set application domain for translations

Show a window when no files are given.

Properly link against zlib where required.

Remove wrong assert.

Get rid of c-formatting message with %1s

Add Messages.sh for gettext extraction.

Properly use max-or-last leaked data value.

Include 0 as first chart datapoint.

advertise heaptrack_gui

Also show total bytes allocated over time.

Also show total number of allocations over time.

Show total leaked data in graph.

Prepare for addition of more visualizations.

Refactors loading of files into its own class and cleans up the
implementation of the (bottom-up) model.

Add about data, enable loading of multiple files.

Group disabling of stdio locking code.

Use binary search in TraceTree.

Rename function - it's not a dlopen callback, but a dl_iterate_phdr one.

Two more coments

Merge branch 'gui'

Run more stuff in parallel.

Add tooltip to header

Merge location columns.

Make filter case insensitive

Show debuggee command line in heaptrack_gui

Make heaptrack more compatible with other debug tools.

Ignore any '--' parameter.

Skip one more level in backtraces in debug builds.

Otherwise, the malloc function would still be shown in the backtrace
and thereby breaking the aggregation we use elsewhere.

Translate summary.

Show full merged backtraces in heaptrack_gui.

use KFormat for byte formatting in Qt model implementation.

Copy the massif-visualizer GUI pattern with open/load/result pages.

Also load the data in a background thread with ThreadWeaver.

Fix style and fix early-return check for Model::data()

Make it possible to filter by function, module and file info.

Allow filtering by file/module as well.

Cleanup CMake code a bit

Link against KF5, use KRecursiveFilterProxyModel, fix some issues.

Deduplicate shown functions by skipping first, merged, level.

Return empty QString when no file was available.

Fixes assertion in ModelTest.

Show backtrace in tooltip.

Add modeltest sources

Show sub-traces of merged allocation data in the model.

Move some helper functions into the shared file, will use that later for tooltips

Add filter by function

Show function, file and module information

Sort view

Show merged allocation data in model.

Move data into model.

Merge branch 'master' into gui

Set version to 0.1.0 and include it in the tools.

Do not crash after injection in ld-linux.

Apparently it is a very bad idea to overwrite e.g. free in ld-linux,
and it triggered crashes when trying to inject heaptrack into a KF5
application such as kwrite.

Cleanup code slightly for readability

Merge branch 'master' into gui

Fix compilation error on some platforms.

See also: https://bugs.gentoo.org/show_bug.cgi?id=548850

Start a simple Qt GUI and share some code with the ASCII printer.

Fix compilation error on some platforms.

See also: https://bugs.gentoo.org/show_bug.cgi?id=548850

Stay backwards compatible to old Boost 1.41 for RHEL 6 compatibility.

Set CMAKE_INSTALL_RPATH_USE_LINK_PATH to true.

This makes it simpler to run heaptrack against e.g. a
libunwind available in the CMAKE_INSTALL_PREFIX. Otherwise,
one would have to set the LD_LIBRARY_PATH manually.

Don't fail to compile when aligned alloc is not available.

Make symlinked heaptrack shell script work properly.

Link against pthread in the heaptrack libraries.

This is required to run properly against debuggees that do not
use threads at all.

Reported-by: Yehezkel Horowitz <horowity@checkpoint.com>
Reported-by: Anatolii Koval <AKoval@luxoft.com>

Use dlmopen when trying to inject heaptrack_inject.

Some systems use an optimized dlopen symbol (especially embeded linux
modifications), but these don't touch dlmopen, which is more general.

This prevents an "dlopen - symbol not found" error when trying to
inject heaptrack on such systems to a running process.

Improve output and document -p and --pid arguments.

Fix build on machines where size_t != lu.

Reported-by: Yehezkel Horowitz <horowity@checkpoint.com>

Don't override LD_PRELOAD, just prepend to it.

This enables usage on targets that use LD_PRELOAD themselves already.

Add backtrace filter via --filter-bt-function.

Only allocations with a function matching the filter will be printed.

Make warnings errors as we rely on the libbacktrace features.

Allow for whitespace in program name and arguments.

Use correct allocation data for massif peak data.

This way, the sum of the detailed backtraces equals the total snapshot
count. While the x axis is wrong then, this is not so important I
think. Rather, we want to find the memory hotspots which is much
easier this way.

Disable malloc_info baseline when attaching to running process.

In such cases, we are more interested in the relative increase. We
do not want to apply the relative threshold based on the absolute
baseline for example, but rather to the data we obtained.

Make start time const.

Don't fail when trying to join the timer thread.

Silence GDB stdout messages by using --batch-silent.

Also print exit message when killing heaptrack via CTRL+C.

Do not load gdbinit file or symbols when attaching to process.

Instead, only load the two libs we actually need, libdl for dlopen
and libheaptrack_inject for the init function.

Cleanup code for operator new skipping in backtraces.

Also stop backtraces after __static_initialization_and_destruction_0.

Additionally, we can now cope with backtraces that either show
main or __libc_start_main, and stop at the first occurrance
of either symbol.

Fix major regression: Get backtrace in malloc properly.

Zomg, I must have been asleep when I comitted this - sorry.

Remove explicit std:: qualification, we use that namespace.

Instead of yielding the thread, sleep for one micro second.

This significantly improves the performance of the threaded
test example. The reason are the far reduced numbers of context
switches (goes down by about 90%):

Perf stat results averaged over ten runs are:

before:
       1537.459666      task-clock (msec)         #    2.741 CPUs utilized            ( +-  1.98% )
           164,214      context-switches          #    0.107 M/sec                    ( +-  4.77% )
             1,238      cpu-migrations            #    0.805 K/sec                    ( +-  1.42% )
             3,996      page-faults               #    0.003 M/sec                    ( +-  0.26% )
     3,531,767,774      cycles                    #    2.297 GHz                      ( +-  1.96% ) [56.85%]
   <not supported>      stalled-cycles-frontend
   <not supported>      stalled-cycles-backend
     4,404,564,712      instructions              #    1.25  insns per cycle          ( +-  1.81% ) [82.34%]
       895,286,284      branches                  #  582.315 M/sec                    ( +-  1.83% ) [82.05%]
        14,800,878      branch-misses             #    1.65% of all branches          ( +-  2.07% ) [83.04%]

       0.560967210 seconds time elapsed                                          ( +-  1.78% )

after:

        940.204408      task-clock (msec)         #    1.970 CPUs utilized            ( +-  0.97% )
            16,628      context-switches          #    0.018 M/sec                    ( +-  2.09% )
             1,709      cpu-migrations            #    0.002 M/sec                    ( +-  2.02% )
             3,733      page-faults               #    0.004 M/sec                    ( +-  0.62% )
     2,299,207,706      cycles                    #    2.445 GHz                      ( +-  0.95% ) [54.67%]
   <not supported>      stalled-cycles-frontend
   <not supported>      stalled-cycles-backend
     3,203,389,330      instructions              #    1.39  insns per cycle          ( +-  1.48% ) [84.25%]
       717,416,828      branches                  #  763.043 M/sec                    ( +-  1.01% ) [77.86%]
        11,127,629      branch-misses             #    1.55% of all branches          ( +-  0.98% ) [76.95%]

       0.477194059 seconds time elapsed                                          ( +-  0.34% )

Note that we utilize less CPUs (which is good, as it safes power), but
still decrease the total run time, as do number of cycles spent
and instructions executed.

Use acquire semantics after all... ;-)

According to this page, the relaxed semantics are a useless
optimization and might in fact degrade performance on some systems:

http://www.boost.org/doc/libs/master/doc/html/atomic/usage_examples.html#boost_atomic.usage_examples.example_spinlock

Cleanup spinlock implementation.

- use atomic::exchange
- use relaxed memory order in loop

Cope with broken backtraces.

Still output a 0 trace index and print ?? later.

Refactor code once more for yet better thread safety at shutdown.

Instead of using flockfile, we use a simple spin lock now. This
is even a bit faster than using flockfile, and does not have any
issues at shutdown, when the file was deleted already.

Also, the spin lock can easily be combined with the check for
when the timer thread should be stopped.

Furthermore, the code is restructured to ensure the thread-unsafe
API is only ever getting called while the lock is held.

To simplify future development, some debug log can now be enabled
which will trace the heaptrack execution.

Set cmake requirement to 2.8.9 and use LINK_PRIVATE.

Hopefully this restores building it with an older CMake version.

Only one trap can be added.

This prevents leakage of the /tmp/heaptrack_fifo$$ files.

Adapt to libunwind changes with unw_set_cache_size.

Silence build warnings, as was done before in vogl/apitrace.

Add noexcept

Compile in pedantic mode.

Remove dead code

Write accurate end time on shutdown.

Also print out bytes allocated per second and allocations per
second in heaptrack_print overview.

Minimize changes against libbacktrace.

Instead, we export more elf internals and call that directly from
heaptrack_interpret. This should make it simpler to keep the
libbacktrace checkout in sync with upstream changes.

Remove dead code and enable more warnings when building.