Как игровой движок распределяет тысячи корутин между потоками?

В статье разбирают shuttle_async, экспериментальный планировщик задач для Vulkan-движка ShuttleEngine. Автор показывает, как локальные очереди и work stealing помогают распределять работу между потоками.

В статье разбирают:
• как устроены локальные деки Chase-Lev и кража задач
• зачем корутинам нужен диспетчер и structured concurrency
• как устроены три режима запуска задач
• что показали замеры на малых, больших и неравномерных задачах

Результаты относятся к конкретному проекту и тестовой машине.

Продолжай читать на Habr!

📣 C++ Ready | #статья

Знаете, почему optional.value_or может выполнить лишнюю работу?

Аргументы функции вычисляются до её вызова. Поэтому fallback внутри value_or запустится даже тогда, когда optional уже содержит значение.

Например, результат загрузки может не понадобиться:

auto name = cachedName.value_or(
    loadNameFromDisk());

Здесь loadNameFromDisk вызывается заранее, а не только при пустом cachedName. Для чтения файла, запроса к базе или построения объекта это лишняя работа.

Если запасное значение дорого получать, проверяем optional отдельно:

auto name = cachedName
    ? *cachedName
    : loadNameFromDisk();

Условный оператор вычисляет только выбранную ветку. Поэтому загрузка выполняется лишь при отсутствии готового значения.

Для дешёвого значения value_or остаётся коротким и удобным:

auto port = configuredPort.value_or(8080);

Ленивое вычисление лучше выражать условием или отдельной функцией.

📣 C++ Ready | #совет

Объединяем пересекающиеся интервалы на C++!

Дан список занятых временных интервалов. Нужно объединить пересекающиеся и соприкасающиеся отрезки.

Представляем каждый интервал парой начала и конца. Считаем границы полуоткрытыми, поэтому отрезки [2, 5) и [5, 7) тоже объединяются:

#include <algorithm>
#include <utility>
#include <vector>

using Interval = std::pair<int, int>;
std::vector<Interval> busy{
    {1, 3}, {2, 5}, {8, 10}, {10, 12}
};

Сначала сортируем пары по началу, а при равенстве по концу. После сортировки каждый следующий интервал можно сравнить только с последним результатом:

std::sort(busy.begin(), busy.end());
std::vector<Interval> merged;

Если новый интервал начинается позже конца последнего, добавляем его отдельно. Иначе расширяем конец уже собранного интервала до максимальной границы:

for (const auto& current : busy) {
    if (merged.empty() ||
        merged.back().second < current.first) {
        merged.push_back(current);
    } else {
        merged.back().second = std::max(
            merged.back().second, current.second);
    }
}

Строгое сравнение оставляет соприкасающиеся интервалы в одной группе. Для полуоткрытых границ результат примера будет таким:

[1, 5) [8, 12)

После сортировки алгоритм делает один проход и работает за O(n log n), где основное время уходит на сортировку.

📣 C++ Ready | #практика

Порядок создания объекта в C++!

Схема показывает, что память под объект выделяется до запуска конструктора. Затем создаются поля класса, и только после этого выполняется тело конструктора.

Сохрани, чтобы не потерять!

📣 C++ Ready | #ресурс

Схема протокола acquire-release в C++!

Release-store и acquire-load помогают одному потоку опубликовать подготовленные данные, а другому безопасно увидеть их после сигнала готовности. Синхронизация возникает, когда acquire-load получает значение от release-store того же atomic-объекта.

На картинке показаны оба потока, общий флаг x и порядок операций до и после передачи сигнала. Подпись отдельно подчёркивает важное условие. Обе операции должны использовать один и тот же atomic-флаг.

📣 C++ Ready | #совет

Знали, что ключ в std::map можно переименовать без пересоздания узла?

Ключи внутри map нельзя менять напрямую, потому что контейнер поддерживает порядок элементов. Начиная с C++17 элемент можно временно извлечь как node handle, изменить его ключ и вставить обратно без копирования хранимого значения.

Сначала извлекаем элемент и проверяем, что он найден:

auto node = users.extract(oldKey);
if (node.empty()) return;

Пустой node handle означает, что такого ключа в контейнере не было. Пока узел извлечён, он не участвует в сортировке map, поэтому ключ можно изменить:

