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

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

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

Напишите 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 система для модульного тестирования и бенчмаркинга. Хотя она является частью стандартной библиотеки Rust, libtest bench все еще считается нестабильной, поэтому доступна только в релизах компилятора nightly. Чтобы работать на стабильном компиляторе Rust, необходимо использовать отдельный бенчмаркинговый арнес. Однако ни один из них не развивается активно.

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

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

Все три поддерживаются Bencher. Так почему выбрать Criterion? Criterion - это де-факто стандартный инструмент для проведения бенчмарка в сообществе Rust. Я бы предложил использовать Criterion для проверки производительности вашего кода. То есть Criterion отлично подходит для измерения реального времени выполнения кода.

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

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

В директории src создайте новый файл под названием lib.rs:

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

Добавьте следующий код в lib.rs:

pub fn play_game(n: u32, print: bool) {
    let result = fizz_buzz(n);
    if print {
        println!("{result}");
    }
}

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(),
    }
}

• play_game: Принимает беззнаковое целое число n, вызывает fizz_buzz с этим числом и, если print равно true, выводит результат.
• fizz_buzz: Принимает беззнаковое целое число n и выполняет собственно логику Fizz, Buzz, FizzBuzz, или число, возвращая результат в виде строки.

Затем обновите main.rs так, чтобы он выглядел следующим образом:

use game::play_game;

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

• game::play_game: Импортируйте play_game из только что созданного нами ящика game с lib.rs.
• main: Основная точка входа в нашу программу, которая проходит через числа 1 до 100 включительно и вызывает play_game для каждого числа, при этом print установлен в true.

Бенчмарк для FizzBuzz

Чтобы провести бенчмарк нашего кода, нам нужно создать директорию benches и добавить файл, который будет содержать наши бенчмарки, play_game.rs:

game
├── Cargo.lock
├── Cargo.toml
└── benches
    └── play_game.rs
└── src
    └── lib.rs
    └── main.rs

Внутри play_game.rs добавьте следующий код:

use criterion::{criterion_group, criterion_main, Criterion};

use game::play_game;

fn bench_play_game(c: &mut Criterion) {
    c.bench_function("bench_play_game", |b| {
        b.iter(|| {
            std::hint::black_box(for i in 1..=100 {
                play_game(i, false)
            });
        });
    });
}

criterion_group!(
    benches,
    bench_play_game,
);
criterion_main!(benches);

• Импортируйте бегунок для бенчмарков Criterion.
• Импортируйте функцию play_game из нашей поставки game.
• Создайте функцию с названием bench_play_game, которая принимает изменяемую ссылку на Criterion.
• Используйте экземпляр Criterion (c) для создания бенчмарка с названием bench_play_game.
• Затем используйте бегунок для бенчмарка (b) для запуска нашего макро-бенчмарка несколько раз.
• Запустите наш макро-бенчмарк внутри “чёрного ящика”, чтобы компилятор не оптимизировал наш код.
• Проитерируйтесь от 1 до 100 включительно.
• Для каждого числа вызовите play_game, установив print в false.

Теперь нам нужно настроить поставку game для запуска наших бенчмарков.

Добавьте следующее в низ вашего файла Cargo.toml:

[dev-dependencies]
criterion = "0.5"

[[bench]]
name = "play_game"
harness = false

• criterion: Добавьте criterion как зависимость для разработки, так как мы используем его только для тестирования производительности.
• bench: Регистрируйте play_game как бенчмарк и установите для harness значение false, так как мы будем использовать Criterion в качестве среды для бенчмаркинга.

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

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

running 0 tests

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

     Running unittests src/main.rs (target/release/deps/game-043972c4132076a9)

running 0 tests

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

     Running benches/play_game.rs (target/release/deps/play_game-e0857103eb02eb56)
bench_play_game         time:   [3.0020 µs 3.0781 µs 3.1730 µs]
Found 12 outliers among 100 measurements (12.00%)
  2 (2.00%) high mild
  10 (10.00%) high severe

🐰 Давай туда обратим! У нас есть первые результаты бенчмарка!

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

Написать 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, print: bool) {
    let result = fizz_buzz_fibonacci(n);
    if print {
        println!("{result}");
    }
}

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

Бенчмарк для FizzBuzzFibonacci

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

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

running 0 tests

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

     Running unittests src/main.rs (target/release/deps/game-043972c4132076a9)

running 0 tests

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

     Running benches/play_game.rs (target/release/deps/play_game-e0857103eb02eb56)
bench_play_game         time:   [20.067 µs 20.107 µs 20.149 µs]
                        change: [+557.22% +568.69% +577.93%] (p = 0.00 < 0.05)
                        Performance has regressed.
Found 6 outliers among 100 measurements (6.00%)
  4 (4.00%) high mild
  2 (2.00%) high severe

О, класс! Criterion сообщает нам, что разница в производительности наших игр FizzBuzz и FizzBuzzFibonacci составляет +568.69%. Ваши числа будут немного отличаться от моих. Однако разница между двуми играми, скорее всего, порядка 5x. Мне это кажется хорошим результатом! Особенно учитывая, что мы добавили в нашу игру такой звучный параметр, как 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, true);
}

