Как проводить бенчмарк-тестирование кода Rust с помощью libtest bench

Everett Pompeii

Что такое бенчмаркинг?

Бенчмаркинг — это практика тестирования производительности вашего кода, чтобы увидеть, насколько быстро (задержка) или сколько (пропускная способность) работы он может выполнить. Этот часто упускаемый из виду этап в разработке программного обеспечения является ключевым для создания и поддержания быстрого и производительного кода. Бенчмаркинг предоставляет необходимые метрики, чтобы разработчики могли понять, насколько хорошо их код работает под различными рабочими нагрузками и условиями. По тем же причинам, по которым вы пишете модульные и интеграционные тесты, чтобы предотвратить регрессию функций, вам следует писать тесты производительности, чтобы предотвратить регрессию производительности. Ошибки производительности — это ошибки!

Напишите FizzBuzz на Rust

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

Правила для FizzBuzz таковы:

Напишите программу, которая выводит целые числа от 1 до 100 (включительно):

• Для кратных трём, выводите Fizz
• Для кратных пяти, выводите Buzz
• Для кратных и трём и пяти, выводите FizzBuzz
• Во всех других случаях, выводите число

Есть множество способов написать FizzBuzz. Так что мы выберем мой любимый:

fn main() {
    for i in 1..=100 {
        match (i % 3, i % 5) {
            (0, 0) => println!("FizzBuzz"),
            (0, _) => println!("Fizz"),
            (_, 0) => println!("Buzz"),
            (_, _) => println!("{i}"),
        }
    }
}

• Создайте функцию main
• Переберите числа от 1 до 100 включительно.
• Для каждого числа вычислите модуль (остаток после деления) для 3 и 5.
• Используйте образцовое сопоставление для двух остатков. Если остаток равен 0, значит число кратно данному фактору.
• Если остаток равен 0 для обоих 3 и 5, то напечатайте FizzBuzz.
• Если остаток равен 0 только для 3, то напечатайте Fizz.
• Если остаток равен 0 только для 5, то напечатайте Buzz.
• В противном случае просто напечатайте число.

Следуйте Шаг за Шагом

Чтобы следовать этому пошаговому руководству, вам потребуется установить Rust.

🐰 Исходный код для этого поста доступен на GitHub

После установки Rust вы можете открыть окно терминала и ввести: cargo init game

Затем перейдите во вновь созданную директорию game.

game
├── Cargo.toml
└── src
    └── main.rs

Вы должны увидеть директорию под названием src с файлом main.rs:

fn main() {
    println!("Hello, world!");
}

Замените его содержимое приведенной выше реализацией FizzBuzz. Затем запустите cargo run. Вывод должен выглядеть так:

$ cargo run
   Compiling playground v0.0.1 (/home/bencher)
    Finished dev [unoptimized + debuginfo] target(s) in 0.44s
     Running `target/debug/game`

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
...
97
98
Fizz
Buzz

🐰 Бах! Вы успешно проходите собеседование по кодированию!

Должен был сгенерироваться новый файл Cargo.lock:

game
├── Cargo.lock
├── Cargo.toml
└── src
    └── main.rs

Прежде чем продолжить, важно обсудить различия между микро- и макро-бенчмаркингом.

Микробенчмаркинг vs Макробенчмаркинг

Существует две основные категории бенчмарков программного обеспечения: микробенчмарки и макробенчмарки. Микробенчмарки работают на уровне, аналогичном модульным тестам. Например, бенчмарк для функции, определяющей Fizz, Buzz или FizzBuzz для одного числа, будет микробенчмарком. Макробенчмарки работают на уровне, аналогичном интеграционным тестам. Например, бенчмарк для функции, которая запускает полную игру FizzBuzz, от 1 до 100, будет макробенчмарком.

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

Бенчмаркинг в Rust

Три популярных варианта для бенчмаркинга в Rust: libtest bench, Criterion, и Iai.

libtest — это встроенная в Rust система для модульного тестирования и бенчмаркинга. Хотя libtest bench является частью стандартной библиотеки Rust, она все еще считается нестабильной, поэтому доступна только в выпусках компилятора nightly. Чтобы работать с стабильным компилятором Rust, необходимо использовать отдельную систему для бенчмаркинга. Однако ни одна из них не находится в активной разработке.

