Abstract:

This talk presents a C++20 technique for converting dynamic, heap-allocated data structures into static, compile-time constants suitable for constrained embedded environments. The speaker, motivated by porting a real-time audio cabinet emulator from a Raspberry Pi to a Raspberry Pi Pico, faced the challenge of an algorithm that produces a std::vector whose final size is not trivially known. The solution leverages the constexpr capabilities of std::vector in C++20. By making the vector-generating function constexpr and its parameters template arguments, the entire computation is shifted to compile-time. This allows for the creation of a std::array with the exact size and contents of the computed vector, completely eliminating the need for runtime dynamic memory allocation. A more generic refinement using a lambda is also presented.

From Dynamic Vector to Static Array at Compile-Time

• 0:00 Introduction: The speaker, Robin Savolm, introduces his work in both GPU simulations and real-time embedded audio. The talk is inspired by his project to port a guitar cabinet emulator from a Raspberry Pi to a much smaller Raspberry Pi Pico, which requires avoiding dynamic memory.
• 2:13 The Problem: An existing algorithm uses a multi-pass process that results in a std::vector of a size that is difficult to predict. To move this to an embedded system without a heap, the size and contents of this data must be known at compile time to create static buffers.
• 3:10 The constexpr Solution: The solution is surprisingly simple in C++20 because std::vector is constexpr. By marking the function that creates the vector as constexpr and passing its inputs as template parameters, the vector can be fully evaluated by the compiler.
• 3:22 Creating a Static Array: Once the constexpr std::vector is generated at compile time, its size can be queried to declare a std::array of the exact required length. The contents are then copied from the vector to the array, resulting in a completely static, heap-free data structure.
• 4:08 A More Generic Implementation: The approach is refined into a more reusable utility. Instead of being tied to a specific function, the utility accepts any invocable object (like a lambda) as a template argument. This allows it to convert any compile-time evaluable range into a static std::array.