• Собираем все аргументы (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 утра в субботу мой пейджер прозвучал:

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

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

fn bench_play_game_100(c: &mut Criterion) {
    c.bench_function("bench_play_game_100", |b| {
        b.iter(|| std::hint::black_box(play_game(100, false)));
    });
}

fn bench_play_game_1_000_000(c: &mut Criterion) {
    c.bench_function("bench_play_game_1_000_000", |b| {
        b.iter(|| std::hint::black_box(play_game(1_000_000, false)));
    });
}

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

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

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

running 0 tests

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

     Running unittests src/main.rs (target/release/deps/game-043972c4132076a9)

running 0 tests

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

     Running benches/play_game.rs (target/release/deps/play_game-e0857103eb02eb56)
bench_play_game         time:   [20.024 µs 20.058 µs 20.096 µs]
                        change: [-0.0801% +0.1431% +0.3734%] (p = 0.21 > 0.05)
                        No change in performance detected.
Found 17 outliers among 100 measurements (17.00%)
  9 (9.00%) high mild
  8 (8.00%) high severe

bench_play_game_100     time:   [403.00 ns 403.57 ns 404.27 ns]
Found 13 outliers among 100 measurements (13.00%)
  6 (6.00%) high mild
  7 (7.00%) high severe

Подождите немного… подождите немного…

bench_play_game_1_000_000
                        time:   [9.5865 ms 9.5968 ms 9.6087 ms]
Found 16 outliers among 100 measurements (16.00%)
  8 (8.00%) high mild
  8 (8.00%) high severe

Что! 403.57 ns x 1,000 должен быть 403,570 ns, а не 9,596,800 ns (9.5968 ms x 1_000_000 ns/1 ms) 🤯 Несмотря на то, что я получил верный код функции последовательности Фибоначчи, я, видимо, допустил ошибку в производительности где-то в коде.

Исправляем 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 playground v0.0.1 (/home/bencher)
    Finished bench [optimized] target(s) in 4.79s
     Running unittests src/main.rs (target/release/deps/game-68f58c96f4025bd4)

running 0 tests

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

     Running unittests src/main.rs (target/release/deps/game-043972c4132076a9)

running 0 tests

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

     Running benches/play_game.rs (target/release/deps/play_game-e0857103eb02eb56)
bench_play_game         time:   [3.1201 µs 3.1772 µs 3.2536 µs]
                        change: [-84.469% -84.286% -84.016%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 5 outliers among 100 measurements (5.00%)
  1 (1.00%) high mild
  4 (4.00%) high severe

bench_play_game_100     time:   [24.460 ns 24.555 ns 24.650 ns]
                        change: [-93.976% -93.950% -93.927%] (p = 0.00 < 0.05)
                        Performance has improved.

bench_play_game_1_000_000
                        time:   [30.260 ns 30.403 ns 30.564 ns]
                        change: [-100.000% -100.000% -100.000%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 4 outliers among 100 measurements (4.00%)
  1 (1.00%) high mild
  3 (3.00%) high severe

Ого! Наш бенчмарк bench_play_game вернулся примерно к тому, где он был для оригинального FizzBuzz. Хотелось бы помнить, какие были итоговые данные. Но уже прошло три недели. История моего терминала не сохраняется так долго. А Criterion сравнивает только с самым последним результатом. Но я думаю, что это близко!

Бенчмарк bench_play_game_100 снизился почти на 10 раз, -93.950%. А бенчмарк bench_play_game_1_000_000 снизился более чем в 10,000 раз! С 9,596,800 ns до 30.403 ns! Мы даже достигли максимума на шкале изменений Criterion, которая идет только до -100.000%!

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

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

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

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

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

$ bencher run --project game "cargo bench"
    Finished bench [optimized] target(s) in 0.07s
     Running unittests src/lib.rs (target/release/deps/game-13f4bad779fbfde4)

running 0 tests

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

     Running unittests src/main.rs (target/release/deps/game-043972c4132076a9)

running 0 tests

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

     Running benches/play_game.rs (target/release/deps/play_game-e0857103eb02eb56)
Gnuplot not found, using plotters backend
bench_play_game         time:   [3.0713 µs 3.0902 µs 3.1132 µs]
Found 16 outliers among 100 measurements (16.00%)
  3 (3.00%) high mild
  13 (13.00%) high severe

bench_play_game_100     time:   [23.938 ns 23.970 ns 24.009 ns]
Found 15 outliers among 100 measurements (15.00%)
  5 (5.00%) high mild
  10 (10.00%) high severe

bench_play_game_1_000_000
                        time:   [30.004 ns 30.127 ns 30.279 ns]
Found 5 outliers among 100 measurements (5.00%)
  1 (1.00%) high mild
  4 (4.00%) high severe

Bencher New Report:
...
View results:
- 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
- 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
- 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 бесплатно.