Самой популярной системой для бенчмаркинга в экосистеме Rust является Criterion. Она работает как на стабильных, так и на nightly выпусках компилятора Rust, и стала фактическим стандартом в сообществе Rust. Criterion также намного более функциональна по сравнению с libtest bench.

Экспериментальной альтернативой Criterion является Iai от того же создателя. Однако она использует подсчет инструкций вместо времени с помощью системных часов: инструкции ЦП, L1-доступы, L2-доступы и доступ к оперативной памяти. Это позволяет проводить одноразовые измерения, так как эти метрики должны оставаться почти идентичными между запусками.

Все три поддерживаются Bencher. Так почему же выбрать libtest bench? Это может быть хорошей идеей, если вы пытаетесь ограничить внешние зависимости вашего проекта и ваш проект уже использует nightly toolchain. В остальных случаях я бы предложил использовать либо Criterion, либо Iai в зависимости от вашего случая использования.

Установка Rust nightly

Сказав все это, мы собираемся использовать libtest bench, поэтому давайте установим наш Rust toolchain на nightly. Создайте файл rust-toolchain.toml в корне вашего проекта game, рядом с Cargo.toml.

[toolchain]
channel = "nightly"

Структура вашего каталога теперь должна выглядеть так:

game
├── Cargo.lock
├── Cargo.toml
├── rust-toolchain.toml
└── src
    └── main.rs

Как только это будет завершено, повторно запустите cargo run. Должно потребоваться минуту для установки нового, nightly toolchain прежде чем повторно запустить и дать вам тот же вывод, что и раньше.

Рефакторинг FizzBuzz

Чтобы протестировать наше приложение FizzBuzz, нам нужно отделить нашу логику от основной функции программы main. Тестовые стенды не могут проводить бенчмаркинг основной функции.

Обновите ваш код, чтобы он выглядел так:

fn main() {
    for i in 1..=100 {
        play_game(i);
    }
}

pub fn play_game(n: u32) {
    println!("{}", fizz_buzz(n));
}

pub fn fizz_buzz(n: u32) -> String {
    match (n % 3, n % 5) {
        (0, 0) => "FizzBuzz".to_string(),
        (0, _) => "Fizz".to_string(),
        (_, 0) => "Buzz".to_string(),
        (_, _) => n.to_string(),
    }
}

Теперь мы разделили наш код на три разные функции:

• main: Основная точка входа в нашу программу, которая проходит через числа от 1 до 100 включительно и вызывает play_game для каждого числа.
• play_game: Принимает беззнаковое целое число n, вызывает fizz_buzz с этим числом и печатает результат.
• fizz_buzz: Принимает беззнаковое целое число n и выполняет реальную логику Fizz, Buzz, FizzBuzz, или число, возвращая результат в виде строки.

Бенчмарк-тестирование FizzBuzz

Чтобы использовать нестабильный крейт libtest, нам нужно включить функцию test для нашего кода и импортировать крейт test. Добавьте следующее в самом верху main.rs:

#![feature(test)]
extern crate test;

Теперь мы готовы добавить наш первый бенчмарк! Добавьте следующее в самом низу main.rs:

#[cfg(test)]
mod benchmarks {
    use test::Bencher;

    use super::play_game;

    #[bench]
    fn bench_play_game(b: &mut Bencher) {
        b.iter(|| {
            std::hint::black_box(for i in 1..=100 {
                play_game(i)
            });
        });
    }
}

• Создайте модуль с именем benchmarks и установите конфигурацию компилятора в test mode.
• Импортируйте запуск бенчмарка Bencher. (🐰 Эй, клевое имя!)
• Импортируйте нашу функцию play_game.
• Создайте бенчмарк с именем bench_play_game, который принимает изменяемую ссылку на Bencher.
• Установите атрибут #[bench], чтобы указать, что bench_play_game - это бенчмарк.
• Используйте экземпляр Bencher (b), чтобы запустить наш макро-бенчмарк несколько раз.
• Запустите наш макро-бенчмарк внутри “black box”, чтобы компилятор не оптимизировал наш код.
• Переберите числа от 1 до 100 включительно.
• Для каждого числа вызовите play_game.

Теперь мы готовы протестировать наш код, запустите cargo bench:

