pgbench

pgbench — запустить тест производительности Postgres Pro

Синтаксис

pgbench -i [параметр...] [имя_бд]

pgbench [параметр...] [имя_бд]

Описание

pgbench — это простая программа для запуска тестов производительности Postgres Pro. Она многократно выполняет одну последовательность команд, возможно в параллельных сеансах базы данных, а затем вычисляет среднюю скорость транзакций (число транзакций в секунду). По умолчанию pgbench тестирует сценарий, примерно соответствующий TPC-B, который состоит из пяти команд SELECT, UPDATE и INSERT в одной транзакции. Однако вы можете легко протестировать и другие сценарии, написав собственные скрипты транзакций.

Типичный вывод pgbench выглядит так:

transaction type: <builtin: TPC-B (sort of)>
default transaction isolation level: read committed
transaction maximum tries number: 1
scaling factor: 10
query mode: simple
number of clients: 10
number of threads: 1
number of transactions per client: 1000
number of transactions actually processed: 10000/10000
tps = 85.184871 (including connections establishing)
tps = 85.296346 (excluding connections establishing)

В первых восьми строках выводятся значения некоторых самых важных параметров. В следующей строке показывается количество выполненных и запланированных транзакций (это будет произведение числа клиентов и числа транзакций для одного клиента); эти количества будут равны, если только выполнение не завершится досрочно или на некоторых клиентах не произойдут отказы из-за ошибок сериализации/взаимоблокировки. В режиме -T выводится только число фактически выполненных транзакций. (Чтобы узнать больше об ошибках сериализации/взаимоблокировки, см. Повторы и отказы из-за ошибок сериализации/взаимоблокировки.) В двух последних строках выводится число транзакций в секунду, вычисленное с учётом и без учёта времени запуска сеансов базы данных.

Для запускаемого по умолчанию теста типа TPC-B требуется предварительно подготовить определённые таблицы. Чтобы создать и наполнить эти таблицы, следует запустить pgbench с ключом -i (инициализировать). (Если вы применяете нестандартный скрипт, это не требуется, но тем не менее нужно подготовить конфигурацию, нужную вашему тесту.) Запуск инициализации выглядит так:

pgbench -i [ другие-параметры ] имя_базы

где имя_базы — имя уже существующей базы, в которой будет проводиться тест. (Чтобы указать, как подключиться к серверу баз данных, вы также можете добавить параметры -h, -p и/или -U.)

Внимание

pgbench -i создаёт четыре таблицы pgbench_accounts, pgbench_branches, pgbench_history и pgbench_tellers, предварительно уничтожая существующие таблицы с этими именами. Если вы вдруг используете эти имена в своей базе данных, обязательно переключитесь на другую базу!

С «коэффициентом масштаба», по умолчанию равным 1, эти таблицы изначально содержат такое количество строк:

table                   # of rows
---------------------------------
pgbench_branches        1
pgbench_tellers         10
pgbench_accounts        100000
pgbench_history         0

Эти числа можно (и в большинстве случаев даже нужно) увеличить, воспользовавшись параметром -s (коэффициент масштаба). При этом также может быть полезен ключ -F (фактор заполнения).

Подготовив требуемую конфигурацию, можно запустить тест производительности командой без -i, то есть:

pgbench [ параметры ] имя_базы

Практически во всех случаях, чтобы получить полезные результаты, необходимо передать какие-либо дополнительные параметры. Наиболее важные параметры: -c (число клиентов), -t (число транзакций), -T (длительность) и -f (файл со скриптом). Полный список параметров приведён ниже.

Параметры

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

Параметры инициализации

pgbench принимает следующие аргументы командной строки для инициализации:

-i
--initialize

Требуется для вызова режима инициализации.

-F фактор_заполнения
--fillfactor=фактор_заполнения

Создать таблицы pgbench_accounts, pgbench_tellers и pgbench_branches с заданным фактором заполнения. Значение по умолчанию — 100.

-n
--no-vacuum

Не выполнять очистку после инициализации.

-q
--quiet

Переключить вывод в немногословный режим, когда выводится только одно сообщение о прогрессе в 5 секунд. В режиме по умолчанию одно сообщение выводится на каждые 100000 строк, при этом за секунду обычно выводится довольно много строк (особенно на хорошем оборудовании).

-s коэффициент_масштаба
--scale=коэффициент_масштаба

Умножить число генерируемых строк на заданный коэффициент. Например, с ключом -s 100 в таблицу pgbench_accounts будут записаны 10 000 000 строк. Значение по умолчанию — 1. При коэффициенте, равном 20 000 или больше, столбцы, содержащие идентификаторы счетов (столбцы aid), перейдут к большим целым числам (типу bigint), чтобы в них могли уместиться все возможные значения идентификаторов.

--foreign-keys

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

--index-tablespace=табл_пространство_индексов

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

--tablespace=табличное_пространство

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

--unlogged-tables

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

Параметры тестирования производительности

pgbench принимает следующие аргументы командной строки для тестирования производительности:

-b имя_скрипта[@вес]
--builtin=имя_скрипта[@вес]

