Корутины C++20 и Asio: ожидание в базе занимает рабочую единицу и у корутин

От корутин естественно ждать, что ожидание, ушедшее в PostgreSQL, рабочую единицу не занимает. Замер это опровергает: у варианта на Boost.Beast с корутинами C++20 занятость при одной рабочей единице читается единицей так же, как у остальных. Плюс вторая ось — что видно в базе после того, как клиент жёстко оборвал соединение, и где здесь кончается наблюдение. Числа пересчитываются из фикстур стенда автоматической сверкой

От корутин естественно ждать такого: блокировка внутри обработчика занимает рабочую единицу, а ожидание, ушедшее в базу, не занимает ни одной. Первая половина на стенде подтверждается. Вторая — нет.

Это и есть содержание статьи. Корутины C++20 поверх Asio дают настоящую приостановку — но приостановить можно только то, что умеет сообщить о готовности. Клиент базы, которым ходит этот сервис, сообщать о ней не умеет. Вызов libpqxx внутри корутины блокирует выполняющий её поток: он возвращается только с готовым результатом. Находка от этого не слабее исходного ожидания, а сильнее: она про то, что модель конкурентности в сервисе задаётся не самым верхним слоем, а самым нижним блокирующим.

digital-cookbook/cpp/service-and-postgres

Ретрофутуристичная схема на кремовой бумаге. В центре одни массивные ворота с единственным засовом поперёк створок, над ними табличка «клиент базы: синхронный», и на обложке это правдоподобное объяснение, а не замер. К воротам ведут две одинаковые дорожки: на левой площадке стоит фигура с табличкой «поток», на правой — точно такая же фигура с маленьким крылатым знаком на рукаве и табличкой «корутина»; обе стоят перед засовом на одном расстоянии от створок. Справа отдельно стоит арка-указатель «объезд», ни с чем не соединённая. Слева внизу врезка: два одинаковых сосуда, заполненных до одной отметки, подпись «занятость читается счётчиком — у обоих одна и та же отметка». Справа внизу пустое кресло и раскрытая книга, рядом на отдельной ножке табличка «предположение: причина осталась здесь». Внизу по центру плита: «один и тот же засов — для потока и для корутины»

В статье

  • какое ожидание от корутин естественно и чем именно оно опровергнуто;
  • что читает счётчик обработчиков в полёте и почему занятость снимается счётом, а не временем ответа;
  • сколько обработчиков корутинный вариант держит в полёте при одной, двух и трёх рабочих единицах — и где это число разобрано подробно;
  • что делает с рабочей единицей ожидание, ушедшее в PostgreSQL, и каким контролем это подтверждено у корутинного варианта;
  • где кончается наблюдение и начинается объяснение — на примере синхронного клиента базы, причины правдоподобной, но не замеренной;
  • что видно в базе после того, как клиент жёстко оборвал соединение, и почему «отмена не доходит» здесь сказать нельзя;
  • как выглядит ожидание, которое поток действительно отпускает;
  • чего эти числа не значат.

Стенд: один сервис, три варианта HTTP-слоя

Сервис написан один. Общая логика — маршруты, работа с базой, пул соединений — лежит в одном файле, и к ней по очереди пристёгиваются три разных слоя HTTP: Boost.Beast на корутинах C++20, Drogon и Crow. Дальше я называю их вариантами: слой — единственное, чем они отличаются. Главный здесь — beast, потому что именно он собран на co_spawn и awaitable<T>, а два других нужны как фон: без них любое наблюдение о корутинном варианте было бы наблюдением об одном сервисе.

Маршрутов три. /q уводит ожидание в базу параметризованным SELECT pg_sleep($1), /block ждёт в самом обработчике и в базу не ходит вовсе, /healthz отдаёт текущую занятость. Ответ — строка контракта с именем варианта, исходом и занятостью на момент входа.

Занятость читается, а не выводится из длительностей ответов: сервис ведёт счётчик обработчиков в полёте, который растёт на входе, падает на выходе и кладёт своё значение на момент входа в строку ответа; вторым, независимым источником служит счёт активных запросов варианта в самой базе. Маршрут /healthz при этом себя не считает — им занятость спрашивают, и наблюдатель, попавший в наблюдаемое, завышал бы ответ. У счётчика три контроля снаружи, и без всех трёх ось объявляется недействительной; метод разобран подробно в статье про три HTTP-слоя.

