Очередной отчётный стрим на бусти проведу 3 мая в 19 часов по Москве.

В программе:
* Новые интересные факты про моего несостоявшегося менеджера Игоря.
* Как меня разводили на смарт-контрактах.
* Зачем был опрос про столы.
* Когда новые главы книги, почему задержка.
* А также любые ваши вопросы, которые можно накидать уже сейчас: https://www.donationalerts.com/r/cpp_lects_rus

P. S. Ваша поддержка моей просветительской деятельности меня очень мотивирует: https://boosty.to/cpp_lects_rus

Минимальная подписка для участия в стриме всего-то 128 рублей. Мне кажется для всех кто на этом канале вообще не деньги ))

#official #boosty

Выложил третью лекцию по атомикам на английском языке.

https://youtu.be/h4k3z69aIMY

В третьей части лекции мы переходим к рассмотрению проблемы рекламации памяти и построению lock-free структур данных. Начинаем мы с рекламации памяти, разбирая в процессе, почему наивные решения на указателях и CAS ломаются, и где именно возникает необходимость аккуратно управлять временем жизни объектов. Далее рассматриваем новые подходы, которые введены в стандарт C++26: RCU и hazard pointers. Обсуждаем, как они работают, какие гарантии дают и какие накладные расходы вносят. После этого мы приступаем к рассмотрению lock-free структур данных. Сначала разбираем простой пример unbounded стека с использованием hazard pointers. Затем bounded MPMC стек, где появляются уже другие сложности: проблема публикации и проблема ABA. Разбираем, как они возникают и как с ними бороться. В завершение рассматриваем lock-free MPMC очередь, обсуждаем влияние моделей памяти на производительность и смотрим на результаты бенчмарков.

00:00 Введение. Проблема рекламации памяти.
07:03 Идея атомарного shared_ptr и её ограничения.
11:05 Решения в C++26: RCU.
23:01 Решения в C++26: Hazard pointers.
31:20 Lock-free unbounded stack с использованием hazard pointers.
35:45 Lock-free bounded MPMC stack: проблема публикации.
42:42 Проблема ABA и способы её решения.
54:40 Lock-free bounded MPMC queue, бенчмаркинг и литература.

#cpp_postgraduate

Выложил первую лекцию по корутинам на английском языке.

https://youtu.be/wmrW6AkRo3c

В этой лекции мы начинаем с базового вопроса: что вообще такое корутина и чем она отличается от обычной функции или thread routine, а также обсуждаем исторический контекст и классификацию сопрограмм: стековые и встроенные (stackless), асимметричные и симметричные и т.д. Основная часть лекции посвящена внутреннему устройству корутин в C++20/23. Разбираем три ко-оператора, интерфейс promise_type, coroutine_handle, awaiters и их контракт. На протяжении лекции мы будем постепенно строить собственные корутинные абстракции -- несколько наивные, но полезные в образовательных целях. Когда основы станут ясны, мы обсудим более сложные вещи, например то, как через awaiters можно реализовать более сложные механизмы -- подписку на событие и пробуждение нескольких корутин на едином объекте синхронизации. Также мы кратко обсудим оператор co_await и возможности для его перегрузки.

00:00 Introduction. Программы, подпрограммы и thread routines.
10:11 Сопрограммы и их классификация. Stackful- и stackless-сопрограммы в C++.
15:41 Генераторы в Python и C++23.
22:10 Внутреннее устройство и строительные блоки сопрограмм. Ко-операторы.
27:25 Интерфейс promise_type и Hello World.
36:50 Напишем свой простой генератор.
45:00 Range-based-использование и когенерация.
50:40 Детали работы ко-операторов. Awaiters.
56:23 Case study: подписка на результат.
01:05:42 Оператор co_await, завершение и список литературы.

#cpp_postgraduate

Минутка 3d-моделей.

Ребята из Iridi прислали исходники Крыса Кейта (Кита?) с обложки моей книги.

Выложил на boosty в бесплатный доступ чисто чтобы хранить поближе к собственно книжке.

https://boosty.to/cpp_lects_rus/posts/7f9999a9-4249-4538-9ddb-40b9338fe40f

#boosty #cppbook

Всем привет. Кто идёт на C++ Russia из моих уважаемых подписчиков, обратите пожалуйста внимание на изменения в программе, внесённые в последний момент.