Добавляет указанный встроенный скрипт в список выполняемых скриптов. Необязательный целочисленный вес, задаваемый после @, позволяет изменить вероятность выбора скрипта. Если он не указан, подразумевается значение 1. В число встроенных скриптов входят tpcb-like, simple-update и select-only. Также принимаются однозначные начала их имён. Со специальным именем list программа выводит список встроенных скриптов и немедленно завершается.

-c клиенты
--client=клиенты

Число имитируемых клиентов, то есть число одновременных сеансов базы данных. Значение по умолчанию — 1.

-C
--connect

Устанавливать новое подключение для каждой транзакции вместо одного для каждого клиента. Это полезно для оценивания издержек подключений.

-d
--debug

Выводить отладочные сообщения.

-D имя_переменной=значение
--define=имя_переменной=значение

Определить переменную для пользовательского скрипта (см. ниже). Параметр -D может добавляться неоднократно.

-f имя_файла[@вес]
--file=имя_файла[@вес]

Добавить в список выполняемых скриптов скрипт транзакции из файла имя_файла. Изменить вероятность выбора этого скрипта позволяет необязательный целочисленный вес, задаваемый после @. Подробности описаны ниже.

-I уровень_изоляции
--default-isolation-level=уровень_изоляции

Задаёт уровень изоляции транзакций по умолчанию:

  • RUC: Read Uncommitted

  • RC: Read Committed

  • RR: Repeatable Read

  • S: Serializable

В отсутствие этого ключа используется уровень Read Committed. За дополнительными сведениями обратитесь к Разделу 13.2.

-j потоки
--jobs=потоки

Число рабочих потоков в pgbench. Использовать нескольких потоков может быть полезно на многопроцессорных компьютерах. Клиенты распределяются по доступным потокам равномерно, насколько это возможно. Значение по умолчанию — 1.

-l
--log

Записать время выполнения каждой транзакции в файл протокола. Подробности описаны ниже.

-L предел
--latency-limit=предел

Транзакции, продолжающиеся дольше указанного предела (в миллисекундах), подсчитываются и отмечаются отдельно, как опаздывающие.

В режиме ограничения скорости (--rate=...) транзакции, которые отстают от графика более чем на заданный предел (в мс) и поэтому никак не могут уложиться в отведённый интервал, не передаются серверу вовсе. Они подсчитываются и отмечаются отдельно как пропущенные.

Вы можете использовать этот параметр вместе с --max-tries, разрешая тем самым повторы транзакций с ошибками сериализации/взаимоблокировки. Транзакция повторяется только в течение указанного времени. За подробностями обратитесь к Повторы и отказы из-за ошибок сериализации/взаимоблокировки.

-M режим_запросов
--protocol=режим_запросов

Протокол, выбираемый для передачи запросов на сервер:

  • simple: использовать протокол простых запросов.

  • extended: использовать протокол расширенных запросов.

  • prepared: использовать протокол расширенных запросов с подготовленными операторами.

По умолчанию выбирается протокол простых запросов. (За подробностями обратитесь к Главе 51.)

-n
--no-vacuum

Не производить очистку таблиц перед запуском теста. Этот параметр необходим, если вы применяете собственный сценарий, не затрагивающий стандартные таблицы pgbench_accounts, pgbench_branches, pgbench_history и pgbench_tellers.

-N
--skip-some-updates

Запустить встроенный упрощённый скрипт simple-update. Краткий вариант записи -b simple-update.

-P сек
--progress=сек

Выводить отчёт о прогрессе через заданное число секунд (sec). Выдаваемый отчёт включает время, прошедшее с момента запуска, а также скорость (в tps), среднее время ожидания транзакций и стандартное отклонение после последнего отчёта. Если какие-либо транзакции после последнего отчёта завершаются отказами вследствие ошибок сериализации/взаимоблокировки, они также попадают в число неуспешных (подробнее см. Повторы и отказы из-за ошибок сериализации/взаимоблокировки). В режиме ограничения скорости (-R) время ожидания вычисляется относительно назначенного времени запуска транзакции, а не фактического времени её начала. Таким образом, в это время включается и среднее время отставания от графика. Если какие-либо транзакции откатываются и повторно выполняются после ошибки сериализации/взаимоблокировки со времени последнего отчёта, в текущий отчёт также включается число таких транзакций и суммарное количество повторений. Чтобы разрешить повторное выполнение транзакций после ошибок сериализации/взаимоблокировки, воспользуйтесь параметром --max-tries.

Примечание

Если пользовательский скрипт содержит несколько транзакций, его выполнение считается неуспешным в случае неуспешного завершения какой-либо из транзакций вследствие ошибок сериализации/взаимоблокировки. Также он считается выполнявшимся повторно, если имело место повторное выполнение какое-либо из его транзакций. Общее количество повторений скрипта складывается из числа повторений всех транзакций в этом скрипте.

-r
--report-per-command

