Meeting C++ Multithreading Workshop
- Fundamentals of multithreading
This workshop about multithreading with modern C++ will be about the high end interface of C++ and the low level details. At the high end, we will cover the known topics like Threads, Shared variables, Save initialization of variables, Thread local data, condition variables and tasks.
That includes the theory, but also a lot of hands on experience with that challenging topic. At the low level details, we will look at the details of the memory model. You will get an idea, what the memory model is all about, how you can reason about your lock-free programs and of course, how you can verify, that your program is data race free.
As this is a workshop and not a seminar, we can adjust the stuff I'm talking about during the day.
James McNellis - Practical C++ Coroutines
One of the most interesting new features being proposed for C++ standardization is coroutines, formerly known as “resumable functions”. C++ coroutines are designed to be highly scalable, highly efficient (no overhead), and highly extensible, while still interacting seamlessly with the rest of the C++ language.
We will begin this session with an in-depth introduction to C++ coroutines. We will look at the rationale for adding coroutines—why they are useful—and will then demonstrate and explain a sequence of coroutines that gradually introduce the features of C++ coroutines. We will show both how to write various forms of coroutines and also how the coroutines extensibility model enables extending libraries to be non-invasively adapted to work with C++ coroutines.
The theory is interesting, and "Hello, World" examples are fun, but how do C++ coroutines fare when applied to a major library or operating system? How well do C++ coroutines work in practice with real-world user interface code, background tasks, and other complexities of real-world software? To answer these questions, we'll explore the application of C++ coroutines to Modern C++ for the Windows Runtime. We'll look at the coroutine types that we designed for the Modern C++ language projection, with a focus on their usability and performance. Most importantly, we'll look at how coroutines can be used with a sophisticated platform library and discover how various problems are greatly simplified with faced with real platform complexities like UI and threading models.