https://cppconf.ru/schedule/table/#day-2

Теперь мой доклад открывает конференцию в субботу утром, а Антон Полухин закрывает в воскресенье вечером (ранее было наоборот).

Поэтому, если вы хотите попасть на мой доклад, вам надо будет встать утром в субботу и не опоздать к получению бейджа. Я в вас верю ))

#official

Выложил вторую лекцию по корутинам на английском языке.

https://youtu.be/huitkyM1UQE

Во второй лекции мы переходим от базовой механики co_await и promise_type к более сложным и практическим аспектам программирования с использованием корутин в C++20/23. Сначала мы обсудим симметричные корутины, различные варианты await_suspend и то, как корутины могут напрямую передавать управление друг другу. Затем, на примере корутинной реализации конечных автоматов, разберём, как с помощью awaiters можно строить довольно сложные модели выполнения. Важной частью лекции является обсуждение взаимодействия корутин с потоками на примере многопоточной подписки на события. Мы разберём, почему встроенные (stackless) корутины могут продолжать выполнение на другом потоке, как устроен фрейм корутины и почему это создаёт сложности для оптимизаций в компиляторах. Также мы рассмотрим корутины как основу для композиции асинхронных вычислений и увидим, как корутины позволяют писать существенно более читаемый асинхронный код по сравнению с callback-based подходами. В завершение разберём внутреннее устройство корутин в компиляторах: фреймы корутин, порождаемые конечные автоматы и даже генерируемый ассемблер.

00:00 Введение. Вспоминаем пройденное.
04:38 Обобщаем awaitable transformations: что, кроме перегрузки co_await, нам доступно?
13:09 Изобретаем симметричные корутины в C++: await_suspend и его механика.
18:42 Case study: конечные автоматы на корутинах.
31:00 Монадические свойства co_await.
37:55 Сочетание корутин с потоками. Многопоточная подписка на события и её сюрпризы.
48:00 Корутинный интерфейс для std::future.
52:05 Корутины как механизм композиции асинхронных задач.
56:18 Внутреннее устройство корутин и их реализация в компиляторах.
01:02:04 Обзор литературы и завершение.

#cpp_postgraduate

Отличный реакт и канал интересный.

Не могу не поделиться самым веселым, на мой взгляд, примером из доклада великолепного Константина Владимирова. Он делал анонс доклада в своем tg канале.

Пример вот такой:

template <auto T = []{}> 
struct S {};

S a; S b;

В чем тут цимес. У нас T - это лямбда. И если мы таким образом определяем переменные, то в тип S записываются разные лямбды, и у нас получаются два разных типа:

static_assert(
    !std::is_same_v<decltype(a), decltype (b)>
);

Если же мы явно укажем пустые треугольные скобки вот так:

S<> a, b;

static_assert(
    std::is_same_v<decltype(a), decltype (b)>
);

То типы, внезапно, станут одинаковыми. Ну, мы один раз объявили тип, и две переменные этого типа.


А теперь вопрос в зал. А что если мы определим эти две переменные точно так же, как во втором варианте, но только без явного указания треугольных скобок?

S a, b;

Давайте вы попробуете угадать?

Ставя треугольные скобки мы исключаем вывод типов. Мы явно указываем, какой тип мы используем.
Но если у нас есть вывод типов, у нас компиляторы начинают вести себя по-разному.

clang падает с ошибкой

```
error: template arguments deduced as 'S<(lambda at <source>:4:20){}>' in declaration of 'a' and deduced as 'S<(lambda at <source>:4:20){}>' in declaration of 'b'
7 | S a, b;
```


А gcc считает, что это два разных типа.

```
static_assert(
!std::is_same_v<decltype(a), decltype (b)>
);
```

Пруф.


Вцелом доклад Константина был просто прекрасным, и я, наверное, понатырю сюда еще примеров из его доклада через пару месяцев. А когда он выйдет в открытый доступ - обязательно дам ссылку. Я был просто в восторге от дурки, которую он показывал.

Выложил лекцию по GPGPU и SYCL на английском языке.

https://youtu.be/Ebj21eXDRDY