Выдать следующую статистику по каждой команде после завершения теста: среднюю длительность выполнения операторов (время выполнения с точки зрения клиента), число отказов и повторений вследствие ошибок сериализации, а также число отказов и повторений вследствие ошибок взаимоблокировки. Столбцы со статистикой по отказам и повторениям выводятся, только если в текущем прогоне pgbench имели место любого рода отказы или повторные попытки выполнения, соответственно. Подробности описаны ниже.

-R скорость передачи
--rate=скорость передачи

Выполнять транзакции, ориентируясь на заданную скорость, а не максимально быстро (по умолчанию). Скорость задаётся в транзакциях в секунду. Если заданная скорость превышает максимально возможную, это ограничение скорости не повлияет на результаты.

Для получения нужной скорости транзакции запускаются со случайными задержками, имеющими распределение Пуассона. При этом запланированное время запуска отсчитывается от начального времени, а не от завершения предыдущей транзакции. Это означает, что если какие-то транзакции отстанут от изначально рассчитанного времени завершения, всё же возможно, что последующие нагонят график.

В режиме ограничения скорости время ожидания транзакций, выводимое по итогам тестирования, вычисляется, исходя из запланированного времени запуска, так что в него входит время, которое очередная транзакция должна была ждать завершения предыдущей транзакции. Это время называется временем отклонения от графика, и его среднее и максимальное значения выводятся отдельно. Время ожидания транзакций с момента их фактического запуска, то есть время, потраченное на выполнение транзакций в базе данных, можно получить, если вычесть время отклонения от графика из времени ожидания транзакций.

Если ограничение --latency-limit задаётся вместе с --rate, транзакция может заведомо не вписываться в отведённое ей время, если предыдущая транзакция завершится слишком поздно, так как ожидаемое время окончания транзакции отсчитывается от времени запуска по графику. Такие транзакции не передаются серверу, а пропускаются и подсчитываются отдельно.

Большое значение отклонения от графика свидетельствует о том, что система не успевает выполнять транзакции с заданной скоростью и выбранным числом клиентов и потоков. Когда среднее время ожидания транзакции превышает запланированный интервал между транзакциями, каждая последующая транзакция будет отставать от графика, и чем дольше будет выполняться тестирование, тем больше будет отставание. Когда это наблюдается, нужно уменьшить скорость транзакций.

-s коэффициент_масштаба
--scale=коэффициент_масштаба

Показать заданный коэффициент масштаба в выводе pgbench. Для встроенных тестов это не требуется; корректный коэффициент масштаба будет получен в результате подсчёта строк в таблице pgbench_branches. Однако при использовании только нестандартных тестов (запускаемых с ключом -f) без этого параметра в качестве коэффициента масштаба будет выводиться 1.

-S
--select-only

Запустить встроенный скрипт select-only (только выборка). Краткий вариант записи -b select-only.

-t транзакции
--transactions=транзакции

Число транзакций, которые будут выполняться каждым клиентом (по умолчанию 10).

-T секунды
--time=секунды

Выполнять тест с ограничением по времени (в секундах), а не по числу транзакций для каждого клиента. Параметры -t и -T являются взаимоисключающими.

Вы можете использовать этот параметр вместе с --max-tries, разрешая тем самым повторы транзакций с ошибками сериализации/взаимоблокировки. Транзакции будут повторяться только в интервале времени, заданном параметром --time. За подробностями обратитесь к Повторы и отказы из-за ошибок сериализации/взаимоблокировки.

-v
--vacuum-all

Очищать все четыре стандартные таблицы перед запуском теста. Без параметров -n и -v pgbench будет очищать от старых записей таблицы pgbench_tellers и pgbench_branches, а также опустошать pgbench_history.

--aggregate-interval=секунды

Длительность интервала агрегации (в секундах). Может использоваться только с ключом -l. С данным параметром в протокол выводится сводка по интервалам (число транзакций, мин./макс. длительность с двумя дополнительными полями, полезными для оценки отклонений, и число транзакций с ошибками сериализации и взаимоблокировки).

В настоящее время этот параметр не поддерживается в Windows.

--max-tries=число_попыток

Разрешить повторение транзакций с ошибками сериализации/взаимоблокировки и установить максимально число попыток выполнения транзакций. Значение по умолчанию — 1, то есть повторы таких транзакций запрещены.

Этот параметр может использоваться совместно с --latency-limit и/или --time, ограничивающими общее время всех попыток выполнения транзакции. В этом случае повторение транзакции допускается только в рамках заданного временного интервала. Указание --max-tries=0 позволяет повторять транзакцию неограниченное число раз, пока позволяет отведённое время; это значение может задаваться только совместно с установкой параметра --latency-limit и/или --time.

Чтобы узнать больше о повторах транзакций при ошибках сериализации/взаимоблокировки, см. Повторы и отказы из-за ошибок сериализации/взаимоблокировки.

--progress-timestamp

При отображении прогресса (с параметром -P) выводить текущее время (в формате Unix), а не количество секунд от начала запуска. Время задаётся в секундах с точностью до миллисекунд. Это помогает сравнивать журналы, записываемые разными средствами.

--sampling-rate=скорость передачи

