heaptrack VS optick

If we are talking replacing the libc allocator, then something like heaptrack is worth mentioning.

https://github.com/KDE/heaptrack

For accurate memory usage I prefer a memory profiler that overrides malloc and friends instead of the ones that probe the OS at regular intervals. You won't find memory spikes with the latter. Try heaptrack on Linux. I haven't found a good one for Windows yet.

I know it is not a profiler, but it is so criminally underrated that I decided to share it: https://github.com/KDE/heaptrack

If none of the above helps - I recommend heaptrack as a tool for tracking down your memory usage.

> memory leaks. It's surprisingly hard to find an easy to use memory leak detection tool.

I can vouch for heaptrack[1] nowadays, although it's pretty much Linux only. It's under the umbrella of KDE, but a heaptrack trace only requires a CLI app, and there is a nice Qt viewer to analyse the memory consumption.

It tracks the memory utilization at the level of malloc'd/free'd bytes. It's fine if your memory leak or other memory utilization problem is on this level. Recently I dealt with an issue, where increasing memory utilization was caused by fragmentation within the allocator. This didn't show up in heaptrack as an increasing memory utilization, but heaptrack still pointed out where most of the temporary allocations happened, leading to the culprit of the fragmentation.

[1] https://github.com/KDE/heaptrack

This is probably what you are looking for https://github.com/KDE/heaptrack

When I had this kind problems (heap related) I always use heaptrack. Take a look here for the details: https://github.com/KDE/heaptrack

Does anyone here have experience with Optick: https://github.com/bombomby/optick ? It looks great but I haven't got the chance to try it. Was wondering how it compares to the other tools listed here.

As a free alternative, I've had multiple people recommend Optick, but I haven't had the chance to play around with it yet, so I can't vouch for it myself.

I have used Tracy to improve the performance of a latency sensitive application. The main advantage of this tool, in comparison to something like the Visual Studio profiler, is the fact that it can highlight the inter thread dependencies and synchronization between the threads. The other main feature, in my opinion, is the statistical tab that is associated to the recorded events: it can show the statistical distribution of the duration of all the invocations of functions and it allows to identify patterns in the performance of the application. Furthermore, a table can be used to sort the invocations of the functions and quickly jump to the point in time when the sample was recorded.

Other notable tools that implement a functionality similar to what is provided by Tracy are Optick https://github.com/bombomby/optick and Intel VTune (sadly specific to only Intel processors) in the Threading analysis.

we don't do systematic perf measurements beyond prod metrics but if we did the good tools are uiCA/IACA/etc, tracy/brofiler, perf/vtune

I highly recommend checking out Optick. I use it almost daily at work :)