Rust support

[ThoFrank]

Adding some sort of rust support to openbsw was always a goal.
I want this to be a discussion about how to achieve it and what rust support is actually supposed to mean.

All ideas are welcome

[ThoFrank]

Build system integration

Corrosion makes "integrating Rust into an existing CMake project" easy.

How should it be integrated (FetchContent vs. submodule vs. copy)? Are there better alternatives?

[marcmo]

you mean corrosion itself? since it's a relatively small unit that is versioned, I would not complicate our build by introducing submodules as long as we don't really need it.
FetchContent seems to be a good option if that is well supported within cmake.
Alternative: can we just copy a fixed version into our admin/cmake folder?

[ThoFrankACN]

Async in OpenBSW and how Rust could hook into it

My understanding of Async in OpenBSW

OpenBSW is built on top of FreeRTOS. This enables the concurrent execution of multiple execution streams called tasks. Tasks can be assigned different priority levels so that more important work will be executed first (preemption).
The Async module builds on top of that and makes it easier and more efficient to orchestrate work packages in different priority levels. It's possible to enqueue Runnables into task specific queue, which will then execute the Runnable in the context of that task.

You could say there is an event loop for each task.
In OpenBSW task never have the same priority. This would be superfluous as scheduling can be done more efficiently in the same task.

How Rust could fit into the picture

Wrapping Rust into Runnables

It would be easily possible to wrap regular Rust functions in Runnables and then schedule them like any other Runnable with OpenBSW Async. But doing so does come with some drawbacks.
The biggest one I see is that managing data is unergonomic. In case you want to persist mutable state across multiple runs of a Runnable this state would need to be placed into static memory. To fulfill Rust's memory guarantees and be able to modify the data one would either need to wrap the data in some sort of Mutex or ensure exclusive ownership through other means.

How about async Rust

Rust has async built into the language. And it's even possible to use it on microcontrollers (for example with embassy).
Async Rust requires a Runtime which polls and schedules tasks to drive the computation. Async tasks usually run cooperatively similar to Runnables in Async OpenBSW.
It would be interesting to allow the execution of async Rust in the same event loop as Cpp Runnables. This would mean Async OpenBSW becomes the executor for async Rust. With one executor per priority level.

Potential Path forward

To test how well async Rust would fit into Async OpenBSW it should be possible to run an of the shelf executor (e.g. Embassy's raw Executor) inside an Async Runnable.

[ThoFrankACN]

I created a proof of concept implementation over here: https://github.com/esrlabs/openbsw-rust

It uses Embassy's raw executor inside an OpenBSW Async Runnable

[ThoFrankACN]

Roadmap of integration

The proof of concept implementation (see here) will be refined and broken up into following PRs:

• Add Rust build system support #356
• Add rustdoc output as another documentation artifact
• Add a panic handler crate
• Add crate for printing to the console
• Add a log::Log implementation crate
• Add async runtime and timer crate