is_awaitable

SPL
Дополним предыдущий пример:

• Вызываем функцию tick;
  
• Находим нужную перегрузку оператора co_await и создаем объект Awaitable, передаем в конструктор временной интервал в 1 секунду;
  
• Вызываем метод await_ready, проверяем необходимо ли ожидание;
  
• Приостанавливаем работу функции tick, сохраняем состояние;
  
• Вызываем метод await_suspend и передаем дескриптор сопрограммы;
  
• Метод await_suspend инициирует асинхронную операцию timer::async, которая ожидает заданное время и вызывает переданный callback. Предаем в callback дескриптор сопрограммы чтобы после ожидания передать ей управление;
  
• Передаем управление вызывающей стороне — функции main;
  
• Функция main вызывает метод стандартного потока ввода get, это синхронная операция, ожидающая ввода. Мы висим, чтобы просто дать завершится инициированным асинхронным операциям;
  
• Ждем одну секунду, асинхронная операция вызывает переданный нами callback, вызов осуществляется в том же потоке, в котором происходило ожидание;
  
• Вызываем метод resume у дескриптора. Метод передает управление сопрограмме: вызывается функция tick на стеке потока, восстанавливаем сохраненное во фрейме состояние, управление передается в точку последней остановки;
  
• Вызывается метод await_resume у объекта Avaitable, созданного при вызове оператора co_await и сохраненного во фрейме;
  
• Метода await_resume ничего не делает и не возвращает результата, оператор co_await завершает свою работу и передает управление, следующей за ним команде;
  
• Функция tick выводит сообщение на экран с помощью стандартного потока вывода "1...";
  
• Вызов следующего оператора co_await. Выполняем все шаги начиная с пункта 2. Отличие только в том, что управление возвращается не функции main, a асинхронной операции, которая вызвала наш callback, т.е. resumer'у. После это асинхронная операция завершает свое выполнение;
  
• Сопрограмма tick завершает свое выполнение (более детально этот процесс мы рассмотрим ниже)

После того как мы определили интерфейс и семантику оператора co_await и типа Awaitable, мы можем вернутся к более детальному изучению типа Promise и настройке сопрограммы.
Promise.
Также как и в случае с Awaitable, чтобы понять роль объекта Promise мы начнем с кода, который генерирует компилятор в процессе обработки сопрограммы
Генерируемый код можно разделить на три часть:

• Создание и инициализация кадра сопрограммы. Инициация выполнения сопрограммы. Т.е. это код который выполняется при первом вызове сопрограммы;
  
• Описание стейт-машины согласно пользовательским запросам передачи управления (вызовы операторов co_awat/co_yield/co_return). Это код, который выполняется при передаче управления сопрограмме т.е. при первом вызове и при возобновление работы;
  
• Завершение выполнения, освобождение ресурсов и удаление кадра. Код выполняется при естественном завершение или принудительном удаление.

Мы упоминали выше что тип Promise участвует в разрешение перегрузки операторов new и delete. Например, при таком определение, будут вызваны пользовательские операторы new и delete:

Более того у нас есть возможность добавить перегрузку оператора new c дополнительными аргументами, набор параметров должен быть согласован с параметрами функции. Это позволяет использовать, например, стандартные механизмы такие как leading-allocator convention.

Независимо от того, перегрузим мы операторы new и delete или нет, компилятор может избавиться от динамического размещения кадра и сохранить состояние на стеке вызывающей стороны.
Следующим шагом мы сохраняем аргументы сопрограммы во фрейм. Здесь есть несколько важных замечаний.
Во-первых нам следует быть крайне осторожными с передачей ссылок. Важно понимать, что сопрограмма ни как не меняет время жизни переданных аргументов, сохраняя ссылочную семантику, но при этом время жизни кадра сопрограммы отличается от стекового кадра обычной функции. Следующий, казалось бы простой пример, в случае со сопрограммой, является случаем Undefined Behavior.

