CppCon 2024

The sender/receiver framework for asynchronous operations in C++ is well on its way towards standardization in C++26. Previously, the theoretical background and implementation of the framework was shown but there wasn't much detail on how an application using sender/receiver would look like.

This presentation shows how to create a simple HTTP server using the sender/receiver framework with matching networking senders together with a coroutine task and and async scope. The code is created live using fundamental facilities. The goal is to demonstrate that the use of an asynchronous framework doesn't necessarily lead to excessive complexity when using C++'s facilities effectively. The resulting server could be embedded into any application, e.g., to inspect its state or change configurations. The takeaway is that it is reasonably straight forward to create an asynchronous program.

This session is an informal “BoF + show-and-tell” meetup for people interested in Cpp2/cppfront.
Here are some ideas:
- Do you have a pull request you're working on? Show it off and get feedback
- Chat in person about some of the GitHub cppfront Discussion topics
- Other related topics welcome!
- Last year Herb used this meeting as a chance to run some informal polls

Hashing is crucial for efficient data retrieval and storage. This presentation delves into computing hashes for aggregated user-defined types and experimenting with various hash algorithms. We will explore the essentials of hash functions and their properties, techniques for hashing complex user-defined types, and customizing std::hash for specialized needs. 
   Additionally, we (re)introduce a framework for experimenting with and benchmarking different hash algorithms. This will allow easy switching of hashing algorithms used by complex data structures, enabling easy comparisons. Hash algorithm designers can concentrate on designing better hash algorithms, with little worry about how these new algorithms can be incorporated into existing code. Type designers can create their hash support just once, without worrying about what hashing algorithm should be used. 
   You will gain practical insights and tools to implement, customize, and evaluate hash functions in C++, enhancing software performance and reliability.

This talk presents a series of effective patterns to address challenges arising when
code is developed that shall operate seamlessly on both GPU (Cuda) and CPU environments.
This scenario is a common oversight among Cuda developers,
given the substantial architectural differences between CPUs and GPUs.

The patterns presented cover a range of scenarios,
from handling stray function calls,
strategies for conditional compilation,
exploiting constexpr functions,
leveraging undefined behaviour,
usage of Cuda specific macros,
conditional instantiation of templates,
and
managing compiler warnings and errors.

Key patterns include: "Host device everything", "Conditional function body", "Constexpr everything", "Disable the warnings", "Defensive Programming", "Conditional Host Device Template", and "Function dispatching".

We evaluate each pattern based on ease of use, maintenance overhead, applicability and known usages. Additionally, pitfalls to avoid and considerations for implementations are provided to guide developers in adopting these patterns effectively.

If you're interested in high-performance computing, this talk is for you! This talk aims to revolutionise how you think about the performance of associative operations.

Associative iteration is a powerful technique that allows for efficient computation of associative operations (addition, multiplication, and other monoids) in `O(log(N))` time as opposed to `O(N)` time.

The name for this technique was coined by my collaborators, and it is my goal to share their insights about it.

Associative Iteration is an absurdly general technique that leverages the properties of associativity that when combined with parallelism can achieve outstanding performance with very little effort.

We define Associative Iteration (unrelated to "iterators" as you might expect) as the repeated application of some associative operation with respect to a "count", some explicit number of operations. This technique applies generally to all monoids, so whether you're concatenating string, multiplying matrices, or simply adding integers, this talk will be useful to you!

Furthermore any "divide and conquer" algorithm that can be represented using this method should achieve near optimal or optimal performance.

This talk will specifically introduce a templated function that allows you to leverage the power of Associative Iteration in a way specific to parallelism.

Programming normal C++ leads to the use of dynamic memory, pointer chasing, and other issues that zap performance. Because there haven’t been practical solutions to those problems we seldom discuss them, creating the impression that they are unavoidable. Fortunately, the same C++ that binds us frees us to devise techniques centered around the concept of “relocatability” to solve those issues. We will explain what relocatability is and how to achieve it.

Consider the example of runtime polymorphism. You may want to have interfaces and implementations of interfaces. If your object refers to a “polymorphic” member, it normally cannot be implemented as a concrete sub-object, only as a base class pointer that points to a dynamically allocated instance of a derived class. This leads to millions of small objects dispersed throughout memory, all referencing one another. This is already very expensive and other issues around object layout makes things worse. One presenter witnessed 7% of Google Search Qrewrite CPU spent on dealloc, which must chase pointers to finish!

When we want to save the state of such programs, we must traverse those complex object graphs and encode them in complex file formats: serialization is required. Restore is further complicated by needing millions of small allocations which are often ephemeral. In general, working with data architected in this way is error prone and has abysmal performance. Our alternative to these complex object graphs is to lay out program data according to program design objectives, in our case allowing object moves. This is the essence of relocation. The set of techniques we will share with you is complete. Now that we can represent program state as simple, relocatable data, save and restore is simply memory mapping buffers.

For runtime polymorphism, we can use “Type Erasure”, the Design Pattern behind `std::function`, tailored for relocatability. Our Type Erasure performs better than normal polymorphism. We get better performance, we have no allocations, no deallocations, and no pointer chasing; resulting in happier programming. For other issues we get benefits of the same magnitude.

We will explain both well known and novel relocation techniques. The novel techniques have required the formulation of Generic Programming concepts including what we call “Value Manager”. We are presenting these for the first time.

In this session, the hosts of CppCast, Timur Doumler and Phil Nash, will be recording CppCast Episode 390: CppCon Special at CppCon in front of a live audience. The guest for this episode is... you! This will be an interactive episode in which the audience can ask us questions directly on the show – about the podcast, our work, or anything else in the world of C++ and beyond!

