Abstract
Async in C++ is in a sad
state. The standard tools -- promises, futures, threads, locks, and
std::async -- are either inefficient, broken, or both. Even worse, there
is no standard way to say _where_ work should happen. Parallel
algorithms, heterogeneous computing, networking & IO, reactive
streams, and more: all critically important foundational technologies
that await a standard abstraction for asynchronous computation.
In this talk, Eric
Niebler digs into the Standard Committee's search for the basis
operations that underpin all asynchronous computation: the long-sought
Executor concept. The latest iteration of Executors is based on the
Sender/Receiver programming model, which provides a generalization of
many existing paradigms in asynchronous programming, including
future/promise, message passing, continuation passing, channels, and the
observer pattern from reactive programming. It also has surprising and
deep connections to coroutines, which further demonstrates the model’s
potential to be a truly unifying abstraction for asynchronous
programming in C++20 and beyond.
Eric will present the
short-term and long-term directions for Executors in ISO Standard C++,
illustrating the design by walking through several implementation
examples. They will talk about the direct connection between coroutines
and the Sender/Receiver model and discuss what it means for the future
of asynchronous APIs in C++. Finally, he will cover how the restrictions
imposed by the Executors model should affect the way you write code
today so your code is ready for the next big revolution in parallel and
concurrent C++ programming.