Fixing Deprecated `heapless::mpmc` In Bevy Engine

Hey Bevy enthusiasts! We've hit a small bump in the road with the recent deprecation of the heapless::mpmc module. This change, introduced in a minor version update, has caused some hiccups, particularly for those of us working on no_std builds. Let's dive into what happened, why it matters, and how we're planning to address it.

What's the Issue?

The heapless crate recently deprecated its mpmc (multi-producer, multi-consumer) module. For those unfamiliar, heapless is a fantastic crate that provides data structures that don't require dynamic memory allocation, making it perfect for embedded systems and environments where you want to avoid the overhead of a heap. The mpmc module offered a way to create concurrent queues, which are incredibly useful for inter-task communication in such environments.

The deprecation, as discussed in this GitHub issue and the official documentation, means that while the code still works for now, it's no longer the recommended way to achieve the same functionality. This is important because we strive to keep Bevy up-to-date with the best practices and maintain a clean, warning-free codebase. In Bevy, we treat warnings as errors in our CI, so a deprecation warning effectively breaks our builds.

Why Did This Break Our Builds?

So, why did a simple deprecation cause so much trouble? Well, in Bevy, we've made a conscious decision to treat compiler warnings as errors. This might seem strict, but it helps us catch potential issues early and ensures that our codebase remains healthy and maintainable. When heapless deprecated the mpmc module, it started emitting deprecation warnings. Because we treat these warnings as errors, our no_std builds, which rely on heapless for certain functionalities, started failing.

Our Immediate Response

In the short term, we've opted to temporarily silence the warnings by using #[allow(deprecated)]. You can see the change in this pull request. This buys us some time to investigate the usage of heapless::mpmc in Bevy and explore alternative solutions without immediately disrupting development. It's important to note that this is just a temporary fix. We don't want to silence warnings indefinitely; we want to address the underlying issue.

Diving Deeper: Investigating the Usage of heapless::mpmc

The next step is to understand exactly where and how we're using heapless::mpmc within Bevy. This involves a thorough audit of our codebase to identify all instances of its usage. Once we have a clear picture of the scope, we can start evaluating potential alternatives.

Identifying Use Cases

Understanding the specific use cases of heapless::mpmc is crucial for finding the right replacement. Are we using it for simple message passing between systems? Or are we leveraging its multi-producer, multi-consumer capabilities for more complex scenarios? The answers to these questions will guide our search for a suitable alternative.

Performance Considerations

Performance is always a key consideration in Bevy. Any replacement for heapless::mpmc must be able to perform at least as well, if not better. We'll need to benchmark different options and carefully analyze their performance characteristics to ensure that we're not introducing any regressions.

Exploring Alternatives

Now comes the fun part: finding a replacement for heapless::mpmc. Several options are available, each with its own trade-offs. Let's explore some of the most promising candidates.

Alternative Crates

Several crates offer similar functionality to heapless::mpmc, but with different implementations and design choices. Some potential alternatives include:

• queue Crate: This crate provides various queue implementations, including a multi-producer, multi-consumer queue. It's a well-established crate with a good reputation.
• crossbeam-channel Crate: While crossbeam-channel typically relies on dynamic allocation, it might be possible to adapt it for no_std environments with some clever engineering.
• embedded- каналы Crate: Specifically designed for embedded systems, this crate could offer a more suitable alternative, aligning well with the original intent of using heapless::mpmc.

Rolling Our Own Solution

In some cases, the best solution might be to roll our own. This would give us complete control over the implementation and allow us to tailor it specifically to Bevy's needs. However, it also requires a significant investment of time and effort.

Evaluating the Trade-offs

Each of these options comes with its own set of trade-offs. We'll need to carefully evaluate these trade-offs to determine the best path forward. Factors to consider include:

• Performance: How does the alternative perform compared to heapless::mpmc?
• Dependencies: Does the alternative introduce any new dependencies?
• Maintenance: How well-maintained is the alternative?
• Complexity: How complex is the alternative to use and understand?

Our Plan of Action

Here's our plan for addressing the deprecation of heapless::mpmc:

1. Complete the Code Audit: We'll finish identifying all instances of heapless::mpmc usage in Bevy.
2. Evaluate Alternatives: We'll thoroughly evaluate the potential alternatives, considering their performance, dependencies, and complexity.
3. Implement and Test: We'll implement the chosen alternative and thoroughly test it to ensure that it meets our needs.
4. Remove the #[allow(deprecated)] Attribute: Once we're confident in the new solution, we'll remove the temporary workaround.

Community Involvement

As always, we welcome community involvement in this process. If you have experience with any of the alternative crates or have ideas for how to solve this problem, please let us know! You can join the discussion on our GitHub repository or our Discord server.

Conclusion

The deprecation of heapless::mpmc presents a small challenge, but it's one that we're confident we can overcome. By carefully investigating the usage of heapless::mpmc in Bevy and exploring alternative solutions, we can ensure that our no_std builds remain healthy and maintainable. Thanks for following along, and stay tuned for updates!

For more information on Rust Embedded development, check out the Rust Embedded Book.