$ cargo bench
   Compiling playground v0.0.1 (/home/bencher)
    Finished bench [optimized] target(s) in 0.02s
     Running unittests src/main.rs (target/release/deps/game-68f58c96f4025bd4)

running 1 test
test benchmarks::bench_play_game ... bench:       4,879 ns/iter (+/- 170)

test result: ok. 0 passed; 0 failed; 0 ignored; 1 measured; 0 filtered out; finished in 0.68s

🐰 Двигаемся вперед, у нас есть наши первые метрики бенчмарк-тестирования!

Наконец, мы можем отдохнуть… Шутка, наши пользователи хотят новую функциональность!

Написать FizzBuzzFibonacci на Rust

Наши ключевые показатели эффективности (KPI) снизились, поэтому наш менеджер по продуктам (PM) хочет, чтобы мы добавили новую функцию. После многочисленных брейнстормингов и интервью с пользователями было решено, что просто FizzBuzz недостаточно. Детям сегодняшнего дня хочется новую игру, FizzBuzzFibonacci.

Правила для FizzBuzzFibonacci следующие:

Напишите программу, которая выводит целые числа от 1 до 100 (включительно):

• Для кратных трем, вывод Fizz
• Для кратных пяти, вывод Buzz
• Для кратных и трем, и пяти, вывод FizzBuzz
• Для чисел, которые являются частью последовательности Фибоначчи, вывод только Fibonacci
• Для всех остальных, вывод самого числа

Последовательность Фибоначчи - это последовательность чисел, в которой каждое следующее число является суммой двух предыдущих. Например, начиная с 0 и 1, следующим числом в последовательности Фибоначчи будет 1. За ним следуют: 2, 3, 5, 8 и так далее. Числа, которые являются частью последовательности Фибоначчи, известны как числа Фибоначчи. Так что нам придется написать функцию, которая определяет числа Фибоначчи.

Есть много способов записать последовательность Фибоначчи и, аналогично, много способов определить число Фибоначчи. Поэтому мы пойдем моим любимым способом:

fn is_fibonacci_number(n: u32) -> bool {
    for i in 0..=n {
        let (mut previous, mut current) = (0, 1);
        while current < i {
            let next = previous + current;
            previous = current;
            current = next;
        }
        if current == n {
            return true;
        }
    }
    false
}

• Создайте функцию под названием is_fibonacci_number, которая принимает беззнаковое целое число и возвращает булево значение.
• Повторяйте для всех чисел от 0 до нашего данного числа n включительно.
• Инициализируйте нашу последовательность Фибоначчи, начиная с 0 и 1 в качестве previous и current чисел соответственно.
• Повторите, пока current число меньше текущей итерации i.
• Добавьте previous и current числа, чтобы получить next число.
• Обновите previous число на current число.
• Обновите current число на next число.
• Как только current станет больше или равным данному числу n, мы выйдем из цикла.
• Проверьте, равно ли current число данному числу n, и если да, верните true.
• В противном случае верните false.

Теперь нам нужно будет обновить нашу функцию fizz_buzz:

pub fn fizz_buzz_fibonacci(n: u32) -> String {
    if is_fibonacci_number(n) {
        "Fibonacci".to_string()
    } else {
        match (n % 3, n % 5) {
            (0, 0) => "FizzBuzz".to_string(),
            (0, _) => "Fizz".to_string(),
            (_, 0) => "Buzz".to_string(),
            (_, _) => n.to_string(),
        }
    }
}

• Переименуйте функцию fizz_buzz в fizz_buzz_fibonacci, чтобы сделать его более описательным.
• Вызовите нашу вспомогательную функцию is_fibonacci_number.
• Если результат is_fibonacci_number равен true, то верните Fibonacci.
• Если результат is_fibonacci_number равен false, тогда выполните ту же логику Fizz, Buzz, FizzBuzz, или число, возвращая результат.

Поскольку мы переименовываем fizz_buzz в fizz_buzz_fibonacci, нам также нужно обновить нашу функцию play_game:

pub fn play_game(n: u32) {
    println!("{}", fizz_buzz_fibonacci(n));
}

Обе наши функции main и bench_play_game могут остаться точно такими же.

Бенчмарк-тестирование FizzBuzzFibonacci

