cargo-call-stack
defmt
cargo-call-stack | defmt | |
---|---|---|
5 | 17 | |
555 | 723 | |
- | 3.5% | |
0.0 | 8.8 | |
2 months ago | 5 days ago | |
Rust | Rust | |
Apache License 2.0 | Apache License 2.0 |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
cargo-call-stack
-
Why choose async/await over threads?
Yes, it's what I wrote about in the last paragraph. If you can compute maximum stack size of a function, then you can avoid dynamic allocation with fibers as well. You are right that such implementations do not exist in right now, but I think it's technically possible as demonstrated by tools such as https://github.com/japaric/cargo-call-stack The main stumbling block here is FFI, historically shared libraries do not have any annotations about stack usage, so functions with bounded stack usage would not be able to use even libc.
-
Ask not what the compiler can do for you
For rust code, I have found https://github.com/japaric/cargo-call-stack to be the best available option, as it does take advantage of how Rust types are implemented in LLVM-IR to handle function pointers / dynamic dispatch a little better. An even better solution would try to use MIR type information as well to further narrow down targets of dynamic calls in a Rust-specific way, but no such tool exists that I know of.
-
Debugging and profiling embedded applications.
cargo-call-stack Static stack analysis!
-
In defense of complicated programming languages
Generators can just dump stuff on the stack. They have additional their own stack for storing their state. If you can prove an upper amount of creation of generators in the call graph, that would however work. There is for example this nice tool for Rust doing the overapproximation.
-
Understanding thread stack sizes and how alpine is different
Not easy at all.
I know that in the small-embedded world, people do work on such things.
Eg https://github.com/japaric/cargo-call-stack
defmt
-
I built a column staggered keyboard with firmware written in Rust!
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.
-
Testing a no_std crate with QEMU and defmt-test?
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.
-
Are there any `no_std` logging or printing libraries (for Wasm targets, or even embedded devices)
On embeded defmt is often used https://github.com/knurling-rs/defmt
-
Debugging and profiling embedded applications.
defmt is a great framework for general logging.
- Print From a Multi-Platform no_std Embedded Library
-
Native Reflection in Rust
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
- Smallest logging implementation?
-
From arduino to rust via avr-hal
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.
-
Are costly debuggers from vendors necessary?
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).
-
Creating formatted strings with no_std on embedded
If the build constraints are amenable for your project, you might also enjoy knurling-rs' defmt logging framework.
What are some alternatives?
hyperswitch - An open source payments switch written in Rust to make payments fast, reliable and affordable
cargo-embed - a cargo extension for working with microcontrollers
itm - ARMv7-M ITM packet protocol decoder library crate and CLI tool.
probe-run - Run embedded programs just like native ones
trice - 🟢 super fast 🚀 and tiny 🐥 embedded device 𝘾 printf-like trace ✍ code, works also inside ⚡ interrupts ⚡ and real-time PC 💻 logging (trace ID visualization 👀)
flip-link - Adds zero-cost stack overflow protection to your embedded programs
nanoprintf - The smallest public printf implementation for its feature set.
egboard - Ergonomic Keyboard with custom firmware in Rust.
rp-hal - A Rust Embedded-HAL for the rp series microcontrollers
usbd-human-interface-device - Batteries included rust USB HID library for usb-device
av1-streaming - AV1 streaming for Linux and Raspberry PI