Зафиксировал первую альфа-версию SObjectizer-5.8.7 с поддержкой C++20 короутин.
В ней, вроде как, заработало все, что хотелось иметь в качестве базовой базы (т.е. самый минимум, без которого не обойтись). Остальное, если будут какие-то дополнительные идеи и возможность их реализовать, появится в последующих версиях (т.е. в 5.8.8, 5.8.9 и т.д.).
В дополнение к этому в сопутствующем проекте so5extra стартовала ветка по адаптации so5extra к обновленному SO-5. Версия so5extra из этой ветки с альфой SO-5.8.7 уже собирается и проходит все тесты.
Текущие работы по SO-5.8.7 идут в ветке 5.8-dev-5.8.7.
Текущие работы по so5extra-1.6.5 идут в ветке 1.6-dev-1.6.5-with-so-5.8.7.
Ближайшие планы:
- внедрить в некоторые части so5extra поддержку асинхронности. В первую очередь в компонент so_5::extra::sync, чтобы можно было делать co_await для синхронного обращения к другому агенту. Возможно, интеграция с короутинами в asio-диспетчерах (но это не точно);
- обновить Wiki проектов SObjectizer и so5extra с описанием новых возможностей;
- после этого синхронно зарелизить SO-5.8.7 и so5extra-1.6.5.
По срокам никаких предсказаний делать не хочу, но если получится уместить все это хотя бы в две недели, то будет здорово.
Теперь о том, что же получилось в SO-5.8.7.
Совместимость с предыдущими версиями SO-5.8
SO-5.8.7 требует C++20 и не может быть скомпилирован в режиме C++17. Это слом совместимости с предшествующими версиями. Но, я надеюсь, что сейчас SO-5 используется, в основном, в проектах на С++20 или свежее. Если кто-то все еще сидит на C++17, то обновляться на 5.8.7 нет смысла, т.к. какой-либо другой функциональности, кроме поддержки C++20 короутин, в новой версии нет.
В остальном, очень надеюсь, ничего не поломалось. Т.е. если вы уже на C++20 или C++23, то достаточно будет просто перекомпилировать код. Если, конечно, вы не обращались к каким-либо низкоуровневым деталям SO-5 напрямую.
О том, почему было принято решение делать 5.8.7, а не 5.9.0, я расписывал здесь. В двух словах -- ветку 5.9 хочется оставить для совсем уж все ломающих изменений. Например, при переходе с заголовочных файлов на модули. Но если кому-то очень сильно не нравится то, что поддержка короутин появилась именно в ветке 5.8 с необходимостью принудительной смены стандарта с C++17 на C++20, то поделитесь своей болью. Пока еще есть возможность отказаться от 5.8.7 в пользу 5.9.0 (призрачная, конечно же, возможность, но пока еще она есть).
Новое пространство имен so_5::cpp_coro
Практически все, что относится к C++20 короутинам, живет в пространстве имен cpp_coro. Практически все из того, что там живет, становится доступно для использования после подключения заголовочного файла so_5/all.hpp.
В частности, в so_5::cpp_coro живет тип task_t<T> который должен использоваться теми короутинами которые хотят работать под управлением и контролем SO-5.
Имя cpp_coro может выглядеть недостаточно удачным. Наверное, таким оно и является. На GitHub-е открыто отдельное обсуждение, так что если у кого-то есть более удобное имя, то можно написать туда, а я постараюсь прислушаться к вашему голосу.
Понятие scheduler-ов для короутин
Важным требованием к короутинам со стороны SO-5 является возобновление короутины на правильном контексте.
SObjectizer гарантирует агентам, что когда агент привязан к конкретному диспетчеру, то event-handler-ы данного агента будут выполняться только на контексте этого диспетчера.
Такие же гарантии должны распространяться и на короутины: если какой-то агент запускает в своем асинхронном event-handler-е короутину, то после завершения co_await приостановленный event-handler должен проснуться на контексте того же диспетчера, к которому привязан агент.
Для этого введено новое понятие scheduler в виде интерфейса scheduler_t, живущего в пространстве имен so_5::cpp_coro. Можно сказать, что scheduler для короутин играет ту же роль, что и dispatcher для агентов.
Для агентов scheduler короутин предоставляется автоматически. Если хочется использовать короутины без агентов, то о создании scheduler-а придется позаботиться самостоятельно. Например, можно воспользоваться готовым классом this_thread_scheduler_t, который привязывает короутины к текущей рабочей нити.
Текущий scheduler
Чтобы запустить связанную с короутинами операцию (например, асинхронный вариант select-а), требуется назначить текущий scheduler. Например, это может выглядеть следующим образом:
|
so_5::wrapped_env_t sobj; so_5::cpp_coro::this_thread_scheduler_t scheduler{ sobj.environment() }; so_5::cpp_coro::current_scheduler_setter_t current_scheduler{ scheduler }; |
Здесь мы сперва создаем экземпляр this_thread_scheduler, затем назначаем его текущим для данной рабочей нити. Этот экземпляр будет оставаться текущим до тех пор пока живет current_scheduler_setter_t.
Когда текущий scheduler назначен, мы можем спокойно обращаться, например, к асинхронному select-у.
Для агентов нет необходимости устанавливать текущий scheduler вручную. Это делает сам SObjectizer. Поэтому в асинхронном событии агента можно просто вызывать асинхронный select без использования current_scheduler_setter.
Асинхронный select для mchain-ов
Асинхронный select является близнецом обычного синхронного select-а, но живет в пространстве имен so_5::cpp_coro. Главное отличие в том, что асинхронный select может работать с асинхронными message-handler-ами в receive_case:
|
so_5::from_all().handle_n(1), so_5::receive_case(some_channel, // Обычный синхронный обработчик входящего сообщения. [](so_5::mhood_t<first_msg> cmd) {...}, // Асинхронный обработчик входящего сообщения. [](so_5::mhood_t<second_msg> cmd) -> so_5::cpp_coro::task_t<void> {...})); |
Внутри асинхронного обработчика можно запускать другие короутины. Например, можно вызвать еще один асинхронный select:
|
co_await so_5::cpp_coro::select( so_5::from_all().handle_n(1), so_5::receive_case(some_channel, // Обычный синхронный обработчик входящего сообщения. [](so_5::mhood_t<first_msg> cmd) {...}, // Асинхронный обработчик входящего сообщения. [&](so_5::mhood_t<second_msg> cmd) -> so_5::cpp_coro::task_t<void> { co_await so_5::cpp_coro::select(...); ... })); |
В новом select-е асинхронными могут быть только message-handler-ы для входящих сообщений (т.е. задаваемые в receive_case). Использовать асинхронный обработчик в send_case нельзя -- я пока не вижу в этом никакого смысла. Если кто-то видит, то дайте знать.
Поддержки асинхронного receive в SO-5.8.7 нет
В версии SO-5.8.7 есть только асинхронная версия select-а, но нет асинхронной версии receive.
Не стал возиться с асинхронным receive из-за ограниченности ресурсов. Как по мне, вместо receive запросто можно использовать select.
Если для кого-то очень важно иметь именно асинхронный receive, то дайте знать. При наличии ресурсов к этой теме можно будет вернуться в последующих релизах SO-5.
Кстати говоря, наличие в SO-5 и receive, и select-а -- это следствие поступательного развития SO-5. Сперва получилось придумать реализацию для receive, а вот над select-ом пришлось поломать голову. Поэтому select удалось сделать значительно позже receive. Из-за чего в SO-5 есть обе эти функции, хотя сейчас receive выглядит избыточной.
Короутины и агенты
Поддержка короутин для агентов должна включаться явным образом
По умолчанию агенты не поддерживают С++20 короутины, эту поддержку нужно включать явным образом в конструкторе агента:
|
class my_agent_with_coros : public so_5::agent_t { public: my_agent_with_coros(context_t ctx) : so_5::agent_t{ ctx + so_5::enable_cpp_coro() } |
Без этого магического вызова so_5::enable_cpp_coro агент не сможет делать подписку асинхронных event-handler-ов.
Все дело в том, что для поддержки короутин у агента должны появится дополнительные данные (например, отдельная локальная очередь заявок). Эти специфические для обработки короутин данные ведут с дополнительному расходу памяти и, в некоторых случаях, снижают скорость доставки сообщений для агентов (об этом речь пойдет ниже).
Т.к. поддержка короутин нужна не всем агентам, то нет смысла заставлять всех агентов нести эти дополнительные накладные расходы. Поэтому поддержку короутин приходится включать явным образом.
Асинхронный event-handler у агента должен возвращать so_5::cpp_coro::task_t<void>
По аналогии с тем, как асинхронные message-handler-ы в select-е возвращают so_5::cpp_coro::task_t<void>, у агентов асинхронные event-handler-ы так же должны возвращать so_5::cpp_coro::task_t<void> (это все не спроста, у SO-5 одинаковые паттерны для распознавания асинхронных message- и event-handler-ов).
Подписка асинхронного event-handler-а делается обычным образом, ничего в этом плане не меняется:
|
void my_agent_with_coros::so_define_agent() { so_subscribe_self() // Обработчик в виде метода агента. .event(&my_agent_with_coros::evt_async_event) // Обработчик в виде лямбды. .event([this](mhood_t<some_msg> cmd) -> so_5::cpp_coro::task_t<void> { ... }); ... } so_5::cpp_coro::task_t<void> my_agent_with_coros::evt_async_event( mhood_t<another_msg> cmd) { ... } |
Пока у агента не завершится текущий асинхронный event-handler другие event-handler-ы этого агента не стартуют
По-моему, это вполне логичное поведение -- пока асинхронный обработчик не сделает окончательный co_return, другие события для агента не запускаются.
Например, возьмем агента:
|
class demo : public so_5::agen_t { // Асинхронный обработчик. so_5::cpp_coro::task_t<void> evt_a(msg_a) { co_await ...; } // Синхронные обработчики. void evt_b(msg_b) {...} void evt_c(msg_c) {...} void so_define_agent() override { so_subscribe_self() .event(&demo::evt_a) .event(&demo::evt_b) .event(&demo::evt_c) ; } void so_evt_start() override { so_5::send<msg_a>(*this, ...); so_5::send<msg_b>(*this, ...); so_5::send<msg_c>(*this, ...); } ... }; |
Когда агент стартует, он отошлет сам себе три сообщения: A, B и C. К моменту выхода из so_evt_start в очереди агента будут стоять три заявки.
Первой будет извлечена заявка для сообщения A. Но это асинхронный обработчик, который может приостановить агента на co_await внутри evt_a. Когда агент приостанавливается на co_await, диспетчер получает возможность перейти к обработке других заявок из очереди. Но заявки с сообщениями B и C для агента demo не будут затронуты. Дело до них дойдет только после того, как у агента полностью завершится evt_a.
Как SObjectizer обрабатывает асинхронные event-handler-ы?
Ключевой момент в SO-5.8.7 в том, что диспетчеры ничего не знают про короутины и асинхронные event-handler-ы. Диспетчеры как работали с обычными execution_demand-ами, у которых нужно вызывать синхронный demand_handler, так и работают.
Короутины и всю связанную с этим кухню удалось практически полностью спрятать от диспетчеров. Тем самым существующие диспетчеры получили возможность обрабатывать агентов с асинхронными event-handler-ами ничего не зная о короутинах внутри агента.
Получилось сделать это за счет двух основных трюков.
Автоматическое разделение асинхронного event-handler-а на несколько синхронных demand_handler-ов
Первый трюк в том, что когда пользователь подписывает асинхронный event-handler, то SO-5.8.7 автоматически оборачивает этот event-handler в несколько синхронных обработчиков.
Первый из них стартовый. Именно он вызывается у агента, когда к агенту прилетает сообщение, на которое был подписан асинхронный event-handler. Стартовый синхронный обработчик создает короутину для асинхронного event-handler-а, но в приостановленном состоянии. После чего сохраняет ее внутри агента (это т.н. current-top-level-task).
Соответственно, у агента либо нет current-top-level-task (что значит, что нет запущенных и еще не завершившихся асинхронных event-handler-ов), либо есть current-top-level-task.
Итак, стартовый синхронный обработчик заполняет current-top-level-task для агента. Изначально этот current-top-level-task приостановлен т.к. task_t в SO-5.8.7 реализует ленивый (lazy) старт короутин. Поэтому для current-top-level-task тут же запускается resume. Если после выхода из resume выясняется, что current-top-level-task завершился (т.е. соответствующий std::coroutine_handle::done возвращает true), то SO-5.8.7 считает, что асинхронный event-handler закончил свою работу. После чего current-top-level-task сбрасывается, агент получает возможность обрабатывать другие события.
Если же current-top-level-task не завершился, то SObjectizer переходит к обработке других заявок для других агентов. А этот агент будет считаться приостановленным (или "замороженным") до тех пор, пока для него не прилетит специальная заявка cpp_coro_resume.
Когда же для агента прилетает cpp_coro_resume, то в дело вступает второй специальный синхронный обработчик, который создается SObjectizer-ом для асинхронного event-handler-а. Этот второй обработчик вновь вызывает resume для current-top-level-task агента.
Когда resume завершается, то мы вновь проверяем статус current-top-level-task. Если короутина завершилась, то считаем, что завершился и текущий асинхронный event-handler. После чего current-top-level-task сбрасывается, а агент "размораживается" и получает возможность обрабатывать другие свои заявки.
Если же короутина еще не завершилась, то текущий агент продолжает считаться "замороженным" и ждет следующей заявки cpp_coro_resume.
Локальные очереди заявок для агентов с короутинами
К диспетчеру может быть привязано множество агентов. Часть из этих агентов будут жить на общей рабочей нити (например, как в случае one_thread диспетчера). Когда один из таких агентов "замораживается" в асинхронном event-handler-е, то диспетчер должен иметь возможность продолжить обслуживание других агентов, игнорируя уже имеющиеся заявки для "замороженного" агента.
Для этого агенты, у которых есть асинхронные event-handler-ы, используют собственные локальные очереди заявок. Т.е. когда к агенту прилетает сообщение и формируется execution_demand, то эта заявка сперва ставится в локальную очередь агента.
Если локальная очередь агента была пуста и появилась новая заявка, то диспетчеру агента отсылается специальная wakeup-заявка. Именно wakeup-заявка ждет в очереди диспетчера. Тогда как реальные execution_demand для агента живут в локальной очереди этого агента.
Пока диспетчер не извлек wakeup-заявку, к агенту может прилететь еще несколько заявок. Может получиться так, что в локальной очереди агента ждут 100 реальных execution_demand, тогда как в очереди диспетчера для этого агента хранится всего лишь одна wakeup-заявка.
Когда диспетчер извлекает wakeup-заявку и начинает ее обслуживать, то реальные execution_demand из локальной очереди агента изымаются и обрабатываются одна за одной. Обработка приостанавливается как только у агента образуется незавершенный current-top-level-task. В этом случае обработка wakeup-заявки прерывается и диспетчер может начать обслуживать заявки других агентов.
Если агент оказался "замороженным" из-за незавершенного current-top-level-task, то заявки из локальной очереди агента не извлекаются до тех пор, пока для агента не придет заявка cpp_coro_resume. Эта заявка может рассматриваться как аналог wakeup-заявки. Разница только в том, что wakup-заявки в очередь диспетчера ставит сам агент когда в его пустую локальную очередь прилетает первая актуальная заявка. А cpp_coro_resume в очередь диспетчера ставит связанный с агентом scheduler короутин когда обнаруживает, что current-top-level-task может быть продолжена.
Все event-handler-ы агентов с короутинами рассматриваются как non-thread-safe
Следствием из того, что у агента есть current-top-level-task, является то, что все события агента автоматически становятся non-thread-safe. Даже если агент привязан к adv_thread_pool диспетчеру, даже если он указывает при подписке so_5::thread_safe, все равно все его обработчики событий будут рассматриваться SObjectizer-ом как non-thread-safe.
Поэтому нет смысла привязывать агента с короутинами к adv_thread_pool диспетчеру.
Лимиты для локальной очереди агента
У агента в очереди может скопиться множество заявок прежде чем диспетчер начнет обслуживать wakeup-заявку для этого агента. И когда wakeup-заявка поступит в обработку, то нить диспетчера может оказаться занятой обслуживанием только тех заявок, которые попали в локальную очередь агента.
Чтобы такой "узурпации" не произошло, есть ограничение на количество реальных заявок из локальной очереди агента, которые можно взять в процессе обработки очередной wakeup-заявки. По умолчанию восемь штук. Если восемь заявок извлекли, но локальная очередь заявок все еще не пуста, то диспетчеру ставится новая wakeup-заявка -- обработка локальной очереди продолжится когда диспетчер дойдет до этой новой wakeup-заявки.
Это значение можно настроить при вызове so_5::enable_cpp_coro().
Так же есть общее ограничение на объем локальной очереди агента. По умолчанию это миллион заявок. Если этот объем будет превышен, то приложение будет принудительно убито путем обращения к std::abort.
Это ограничение также можно настроить при вызове so_5::enable_cpp_coro().
Локальная очередь заявок для агента увеличивает накладные расходы на диспетчеризацию заявок для агента
Увы, это так 🙁
Приходится захватывать сперва замок для локальной очереди, затем, вероятно, еще и замок для очереди диспетчера. Что не бесплатно. В некоторых сценариях работы (когда заявки не скапливаются в очереди агента и приходится постоянно выставлять wakeup-заявку) доставка сообщений до агента с короутинами будет обходиться, приблизительно, в два раза дороже, чем до обычных агентов.
Не все диспетчеры поддерживают привязку агентов с короутинами
Диспетчеры не видят короутин потому, что SObjectizer дробит исполнение короутин на отдельные синхронные demand_handler-ы. Однако, сам факт того, что event-handler для агента может быть приостановлен и у диспетчера появляется возможность использовать освободившуюся рабочую нить для обслуживания заявок других агентов, может противоречить назначению диспетчера.
Например, в SO-5 есть prio_one_thread::strictly_ordered диспетчер, который гарантирует, что заявки менее приоритетных агентов пойдут в работу только после того, как закончатся заявки высокоприоритетных агентов.
Т.е. если у агента с высоким приоритетом случилась "заморозка" асинхронного event-handler-а, то prio_one_thread::strictly_ordered диспетчер не имеет права перейти к обслуживанию других заявок. Но в текущей реализации SO-5.8.7 диспетчер даже не знает про существование короутин и про то, что случилась "заморозка" агента. Он просто видит, что очередной синхронный demand_handler закончился, в очереди есть другие заявки, поэтому нужно брать их и запускать для них соответствующие demand_handler-ы.
Чтобы не происходило такого нарушения логики работы диспетчера каждый диспетчер через disp_binder сообщает поддерживает ли он короутины или нет. Для этого в интерфейс disp_binder_t был добавлен новый метод does_support_cpp_coro_suspension. По умолчанию, он возвращает false.
Большинство штатных диспетчеров SO-5 переопределяют этот метод чтобы возвращать true. За исключением prio_one_thread::strictly_ordered. Этот диспетчер, по описанным выше причинам, возвращает false.
Если вы реализовали свой собственный диспетчер, то при переходе на SO-5.8.7 нужно будет разобраться с тем, нарушает ли "заморозка" агентов логику работы вашего диспетчера или нет. Если не нарушает, то в вашу реализацию disp_binder_t нужно будет добавить переопределение does_support_cpp_coro_suspension с возвратом true.
У агента появился новый виртуальный метод so_evt_async_start
Этот метод имеет прототип:
|
so_5::cpp_coro::task_t<void> so_evt_async_start() |
В классе agent_t есть его пустая реализация, которая содержит только co_return.
Этот метод нужен для случаев, когда агент должен стартовать сразу с запуска короутины, чтобы не приходилось делать вот так:
|
class agent_with_async_start : public so_5::agent_t { // Специальный сигнал, чтобы запустить асинхронный event-handler. struct msg_async_start final : public so_5::signal_t {}; ... void so_define_agent() override { so_subscribe_selt().event(&agent_with_async_start::evt_async_start); ... } void so_evt_start() override { ... // Отправляем сигнал, чтобы инициировать запуск асинхронного // event-handler-а. so_5::send<msg_async_start>(*this); ... } ... so_5::cpp_coro::task_t<void> evt_async_start(mhood_t<msg_async_start>) { ... // Вот только сейчас можно делать то, что нам нужно. } }; |
Чтобы не повторять все эти действия снова и снова можно использовать so_evt_async_start:
|
class agent_with_async_start : public so_5::agent_t { ... so_5::cpp_coro::task_t<void> so_evt_async_start() override { ... // Сразу можно делать то, что нам нужно. } }; |
Если у агента включена поддержка C++20 короутин, то so_evt_async_start запускается сразу же после успешного завершения so_evt_start. Фактически, к агенту прилетает всего одна evt_start-заявка, в процессе обработки которой сперва вызывается so_evt_start, а следом -- so_evt_async_start.
Однако, so_evt_async_start не вызывается, если so_evt_start завершается выбросом исключения. В этом случае считается, что агент не смог нормально стартовать (даже если агент использует ignore_exception в качестве exception_reaction), а раз так, то и асинхронный старт ему не нужен.
Примечание. Асинхронного аналога so_evt_finish нет. Что-то мне не приходят в голову сценарии, когда гипотетический so_evt_async_finish был бы нужен. Да и есть очень большие сомнения в реализуемости этого самого асинхронного финиша.
Оборачивание чужих короутин в so_5::cpp_coro::task_t
Предположим, что в асинхронном событии агента мы вынуждены сделать co_await для "чужой" короутины. Что-то вроде:
|
so_5::cpp_coro::task_t<void> my_agent::evt_some(some_msg cmd) { // (0) ... co_await some_3rd_party_lib::async_function(...); // (1) ... // (2) } |
В точке (0) стартует "наша" короутина в виде асинхронного event-handler-а evt_some.
Обращение к сторонней async_function в точке (1) происходит на рабочей нити, которую SO-5 выделил my_agent. Но в async_function короутина evt_some может быть перемещена на другой рабочий контекст, которым владеет и распоряжается some_3rd_party_lib. Соответственно, "наша" короутина может быть "разморожена" на чужом рабочем контексте и в точке (2) мы окажемся совсем не там, где должны были бы (агенты в SO-5 должны работать только на тех диспетчерах, к которым привязаны).
Чтобы обеспечить эту гарантию в so_5::cpp_coro::task_t::promise_type определяется метод await_transform, который проверяет тип Awaiter-а, созданного внутри нашего асинхронного event-handler-а. Если этот Awaiter не имеет отношения к SObjectizer, то создается специальная вспомогательная обёртка.
Задача этой вспомогательной обёртки в том, что когда "чужая" короутина будет разбужена на "чужом" рабочем контексте, наш асинхронный event-handler не был "разморожен" сразу. Вместо этого диспетчеру, к которому привязан наш агент, будет отправлена заявка cpp_coro_resume. Эта заявка будет обработана на правильном контексте, что и позволит "разморозить" событие агента в точке (2) именно на нужном нам диспетчере.
Аналогичная кухня происходит и в асинхронном select-е:
|
co_await so_5::cpp_coro::select(so_5::from_all().handle_n(1), so_5::receive_case(ch, [](some_message cmd) -> so_5::cpp_coro::task_t<void> { // (0) ... co_await some_3rd_party_lib::async_function(...); // (1) ... // (2) })); |
Только в случае с асинхронным select-ом за возврат управления на нужную нить отвечает не диспетчер, а scheduler, посредством которого асинхронный select был запущен.
Часть связанных с короутинами операций выполняется в noexcept контекстах
...со всеми вытекающими отсюда последствиями -- все приложение может быть убито через std::terminate если в таком контексте возникнет исключение.
В частности, постановка заявок wakeup и cpp_coro_resume выполняется в noexcept-функциях. Поэтому, если очередь, в которую заявки помещаются, использует динамическую память, то потенциально есть шанс получить std::bad_alloc. В этом случае восстановить нормальную работу приложения уже не получится, т.к. потеря wakeup- или cpp_coro_resume-заявок означает, что локальная очередь агента перестанет обслуживаться и агент, по сути, перестанет работать.
Есть идея о том, как данную особенность можно смягчить. Но пока она все еще остается идеей. Если у кого-то будут соображения на сей счет, то я с интересом выслушаю.
В SO-5.8.7 нет механизма cancellation для короутин
Если агент в своем асинхронном event-handler-е запустил короутину, то эта короутина должна завершиться. В противном случае агент не сможет продолжать свою работу. А SObjectizer Environment не сможет выполнить процедуру shutdown если таковая будет начата.
Скажу честно, до этого аспекта просто не дошли руки. Насколько я понимаю, в самом стандарте C++ нет никакого намека на штатный механизм cancellation для короутин. Полагаю, этот аспект был отдан на откуп конкретным реализациям, но при этом стандарт не говорит о том, как в конкретную короутину передать какие-то специфические штуки (вроде конкретного аллокатора или конкретной cancellation point).
Поэтому область сия пока что является "черной дырой", в которую еще не было возможности заглянуть. И если у кого-то есть соображения или опыт соединения короутин с какими-то cancellation point-ами, то поделитесь, пожалуйста.
Комментариев нет:
Отправить комментарий