Теперь мы можем заново запустить наш бенчмарк:

$ cargo bench
   Compiling playground v0.0.1 (/home/bencher)
    Finished bench [optimized] target(s) in 0.00s
     Running unittests src/main.rs (target/release/deps/game-68f58c96f4025bd4)

running 1 test
test benchmarks::bench_play_game ... bench:      22,167 ns/iter (+/- 502)

test result: ok. 0 passed; 0 failed; 0 ignored; 1 measured; 0 filtered out; finished in 0.62s

Прокручивая назад нашу историю терминала, мы можем сделать сравнение между производительностью наших игр FizzBuzz и FizzBuzzFibonacci: 4,879 нс против 22,167 нс. Ваши числа будут немного отличаться от моих. Однако разница между двуми играми, вероятно, около 5 раз. Мне кажется, это хорошо! Особенно для добавления такой нарядной функции, как Fibonacci в нашу игру. Детишкам понравится!

Расширяем FizzBuzzFibonacci на Rust

Наша игра стала хитом! Дети действительно любят играть в FizzBuzzFibonacci. Настолько сильно, что нам донеслись слухи от боссов, что они хотят создать продолжение. Но мы живем в современном мире, нам нужен ежегодный повторяющийся доход (ARR), а не разовые покупки! Новое видение нашей игры - это открытая игра, больше не нужно жить в пределах от 1 до 100 (даже если это включительно). Нет, мы открываем новые горизонты!

Правила для Open World FizzBuzzFibonacci следующие:

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

• Для кратных трем, выводит Fizz
• Для кратных пяти, выводит Buzz
• Для кратных и трем, и пяти, выводит FizzBuzz
• Для чисел, которые являются частью последовательности Фибоначчи, выводит только Fibonacci
• Для всех остальных чисел, выводит само число

Чтобы наша игра работала с любым числом, нам нужно будет принять аргумент командной строки. Обновите функцию main так, чтобы она выглядела так:

fn main() {
    let args: Vec<String> = std::env::args().collect();
    let i = args
        .get(1)
        .map(|s| s.parse::<u32>())
        .unwrap_or(Ok(15))
        .unwrap_or(15);
    play_game(i);
}

• Собираем все аргументы (args), переданные нашей игре из командной строки.
• Получаем первый аргумент, переданный нашей игре, и анализируем его как беззнаковое целое число i.
• Если парсинг сфейлился или аргумент не был передан, по умолчанию считаем, что в нашу игру играют с 15 на входе.
• Наконец, играем в нашу игру с новым разобранным беззнаковым целым числом i.

Теперь мы можем играть в нашу игру с любым числом! Используйте cargo run, затем -- для передачи аргументов нашей игре:

$ cargo run -- 9
   Compiling playground v0.0.1 (/home/bencher)
    Finished dev [unoptimized + debuginfo] target(s) in 0.44s
     Running `target/debug/game 9`
Fizz

$ cargo run -- 10
    Finished dev [unoptimized + debuginfo] target(s) in 0.03s
     Running `target/debug/game 10`
Buzz

$ cargo run -- 13
    Finished dev [unoptimized + debuginfo] target(s) in 0.04s
     Running `target/debug/game 13`
Fibonacci

А если мы опустим или передадим недействительное число:

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.03s
     Running `target/debug/game`
FizzBuzz

$ cargo run -- bad
    Finished dev [unoptimized + debuginfo] target(s) in 0.05s
     Running `target/debug/game bad`
FizzBuzz

Вау, это было детальное тестирование! CI проходит. Наши шефы в восторге. Давайте пустим это в продакшн! 🚀

Конец

🐰 … конец вашей карьеры, может быть?

Шутка ли, всё в огне! 🔥

Сначала казалось, что все идет нормально. Но в 02:07 утра в субботу мой пейджер прозвучал:

📟 Ваша игра в огне! 🔥

Выпрыгнув из кровати, я пытался понять, что происходит. Я попытался пройтись по логам, но это было сложно, потому что все постоянно вылетало. Наконец, я нашёл проблему. Дети! Им настолько понравилась наша игра, что они играли в нее аж до миллиона! В свете гениального озарения, я добавил два новых бенчмарка:

