CppCon 2024

Using the volatile keyword correctly is vital when accessing hardware devices in C++. Unfortunately, the volatile keyword is among the most misunderstood aspects of the language. If you don’t use volatile appropriately, you may find the compiler generating code that’s very different from what you intended.

This session will help you write more robust device drivers that avoid common mistakes surrounding volatile. Step by step, it explains:

 
• Why volatile is necessary

 
• How volatile affects the code that the compiler generates

 
• How you should place volatile in object declarations

 
• Which statements the compiler is and isn’t allowed to reorder around accesses to volatile objects

 
• How to avoid misusing volatile

 
• How to avoid introducing inefficiencies when using volatile objects

Message reception and dispatch is something common to many codebases. And deep down, we know that Boolean algebra underlies everything we do. But we seldom give it a second thought, or if we do, we probably dismiss it as trivial; something we learned in college and quickly outgrew.

This talk shows the unreasonable effectiveness of going back to basics and really understanding and unlocking the power of Boolean algebra in the design of a message handling library for embedded systems. We’ll talk about separating message layout and semantics, how to match against messages for dispatch, and particularly how to compose and simplify constraints at compile time, in order to do the least at runtime. We’ll also introduce Boolean implication and see a non-obvious application which is key to a generic approach. Finally we’ll see how message matchers can be generically transformed using compile-time information, allowing complete flexibility of expression and maximum runtime performance.

This presentation introduces a multi-producer, multi-consumer, lock-free queue with unique characteristics. We will cover the C++17 implementation and the std::atomic features required for this queue based on the CPU atomic instructions and discuss the queue's portability across various CPU architectures, beyond just X86_64 and runtime environments.

Efficient message queue-based communication between threads is crucial for optimal performance in multi-threaded applications. Queues are fundamental data structures that interact with various aspects of the application environment, including schedulers, memory allocation systems, and CPU hardware architectures.

Many use cases such as trading platforms, games, audio processing and other fields have strict latency and scaling requirements and this queue implementation has proved to reduce system latencies.

The presentation will feature the design of the queue, the required template language features, bandwidth and latency consideration, and multiple demo applications. Comparing this queue implementation’s benchmark results with other existing queues will follow. Finally, we will discuss potential future work and areas for improvement.

Join us to explore how this innovative queue implementation can improve your multi-threaded application performance.

All presentation materials, including the C++17 source code, slides, benchmarks, and demo applications are available on GitHub.

For years, developers have overlooked a powerful tool for reducing binary size: C++ exceptions. Join me on a deep dive into the world of exceptions and discover how they can be harnessed to create more space efficient firmware. We’ll explore the requirements and best practices of embedded development, and show what is required to use exceptions in that environment. By the end of this talk, you’ll have a thorough understanding of how exceptions are handled, what their space costs are, and how exceptions compare to functional errors as values.

Low level interactions are a core part of embedded implementations. All too often, C++ developers rely on C constructs and interactions due to prior biases around language support.  Herein we present effective leveraging of C++20 and C++23 constructs in an embedded driver code base. From using an existing C driver more effectively with modern C++ smart pointers to leveraging constexprs for bit and byte manipulation in the standard library, we will go over how you can stay on the cutting edge of the C++ language evolution in the embedded space.

Writing correct and high-performing IPC (Intra-Process Communication) programs in a constrained environment provides significant challenges. Properly utilizing function interfaces, data types, and ensuring correct data flow are part of the challenge during programming of IPC applications. Furthermore, debugging run-time bugs coming from IPC are some of the hardest and most time-consuming bugs.

We leverage the power of C++20 and concepts to define modern interfaces and constraints, that make IPC programs easy to understand. We introduce a pattern called CCI (Concept, Constraint, and Implementation) to facilitate the creation of modern interfaces encapsulating low-level IPC functions. Therefore, we mitigate numerous pitfalls stemming from IPC programming and prevent run-time bugs.

After explaining CCI and getting a good grounding, we start the re-work of low-level code around CCI. We show how features of C++20 help us utilize CCI. After that, we provide the general assessment of CCI pattern and compare the output of the assembly code regarding the performance.

Small embedded devices might only have one processing core but hardware accelerators, peripherals, and external events abound. Asynchronous event handling is the bread and butter of these systems; however, the lack of robust libraries in the bare-metal arena often result in a concurrency nightmare.

After a short sender/receiver primer, we will explore some patterns and idioms that have proven useful when employing the design in a high availability, complex embedded device. We will use [Intel's open source bare-metal senders and receivers library](https://github.com/intel/cpp-baremetal-senders-and-receivers) as well as other open source packages to build elegant, declarative solutions around interrupt handling, schedulers, devices drivers, and communication protocols. The patterns will be demonstrated on an STM32 target controlling a simple robot.

While this talk is focused on bare-metal implementations and embedded concerns, the shape of a solution is applicable to many domains and environments. Join me as we wrangle concurrency using the sender and receiver design.

This session will feature detailed case studies that measure the overhead associated with common programming abstractions in the context of embedded systems. By examining both compile-time and run-time implications, attendees will gain valuable insights into how these abstractions impact system resources like memory usage and execution speed.

Key areas of exploration will include:

- **Encapsulation**: Assessing the cost of data hiding and interface protection depending on implementation strategies.
- **Inheritance**: Evaluating the costs and benefits of using class hierarchies in environments where memory and processing power are limited.
- **Polymorphism**: Comparing run-time polymorphism via virtual functions to compile-time alternatives like templates and concepts, analyzing their respective impacts on performance and flexibility.

Through empirical data and performance metrics, participants will observe how traditional object-oriented techniques affect resource utilization. The discussion will also cover the advantages and trade-offs of these techniques, providing a balanced view of their impact on embedded systems.

Designed for developers and system architects working within the constraints of embedded systems, this talk aims to provide valuable insights into making informed decisions about when and how to use specific programming abstractions. Attendees will leave with a clearer perspective on optimizing their code for maximum efficiency, armed with practical knowledge about the trade-offs involved in adopting various software design paradigms.

Ever wrestled with an embedded unit that had a mind of its own? That was my reality a few years ago.
This unit, built with Linux, C++, and QT, was designed to be a reliable middleman, handling RF frames from a multitude of endpoints.
But it was a bit of a wildcard - unexplained resets, occasional data loss, and all.
It was supposed to support 7500 endpoints, but once we hit 5000, it started to show signs of strain.

The software was a tough nut to crack - maintaining it was a challenge and it wasn't exactly a developer's favorite.
But here's where the plot thickens: after two years of relentless work, we transformed this underdog into a champion.
The unit now supports 10,000 endpoints, with zero resets or data loss.

Intrigued? Join me as I unravel the journey of this remarkable turnaround.
Let's dive into the world of embedded systems and explore how we turned the tide in our favor.
It's a tale of performance improvements, overcoming challenges, and making the impossible possible.
If you've ever wondered how to boost efficiency in embedded systems, or if you're just a fan of a good tech turnaround story, this talk is for you.