CppCon 2024

This talk examines the use of C++ in building distributed robotic surgical systems, emphasizing safety, performance, and reliability. While C++ offers strong performance benefits, it also presents challenges in meeting industry standards and regulations in the medical technology field. We discuss the architectural decisions and strategies employed to meet international safety standards for medical devices, and present techniques for writing efficient, safe and reliable software. Our experience in building a surgical robotic system serves as a case study, highlighting the challenges and solutions in this highly regulated domain.

If you've ever struggled to write tests for domain-specific functions with complicated, real-world inputs, this talk is for you!  We'll use the Motion Planning component in a self-driving stack as a case study (although you won't need any prior Motion Planning experience to follow the talk).  In building objects for our test inputs, we faced the classic dilemma.  If we make the objects simple, they're hardly meaningful, and the tests amount to little more than smoke tests.  If we try constructing more realistic objects, it takes tremendous amounts of boilerplate code (which obscures what is actually being tested) --- and what's worse, these finicky construction methods go stale and break easily as implementation details evolve.

There is a better way!  To find it, we take our inspiration from a (paraphrased) Kent Beck quote: "First, make the test easy.  (Warning: this may be hard!)  Then, write the easy test."  What this means is investing in full-fledged testing support libraries.  First, we build foundational domain-specific APIs: user-friendly paths, poses, and speed profiles.  Then, we provide APIs that bridge the gap between what the user pictures in their head when they want to write a test (a "scene"), and the data structures that represent that situation in the software (a sequence of planner input messages on different channels).  This "scene description" that the user writes is high level and doesn't depend on implementation details, so it resists going stale, as we'll illustrate with an example involving road construction zones.  On the implementation side, the problem decomposes beautifully: each planner input (map, actors, etc.) can be constructed from the information in the scene description, independently of all other inputs, helped along by the paths and speed profiles.

These ideas could be implemented in many languages, but C++ particularly excels at delivering performance, robustness, and flexible, natural APIs.  As an example, we'll explain the benefits of describing each planner input with a "smart" tag type, containing both the name and the message type.  On the implementation side, variadic templates make it easy to conjure up containers and interfaces that operate on "all planner inputs", eliminating the risk of forgetting to update some callsite when we add a new one.  On the interface side, end users see none of this complexity: they can simply use _instances_ of these tag types as "indexes" into these containers in a natural way.  This fluency and power makes more complicated test cases possible: it becomes easy to select and "tweak" any planner input to ensure we respond correctly when the messages are malformed, delayed, or absent.  Overall, we hope our experience enabling high-quality Motion Planning testing at scale will have lessons that can be adapted to a variety of other domains.

Localization in mobile robotics, critical for autonomous navigation, is a challenging problem often addressed through particle filter algorithms, also known as Monte-Carlo Localization (MCL) estimation. The integration of the ranges library in C++20 introduced powerful new tools to enhance the implementation of these algorithms, further extended in C++23. This talk explores the use of these modern C++ features to develop efficient, composable particle filter algorithms that are well-suited for both 2D and 3D localization tasks.

Attendees can expect an introduction to the basics of particle filters, providing a foundation for understanding their application in robotics. They will then be taken through the design and implementation of a series of essential functions for a particle filter library. These examples will demonstrate how C++23 ranges can be used to refactor traditional MCL approaches into more flexible and efficient solutions.

Motion planning algorithms play a crucial role in enabling robot arm to navigate complex environments efficiently. They are required to determine a robot's trajectory and optimize its motion to minimize cycle time and maximize throughput. In this talk, we delve into optimizing a robotic arm motion planner using the CHOMP algorithm, highlighting the significance of employing good coding practices and design patterns.

Beginning with an overview of motion planning techniques and the rationale behind selecting the CHOMP algorithm for robotic arm manipulation, we scrutinize the initial naive code implementation. Transitioning to modern C++ implementation, we introduce key concepts utilized in the refactor and present code snippets illustrating the transformation from legacy to modern paradigms.

Attendees will glean insights into identifying and addressing challenges in legacy code, mastering essential modern C++ concepts for motion planning optimization, and quantifying the tangible benefits through performance metric comparisons. It will further encourage them to integrate design patterns into robotics programs.

C++23 introduced std::mdspan, a multi-dimensional view type that expanded on the capabilities of its predecessors, std::span and std::string_view, by eliminating the restriction to view into contiguous blocks of memory. Multidimensional array-type data structures are commonly used in robotics applications such as RGB and depth images, as well as occupancy grids for navigation. While these alone present a compelling alternative to hand-rolled data structures, this talk will illustrate the flexibility of the layout and accessor policy customization points included in std::mdspan, demonstrating its potential through various examples, including helping a robot arm inventory beer bottles.

This talk will review conventional use cases of std::mdspan in robotics, such as occupancy grids and submaps for determining obstacles and collision checking with polygonal footprints, as well as handling camera images retrieved after deep learning inference. Additionally, we will discuss commanding single and dual robot arms for inventory inspection using synchronous and asynchronous strategies via the std::mdspan accessor policy and std::future.

While these toy examples may have speculative applications, they highlight the flexibility and extensibility of this new data structure for novel use cases.

Have you ever wanted to run a Llama 2 model in C++? In this talk, we'll dive into C++ techniques for Llama 2 model inference. We'll start with a model trained in PyTorch and explore different ways to implement the inference solution for the Llama 2 language model, focusing on keeping things simple and minimal.

Llama 2 is a cutting-edge language model that's making waves in the field of natural language processing. It can generate human-like text, understand complex language tasks, and is used in everything from chatbots to content creation. Its efficiency and accuracy are setting new industry standards, making it an invaluable tool for developers and researchers.

Inspired by the awesome llama.cpp and llama2.c projects, this talk aims to show a simple and educational approach. We'll hard-code the Llama 2 architecture and create the inference in pure C++ with no dependencies. Join us to learn how to build Llama 2 models efficiently using a streamlined and dependency-free C++ solution. If time allows, we will also explore additional C++ techniques for fast Llama 2 model inference.

By the end of the talk, you'll have an understanding of what Llama 2 is and how it works. You'll also learn practical ways to implement the Llama 2 model inference in C++ and potential optimizations.

Motion planning is a crucial capability for robots operating in unstructured environments, enabling them to navigate and interact with their surroundings safely and efficiently. However, motion planning algorithms are computationally expensive, often requiring hundreds of thousands or millions of evaluations of subroutines, such as forward kinematics, collision checking, and nearest neighbor lookup.

This talk will present an approach to accelerating motion planning subroutines, specifically focusing on forward kinematics calculations, through compile-time optimizations. The proposed method leverages code generation techniques to directly translate Unified Robot Description Format (URDF) into optimized C++ code. Additionally, by generating hardware-specific code, such as CUDA for parallel computations, significant performance gains can be achieved. Throughout the presentation, I will compare and benchmark the compiled URDF to a naive implementation of forward kinematics and evaluate the performance impact of certain design decisions, such as memory layout and compiler flags.

The presentation will demonstrate how the aforementioned code generation process can be seamlessly integrated into the C++ build process using CMake and Jinja templates, enabling easy adoption. Attendees will gain insights into the benefits of compile-time optimizations for performance-critical applications and learn how to leverage this approach to enhance the efficiency of their own robotics or computationally-intensive systems.