#[bench]
fn bench_play_game_100(b: &mut Bencher) {
    b.iter(|| std::hint::black_box(play_game(100)));
}

#[bench]
fn bench_play_game_1_000_000(b: &mut Bencher) {
    b.iter(|| std::hint::black_box(play_game(1_000_000)));
}

• Микро-бенчмарк bench_play_game_100 для игры с числом сто (100)
• Микро-бенчмарк bench_play_game_1_000_000 для игры с числом один миллион (1_000_000)

Когда я запустил его, я получил это:

$ cargo bench
   Compiling game v0.1.0 (/home/bencher)
    Finished bench [optimized] target(s) in 0.75s
     Running unittests src/main.rs (target/release/deps/game-6e1cb3355509b761)

running 3 tests
test benchmarks::bench_play_game           ... bench:      22,458 ns/iter (+/- 1,508)
test benchmarks::bench_play_game_100       ... bench:         439 ns/iter (+/- 21)

Подождите … подождите …

test benchmarks::bench_play_game_1_000_000 ... bench:   9,586,977 ns/iter (+/- 15,923)

Что! 439 нс x 1,000 должно быть 439,000 нс, а не 9,586,977 нс 🤯 Несмотря на то, что мой код для последовательности Фибоначчи функционально правильный, у меня, должно быть, где-то есть ошибка производительности.

Исправляем FizzBuzzFibonacci в Rust

Давайте еще раз взглянем на функцию is_fibonacci_number:

fn is_fibonacci_number(n: u32) -> bool {
    for i in 0..=n {
        let (mut previous, mut current) = (0, 1);
        while current < i {
            let next = previous + current;
            previous = current;
            current = next;
        }
        if current == n {
            return true;
        }
    }
    false
}

Теперь, когда я думаю о производительности, я понимаю, что у меня есть ненужный, дополнительный цикл. Мы можем полностью избавиться от цикла for i in 0..=n {} и просто сравнить значение current с данной числом (n) 🤦

fn is_fibonacci_number(n: u32) -> bool {
    let (mut previous, mut current) = (0, 1);
    while current < n {
        let next = previous + current;
        previous = current;
        current = next;
    }
    current == n
}

• Обновите вашу функцию is_fibonacci_number.
• Инициализируйте последовательность Фибоначчи, начав с 0 и 1, как previous и current числах соответственно.
• Итерируйте пока current число меньше данного числа n.
• Добавьте previous и current число, чтобы получить next число.
• Обновите число previous на число current.
• Обновите число current на число next.
• Как только current становится больше или равно данному числу n, мы выйдем из цикла.
• Проверьте, равно ли current число данному числу n, и верните этот результат.

Теперь давайте запустим эти бенчмарки и посмотрим, как нам удалось:

$ cargo bench
   Compiling game v0.1.0 (/home/bencher)
    Finished bench [optimized] target(s) in 0.75s
     Running unittests src/main.rs (target/release/deps/game-6e1cb3355509b761)

running 3 tests
test benchmarks::bench_play_game           ... bench:       5,570 ns/iter (+/- 390)
test benchmarks::bench_play_game_100       ... bench:          46 ns/iter (+/- 3)
test benchmarks::bench_play_game_1_000_000 ... bench:          53 ns/iter (+/- 4)

test result: ok. 0 passed; 0 failed; 0 ignored; 3 measured; 0 filtered out; finished in 9.24s

Ого! Наш бенчмарк bench_play_game снова опустился примерно до того уровня, что и был для первоначального FizzBuzz. Жаль, что я не могу вспомнить точно, какой был этот показатель. Прошло три недели. Моя история терминала не ведется настолько далеко. Но я думаю, что это близко!

Бенчмарк bench_play_game_100 упал почти в 10 раз, 439 нс до 46 нс. И бенчмарк bench_play_game_1_000_000 снизился более чем в 10,000 раз! 9,586,977 нс до 53 нс!

🐰 Эй, хоть мы поймали это баг с производительностью до того, как он попал в продакшн… а, точно. Ну да ладно…

Отслеживание регрессий производительности в CI

Руководители были недовольны потоком отрицательных отзывов, которые наша игра получила из-за моей ошибки в производительности. Они сказали мне, чтобы это больше не происходило, и когда я спросил как, они просто сказали мне больше этого не делать. Как мне это контролировать‽