Частота выборки для записи данных в протокол, изменяя которую можно уменьшить объём протокола. При указании этого параметра в протокол выводится информация только о заданном проценте транзакций. Со значением 1.0 в нём будут отмечаться все транзакции, а с 0.05 только 5%.

Обрабатывая протокол, не забудьте учесть частоту выборки. Например, вычисляя скорость (tps), вам нужно будет соответственно умножить содержащиеся в нём числа (то есть, с частотой выборки 0.01 вы получите только 1/100 фактической скорости).

Общие параметры

pgbench принимает следующие общие аргументы командной строки:

-h компьютер
--host=компьютер

Адрес сервера баз данных

-p порт
--port=порт

Номер порта сервера баз данных

-U имя_пользователя
--username=имя_пользователя

Имя пользователя для подключения

-V
--version

Вывести версию pgbench и завершиться.

-?
--help

Вывести справку об аргументах командной строки pgbench и завершиться.

Замечания

Каково содержание «транзакции», которую выполняет pgbench?

Программа pgbench выполняет тестовые скрипты, выбирая их случайным образом из заданного списка. В том числе это встроенные скрипты, заданные аргументами -b, и пользовательские скрипты, заданные аргументами -f. Для каждого скрипта можно задать относительный вес после @, чтобы скорректировать вероятность его выбора. Вес по умолчанию — 1. Скрипты с весом 0 игнорируются.

Стандартный встроенный скрипт (также вызываемый с ключом -b tpcb-like) выдаёт семь команд в транзакции со случайно выбранными aid, tid, bid и delta. Его сценарий написан по мотивам теста производительности TPC-B, но это не собственно TPC-B, потому он называется так.

  1. BEGIN;

  2. UPDATE pgbench_accounts SET abalance = abalance + :delta WHERE aid = :aid;

  3. SELECT abalance FROM pgbench_accounts WHERE aid = :aid;

  4. UPDATE pgbench_tellers SET tbalance = tbalance + :delta WHERE tid = :tid;

  5. UPDATE pgbench_branches SET bbalance = bbalance + :delta WHERE bid = :bid;

  6. INSERT INTO pgbench_history (tid, bid, aid, delta, mtime) VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);

  7. END;

При выборе встроенного скрипта simple-update (или указании -N) шаги 4 и 5 исключаются из транзакции. Это позволяет избежать конкуренции при обращении к этим таблицам, но тест становится ещё менее похожим на TPC-B.

При выборе встроенного теста select-only (или указании -S) выполняется только SELECT.

Пользовательские скрипты

Программа pgbench поддерживает запуск пользовательских сценариев оценки производительности, позволяя заменять стандартный скрипт транзакции (описанный выше) скриптом, считываемым из файла (с параметром -f). В этом случае «транзакцией» считается одно выполнение данного скрипта.

Файл скрипта содержит одну или несколько команд SQL, разделённых точкой с запятой. Пустые строки и строки, начинающиеся с --, игнорируются. В файлах скриптов также могут содержаться «метакоманды», которые обрабатывает сама программа pgbench, как описано ниже.

Примечание

До версии Postgres Pro 9.6, SQL-команды в файлах скриптов завершались символами перевода строки, и поэтому они не могли занимать несколько строк. Теперь для разделения последовательных команд SQL требуется добавлять точку с запятой (хотя без неё можно обойтись в конце SQL-команды, за которой идёт метакоманда). Если вам нужно создать файл скрипта, работающий и со старыми версиями pgbench, записывайте каждую команду SQL в отдельной строке и завершайте её точкой с запятой.

Для файлов скриптов реализован простой механизм подстановки переменных. Переменные можно задать в командной строке параметрами -D, описанными выше, или метакомандами, рассматриваемыми ниже. Помимо переменных, которые можно установить параметрами командной строки -D, есть несколько автоматически устанавливаемых переменных; они перечислены в Таблице 1. Если значение этих переменных задаётся в параметре -D, оно переопределяет автоматическое значение. Когда значение переменной определено, его можно вставить в команду SQL, написав :имя_переменной. Каждый клиентский сеанс, если их несколько, получает собственный набор переменных.

Таблица 1. Автоматические переменные

ПеременнаяОписание
scaleтекущий коэффициент масштаба
client_idуникальное число, идентифицирующее клиентский сеанс (начиная с нуля)

Метакоманды в скрипте начинаются с обратной косой черты (\) и продолжаются до конца строки. Аргументы метакоманд разделяются пробелами. Поддерживаемые метакоманды представлены ниже:

\set имя_переменной выражение

Устанавливает для переменной имя_переменной значение, вычисленное из выражения. Выражение может содержать целочисленные константы (например, 5432), константы с плавающей точкой двойной точности (например, 3.14159), ссылки на переменные (:имя_переменной), унарные операторы (+, -), бинарные операторы (+, -, *, /, %), вычисляемые в обычном порядке, вызовы функций, а также скобки.

Примеры:

\set ntellers 10 * :scale
\set aid (1021 * random(1, 100000 * :scale)) % (100000 * :scale) + 1
\sleep номер [ us | ms | s ]

