От статьи про три HTTP-фреймворка обычно ждут сводной таблицы с одним числом на строку и победителем в последнем столбце — здесь такой таблицы не будет, и дело не в скромности замера: ни пропускной способности, ни задержки этот стенд не мерит вовсе, и ни одного числа про них в тексте нет.
Замерено другое, и оно оказалось содержательнее. Число рабочих единиц, которое сервис получает при запуске, и число обработчиков, которые он держит в полёте разом, — это две разные величины, и совпадают они не у всех вариантов. А ожидание — хоть в самой базе, хоть в очереди за свободным слотом пула — рабочую единицу удерживает, и удерживает у всех трёх слоёв одинаково.
digital-cookbook/cpp/service-and-postgresВ статье
- как устроен стенд и чем доказано, что три варианта различаются только слоем HTTP;
- почему занятость читается счётчиком, а не выводится из длительностей ответов;
- сколько обработчиков каждый вариант держит в полёте при одной, двух и трёх рабочих единицах;
- почему одно из трёх чисел неустойчиво — и почему это записано, а не усреднено;
- что делает с рабочей единицей ожидание в базе и где контроль этой оси не подтвердился;
- сколько соединений открыто при названном размере пула и почему у двух вариантов это число говорит не о пуле;
- почему собственный пул Drogon замерен, но в общую таблицу не входит;
- чего эти числа не значат.
Стенд: один сервис, три варианта HTTP-слоя
Сервис написан один. Общая логика — маршруты, работа с базой, пул соединений — лежит в одном файле, и к ней по очереди пристёгиваются три разных слоя HTTP: Boost.Beast на корутинах C++20, Drogon и Crow. Дальше я называю их вариантами: слой — единственное, чем они отличаются.
Маршрутов три. /q уводит ожидание в базу параметризованным
SELECT pg_sleep($1), /block ждёт в самом обработчике и в базу не
ходит вовсе, /healthz отдаёт текущую занятость. Ответ — строка
контракта с именем варианта, исходом и занятостью на момент входа.
«Различаются только слоем» — это замерено, а не объявлено. Один
базовый образ, закреплённый дайджестом; один компилятор; одна версия
libpqxx 7.10; один и тот же файл общей логики; один и тот же текст
запроса. Версии инструментов (g++ 14.2.0, cmake 3.31.6) и флаги
сборки общей библиотеки (-O3 -DNDEBUG -std=gnu++20) снимаются в каждом
собранном образе и лежат в фикстуре рядом с числами. Контрольная сумма
точки входа снимается с собранного бинарника и сверяется между
фикстурами разных осей — без этого две фикстуры из разных сборок
совпадали бы согласованно, но неверно.
Три переменные запуска — имя варианта, число рабочих единиц и размер пула — читаются до открытия порта, запасных значений не имеют и в образ не запечены: сервис без любой из них отказывается стартовать, и это тоже снято замером, а не обещано.
Счёт из базы всегда идёт по application_name варианта — иначе соседние
варианты и служебные сессии смешивались бы в одну кучу молча.
Занятость читается, а не выводится из времени
Ловушка — выводить занятость из длительностей. Ответы делят на «волны»: проба, уложившаяся в одно ожидание, считается обслуженной сразу, остальные — дождавшимися. Чтобы отличить волну от дрожания рабочей машины, ожидание приходится растягивать — до пятнадцати секунд, с полным прогоном около четырнадцати часов; окно замера растёт впятеро, и ровно настолько же растёт шанс поймать в него чужую нагрузку. Такой стенд мерит рабочую машину, а не варианты.
Поэтому занятость здесь читается:
- сервис ведёт счётчик обработчиков в полёте — он растёт на входе, падает на выходе, в том числе при выходе исключением, и кладёт своё значение на момент входа в строку ответа;
- маршрут
/healthzотдаёт текущую занятость и себя не считает: им её спрашивают, и наблюдатель, попавший в наблюдаемое, завышал бы ответ на единицу; - вторым, независимым источником служит счёт активных запросов
варианта в самой базе — по
pg_stat_activity, снятый пока пробы в полёте.
Дрожание после этого ничего не значит для счёта: ответ может прийти когда угодно, счётчик всё равно скажет, сколько обработчиков было внутри в момент входа. Ожидание — секунда, полный прогон обеих фикстур занимает около пяти с половиной минут.
Разброс у drogon при трёх рабочих единицах от залпа к залпу — не артефакт измерителя: счётный метод на тех же бинарниках тоже даёт разные числа.
Счётчик — измеряющий код внутри предмета, и у него три контроля
Риск назван заранее: счётчик живёт в том же процессе, что и предмет, то есть слеп заодно с ним. Поэтому у него контроли снаружи.
- Положительный. При прочем равном счётчик обязан идти за числом рабочих единиц: при одной единице читаться единицей, при трёх — больше.
- Отрицательный. В постановке, где пробы уходят по очереди и не перекрываются, счётчик обязан читаться единицей при любом числе рабочих единиц.
- Граница клиента. У каждого обращения к
/healthzрядом лежит число проб, которые клиент ещё считает отправленными и не завершёнными, снятое до обращения. Прочитанная занятость не имеет права её превысить: это верхняя оценка, посчитанная снаружи сервиса и не зависящая от того, что докладывает сам счётчик.
Без всех трёх ось объявляется недействительной, и таблица не печатается вовсе. Это записано полем в фикстуре, а не обещанием в README.
Про маршрут /healthz есть отдельная оговорка. Он тоже обычный
запрос и способен встать в очередь за занятыми обработчиками. Стенд
кладёт в фикстуру сырую задержку каждого обращения и никакого вывода из
неё не делает — в этой статье её нет по той же причине, по которой здесь
нет ни одного числа про скорость. Что стоит унести из этой колонки —
факт, а не величина: у beast и crow при трёх рабочих единицах ответ
получило каждое обращение, у drogon в этом прогоне — 14 обращений
из 15. Это поле фикстуры читает проверка, а не только записывает
прогон.
Сколько обработчиков вариант держит в полёте
Постановка. Четыре одновременных запроса /block в залпе, три
залпа на настройку, ожидание в обработчике — секунда. Настройки — одна,
две и три рабочие единицы. Публикуется наименьшее по залпам: утверждение
«держит разом столько-то» обязано выдерживать каждый залп, а не лучший
из них.
| вариант | 1 рабочая единица | 2 рабочие единицы | 3 рабочие единицы | устойчиво по залпам |
|---|---|---|---|---|
| beast | 1 | 2 | 3 | да |
| crow | 1 | 1 | 2 | да |
| drogon | 1 | 2 | 1 (по залпам 2, 1, 3) | нет |
До залпа занятость читается нулём у всех трёх вариантов — иначе любое число ниже читалось бы из чужого остатка.
Первое, что видно: одно и то же число рабочих единиц значит у трёх слоёв разное. При трёх рабочих единицах beast держал в полёте три обработчика, crow — два. Это не «столько-то против столько-то» в пользу кого-то: это про то, что настройка с одинаковым именем у разных слоёв подключена к разному, и переносить её значение с одного слоя на другой нельзя.
Второе: у drogon число при трёх рабочих единицах неустойчиво. По залпам одного прогона вышло 2, 1 и 3 — то есть не воспроизвелось даже внутри одной сессии. В фикстуре стоит отдельное поле, объявляющее число неустойчивым; сверка сводок такие числа не сличает вовсе, а в таблице стоит наименьшее наблюдённое. Следующий прогон вправе дать другое число, и это не опровергло бы записанного здесь, а подтвердило бы неустойчивость.
Оба контроля счётчика держатся у всех трёх вариантов: при одной рабочей единице занятость читается единицей, при трёх — больше; в постановке с непересекающимися пробами занятость читается единицей при любом числе рабочих единиц.
Ожидание в базе занимает рабочую единицу
Вторая половина оси — про маршрут /q, где ожидание уходит не в
обработчик, а в саму PostgreSQL.
Постановка. Две одновременные пробы /q?sleep_ms=1000, пять залпов
на настройку, две настройки — одна рабочая единица и три.
Результат у всех трёх вариантов одинаков: при одной рабочей единице двоих в полёте не было ни в одном из 15 залпов. Ожидание, ушедшее в базу, рабочую единицу не освобождает — включая вариант на корутинах.
Наблюдение и объяснение. Наблюдение: при одной рабочей единице занятость читается единицей, сколько бы проб ни ждало. Объяснение (не замер): синхронный клиент базы — правдоподобная причина, но замером она не является: ожидание ответа от сервера блокирует ту единицу, в которой обработчик исполняется. Стенд снял следствие, а не механизм: чтобы утверждать объяснение, пришлось бы смотреть, что делает libpqxx, а не что видно снаружи.
Где контроль этой оси не подтвердился
Сказать «занята именно рабочая единица, а не сервис целиком» можно только показав, что при трёх рабочих единицах пробы перекрываются. Иначе то же наблюдение объяснялось бы и тем, что сервис обслуживает по одному запросу в принципе.
| вариант | залпов с перекрытием (из пяти) | запас контроля | строка публикуется |
|---|---|---|---|
| beast | 5 | 1 | да |
| crow | 3 | 0 | нет |
| drogon | 3 | −1 | нет |
Запас контроля — это разница между ёмкостью варианта на контрольной настройке и числом проб в залпе. У crow он равен нулю, у drogon отрицателен: ёмкость на контрольной настройке не превышает числа проб, и одного неперекрывшегося залпа хватает, чтобы «перекрылось всегда» стало ложью. Их строки помечены непубликуемыми — вывод для них не подтверждён, и это записано полем, а не оговоркой в тексте. Само число «три из пяти» свойством варианта не называется: оно меняется между сессиями.
Два источника занятости сошлись во всех 30 залпах маршрута /q —
счётчик внутри сервиса и счёт активных запросов в самой базе. Здесь
важна деталь метода: второй источник опрашивается отдельным потоком со
своим шагом и не делит цикл с опросом /healthz. При общем цикле
«сошлись» значило бы «не поймали момент», а не «совпало»: цикл
/healthz сам стоит в очереди за занятым сервисом и успевает один-два
витка за весь залп. Оба исхода различены в фикстуре отдельными
полями: «источники разошлись» и «источник не поймал момент».
Пул соединений: сколько их открыто на самом деле
Вторая ось статьи — про то, что происходит между слоем HTTP и базой.
Пул в стенде один на три варианта и написан руками в общей логике. Без него соединение открывается на каждый запрос и закрывается вместе с ним — у всех трёх, включая drogon; это видно пробой, а не чтением кода: во время залпа соединений ровно столько, сколько запросов в полёте, а после залпа — ноль. Контроль «пул на один слот против пула на восемь» без пула сравнивал бы настройку саму с собой.
Постановка. Восемь одновременных запросов /q?sleep_ms=1000, восемь
рабочих единиц, три залпа на настройку. Пара различается только размером
пула, который приходит при запуске переменной окружения. Число соединений
снимается из pg_stat_activity по имени приложения варианта во время
залпа и сразу после. Публикуется наибольшее по залпам.
| вариант | пул на 1 | пул на 8 | в полёте при пуле на 8 | по залпам при пуле на 8 | обслужено |
|---|---|---|---|---|---|
| beast | 1 | 8 | 8 | 8, 8, 8 | 24 из 24 |
| crow | 1 | 7 | 7 | 7, 7, 7 | 24 из 24 |
| drogon | 1 | 6 | 6 | 5, 5, 6 | 24 из 24 |
До залпа соединений варианта в базе ноль. Ни одна проба не осталась необслуженной ни на одной настройке.
Контроль сошёлся: счётчик соединений пошёл за настройкой у всех трёх вариантов и ни у одного не превысил названный потолок.
Два числа стоит прочитать вместе
Соседний столбец не украшение — без него таблица читается неправильно.
При пуле на восемь слотов и восьми рабочих единицах у crow в полёте было семь обработчиков — и соединений у него открылось семь. У drogon в полёте шесть — и соединений шесть. Числа совпадают не случайно: пул открывает новое соединение, только когда все уже открытые выданы, а возвращённое держит открытым до следующего обработчика. Поэтому открытых не бывает больше, чем обработчиков разом держало соединения. Столбец считает именно открытые соединения, включая простаивающие в пуле, — не выданные и не активные запросы.
Почему при восьми одновременных запросах и восьми рабочих единицах разом в полёте оказалось семь или шесть, стенд не установил: предел слоя, распределение соединений между потоками и недогруженная проба дают одно и то же равенство, а контроля насыщения со стороны клиента нет.
Отсюда вывод оси. Насыщение пула — не свойство пула. Число, снятое при названном размере пула, говорит о пуле только тогда, когда оно в этот размер упёрлось. У beast упёрлось: при восьми рабочих единицах в полёте восемь обработчиков и соединений восемь при восьми слотах. У crow и drogon в пул не упёрлось, и называть их числа ёмкостью пула нельзя.
Число drogon и здесь — наблюдение этого прогона, а не величина. По залпам оно дало 5, 5 и 6, то есть снова не воспроизвелось внутри одной сессии. Это то же свойство, что и неустойчивая ёмкость drogon на первой оси. У beast и crow число внутри сессии держится.
Очередь за слотом тоже занимает рабочую единицу
Находка, которой в таблице выше нет.
При пуле на один слот и восьми рабочих единицах занятость читается 8 у beast, 7 у crow и 7 у drogon — при восьми одновременных запросах. То есть тот, кто стоит в очереди за слотом, рабочую единицу всё это время удерживает. Вариант на корутинах здесь ничем не отличается от остальных. У drogon число по залпам вышло 5, 7 и 5 — та же неустойчивость, и публикуется наибольшее наблюдённое.
И оговорка, без которой находка превратилась бы в утверждение о технологии, которого под ней нет. Ожидание слота в этом пуле блокирующее, и так сделано намеренно. Отдать ожидание планировщику корутин можно было бы ровно у одного варианта из трёх — и тогда ось мерила бы разницу двух ожиданий, а не размер пула. Пул, отдающий ожидание планировщику, дал бы у beast другое число. С ожиданием в базе, которое рабочую единицу тоже удерживает, это совпадает по виду, но не по причине.
Собственный пул Drogon: свойство слоя, выведенное за ось
Здесь нужна честная асимметрия, и прятать её нельзя.
У Drogon есть свой клиент базы с собственным пулом, у Beast и Crow такого клиента нет — не потому, что он там хуже сделан, а потому, что это слои разного состава: Drogon несёт с собой целый набор, включающий доступ к базе, а Beast и Crow — примитивы HTTP и ничего больше. Это свойство слоя, и оно не достоинство и не недостаток: оно просто определяет, что именно у каждого есть под рукой.
Собственный пул Drogon в образе действительно работает, и это замерено отдельной пробой: число соединений идёт за его настройкой так же — один слот даёт одно соединение, восемь дают восемь.
И ровно поэтому эта строка в общую таблицу не входит. Собственный клиент фреймворка ходит в базу через libpq, а три варианта оси — через общий для них libpqxx; это снято списком связей собранного бинарника, а не объявлено. Строка помечена в фикстуре полем «вне оси» с причиной: в одной таблице с остальными она сравнивала бы клиентов базы, а не слои HTTP, и главное правило стенда — «варианты различаются только слоем» — рухнуло бы. Поэтому в оси пул у всех трёх одинаковый и написан руками.
Чего эти числа не значат
Названо явно, чтобы умолчание не читалось как результат.
Ничего про пропускную способность и задержку. Ни числом, ни словом, ни намёком на направление. Стенд считает обработчиков и соединения — и не мерит ни пропускной способности, ни задержки, которых обычно ждут от статьи про три HTTP-фреймворка.
Что какой-то вариант лучше другого — из этих чисел не следует. Одно и то же число рабочих единиц значит у трёх слоёв разное, и стенд это записывает, а не усредняет.
Что ёмкость drogon воспроизводима. Она плавает и между залпами одного прогона, и между сессиями; публикуется наименьшее наблюдённое, а не типичное и не ожидаемое.
Что число соединений drogon воспроизводимо. То же самое: по залпам одного прогона оно разное, и это объявлено полем в самой фикстуре.
Что число при пуле на 8 — ёмкость пула. У crow и drogon оно равно числу запросов, которые слой держал разом, а не числу слотов.
Что занятость при пуле на 1 — свойство слоя или корутин. Это свойство написанного в стенде пула: ожидание слота в нём блокирующее. Другой пул дал бы другое число.
Почему ожидание в базе занимает рабочую единицу. Синхронность клиента базы — правдоподобное объяснение, но замером оно не является: снято следствие.
Что контроль оси ожидания в базе подтверждён везде. У crow и drogon он не подтверждён, и их строки помечены непубликуемыми.
Что у Drogon пул чем-то выделяется среди трёх. Собственный клиент базы у этого слоя есть, а у двух других нет — это состав слоя, и в ось он не взят, потому что сравнивал бы драйверы.
Ничего про другую машину. Обе сессии сравнения сняты в одном окружении. Сводка прогонов отвечает на вопрос «держатся ли числа между прогонами», а не «держатся ли они у другого читателя».
Выводы
Настройка с одинаковым именем подключена у трёх слоёв к разному. При трёх рабочих единицах beast держал в полёте три обработчика, crow — два, а у drogon число не воспроизвелось даже внутри одного прогона. Число рабочих единиц — это настройка запуска, а не обещание, и проверять его значение приходится замером на своём слое.
Ожидание удерживает рабочую единицу, откуда бы оно ни пришло. При одной рабочей единице ожидание в базе не дало двоих в полёте ни в одном из 15 залпов у всех трёх вариантов; при пуле на один слот и восьми рабочих единицах очередь за слотом удерживает единицу у каждого, кто в ней стоит. Вариант на корутинах в обоих случаях ведёт себя как остальные — и во втором случае это свойство написанного здесь пула, чьё ожидание слота сделано блокирующим намеренно.
Размер пула и число соединений — разные величины. При пуле на 8 слотов и восьми рабочих единицах beast открыл 8 соединений, crow — 7, drogon — 6, и у двоих последних это число говорит не о пуле, а о том, сколько запросов их слой держал разом.
Неустойчивое число честнее опубликовать неустойчивым. У drogon плавают обе величины — и ёмкость, и число соединений. Их можно было бы усреднить и получить гладкую таблицу; вместо этого в фикстуре стоит поле, объявляющее число наблюдением одного прогона, а сверка сводок такие числа не сличает вовсе.
Счётчик, живущий внутри предмета, требует контролей снаружи. Положительный, отрицательный и граница, посчитанная клиентом, — без всех трёх ось объявляется недействительной. А метод, выводящий занятость из длительностей ответов, не годится вовсе: он мерит рабочую машину, а не варианты.
Числа выше читаются из фикстур стенда автоматической сверкой, а не из моей памяти о них.
Ссылки
- Стенд: digital-cookbook/cpp/service-and-postgres —
bash bench/run-all.shснимает все оси,python3 scripts/analyze-pool.pyпечатает разбор оси пула вместе с контролями. - Соседи по стенду: корутины C++20 и Asio, PostgreSQL из C++ и libpqxxготовится, с 23 ноября.
- Рамка серии: C++ в 2026: где он по-прежнему незаменим.
- Первоисточники: Drogon, Crow, Boost.Beast, pg_stat_activity.
Обсуждение в Telegram
Присоединиться →