В этой лекции мы обсудим, почему модель программирования для графики и гетерогенных вычислений исторически отличается от обычного C++. Начнём с классических шейдерных языков, stateful memory, binding tables и адресных пространств, а затем перейдём к OpenCL и проблемам separate-source compute API. После этого разберём основы SYCL как примера single-source подхода к гетерогенному программированию, познакомимся с устройствами и очередями, а также с моделью исполнения SIMT. На примерах сложения векторов и перемножения матриц посмотрим, как часть работы отправляется на устройство и как SYCL описывает зависимости между вычислениями. Основная часть лекции посвящена памяти и синхронизации. Мы постепенно оптимизируем перемножение матриц и разбираем, как на производительность влияют разные виды памяти, tiled execution, барьеры и specialization constants. Затем обсудим гистограмму как пример конкурентного доступа к данным и поговорим об атомиках в GPU API. В финале вернёмся к C++ и обсудим природу указателей, а также generic address space в SYCL. На протяжении всей лекции нас будет сопровождать большое количество замеров производительности.

Timeline.
00:00 Введение. Гетерогенные вычисления и GPU как execution model.
03:50 Память в классических шейдерных языках на примере GLSL: stateful и stateless pointers.
10:35 Первые compute API с раздельными исходниками на примере OpenCL. Проблема небезопасности типов в API.
15:40 На пути к единому compute API: как расширять C++ для гетерогенного программирования?
19:34 Основы SYCL: очереди, command groups, iteration space и vector addition.
29:15 Перемножение матриц -- основная задача GPGPU.
35:28 Более интересное управление памятью: shared memory, device memory и снова аллокаторы.
40:25 Продолжаем умножать матрицы: приватная память, oneMKL и первые замеры.
45:15 Локальная память и барьеры. Инверсия параллелизма внутри рабочей группы.
52:52 Улучшаем перемножение матриц: tiled multiplication, specialization constants и ещё немного замеров.
59:52 Конкурентный доступ к данным: гистограмма, атомики и memory model в GPU API.
01:09:53 Обсуждение природы указателей, generic address space в SYCL, hierarchical parallelism и завершение лекции.

#cpp_postgraduate

В этом июле где то в 10-х числах у меня есть шанс побывать на Дальнем Востоке (Владивосток, возможно Находка). Просьба местных обозначиться в чате или у меня в лс и сказать (1) есть ли заинтересованность, (2) когда и где лучше устроить встречу с читателями и (3) можете ли вы помочь с организацией.

#author_event

Выложил лекцию по std::execution на английском языке. Это последняя, 28-я лекция англоязычного магистерского курса.

https://youtu.be/ZMcUTZppCAw

Финальная лекция магистерского курса по C++ посвящена std::execution -- новой модели исполнения, которая входит в C++26. Мы начнём с давно известных механизмов: параллельных алгоритмов стандартной библиотеки, ручного запуска потоков и std::async. На примере параллельного reduce посмотрим, почему этих средств быстро становится недостаточно, если хочется не просто запустить несколько потоков, но также аккуратно описывать и комбинировать вычисления. После этого перейдём к senders/receivers: разберём, что такое scheduler, sender, receiver и operation state, как работают адапторы и как вычисление может переходить между разными execution resources. Свяжем эту тему с миром GPGPU через bulk-вычисления, посмотрим на рекурсивное порождение асинхронных задач через execution scopes и обсудим разные варианты завершения вычислений. В конце поговорим о связи std::execution с корутинами, отмене задач через environment и ещё раз соберём общую картину: как C++26 предлагает описывать асинхронное и параллельное исполнение без ручного управления потоками.

Timeline
00:00 Введение. Параллельные алгоритмы в стандартной библиотеке.
03:30 Пишем собственный параллельный reduce.
10:05 std::async и его особенности. Замеры производительности.
16:50 Единая абстракция исполнения. Основы std::execution в C++26.
26:59 Концепт sender и адапторы.
35:00 Монадическая природа вычислений и let_value.
40:16 Адаптор bulk: снова заходим в мир GPGPU.
46:05 Параллельный reduce с использованием std::execution.
49:40 Execution scopes: динамическое создание задач. Параллельная сортировка.
54:41 Каналы в sender. Поведение upon_error и upon_stopped. Сигнатуры завершения.
01:02:19 Проверка completion signatures: упражнение в метапрограммировании и рефлексии.
01:06:50 Связь сендеров с корутинами: execution::task.
01:14:40 Снова многопоточная подписка и отмена задач.
01:18:47 Основные концепции ещё раз, список литературы и завершение.

#cpp_postgraduate