Счёт из базы всегда идёт по application_name варианта — иначе соседние варианты и служебные сессии смешивались бы в одну кучу молча.

Ожидание, которое замер опроверг

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

Чем оно опровергнуто. Две одновременные /q?sleep_ms=1000 показывают обратное у всех трёх вариантов, включая корутинный; замер ниже это подтверждает.

Объяснение (не замер): libpqxx синхронен, и приостановить co_await на нём не на чем — корутина остаётся внутри сетевого вызова драйвера ровно так же, как остался бы обычный поток. Это правдоподобная причина, но стенд её не проверял: он снял следствие — прочитанную занятость, — а не то, что происходит внутри клиента базы.

Ловушка здесь шире одного стенда. Асинхронная модель верхнего слоя не делает асинхронным всё, что под ней: она ровно настолько асинхронна, насколько асинхронен самый нижний вызов в цепочке. Проверяется это не чтением документации слоя, а счётом занятости на своём сервисе.

Что делает с рабочей единицей ожидание в базе

Постановка. Две одновременные пробы /q?sleep_ms=1000, 5 залпов на настройку, две настройки — 1 рабочая единица и 3. Занятость читается счётчиком на момент входа, вторым источником идёт счёт активных запросов варианта в базе.

Результат у корутинного варианта: при 1 рабочей единице занятость читалась единицей в каждом из 5 залпов — двоих в полёте не было ни разу. У crow и drogon при той же настройке вышло то же самое: по всем трём вариантам это 15 залпов, и ни в одном из них при 1 рабочей единице в полёте не было двоих.

Контроль оси у корутинного варианта подтвердился. Чтобы сказать «занята именно рабочая единица, а не сервис целиком», нужно показать, что при 3 рабочих единицах пробы перекрываются: иначе то же наблюдение объяснялось бы тем, что сервис обслуживает по одному запросу в принципе. У beast при 3 рабочих единицах занятость читалась двойкой во всех 5 залпах, то есть пробы перекрылись в каждом; запас контроля — 1, и строка оси помечена публикуемой. У двух других вариантов контроль подтвердился не везде, и их строки помечены непубликуемыми — таблица контроля целиком разобрана в статье про три HTTP-слоя.

Два источника занятости сошлись. Счётчик внутри сервиса и счёт активных запросов в самой базе дали одно и то же число во всех 10 залпах маршрута /q у корутинного варианта и во всех 30 по трём вариантам — ни одного расхождения и ни одного пропущенного момента. Это существенно именно здесь: утверждение «ожидание в базе рабочую единицу занимает» опирается на счётчик, живущий внутри предмета, и подтверждено оно счётом снаружи, из самой PostgreSQL.

Сборка у осей одна. Фикстура этой оси сверяет контрольную сумму собранного бинарника с суммой из фикстуры соседней оси: иначе две фикстуры, снятые с разных сборок, сходились бы согласованно и неверно.

Блокировка в обработчике: где корутинный вариант всё-таки отличается

Для контраста — вторая половина ожидания, которая подтверждается. Маршрут /block ждёт в самом обработчике и в базу не ходит вовсе.

Постановка. 4 одновременных запроса /block в залпе, 3 залпа на настройку, ожидание в обработчике — секунда. Публикуется наименьшее по залпам.

вариант 1 рабочая единица 2 рабочие единицы 3 рабочие единицы
beast 1 2 3
crow 1 1 2
drogon 1 2 1 (по залпам 2, 1, 3)

У корутинного варианта число совпало с числом рабочих единиц на всех трёх настройках: 1, 2 и 3. У crow при 3 рабочих единицах в полёте оказалось 2, а у drogon число не воспроизвелось даже внутри одного прогона — по залпам вышло 2, 1 и 3, и публикуется наименьшее наблюдённое. Разбор этой таблицы, её контролей и неустойчивости drogon — в статье про три HTTP-слоя; здесь она нужна ради одного сопоставления.

Сопоставление узкое, и границу у него стоит назвать. При одной рабочей единице ни ожидание в обработчике, ни ожидание в базе у корутинного варианта перекрытия не дали: оба маршрута прочитали единицу. Ожидаемой разницы при одной единице нет. Больше отсюда не следует: при трёх единицах /block проверялся четырьмя запросами в залпе, а /q — двумя, и их числа говорят о размере залпа, а не о разнице маршрутов. Равенство двух маршрутов при нескольких единицах стенд не проверял.