Your code is not working -- PANIC! Well, not quite! In this session we are going to show you how to write tests to uncover bugs in the first place (and to guard against regressions when they’re fixed) and how to identify the bugs’ root causes with a debugger. These two fundamental software engineering skills (debugging and testing) in combination helps us write better software by improving our confidence that bugs do not reappear -- especially as software scales and changes over time. Debugging and testing are two related skillsets, and in this talk we will provide an introduction and concrete tools showing by example how to utilize each skill together. If you have never used a debugger and think ‘if it compiles it must work’ then this is the talk for you.

In the world of C++, efficient string handling is crucial for performance-critical applications. Enter string_view, a lightweight view into character sequences. In this talk, we’ll explore the fundamentals of string_view, its advantages over traditional string, how it compares to std::span, common pitfalls to avoid, and practical case studies for using it effectively. Whether you’re a beginner or an intermediate developer, join us to enhance your code’s performance and adopt better practices.

XOffsetDatastructure is a serialization library designed to reduce or even eliminate the performance consumption of serialization and deserialization in the game industry by utilizing zero-encoding and zero-decoding. It is also a collection of high-performance data structures designed for efficient read and in-place/non-in-place write, with performance comparable to STL. 

Custom allocators are used to keep fields in contiguous memory, enabling them to be sent directly. Offset pointers are used to maintain pointer validity after buffer resizing and memory movement caused by modifications to variable-size fields. Some other techniques, such as containers that support offset pointers and auto-resizing mechanisms, are involved.

The performance statistics demonstrate that XOffsetDatastructure is a high-performance library, offering advantages in terms of encoding and decoding time, read and write performance, and message size compared to other modern C++ serialization libraries.

API design and code performance are some of the most discussed topics in the C++ community. However, surprisingly little is said about the fundamental element of programming where they meet: the function signature. As a result, overhead that can be incurred inside every function body and at every call site is not commonly recognized. Non-inlined function calls are places where the ABI specification comes into play, and its effect on the generated assembly doesn’t always match expectations, even on the common platforms.

In this talk, we’ll bridge the gap and provide a comprehensive list of performance pitfalls to be aware of when designing a function signature, including a compiler’s view on the frequently debated questions:
- returning by value or by output parameter;
- passing parameters by value or by reference;
- using abstractions that are commonly considered to have zero runtime overhead, such as std::unique_ptr and std::span.

Kris will explain Bitcoin Script, a stack-based scripting language integral to Bitcoin's transaction validation process, Bitcoin Script plays a crucial role in defining custom transaction rules and smart contract functionalities. He will explore the inner workings of Bitcoin Script from a technical standpoint, focusing on its implementation details in C++.

Attendees will gain insights into key concepts such as opcodes, stack operations, and the evaluation engine, as well as security considerations for safe script execution. Additionally, practical use cases will be examined to demonstrate Bitcoin Script's real-world scenarios.

–

In Eduardo Madrid’s presentation, Role Playing Bitcoin Protocols Including the Lightning Network, scheduled for Thursday, with just an intuitive understanding of Bitcoin Script he will describe the higher abstraction level protocols, such as the Lightning Network.

Join us on Friday for a panel in which Eduardo, Jon, and Kris will answer Bitcoin questions.

You must have a certain skill set to write a scripting binding interface for C++ like luabind, sol2, pybind, or ChaiScript. This is a skill set that few seem to posses. But developing this skill set helps you to understand the language in a new, deeper, and more unique way.

We will start from the first principles of what we are trying to accomplish and why. We will then cover the basics of deducing function signatures with templates and the limitations that are hit when you have function overloads. We will wrap these user provided functions with a compile time <-> runtime interface, then demonstrate a simple function dispatch engine.

If we have time, we will then show function reference syntax and how you can use this to bind script engine functions back into the C++ statically typed world.

We will not get to an actual parser for a scripting language. That will be left as an exercise to the viewer.

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.

An experience report with tips and tricks for how to make incremental improvements to legacy code and how to prepare C++ code for reuse that has deep dependencies in legacy codebases. We will study real world examples from the merger of three companies all with 20+ year old C++ codebases.

The first part of the talk will cover techniques for making incremental changes to a large legacy C++ codebase. Adopting static analysis and runtime sanitizers, adding test coverage, updating conventions and style, using modern idioms, deprecating and removing legacy code, and fixing undefined behavior all comes with a cost. We will look at practical techniques for making incremental change in these areas without breaking the bank.

In the second part of the talk we will cover the challenges involved with sharing and reusing C++ code from a large legacy codebase and pragmatic techniques for sharing code. Examples will cover easy to extract pieces of code to libraries with deep legacy dependencies. Techniques will range from source code sharing, to hiding behind a DLL boundary, and methods that fall in between.

Practical software does not run in abstract vacuum, it runs on underlying hardware platforms. Practical software engineering does not exist in abstract vacuum either. The software layer sits in between the domain specific requirements on top and the underlying runtime platforms below. Many interesting developments have happened on all three of those layers over the years, and while contemporary hardware has gone a long way forward, it often suffers from the attention deficit caused by an overshadowing flood of advancements and “advancements” in the software part of the universe. This new shiny programming language is safe, performant, and solves a backlog of problems that have been dragging for long. While that new shiny programming paradigm automagically relieves from dealing with low level details and the toolchain is plain amazing. The hardware side brings into this fistfight a set of new architectures, ISAs, and hardware abstractions – just to stay on par with the software side. Looks perfect? What else would an engineer dream about, no?
Not really. Let’s take a look at the contemporary commodity hardware platforms of today, and also at the trendy software engineering waves of today, and try to sense how and why it could (and frequently does) cross out the potential benefits of hardware advancements – and what could be done to actually be friendly to your underlying hardware, and at what cost.