retina VS gdbstub

Yeah, excellent description of why the volume is so high, and when you're tracing a multithreaded one there's the additional noise from the way they're interleaved.

Besides filtering, I forgot to mention that some kind of aggregation/summary. strace flags are useful; even better to write a little program with eBPF (on Linux) or DTrace (on macOS/BSD/Solaris). I like being able to do stuff like this: https://github.com/scottlamb/retina/issues/5#issue-933945792

I suspected exactly that in this issue in one of my libraries, but when I actually looked with strace, I didn't see many syscalls returning EWOULDBLOCK. So then after that measurement, my new theory was that e.g. tokio::net::{Udp,Tcp}Socket would skip actually issuing the syscall if the mio layer hasn't returned availability since the last poll. Not true? Maybe I need to run my experiment again...

I'm plugging my new RTSP library retina into moonfire-nvr. But progress may be slow this week due to family obligations.

now integrate gdbstub to support debugging code inside the emulator :)

Shameless plug, but have you considered integrating gdbstub rather than rolling your own debugger? I know a couple folks out there have successfully integrated it into their PS1 emulators with great success.

I've worked really hard to keep gdbstub panic free in its minimal configuration, going so far as to write some informal scripts that parse rustc's asm output to scan for the presence of panicking code paths.

crates.io | docs | repo

As a totally shameless plug, I'm the maintainer of gdbstub, a bare-metal, no_std, no_alloc, and size-optimized implementation of the GDB Remote Serial Protocol. One of the major changes slated for the upcoming release 0.6 is support for a new state-machine based API, which makes it possible to drive gdbstub directly via bare metal interrupt handlers (i.e: send/recv data over UART, handling breakpoints via the undefined instruction trap interrupt, etc...).

Continue working on a new API in gdbstub that'll make it easier to use directly from an interrupt handler when debugging code in a no_std, bare-metal OS environment.

I ran into almost this exact same problem while working on gdbstub, whereby I an API that allowed users to mix/match protocol features however they wanted, while also preventing users from accidentally implementing mutually-exclusive features. Moreover, I wanted to have a "zero cost" way to enable/disable API features without relying on cargo features. The solution I came up with is something I've been calling "Inlineable Dyn Extension Traits", or IDETs.

For a concrete example of how smart the Rust compiler is, I have a small writeup + test-repo that benchmarks a technique I came up with while working on gdbstub that [ab]uses the compiler's devirtualization and inlining optimizations to create runtime feature flags that are entirely compiled out if hard-coded to false at runtime.