Приостанавливает выполнение скрипта на заданное число микросекунд (us), миллисекунд (ms) или секунд (s). Когда единицы не указываются, подразумеваются секунды. Здесь число может быть целочисленной константой или ссылкой :имя_переменной на переменную с целочисленным значением.

Пример:

\sleep 10 ms
\setshell имя_переменной команда [ аргумент ... ]

Присваивает переменной имя_переменной результат команды оболочки команда с указанными аргументами. Эта команда должна просто выдать целочисленное значение в стандартный вывод.

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

Пример:

\setshell назначаемая_переменная команда строковый_аргумент :переменная ::строка_начинающаяся_двоеточием
\shell команда [ аргумент ... ]

Действует так же, как и \setshell, но не учитывает результат команды.

Пример:

\shell команда строковый_аргумент :переменная ::строка_начинающаяся_двоеточием

Встроенные функции

Функции, перечисленные в Таблице 2, встроены в pgbench и могут применяться в выражениях в метакоманде \set.

Таблица 2. Функции pgbench

ФункцияТип результатаОписаниеПримерРезультат
abs(a)то же, что и aмодуль числа (абсолютное значение)abs(-17)17
debug(a)то же, что и aвыводит a в stderr и возвращает adebug(5432.1)5432.1
double(i)doubleприведение к типу с плавающей точкойdouble(5432)5432.0
greatest(a [, ... ] )double, если любой из аргументов (a) — double, а иначе целое числонаибольшее значение среди аргументовgreatest(5, 4, 3, 2)5
int(x)integerприведение к целочисленному типуint(5.4 + 3.8)9
least(a [, ... ] )double, если любой из аргументов (a) — double, а иначе целое числонаименьшее значение среди аргументовleast(5, 4, 3, 2.1)2.1
pi()doubleзначение константы PIpi()3.1415926535​8979323846
random(lb, ub)integerслучайное целое число с равномерным распределением в интервале [lb, ub]random(1, 10)целое между 1 и 10
random_exponential(lb, ub, parameter)integerслучайное целое число с экспоненциальным распределением в интервале [lb, ub], см. нижеrandom_exponential(1, 10, 3.0)целое между 1 и 10
random_gaussian(lb, ub, parameter)integerцелое число с распределением Гаусса в интервале [lb, ub], см. нижеrandom_gaussian(1, 10, 2.5)целое между 1 и 10
sqrt(x)doubleквадратный кореньsqrt(2.0)1.414213562

Функция random выдаёт значения с равномерным распределением, то есть вероятности получения всех чисел в интервале равны. Функции random_exponential и random_gaussian требуют указания дополнительного параметра типа double, определяющего точную форму распределения.

  • Для экспоненциального распределения parameter управляет распределением, обрезая быстро спадающее экспоненциальное распределение в точке parameter, а затем это распределение проецируется на целые числа между границами. Точнее говоря, с


    f(x) = exp(-parameter * (x - min) / (max - min + 1)) / (1 - exp(-parameter))

    значение i между min и max выдаётся с вероятностью: f(i) - f(i + 1).

    Интуиция подсказывает, что чем больше parameter, тем чаще будут выдаваться значения, близкие к min, и тем реже значения, близкие к max. Чем parameter ближе к 0, тем более плоским (более равномерным) будет распределение. В грубом приближении при таком распределении наиболее частый 1% значений в диапазоне рядом с min выдаётся parameter% времени. Значение parameter должно быть строго положительным.

  • Для распределения Гаусса по интервалу строится обычное нормальное распределение (классическая кривая Гаусса в форме колокола) и этот интервал обрезается в точке -parameter слева и +parameter справа. Вероятнее всего при таком распределении выдаются значения из середины интервала. Точнее говоря, если PHI(x) — функция распределения нормальной случайной величины со средним значением mu, равным (max + min) / 2.0, и


    f(x) = PHI(2.0 * parameter * (x - mu) / (max - min + 1)) /
           (2.0 * PHI(parameter) - 1)

    тогда значение i между min и max включительно выдаётся с вероятностью: f(i + 0.5) - f(i - 0.5). Интуиция подсказывает, что чем больше parameter, тем чаще будут выдаваться значения в середине интервала, и тем реже значения у границ min и max. Около 67% значений будут выдаваться из среднего интервала 1.0 / parameter, то есть плюс/минус 0.5 / parameter от среднего значения, и 95% из среднего интервала 2.0 / parameter, то есть плюс/минус 1.0 / parameter от среднего значения; например, если parameter равен 4.0, 67% значений выдаются из средней четверти (1.0 / 4.0) интервала (то есть от 3.0 / 8.0 до 5.0 / 8.0) и 95% из средней половины (2.0 / 4.0) интервала (из второй и третьей четвертей). Чтобы преобразование Бокса-Мюллера было быстрым, parameter должен быть не меньше 2.0.

В качестве примера взгляните на встроенное определение транзакции типа TPC-B:

