Add implicit values to program options.

Merge code to print merged backtraces :)

C++' pointer-to-member is a really powerful feature - wow!

Prettify output of top-allocator places.

TODO: do something similar in the other places as well.

Merge allocation data by instruction pointer.

This is safe to do except for the peak memory consumption where
we cannot ignore the temporal dependency.

Otherwise this greatly improves the output as multiple calls to the
same function from different places get merged and thus show up
as one fat data point, instead of multiple thinner ones.

Skip operator new(unsigned long) (and new[]) from start of backtraces.

Make indices typesafe.

Fix name of variables.

Add a bit of recursion to the callgraph test debugee

Fix regression and properly stop backtraces at main function again.

Cleanup code and reduce duplication.

Split trace and instruction pointer data.

The debug info for a ip is only required once, whereas a trace
contains the mapping between an IP and the parent IP, which can
be outputted many times in different combinations.

This way we don't call the libbacktrace functions as often and
decrease the file size, at the cost of memory consumption during
the debugee run (in heaptrack_interpret). The memory consumption
significantly decreases in heaptrack_print though.

Reduce amount of cout flushing.

std::endl also flushes the output which is pretty bad for performance.
Instead, only use endl when it makes sense, i.e. between output blocks.

Cleanup code: encapsulate data reading and make more stuff private.

Add test for call graphs, this should be merged better.

Improve headings of different output sections.

Take dlclose into account and update module cache accordingly.

Make it possible to validate the correctness of allocation overloads.

This is still flaky, apparently some function related to TLS allocation is missing.

Improve output of -h

Do not clash --print-histogram with --help.

Do not link directly to libheaptrack.

The interpreter is important for useful data imo.

Shorten template identifiers by default.

Use boost::program_options and make output configurable.

Simplify code, we use the std namespace.

Simplify code a bit.

Output pointer adresses without 0x prefix.

This just needlessly increases the file size.
We now cast to uintptr_t and output as %lx.

Do not output function, file and line index for unknown locations.

The null value is the default anyways and we do not need to
output that information and can thereby decrease the filesize a bit
for debugees with many occasions of missing debug information.

Also show individual peak allocations.

Also show top-ten allocation places (ignoring deallocations).

Use %p to print out ptr addresses.

Add some debug output to show whats currently going on.

Optimize: don't sync cin/cout/cerr with stdio for our single-threaded c++ apps.

Cleanup code a bit.

Add comment on why we use stdio here.

Fixup check for executable debuggee.

Call which first to also find the exe in PATH.

Add heaptrack --help.

Cleanup output messages to make it simpler to understand heaptrack.

Install heaptrack shell script and use the proper paths therein.

We get the relative paths from the install directory to our lib
and libexec target folders and write that into the shell script.

Some more cleanup and restructuring.

Rename to heaptrack and start cleaning up the code structure.

Remove mallocinfo code, it's in the old repo.

Directly evaluate the backtrace data.

This makes the final data interpretable even when the binary or
any library changes in between. It also makes it possible to ship
the data file to an external computer for further evaluation.

Hide anything above __libc_start_main as its garbage.

Use named pipe to compress output data on the fly.

This is plain awesome imo :) Really easy to get implemented and
the evaluation code is also more or less untouched thanks to Boost's
iostreams library with nice support for gzip data.

Fixup example code, use proper delete[].

Do not output new IP id.

The data is outputted in a sequentail way and thus this information is obsolete.

Directly link malloctrace into test executables.

Output all numbers in hex form.

This reduces the output data file size slightly and simplifies the
evaluation code as we do not have to switch between different
formats all the time.

Do not output 0x prefix for addresses.

This reduces the size of the output data files.

Decrease runtime memory overhead by getting rid of AllocationInfo.

We now output every allocation's ptr and only output it for a free.
This not only reduces the runtime CPU overhead, but also drastically
reduces the memory overhead as the relatively large AllocationInfo
map is not required anymore.

The size of the output data files increases, but the cost seems to
be bearable and worth the reduces memory overhead imo.

realloc with nullptr is the same as pure malloc.

In such a case, don't handle the realloc like a free followed by a
malloc. It's just the malloc then.

Store backtrace information in a memory efficient tree structure.

Instead of storing all individual traces that ever call any of the
allocation functions, we now store a tree of instruction pointers.

