CppNorth2022

The C++ specification defines, in the library part of the spec, all sorts of requirements for containers and algorithms. Those requirements include complexity requirements, invalidation and concurrency rules. In this talk we will explore a sample of these rules to better understand the considerations of the spec and the practical implications. We would understand the limitations posed for library implementers and for users, go through some benchmarks and conclude with some practical advice and recommendations.

A Real-time system needs to respect a set of constraints; typically, such systems are defined as systems for which delivering the right results but not on time is as bad as not delivering the right results. Depending on the system, the impact of not respecting these constraints can go from unpleasantness or discomfort (so-called "soft" real-time) to actual physical harm ("hard" real-time).

Most real-time constraints fall in one of four categories: a task has to be [b]rief (execution has to complete within a fixed amount of time once started), [i]mmediate (low-latency: execution has to start within a fixed amount of time following some event), or iterate with [r]egularity (e.g.: task has to be executed n times per second) or [c]onstancy (e.g.: task has to be executed every 1/nth of a second).

In the case of [r] and [c]-type tasks, there tends to be some residual time between two consecutive executions of a task. That time can be spent sleeping, but it can also be invested towards performing non-real-time tasks which help the real-time system behave better as a whole.

In this talk, we will examine how one can leverage C++ to achieve the goal of making a real-time system behave better by changing the way non-real-time tasks are performed.

Imagine writing parallel code that can run on any platform - CPUs, GPUs, DPUs, specialized accelerators, etc - without any language or vendor extensions, external libraries, or special compilation tools. It's no longer just a dream - you can do it today in Standard C++!

Parallelism is increasingly common in software, from supercomputer simulations to mobile applications. But writing parallel code is increasingly challenging, due to an explosion of diversity in hardware, a trend that's likely to continue into the future. To meet this challenge, the C++ Committee has developed C++ Standard Parallelism, a parallel programming model for Standard C++ that is portable to all platforms, from your smartwatch to your supercomputer, and delivers reasonable performance and efficiency for most use cases.

Our vision of C++ Standard Parallelism consists of three key components:

Common parallel algorithms that dispatch to vendor-optimized parallel libraries
Tools to write your own parallel algorithms that run anywhere.
Mechanisms for composing parallel invocations of algorithms into task graphs.
In this talk, we'll dive into the roadmap for C++ Standard Parallelism - we'll discuss what we already have that you can use today, what's coming down the line, and where the future may lead us.

Among the many new additions to C++20 are Ranges, a modern revision of the STL offering updated algorithms and new “views” with lazy evaluation.

In this example-based talk we’ll work through several practical demonstrations of how the new Ranges functionality may be used to solve everyday problems concisely, elegantly and efficiently. In addition, we’ll offer tips on how to avoid common errors in your Ranges code, and demonstrate a couple of useful utility functions which you can drop into your codebase today.

This is the third and final talk of The Algorithm Intuition Trilogy, the first two talks being Algorithm Intuition (C++Now 2019) and Better Algorithm Intuition (Meeting C++ 2019). This talk will explore the history of a programming language that has algorithms built into its core. This language has many links to modern programming languages today - including C++ - and studying this language has been the most fun and most rewarding academic task I have ever completed. I hope to share everything I have learned about this language and how you can apply it to C++ (and any language).