Второе замечание касается порядка сохранения аргументов и создания объекта типа Promise. Нужно иметь ввиду что все дальнейшее оперирование с аргументами в теле сопрограммы осуществляется с копиями аргументов, сохраненных в кадре сопрограммы, поэтому мы сначала сохраняем аргументы, а потом создаем объект типа Promise и вызываем (если нашли) соответствующим перегруженный конструктор, в конструктор передаем именно скопированные аргументы, а не изначальные объекты. Это позволяет сохранить естественное восприятие потока управления и избежать неприятных эффектов, если Promise в конструкторе сохранил ссылку на какой-нибудь аргумент, тогда объект, на который мы будем ссылаться из Promise, будет существовать на протяжение всего времени жизни кадра сопрограммы.
Далее мы обращаемся к объекту типа Promise и вызываем метод get_return_object. Создаваемый объект не обязательно должен в точности соответствовать типу возвращаемого результата, по необходимости и возможности может быть выполнено неявное преобразование. В стандарте нет требования в какой момент выполнять неявное преобразование: в момент создания объекта и вызова get_return_object или в момент возвращения вызываемой стороне. Это важно, например, если мы используем какие-то операции с побочными эффектами, реализуя императивную последовательность выполнения. Пример эксплуатации такого преобразования Мonadic composition.

Мы уже встречали тип std::coroutine_handle — эти дескриптор сопрограммы, обеспечивает низкоуровневую функциональность оперирования сопрограммой: передача управления (возобновление выполнения) и удаление. Статический метод from_promise, позволяет получить дескриптор сопрограммы по объекту Promise.
В заключение мы вызываем функцию couroutine_states и передаем управление стейт-машине, после того как функция couroutine_states вернет управление, приостановив или завершив выполнение сопрограммы, мы возвращаем ранее созданный методом get_return_object объект вызывающей стороне.
State Machine.
Функции couroutine_states описание стейт-машину согласно пользовательскому набору вызовов операторов co_awat/co_yield/co_return и вызывается автоматически при передаче управления сопрограмме: при первом вызове или при возобновление работы, вызовом метода дескриптора resume. Указатель на функцию сохранен в кадре сопрограммы.

Если вернутся к коду, который генерируется вызовом оператора co_await, то можно заметить метку resume_point — точка пробуждения.

Для каждого вызова оператора co_await в служебном или пользовательском коде генерируется уникальная метка — порядковый номер оператора co_await, этот номер так же идентифицирует текущие состояние сопрограммы и сохраняется в кадре в поле state, перед передачей управления вызывающей стороне. И первое что мы делаем при вызове — это смотрим на текущее состояние, безусловно переходим к соответствующей ветке, возобновляем работу и завершаем вызов оператора co_await в пользовательском коде.
При первом вызове сопрограммы состояние не будет задано и мы перейдем к вызову метода initial_suspend с последующей передачей результата оператору co_await. Задача этого вызова определить: следует ли начать выполнение пользовательского кода немедленно или выполнение должно быть отложено. Стандарт предоставляет два тривиальных типа реализующих концепцию Avaitable: std::suspend_never, std::suspend_always, которые упрощают реализацию метода initial_suspend, позволяя реализовать две наиболее распространенных модели поведения.

Далее следует выполнение пользовательского кода. Если включена поддержка исключений, то пользовательский код заключается в блок try-catch с вызовом метода unhandled_exception в случае возбуждения исключения.
В пользовательском коде, помимо оператора co_await, могут встречаться операторы co_yield и co_return. Эти операторы позволяют передавать вызываемой стороне промежуточный или конечный результат выполнения сопрограммы. Передача результат осуществляется средствами объекта Promise, но с разной семантикой.
Оператор co_yield <expr> эквивалентен вызову:

Т.е. оператор позволяет сохранить промежуточный результат в объекте Promise и вернуть управление вызывающей стороне для дальнейшей манипуляции полученными данными. Типичная реализация метода yield_value выглядит так:

