cargo-trace VS parca-agent

Are the authors here? Thanks for this! I'm always thrilled to see advances in profiling tools.

I'm curious what they have to say about complexity/necessity of interpreting all of DWARF. cargo-trace (an neat and conceptually similar but abandoned project, I think) [1] says:

> It can be empirically determined that almost all dwarf programs consist of a single instruction and use only three different instructions. rip+offset, rsp+offset or *cfa+offset, where cfa is the rsp value of the previous frame. The result of the unwinding is an array of instruction pointers.

Do you find this to be true? Is more complex interpreting of DWARF necessary?

And in the lkml thread linked from the article, Linus is extremely pessimistic about DWARF unwinding, [2] I'm sure not without justification. He's talking about kernel stacks, and I think the trade-off is different when you're trying to profile existing userspace applications and libraries compiled and implemented however, but nonetheless I'm curious to hear the authors say how applicable they think his points are.

[1] https://github.com/dvc94ch/cargo-trace

[2] https://lkml.org/lkml/2012/2/10/356

If that's true, you should probably update the docs. Everything I could find implied dotnet, jvm, python were still unsupported. For example, the roadmap section of the readme mentions most of these but nothing mentions dotnet. However I did find your tickets and a demo being merged in which makes it seem maybe supported?

Ticket: https://github.com/parca-dev/parca-agent/issues/161

Demo: https://github.com/parca-dev/parca-demo/pull/18

Couldn't see any advantages to this over https://github.com/parca-dev/parca-agent. Which uses eBPF so it can be used with non-instrumented apps and code paths.

The pervasive lack of frame pointers is the reason why we've developed a custom format derived from DWARF unwind information thanks to some insights: DWARF unwind information is incredible flexible, it supports many arches and allows restoring any arbitrary register. But we only need 3: the frame pointer, the stack pointer, and in non-x86 the return address.

In addition, this encoding doesn't use that many bytes, but unfortunately reading and parsing that information is quite expensive.

For that reason I've developed a new unwinder that uses custom unwind information derived from DWARF (https://www.polarsignals.com/blog/posts/2022/11/29/profiling..., previously discussed in https://news.ycombinator.com/item?id=33788794) that runs in BPF. This new compact representation can be binary searched easily and each unwind row has a size of 16 bytes. I are currently working on reducing it down to ~10 bytes.

All the code is fully OSS (Apache 2.0 for userspace and GPL for BPF), and part of the Parca project (https://github.com/parca-dev/parca-agent).

We've also given some talks in FOSDEM going deeper into how we made it scale for many big processes.

I find this surprising! Was this for off the shelf applications or some custom binaries?

As mentioned above, we see DWARF expressions such as `DW_CFA_def_cfa_expression` on the regular. See the "Test Plan" section and commit messages of the PR that introduced support for this particular opcode [0]

[0]: https://github.com/parca-dev/parca-agent/pull/1058

Let's see an example perf map file for NodeJS. The runtimes out there output this file with more or less the same format, more or less!

The good news is we got you covered. If you are using Parca Agent, we already do the heavy lifting for you to symbolize captured stack traces. And we keep extending our support for the different languages and runtimes.