Use thread instead of signal and increase timestamp frequency.

Sadly, this creates a new thread for every timer apparently,
but still, it's better than using signals which randomly influence
other functions and sometimes fubar our output files. Or so I think.

Remember the debugee command line.

This is sometimes useful and also tracked by massif and other tools.

Simplify code and write exe path directly to stream.

No need for a temporary string allocation here.

Simplify code, it's not worth the imagined performance gain.

Unset automatic locking of stdout and stdin.

This is not required in the heaptrack_interpret process.

Prefer C I/O API for speed.

It's sad that this gives such a noticeable speedup :(

Use fputs if we don't need to format anything.

Cleanup module handling code and change the file format a bit.

We now output a single line per module and delegate the whole
interpretation of the dl_phdr_info data to heaptrack_interpret.

This allows us to reduce the size of Module a bit, leading to hope-
fully faster binary searches amongst other benefits.

Remove code that depends on local libunwind patches.

Fixup handling of posix_memaling.

The return value of zero indicates success here. This should fix
some inconsistencies on applications that use this function.

Don't print 0B leaked lines.

Properly take cfree into account.

Ensure we only ever initialize once.

Use the same error handler for both init error callbacks.

This happens rarely, and the error message is still helpful.

Fixup callback handlers, the wrong data was passed in.

Cleanup: get rid of obsolete isExe member in module.

It is only required for the call to backtrace_fileline_initialize.

Add seconds elapsed to heaptrack log for future evaluation.

Support building against libunwind from different include directory

Delete obsolete files.

These are used in VOGL, but not in heaptrack, so get rid of them.

Support atomic functions if possible.

Prevent crashes in apps using QProcess.

Prevent issues and file corruption when tracking a forking process.

Thankfully there is pthread_atfork which can be used to get notified
about fork calls. We stop heaptrack before forking and only continue
it in the parent process. In the child process we stop heaptrack
alltogether.

TODO: make it possible to track child processes.

Also use LineReader in heaptrack_interpret.

Be more forgiving when encountering bad data.

Still no clue where the bad data comes from though...

Optimize findAllocation calls by leveraging monotonicity of indices.

By comparing the incoming trace index to the largest index we so
far encountered, we can already decide whether:

a) if the index is equal to the largest one, the same location is used
repeatedly, i.e. in a loop, and we can directly return the last item.
b) if the index is larger than the last known one, we'll definitely
not find it and can thus insert directly and return
c) only if the index is lower than the last index do we actually need
to do a binary search.

This yields a small but noticeable speedup from ~14.5s to 13.4s for
one of my files.

Slightly cleanup and optimize LineReader::readHex

minor cleanup

Don't fill sizeHistogram if we are not going to print it.

Introduce optimized reader class for faster reading of hex numbers.

In my benchmark on a big data file this reduces the runtime of
heaptrack_print from 24s to 16s. The whole function is pretty simple
so I'm willing to sacrifice simplicity for this big performance win.

Improve error checking when reading data file.

Format byte sizes to KB/MB/GB/TB.

Fallback to __libc_start_main when main is not found.

Change the output format slightly for better readability.

Merge allocations from equivalent locations.

Equivalent means the data is the same except for the instruction pointer
address itself. Useful when we are missing some debug information.

Cleanup code and also initialize fileline only once.

This fixes a regression when looking at kdepim with heaptrack.

Reduce looping

Only call backtrace_create_state once per file.

Also improve the checks for overlapping libraries which was wrong.

Combined this drastically cuts the memory consumption and improve
the runtime of the heaptrack_interpret process again.

Fix more issues related to improper backtrace symbol lookups.

We now clear the list of known modules also in heaptrack_interpret
and really forget about all modules. This ensures we don't keep
invalid modules around and improperly associate instruction pointer
addresses to these modules.

This fixes the heaptrack usage for me on larger applications such
as KMail or plasma-desktop (KDE4).

Take each PT_LOAD dlpi_phdr as its own module.

This fixes some issues with incorrect backtrace symbols when shared
libraries are used, as the new example shows. Before e.g. libc.so
overlapped with many other libraries and incorrectly chosen to
find the backtrace symbol. With this patch, this issue is gone.

Add whitespace before lib name.

Fix warning about missing debug infos in linux-vdso.so.N

Check for main index while reading the data in.

Skip operator new etc. when encountering the trace.

This makes it much simpler and all backtraces are filtered automatically.

Write histogram to file specified by cli argument

Improve the output to better understand what the numbers mean.

Fix compilation on OpenSUSE

Fix compilation when passing flags on the command line as well

Skip all operator new locations, even when the IP differs.

This was occurring in a real-world data file for me, where
operator new(unsigned long) was encountered twice at different IPs.

Don't get confused by operator<, <<, > and >>.

Share code.

Make it possible to switch between merged and non-merged backtraces.

Add some comments, esp. about implementing better trace merging.

remove obsolete debug output

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.