Обрыв клиента: что видно и что объяснено

Вторая ось статьи — про событие, которое в эксплуатации происходит постоянно: клиент ушёл, не дождавшись ответа. Для корутинного слоя это вопрос с подвохом, потому что у Asio есть собственная отмена, и соблазн объявить её действующей велик.

Постановка. Проба шлёт /q?sleep_ms=3000, через секунду жёстко закрывает свой сокет — SO_LINGER в ноль, то есть RST, — и ещё через секунду счёт активных запросов варианта снимается из pg_stat_activity по имени приложения. Сервис ради этой оси не тронут вовсе: обрыв делает проба своим сокетом, маршрута «оборвать» у сервиса нет.

вариант после ответа (контроль) до обрыва после обрыва через всё окно
beast 0 1 1 0
crow 0 1 1 0
drogon 0 1 1 0

Запрос переживает уход клиента у всех трёх вариантов, и корутинный не исключение: через секунду после обрыва он всё ещё виден активным. И он кончается сам — через полное окно ожидания активных ноль, то есть речь не о застрявшей навсегда сессии.

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

  • запрос был виден активным до обрыва — иначе «остался активным» читалось бы из пустых данных, а проверка отсутствия на пустых данных проходит всегда;
  • байт от сервиса до обрыва пришло 0 — то есть клиент действительно ушёл раньше ответа, а не после него;
  • счёт снят по имени приложения именно этого варианта.

Где здесь кончается наблюдение

Это то самое место, где проще всего соскользнуть, и потому его стоит проговорить буквально.

Наблюдение: запрос остался активным в базе после того, как клиент жёстко закрыл сокет. Это снято счётом из pg_stat_activity, у трёх вариантов, с контролем и тремя условиями выше.

Объяснение (не замер): обработчик корутинного варианта ждёт ответа базы блокирующим вызовом, и пока этот вызов идёт, за разрывом соединения никто не следит — сокет клиента не читается, а запроса отмены в libpq, по этому объяснению из чтения кода, никто не передаёт. Точнее всего сказать так: в этой реализации RST не остановил запрос в наблюдаемом окне. Остановила бы его реализация, которая следит за разрывом, — стенд не проверял. Снято следствие, механизм не снят.

В стенде это разделение механическое: разбор не печатает слов про libpq и про доходящую отмену без пометки «объяснение, не замер». Проверено подменой: если снять пометку или убрать запрет, проверка краснеет.

Практический вывод от объяснения не зависит и держится на наблюдении. Не рассчитывайте, что клиентский таймаут автоматически отменит запрос в базе: в нашей пробе RST его не остановил. Если нужно, чтобы запрос прекращался, этого придётся добиваться отдельно — средствами самой базы или клиента, — и проверять замером, а не ожиданием.

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

Чтобы находка не читалась как «корутины бесполезны», стоит показать противоположный случай. Стенд его не мерил: это иллюстрация того, где проходит граница, а не замер.

Маршрут /block ждёт так:

// Поток стоит, пока идёт ожидание: корутина здесь ничего не меняет.
std::this_thread::sleep_for(std::chrono::milliseconds(ms));

То же ожидание, отданное циклу событий, выглядит так:

// Корутина приостанавливается, поток уходит обслуживать другие запросы.
asio::steady_timer timer(co_await asio::this_coro::executor);
timer.expires_after(std::chrono::milliseconds(ms));
co_await timer.async_wait(asio::use_awaitable);

Разница не в слове co_await, а в том, что стоит за ним: таймер Asio умеет сообщить циклу событий, когда ожидание кончится, а sleep_for не умеет. С базой так же. Чтобы запрос к PostgreSQL отпускал поток, ждать нужно не вызова, возвращающего готовый результат, а событий на сокете соединения.