The tree is constructed from top-to-bottom and each node representing
an instruction pointer gets associated with a unique index. This
index is enough to reconstruct the backtrace from that point by
iterating over the parent indices, which is now done in the evaluation
program.

A nice side effect is that the data file becomes smaller for bigger
application evaluation runs, as common parts at the beginning of
every allocation trace can be implicitly shared.

Cleanup code and make it explicitly work with the unw_backtrace api.

Use unw_backtrace instead of manual unw_step loop.

The former is potentially much more performant but may require some
work on libunwind, which I'm currently investigating.

Add warning about unknown executable format

Enable per-thread unwind caching.

This is much more performant as libunwind will not also add another
serialization point, it will also trigger calls to sigprocmask for
every mutex lock/unlock.

Refactor DUMP_MALLOC_TRACE_OUTPUT handling.

Now we can set it to stderr or stdout/- to print directly to the
console. Other files get $$ replaced by the PID of the host app.
This allows us to set DUMP_MALLOC_TRACE_OUTPUT to /dev/null to
disable output.

Do not add garbadge null-ip's from end-of-line.

Prepend output file with 'malloctrace.' even when env var is not set.

Also add some code comments on future things to do.

Simplify code and reduce overhead at trace time.

We now evaluate the IP to module connection at evaluation time,
rather than during tracing to reduce the overhead. This also gets
rid of the rather large IP cache, thereby reducing the memory
overhead.

Save ptr start and end address instead of start + size.

Also output that size.

Return early for now, without bzipping output files.

Add a threaded test application

Extract some more information on the allocation data, such as a size histogram.

Use stack-allocated trace buffer.

This seems to be required in multithreaded applications as otherwise
I get random crashes or deadlocks...

Break when encountering zero-IP.

This is senseless imo. Also, continuing would be very slow as
libunwind would try to ask dwarf info for the next IP for that
address which is bad, performance wise. And again, it will never
find anything and we just pay for nothing.

Take trace size into account for hash generation.

Skip instructions which we cannot make sense of.

Fixup environment passing via gdb to the library.

Abort on failure.

Preallocate trace buffer once.

Cleanup environment

Disable error messages when dwarf info is missing.

Get file and line from dwarf info if possible.

Update trace script.

Use vectors everywhere and be pedantic about input data.

Print total leaked bytes and number of allocations.

Don't do manual reserve calls, its slower than the default way.

Introduce a memleak in the test app.

Print top allocators and all leaks in a sorted way.

Refactor code: work with just a single file and use vector for traces.

The latter will allow us to sort the traces later on for evaluation
purposes easily.

Demangle function names.

Refactor malloc tracing, synchronize most of the stuff after all.

I completely forgot before that a free can follow a malloc in a
different thread which is perfectly fine. To support this, we must
centralize our data handler after all.

This is not too bad as we can merge the multi-thread data into one
file that way and have it interleaved properly which will be good
for later evaluation.

From a contention point of view, I tried to minimize it as much as
possible. Further evaluation and profiling will be done later.

Bring back trace and ip cache to reduce generated filesize.

Also speeds up things as repeated large prints are actually quite
slow. Furthermore we extend the tool to actually interpret the data.

Check for valid malloc/free before handling it.

Reserve place for 32 modules.

Reimplement backtrace reading and offload dwarf info interpretation.

This makes the profiling run much faster. The later evaluation is
not so performance critical then thereafter.

Fix regression I introduced

Use relative module offsets instead of baseAddress + address.

Add kdev project file.

Add start of a malloc trace evaluation executable.

This shows that we can do post-mortem address resolution.
Not yet really functional but enough for a quick test.

Remove uuid code, not required for my usecase afaik.

Cleanup code, insert data directly in a sorted order.

Port bsearch to C++ STL's std::lower_bound.

Adapt code to my coding style.

Cleanup code a bit by removing unused functions.

Get proper dwarf-based backtraces with filename and line numbers.

This code is based on the libbacktrace from GCC, see:
https://github.com/mirrors/gcc/tree/master/libbacktrace

Furthermore, we include btrace.{cpp,h} and CMakeLists.txt, based
on Vogl from Valve Software/RAD Game Tools, see:
https://github.com/ValveSoftware/vogl.git

Add todo on sub-tree matching

Don't create single-entry trees output.

Save memory, use unsigned int instead of size_t for ids.

The number of call stacks should hopefully fit into that range.

Only print a given call-tree once