Пользовательский тип Task может реализовывать разные стратегии получения доступа к сохраненным в объекте Promise значениям. Один из наиболее выразительных вариантов использования семантики оператора coyield — это [генераторы](https://en.wikipedia.org/wiki/Generator(computer_programming)). Пример генератора из библиотеки cppcoro
В свою очередь оператор co_return в контексте пользовательского кода обладает такой же семантикой как и оператор return. Позволяет принудительно завершить выполнение и вернуть результат вызывающей стороне.

• Вызов co_rеturn без операндов эквивалентен:
  
  // co_return;
  frame->promise.return_void();
  goto final_suspend;
  
  
• Если тип результат вычисления выражения, переданного оператору в качестве аргумента, отличен от void, то вызов co_rеturn эквивалентен следующему коду
  
  // co_return <expr>;
  promise.return_value(<expr>);
  goto final_suspend;
  
  
• Если же тип результата вычисления выражения void, то вызов генерирует следующий код
  
  // co_return <expr>;
  <expr>;
  promise.return_void();
  goto final_suspend;
  
  

Важно, если в пользовательском коде нет операторов co_return, то в конце тела функции генерируется вызов оператора без аргументов co_return;. Т.е. выражение frame->promise.return_void() должно быть валидно.
После передачи результата вычислений в Promise через вызов методов return_value или return_void мы завершаем выполнение пользовательского кода и переходим к служебному вызову final_suspend.
В противовес методу initial_suspend, вызов метода final_suspend позволяет настроить поведение сопрограммы в момент завершения своего выполнения. Задача вызова дать возможность пользователю обработать и опубликовать результат выполнения, сигнализировать о завершение вычислений или передать выполнение другой сопрограмме.

Мы рассмотрели все случаи использования оператора co_await как в пользовательском так и в служебном коде. Он вызывается с результатами вызова init_suspend и final_suspent, приостанавливает работу сопрограммы в случае вызова оператора co_yeild, может быть вызван в пользовательском коде с произвольным выражением. У последнего использования есть одна особенность. Если тип Promise определяет метод await_transform, то любой вызов оператора co_await в пользовательском коде транслируется в вызов

Это достаточно мощный инструмент, например, помимо вызова оператора co_await с типами, которые не поддерживают концепцию Avaitable, мы можем запрещать использование или менять поведение уже определенных сущностей. Например можно запретив прямые вызовы оператора co_await в генераторе.

Вместо заключения
Примеры кода:

• cppcoro. Библиотека примитивов асинхронной и кооперативной композиции построенная на сопрограммах Coroutine TS;
  
• folly. Реализована экспериментальная поддержка стандартных сопрограмм;

Возможное дальнейшее развитие:

• Coroutines TS Simplifications;
  
• Revisiting allocator model for coroutine;

Ссылки:

• Working Draft, Standard for Programming Language C++ (N4830);
  
• Coroutine TS (N4760);
  
• First-class symmetric coroutines in C++;
  
• Core Coroutines;
  
• Low-level API for stackful coroutines;
  
• A low-level API for stackful context switching;
  
• Coroutines: Use-cases and Trade-offs;
  
• Revisiting Coroutines;
  
• Stackful Coroutines and Stackless Resumable Functions;
  
• Resumable Functions;
  
• Resumable Expressions;
  
• Coroutines in LLVM;
  
• Boost Coroutine2;

Буду рад комментариям и предложениям (можно по почте yegorov.alex@gmail.com)
Спасибо!
===========
Источник:
habr.com
===========
Похожие новости:

• [Программирование, Конференции, Научно-популярное] Core Dump — видео канал о компьютерной науке
  
• [Карьера в IT-индустрии, Программирование] Украденное резюме, человек, который ушел в Кемерово, призыв кандидата и другие «увлекательные» истории трэш-собеседовани
  
• [Swift, Программирование, Разработка мобильных приложений, Разработка под iOS] Виджеты в iOS 14 – возможности и ограничения
  
• [Программирование, Разработка под iOS, Разработка мобильных приложений] Формальные грамматики на службе мобильного клиента
  
• [FPGA, Высокая производительность, Искусственный интеллект, Конференции, Программирование микроконтроллеров] Бывший вице-президент Sun, MIPS и DEC прокомметировал покупку компании ARM компанией NVidia
  
• [Java, Open source, Анализ и проектирование систем, Программирование] Добавляем ORM в проект за четыре шага
  
• [Алгоритмы, Программирование, Спортивное программирование, Хакатоны] Программирование как вид спорта: что делать, чтобы побеждать на соревнованиях
  
• [Lua, Программирование] Транслитерация русского текста для отправки сообщений в Телеграмм из Микротик РоутерОС
  
• [JavaScript, Node.JS, Программирование, Разработка веб-сайтов] Web Cryptography API: пример использования
  
• [Карьера в IT-индустрии, Программирование, Учебный процесс в IT] «Раньше я не представлял лекции в МГУ по Zoom». Интервью с преподавателем Техносферы

Теги для поиска: #_c++, #_programmirovanie (Программирование), #_s++ (С++), #_c++20, #_coroutines, #_c++, #_programmirovanie (
Программирование
)