auto oldKey = node.key();
node.key() = newKey;

Сам объект и его mapped value остаются внутри узла. Это полезно, когда значение дорого копировать или оно не копируется вовсе:

auto& profile = node.mapped();
profile.lastSeen = now;

Теперь пробуем вернуть узел и проверяем результат, потому что newKey мог уже появиться в map:

auto result = users.insert(std::move(node));
if (result.inserted) {
    std::cout << "renamed\n";
}

При конфликте запись не теряется, она остаётся в result.node. Можно восстановить старый ключ и вернуть её в контейнер:

if (!result.inserted) {
    result.node.key() = oldKey;
    users.insert(std::move(result.node));
}

Успешная вставка возвращает тот же узел без пересоздания значения. Такой приём удобен для переименования ключей, если важно сохранить объект и явно обработать возможный конфликт.

📣 C++ Ready | #совет

Почему компаратор с <= может сломать std::sort?

При сортировке чисел по возрастанию хочется написать сравнение так:

std::sort(values.begin(), values.end(),
          [](int a, int b) { return a <= b; });

Проблема проявляется, когда в диапазоне есть одинаковые значения. Для двух равных чисел компаратор возвращает true, хотя ни одно из них не должно стоять раньше другого.

Проверим самую простую ситуацию:

auto lessOrEqual = [](int a, int b) { return a <= b; };
std::cout << lessOrEqual(5, 5);

Результат равен 1. Но std::sort требует строгий слабый порядок, элемент не может быть меньше самого себя. Использование такого компаратора нарушает требования алгоритма.

Правильный вариант для возрастания использует строгое сравнение:

std::sort(values.begin(), values.end(),
          [](int a, int b) { return a < b; });

Если у объектов несколько полей, добавь запасной критерий. Например, при одинаковом приоритете можно сравнить id:

if (a.priority != b.priority) return a.priority < b.priority;
return a.id < b.id;

Так порядок будет предсказуемым и для равных приоритетов. Если же требуется сохранить исходный порядок равных элементов, используй std::stable_sort с корректным строгим компаратором, а не заменяй < на <=.

📣 C++ Ready | #совет

Gemini Pro на 24 месяца за 800₽!

Вместо 39.000₽ — всего 800₽ ($9.9) за 2 года. По акции сейчас это 33₽ в месяц, в 48 раз выгоднее!

➡Argon 4.0 + Claude Opus 5.5 — для кода
➡Nano Banana 2 Pro — для картинок
➡Генерация видео — ролики и анимации
➡AntiGravity + 5 ТБ облака
➡Opus 5.5 и Sonnet 5.5
➡Youtube Premium

Акция ограничена по времени, дальше будет официальная цена 480$!

Приобрести можно в Магазине с 20.000+ покупок и 2000+ отзывов (есть возвраты и замены).

Объединяем две хронологии событий без повторной сортировки!

Представим, что приложение получило события из двух источников. Каждый источник уже отсортировал свои записи по времени. Чтобы получить общую хронологию, не нужно складывать всё вместе и сортировать заново, два упорядоченных диапазона можно слить.

Опишем событие и подготовим два входных списка. Внутри каждого время должно идти по возрастанию:

struct Event {
    int time;
    std::string message;
};

std::vector<Event> app = {{10, "start"}, {30, "save"}};
std::vector<Event> worker = {{20, "job"}, {40, "done"}};

Заранее выделим место под все записи. Это не меняет размер вектора, но избавляет его от лишнего расширения при добавлении элементов:

std::vector<Event> timeline;
timeline.reserve(app.size() + worker.size());

Теперь используем std::ranges::merge. Проекции сообщают алгоритму, что сравнивать нужно поле time, а не весь объект:

std::ranges::merge(app, worker, std::back_inserter(timeline),
                   {}, &Event::time, &Event::time);

Результат будет идти в порядке 10, 20, 30, 40. Если времена совпадут, алгоритм сохранит порядок элементов внутри каждого исходного списка. Записи с одинаковым временем не исчезают, merge переносит их все.

Проверим результат обычным обходом:

for (const Event& event : timeline) {
    std::cout << event.time << " " << event.message << '\n';
}

Слияние работает за время, пропорциональное сумме длин списков, и удобно для логов, событий и результатов нескольких запросов.

📣 C++ Ready | #практика