\set aid random(1, 100000 * :scale)
\set bid random(1, 1 * :scale)
\set tid random(1, 10 * :scale)
\set delta random(-5000, 5000)
BEGIN;
UPDATE pgbench_accounts SET abalance = abalance + :delta WHERE aid = :aid;
SELECT abalance FROM pgbench_accounts WHERE aid = :aid;
UPDATE pgbench_tellers SET tbalance = tbalance + :delta WHERE tid = :tid;
UPDATE pgbench_branches SET bbalance = bbalance + :delta WHERE bid = :bid;
INSERT INTO pgbench_history (tid, bid, aid, delta, mtime) VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);
END;

С таким скриптом транзакция на каждой итерации будет обращаться к разным, случайно выбираемым строкам. (Этот пример показывает, почему важно, чтобы в каждом клиентском сеансе были собственные переменные — в противном случае они не будут независимо обращаться к разным строкам.)

Протоколирование транзакций

С параметром -l, но без --aggregate-interval, pgbench записывает в протокол время, которое ушло на выполнение каждой транзакции. Этот файл протокола будет называться pgbench_log.nnn, где nnn — PID процесса pgbench. Если используется параметр -j со значением 2 или больше, будет создано несколько рабочих потоков, и каждый будет записывать отдельный протокол. Первый рабочий процесс будет использовать файл с тем же именем, что и в стандартном случае с одним потоком, а файлы остальных потоков будут называться pgbench_log.nnn.mmm, где mmm — последовательный номер потока, начиная с 1.

Протокол имеет следующий формат:

код_клиента число_транзакций длительность номер_скрипта время_эпохи время_мкс [отставание_от_графика] [ повторы_сериализации повторы_взаимоблокировки ]

Здесь длительность — общее время транзакций (в микросекундах), номер_скрипта показывает, какой файл скрипта использовался (это полезно при указании нескольких скриптов ключами -f и -b), время_эпохи/время_мкс — отметка времени в формате Unix и смещение в микросекундах (из этих чисел можно получить время стандарта ISO 8601 с дробными секундами), показывающие, когда транзакция была завершена. Поле отставание_от_графика представляет разницу между запланированным временем запуска транзакции и фактическим временем запуска (в микросекундах). Оно выводится только когда применяется параметр --rate. Когда одновременно применяются параметры --rate и --latency-limit, в поле длительность для пропущенных транзакций будет выводиться skipped. Поля повторы_сериализации и повторы_взаимоблокировки отражают общее количество попыток выполнения транзакции после соответствующих ошибок при выполнении текущего скрипта. Они присутствуют, только если максимально возможное число попыток не равно 1 (--max-tries). Для транзакций, оказавшихся неуспешными из-за ошибок сериализации или взаимоблокировки, в столбце длительность будет выводиться failed (за дополнительными сведениями обратитесь к Повторы и отказы из-за ошибок сериализации/взаимоблокировки).

Примечание

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

Фрагмент полученного протокола:

0 199 2241 0 1175850568 995598
0 200 2465 0 1175850568 998079
0 201 2513 0 1175850569 608
0 202 2038 0 1175850569 2663

Ещё один пример с --rate=100 и --latency-limit=5 (обратите внимание на дополнительный столбец отставание_от_графика):

0 81 4621 0 1412881037 912698 3005
0 82 6173 0 1412881037 914578 4304
0 83 skipped 0 1412881037 914578 5217
0 83 skipped 0 1412881037 914578 5099
0 83 4722 0 1412881037 916203 3108
0 84 4142 0 1412881037 918023 2333
0 85 2465 0 1412881037 919759 740

В этом примере транзакция 82 опоздала, так как её длительность (6.173 мс) превысила ограничение в 5 мс. Следующие две транзакции были пропущены, так как было слишком поздно их начинать.

Ниже показан фрагмент файла журнала с отказами и повторными попытками при максимальном числе попыток, равном 10:

3 0 47423 0 1499414498 34501 3 0
3 1 8333 0 1499414498 42848 0 0
3 2 8358 0 1499414498 51219 0 0
4 0 72345 0 1499414498 59433 6 0
1 3 41718 0 1499414498 67879 4 0
1 4 8416 0 1499414498 76311 0 0
3 3 33235 0 1499414498 84469 3 0
0 0 failed 0 1499414498 84905 9 0
2 0 failed 0 1499414498 86248 9 0
3 4 8307 0 1499414498 92788 0 0

Когда проводится длительное тестирование с большим количеством транзакций, файлы протоколов могут быть очень объёмными. Чтобы в них записывалась только случайная выборка транзакций, можно запустить команду с параметром --sampling-rate.

Протоколирование с агрегированием

С ключом --aggregate-interval протоколы имеют несколько иной формат:

начало_интервала число_транзакций сумма_длительности сумма_длительности_2 мин_длительность макс_длительность отказы [сумма_задержки сумма_задержки_2 мин_задержка макс_задержка [пропущено_транзакций]] [ повторенные_транзакции повторы_сериализации повторы_взаимоблокировки ]

