dhat-rs VS defmt

dhat for heap profiling

You could wrap the global allocator similar to dhat to instrument heap allocations. dhat itself depends on std.

I'm no expert in this, but I think you'll want something like https://github.com/nnethercote/dhat-rs

I am requesting comment on a new design for my dhat-rs profiling crate at https://github.com/nnethercote/dhat-rs/issues/17.

https://github.com/nnethercote/dhat-rs is a bit like this, albeit for heap allocation profiling. But it's experimental and I'm not really maintaining it right now.

https://github.com/nnethercote/dhat-rs is an incredibly useful tool, but to slow to run in production.

As someone who had only done embedded programming in the Arduino IDE, utilizing the defmt crate for logging with OpenOCD and GDB was an amazing experience. Although I still had no idea on to implement USB-HID for actually sending the key reports, until I discovered the usbd-human-interface-device crate and everything became so much easier. I just needed to create an iterator over Keyboard events and the crate would handle the rest as an added benefit the crate also supports multiple devices, so adding mouse support was as easy as creating a separate iterator over WheelMouseReport.

I think I want to use the QEMU emulator (as suggested in the Embedded Rust Book) and tests created with defmt-test. But I can't figure out how to get them to work together.

On embeded defmt is often used https://github.com/knurling-rs/defmt

defmt is a great framework for general logging.

Great writeup! The defmt logging crate uses a linker script to extract debug symbols so that you get nicely formatted stack traces on embedded systems. It works on linux, macos and windows. I wonder if the same technique can be applied to this project. It needs a runner though so may not be the right approach.

https://github.com/knurling-rs/defmt

Just played with embedded stuff today. defmt can be used for logging instead of println since there's not really a stdout when running on bare metal.

yYeah. For example, instead of printf("Variable X = %d, y=%f", x, y), where the micro then formats the string and pushes it out a serial port, blocking until its sent, I can write LOG("Variable X = %d, Y=%f, x, y), and what actually happens is a unique pointer to the string, and a tagged raw int and float get pushed onto a buffer, which takes about 15 instructions and takes up 16 bytes in the buffer. The buffer is then asynchronously sent out over the serial port, and the PC knows how to map the string ID to the actual string (this can by dynamically fetched from the micro or stored like debug info if there's not enough flash for the strings), and applies the formatting. There's an added bonus that it's super easy to take any variable which is logged and plot it live over time. There's also stuff like if the system crashes and the watchdog resets it, the buffer can be read out from memory to catch anything which wasn't sent out yet. It's a bit more of a complex system to set up but it really makes printf feel like the stone age when you get to using it. For an example of a similar system in rust, https://github.com/knurling-rs/defmt is implementing the same ideas (I don't know of any publicly available equivalent in C or C++, but you can implement it the same, though C++ is easier and it helps to know your way around a linker script to make something properly ergonomic).

If the build constraints are amenable for your project, you might also enjoy knurling-rs' defmt logging framework.