К счастью, я нашел этот замечательный инструмент с открытым исходным кодом под названием Bencher. У него есть очень щедрый бесплатный уровень, поэтому я могу использовать Bencher Cloud для своих личных проектов. А на работе, где все должно быть в нашем приватном облаке, я начал использовать Самостоятельный хостинг Bencher.

У Bencher есть встроенные адаптеры, поэтому их легко интегрировать в CI. После прочтения руководства по быстрому старту, я могу запускать свои бенчмарки и отслеживать их с помощью Bencher.

$ bencher run --project game "cargo bench"
    Finished bench [optimized] target(s) in 0.03s
     Running unittests src/main.rs (target/release/deps/game-6e1cb3355509b761)

running 3 tests
test benchmarks::bench_play_game           ... bench:       5,690 ns/iter (+/- 1,091)
test benchmarks::bench_play_game_100       ... bench:          48 ns/iter (+/- 7)
test benchmarks::bench_play_game_1_000_000 ... bench:          51 ns/iter (+/- 3)

test result: ok. 0 passed; 0 failed; 0 ignored; 3 measured; 0 filtered out; finished in 2.81s

Bencher New Report:
...
View results:
- benchmarks::bench_play_game (Latency): https://bencher.dev/console/projects/game/perf?measures=52507e04-ffd9-4021-b141-7d4b9f1e9194&branches=3a27b3ce-225c-4076-af7c-75adbc34ef9a&testbeds=bc05ed88-74c1-430d-b96a-5394fdd18bb0&benchmarks=077449e5-5b45-4c00-bdfb-3a277413180d&start_time=1697224006000&end_time=1699816009000&upper_boundary=true
- benchmarks::bench_play_game_100 (Latency): https://bencher.dev/console/projects/game/perf?measures=52507e04-ffd9-4021-b141-7d4b9f1e9194&branches=3a27b3ce-225c-4076-af7c-75adbc34ef9a&testbeds=bc05ed88-74c1-430d-b96a-5394fdd18bb0&benchmarks=96508869-4fa2-44ac-8e60-b635b83a17b7&start_time=1697224006000&end_time=1699816009000&upper_boundary=true
- benchmarks::bench_play_game_1_000_000 (Latency): https://bencher.dev/console/projects/game/perf?measures=52507e04-ffd9-4021-b141-7d4b9f1e9194&branches=3a27b3ce-225c-4076-af7c-75adbc34ef9a&testbeds=bc05ed88-74c1-430d-b96a-5394fdd18bb0&benchmarks=ff014217-4570-42ea-8813-6ed0284500a4&start_time=1697224006000&end_time=1699816009000&upper_boundary=true

Используя это замечательное устройство для путешествий во времени, которое мне дал милый кролик, Я смог вернуться в прошлое и повторить то, что бы произошло, если бы мы использовали Bencher с самого начала. Вы можете увидеть, где мы впервые внесли ошибочную реализацию FizzBuzzFibonacci. Я немедленно получил ошибки в CI в виде комментария к моему запросу на вытягивание. В тот же день я исправил ошибку производительности, устранив не нужный, лишний цикл. Никаких пожаров. Только довольные пользователи.

Bencher: Непрерывное тестирование производительности

Bencher - это набор инструментов для непрерывного тестирования производительности. Когда-нибудь регрессия производительности влияла на ваших пользователей? Bencher мог бы предотвратить это. Bencher позволяет вам обнаруживать и предотвращать регрессии производительности до того, как они попадут в продакшн.

• Запустить: Запустите свои тесты производительности локально или в CI, используя ваши любимые инструменты для этого. CLI bencher просто оборачивает ваш существующий аппарат тестирования и сохраняет его результаты.
• Отслеживать: Отслеживайте результаты ваших тестов производительности со временем. Мониторите, запрашивайте и строите графики результатов с помощью веб-консоли Bencher на основе ветки исходного кода, испытательного стенда и меры.
• Поймать: Отлавливайте регрессии производительности в CI. Bencher использует инструменты аналитики, работающие по последнему слову техники, чтобы обнаружить регрессии производительности, прежде чем они попадут в продакшн.

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

Начните отлавливать регрессии производительности в CI — попробуйте Bencher Cloud бесплатно.