Здесь начало_интервала — начальное время интервала (в формате времени Unix), число_транзакций — количество транзакций в данном интервале, сумма_длительности — суммарная длительность транзакций (что позволяет легко вычислить среднюю длительность). Два поля, сумма_длительности и сумма_длительности_2 (представляющее сумму квадратов длительностей) полезны для оценки дисперсии. За ними идут поля мин_длительность — минимальная длительность в интервале и макс_длительность — максимальная. Следующее поле отказы содержит число транзакций, оказавшихся неуспешными из-за ошибок сериализации/взаимоблокировки в данном интервале (за подробностями обратитесь к Повторы и отказы из-за ошибок сериализации/взаимоблокировки). Транзакция учитывается в том интервале, в котором она была зафиксирована. Завершающие поля, сумма_задержки, сумма_задержки_2, мин_задержка и макс_задержка, присутствуют, только если применяется параметр --rate. Они отражают время, на которое задержалась каждая транзакция, ожидая завершения предыдущей, то есть разницу между временем фактического запуска и запланированным временем. Следующее поле, пропущено_транзакций, тоже присутствует, только если применяется параметр --latency-limit. Поля повторенные_транзакции, повторы_сериализации и повторы_взаимоблокировки присутствуют, только если максимальное число повторений транзакции не равно 1 (--max-tries). Они отражают количество повторно выполненных транзакций и общее число повторений после соответствующих ошибок в интервале.

Примечание

Если пользовательский скрипт содержит несколько транзакций и какие-либо из его транзакций завершаются неуспешно из-за ошибок сериализации/взаимоблокировки, его отказ засчитывается в поле отказы только один раз. Аналогично, в случае повторения каких-либо из транзакций счётчик повторенные_транзакции увеличивается на один, вне зависимости от количества повторявшихся транзакций. Однако поля повторы_сериализации и повторы_взаимоблокировки содержат сумму всех повторных попыток выполнения любой из транзакции этого скрипта вследствие соответствующих ошибок.

Пример вывода:

1345828501 5601 1542744 483552416 61 2573 0
1345828503 7884 1979812 565806736 60 1479 0
1345828505 7208 1979422 567277552 59 1391 0
1345828507 7685 1980268 569784714 60 1398 0
1345828509 7073 1979779 573489941 236 1411 0

Заметьте, что простой протокол (без агрегирования) содержит номера подключаемых файлов скриптов, в отличие от протокола с агрегированием. Таким образом, если вам нужны подобные сведения, но в разрезе скриптов, вам придётся агрегировать данные самостоятельно.

Отчёт по операторам

С параметром -r программа pgbench собирает следующую статистику по каждому оператору:

  • latency — время выполнения для каждого оператора. pgbench выводит среднее по всем успешным попыткам выполнения оператора.

  • Число отказов вследствие ошибок сериализации и взаимоблокировки. За дополнительной информацией обратитесь к Повторы и отказы из-за ошибок сериализации/взаимоблокировки.

  • Число повторных попыток выполнения после ошибки сериализации/взаимоблокировки в этом операторе; они обозначаются как повторы при сериализации и повторы при взаимоблокировке, соответственно.

В отчёте выводятся столбцы со статистикой по отказам и повторным попыткам, только если в текущем прогоне pgbench имели место любого рода отказы или повторные попытки, соответственно.

Примечание

Если пользовательский скрипт содержит несколько транзакций, подсчитываются отказы и повторные попытки выполнения всех транзакций. Таким образом, общее количество отказов и/или повторений может превышать количество отказов и/или повторений скриптов транзакций, соответственно.

Все эти значения вычисляются для каждого оператора, выполняемого каждым клиентом, и выдаются после завершения теста.

Со скриптом по умолчанию вывод будет примерно таким:

starting vacuum...end.
transaction type: <builtin: TPC-B (sort of)>
default transaction isolation level: read committed
transaction maximum tries number: 1
scaling factor: 1
query mode: simple
number of clients: 10
number of threads: 1
number of transactions per client: 1000
number of transactions actually processed: 10000/10000
latency average = 15.844 ms
latency stddev = 2.715 ms
tps = 618.764555 (including connections establishing)
tps = 622.977698 (excluding connections establishing)
script statistics:
 - statement latencies in milliseconds:
        0.002  \set aid random(1, 100000 * :scale)
        0.005  \set bid random(1, 1 * :scale)
        0.002  \set tid random(1, 10 * :scale)
        0.001  \set delta random(-5000, 5000)
        0.326  BEGIN;
        0.603  UPDATE pgbench_accounts SET abalance = abalance + :delta WHERE aid = :aid;
        0.454  SELECT abalance FROM pgbench_accounts WHERE aid = :aid;
        5.528  UPDATE pgbench_tellers SET tbalance = tbalance + :delta WHERE tid = :tid;
        7.335  UPDATE pgbench_branches SET bbalance = bbalance + :delta WHERE bid = :bid;
        0.371  INSERT INTO pgbench_history (tid, bid, aid, delta, mtime) VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);
        1.212  END;

Ещё один пример вывода для скрипта по умолчанию с выбором сериализуемого уровня изоляции (-I S):