У libpq для этого есть асинхронный интерфейс, но стенд этот путь не проверял, и пример кода здесь сознательно не приведён. Корректная реализация длиннее, чем кажется. Вот что она обязана учесть — это объяснение по документации libpq, а не проверенный рецепт:

  • соединение переводится в неблокирующий режим, запрос уходит через PQsendQueryParams, и результат каждого из этих вызовов проверяется;
  • пока PQflush возвращает единицу, нужно следить за обеими готовностями сокета — к записи и к чтению — и реагировать на любую из них: сервер может не принимать данные, пока клиент не прочитает его сообщения, и тогда при готовности к чтению вызывается PQconsumeInput. Ожидание одной только записи может зависнуть;
  • PQflush, вернувший −1, и PQconsumeInput, вернувший ноль, — это отказ, а не конец ожидания;
  • дальше ждать готовности к чтению, звать PQconsumeInput и проверять PQisBusy, пока ответ не соберётся целиком, а у каждого результата PQgetResult проверять статус, а не только то, что он пришёл;
  • сокет из PQsocket принадлежит клиентской библиотеке. Обёртка Asio, которой его отдали, закроет его при уничтожении, в том числе при выходе по исключению, — владение нужно явно вернуть, иначе соединение останется с закрытым сокетом.

Ради этого придётся спуститься ниже libpqxx, которой пользуется стенд, — и именно поэтому в стенде этого пути нет.

Чего эти числа не значат

Названо явно, чтобы умолчание не читалось как результат.

Ничего про пропускную способность и задержку. Ни числом, ни словом, ни намёком на направление. Стенд считает обработчиков в полёте и активные запросы в базе — и не мерит ни пропускной способности, ни задержки, которых обычно ждут от статьи про асинхронность.

Что какой-то вариант лучше другого — из этих чисел не следует. Одно и то же число рабочих единиц значит у трёх слоёв разное, и стенд это записывает, а не усредняет.

Почему ожидание в базе занимает рабочую единицу. Синхронность клиента базы — правдоподобное объяснение, но замером оно не является: снято следствие.

Что корутины C++20 или Asio чего-то не умеют. Замерен один сервис с одним клиентом базы, вызываемым одним способом. Про корутины вообще и про Asio вообще отсюда не следует ничего: с клиентом, умеющим сообщать о готовности, числа были бы другими, и такого замера здесь нет.

Что ёмкость drogon воспроизводима. Она плавает и между залпами одного прогона, и между сессиями; публикуется наименьшее наблюдённое, а не типичное и не ожидаемое.

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

Что запрос переживает любой уход клиента. Замерен один способ: жёсткое закрытие сокета, то есть RST. Про вежливое закрытие, про таймаут промежуточного узла и про обрыв сети отсюда не следует ничего — это разные события и для сокета, и для слоя HTTP.

Что «через секунду» — граница. Интервалы обрыва и счёта выбраны с запасом внутри трёхсекундного ожидания. Сколько именно запрос живёт после обрыва, стенд не мерил: он мерил, что через секунду тот ещё жив, а к концу окна его уже нет.

Ничего про другую машину. Обе сессии сравнения сняты в одном окружении. Сводка прогонов отвечает на вопрос «держатся ли числа между прогонами», а не «держатся ли они у другого читателя».

Выводы

Ожидание в базе занимает рабочую единицу и у корутин. Естественное ожидание, что не занимает, замер опровергает: при 1 рабочей единице двоих в полёте не было ни в одном из 15 залпов по трём вариантам.

Асинхронность сервиса задаёт самый нижний блокирующий вызов, а не самый верхний слой. Корутинный вариант держит в полёте столько обработчиков, сколько ему дано рабочих единиц, — 1, 2 и 3 на трёх настройках, — но ожидание, ушедшее в базу, единицу у него не освобождает, как не освобождает и у остальных. Объяснение (не замер) здесь одно — синхронный клиент базы, которому нечего сообщить планировщику корутин.

Проверять это нужно счётом, а не доверием к слою. Занятость читается счётчиком обработчиков в полёте и подтверждается вторым источником — счётом активных запросов в самой базе; у корутинного варианта два источника сошлись во всех 10 залпах маршрута /q, а по трём вариантам — во всех 30.

В этой реализации уход клиента запрос не прекратил. У всех трёх вариантов через секунду после жёсткого обрыва запрос виден активным, а к концу окна кончается сам. Сервис за разрывом не следит, пока ждёт базу; что изменила бы реализация, которая следит, стенд не проверял — объяснение помечено объяснением.

Числа выше читаются из фикстур стенда автоматической сверкой, а не из моей памяти о них.

Ссылки

Обсуждение в Telegram

Присоединиться →