starting vacuum...end.
transaction type: <builtin: TPC-B (sort of)>
default transaction isolation level: serializable
transaction maximum tries number: 100
scaling factor: 1
query mode: simple
number of clients: 10
number of threads: 1
number of transactions per client: 1000
number of transactions actually processed: 9676/10000
number of transactions failed: 324 (3.240 %)
number of transactions retried: 5629 (56.290 %)
number of retries: 103299 (serialization: 103299, deadlocks: 0)
number of transactions above the 100.0 ms latency limit: 21 (0.217 %)
latency average = 16.138 ms
latency stddev = 21.017 ms
tps = 413.650224 (including connections establishing)
tps = 413.686560 (excluding connections establishing)
script statistics:
 - number of transactions skipped: 0 (0.000%)
 - statement latencies in milliseconds, serialization failures and retries,
   deadlock failures and retries:
  0.002    0      0  0  0  \set aid random(1, 100000 * :scale)
  0.000    0      0  0  0  \set bid random(1, 1 * :scale)
  0.000    0      0  0  0  \set tid random(1, 10 * :scale)
  0.000    0      0  0  0  \set delta random(-5000, 5000)
  0.121    0      0  0  0  BEGIN;
  0.290    0      2  0  0  UPDATE pgbench_accounts
                           SET abalance = abalance + :delta WHERE aid = :aid;
  0.221    0      0  0  0  SELECT abalance FROM pgbench_accounts
                           WHERE aid = :aid;
  0.266  212  72127  0  0  UPDATE pgbench_tellers
                           SET tbalance = tbalance + :delta WHERE tid = :tid;
  0.222  112  31170  0  0  UPDATE pgbench_branches
                           SET bbalance = bbalance + :delta WHERE bid = :bid;
  0.178    0      0  0  0  INSERT INTO pgbench_history
                                  (tid, bid, aid, delta, mtime)
                           VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);
  1.210    0      0  0  0  END;

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

Учтите, что сбор дополнительных временных показателей влечёт некоторые издержки и приводит к снижению средней скорости и, как результат, падению TPS. На сколько именно снизится скорость, во многом зависит от платформы и оборудования. Хороший способ оценить, каковы эти издержки — сравнить средние значения TPS, получаемые с подсчётом времени операторов и без такого подсчёта.

Повторы и отказы из-за ошибок сериализации/взаимоблокировки

Транзакции с ошибками сериализации или взаимоблокировки откатываются и повторяются до успешного выполнения или до достижения максимального числа попыток, задаваемого параметром --max-tries. Вы также можете ограничить время попыток с помощью параметра --latency-limit и/или --time; в этих случаях можно разрешить неограниченное число попыток в течение заданного отрезка времени, установив значение 0 для параметра --max-tries. Если последняя попытка выполнить транзакцию не удаётся, транзакция считается неуспешной.

Примечание

Будьте осторожны, планируя повторение транзакций с командами оболочки. В отличие от результата команд SQL, действие команд оболочки не отменяется, не считая изменения значений переменных командой \setshell. Если команда оболочки завершается ошибкой, клиент отключается и не перезапускается.

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

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

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

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

Примечание

Если пользовательский скрипт содержит несколько транзакций, его выполнение считается неуспешным в случае неуспешного завершения какой-либо из транзакций вследствие ошибок сериализации/взаимоблокировки. Также он считается выполнявшимся повторно, если имело место повторное выполнение какое-либо из его транзакций. Общее количество повторений скрипта складывается из числа повторений всех транзакций в этом скрипте.

Полезные советы

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

Во-первых, никогда не доверяйте тестам, которые выполняются всего несколько секунд. Воспользуйтесь параметром -t и -T и установите время выполнения не меньше нескольких минут, чтобы избавиться от шума в средних значениях. В некоторых случаях для получения воспроизводимых результатов тестирование должно продолжаться несколько часов. Чтобы понять, были ли получены воспроизводимые значения, имеет смысл запустить тестирование несколько раз.

Для стандартного сценария по типу TPC-B начальный коэффициент масштаба (-s) должен быть не меньше числа клиентов, с каким вы намерены проводить тестирование (-c); в противном случае вы, по большому счёту, будете замерять время конкурентных изменений. Таблица pgbench_branches содержит всего -s строк, а каждая транзакция хочет изменить одну из них, так что если значение -c превышает -s, это несомненно приведёт к тому, что многие транзакции будут блокироваться другими.

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

Полезность результатов pgbench также может ограничиваться тем, что тестирование с большим числом клиентских сеансов само по себе нагружает систему. Этого можно избежать, запуская pgbench на другом компьютере, не на сервере баз данных, хотя при этом большое значение имеет скорость сети. Иногда, оценивая производительность одного сервера, полезно запускать даже несколько экземпляров pgbench параллельно, на отдельных клиентских компьютерах.

Безопасность

Если к базе данных, которая не приведена в соответствие шаблону безопасного использования схем, имеют доступ недоверенные пользователи, не запускайте pgbench в этой базе. Программа pgbench использует неполные имена и не настраивает для себя путь поиска.