It is not about Keanu Reeves but a benchmark tool.

Akira Hayakawa

Last update: Feb 12, 2022

Related tags

Profiling benchman

Overview

benchman

Features

Focus on one-shot benchmark
RAII-style
Statistics (Average, Median, 95% and 99% percentile)
Colored output
Tagging
Nesting

Motivation

I guess there are two types of benchmarks.

One is a benchmark of a small and fast function in which we want the statistics from a million of iterations. For this type of benchmark, Criterion.rs is a good fit.

Another type is what I call one-shot benchmark.

You may have wanted to write a benchmark program like this.

let mut db = DB::new();

let t = Instant::now();
db.write(...);
println!("write: {:?}", t.elapsed());

let t = Instant::now();
db.read(...);
println!("read: {:?}", t.elapsed());

According to Criterion.rs #531, this type of benchmark is infeasible with Criterion.rs because Criterion is focusing on the first type.

That's why I started to create benchman.

RAII-style measurement

RAII is a good technique to manage resource access. My idea behind designing benchman is that stopwatch is like a resource because it is like a producer of a benchmark result that sends the result to the single central consumer and there is a strict rule that stopwatch shouldn't send the result twice.

With this idea, the library is designed like this.

let stopwatch = benchman.get_stopwatch("some_tag");
do_something();
drop(stopwatch);

// or

{
    let _sw = benchman.get_stopwatch("some_tag");
    do_something();
}

When the stopwatch is dropped, the measurement result is sent to the central database.

Screenshot

Author

Akira Hayakawa (@akiradeveloper)

You might also like...

Verdun is a HTTP stress-test/benchmark tool written in Rust.

Verdun is a HTTP stress-test/benchmark tool written in Rust. 🦀 It supports testing a single URL, loading multiples URLs from a file or automatically navigating a website (auto discovery)

2 Feb 23, 2022

hb is an endpoint focused HTTP load testing / benchmark tool.

hb hb is an endpoint focused HTTP load testing / benchmark tool. Description The goal of hb is to provide a simple, robust tool to apply load against

2 Aug 23, 2022

rusty-riscy is a performance testing and system resource monitoring tool written in Rust to benchmark RISC-V processors.

rusty-riscy rusty-riscy is a performance testing and system resource monitoring tool written in Rust to benchmark RISC-V processors. Objectives To cre

4 May 3, 2022

A http server benchmark tool written in rust 🦀

rsb - rust benchmark rsb is a http server benchmark tool written in rust. The development of this tool is mainly inspired by the bombardier project, a

45 Apr 10, 2023

Blazing fast tool to benchmark Starknet sequencers 🦀

Gomu Gomu no Gatling Blazing fast tool to benchmark Starknet sequencers 🦀 . Installation From source git clone https://github.com/keep-starknet-stran

7 Jul 7, 2023

A simple disk benchmark tool.

simple-disk-benchmark A simple disk benchmark tool. Operating Systems Currently, macOS and Linux are tested. Windows may work but is not tested. Devel

7 Jul 31, 2023

Simple and portable (but not inflexible) GUI library in C that uses the native GUI technologies of each platform it supports.

libui: a portable GUI library for C This README is being written. Status It has come to my attention that I have not been particularly clear about how

10.4k Dec 31, 2022

The Bloat-Free Browser Game in Rust but in C and not in a Browser

rust-browser-game but native and rendered with SDL in C without the Browser The original idea of rust-browser-game is that the game.wasm module is com

12 Sep 26, 2022

This crate provide parsing fontconfig file but not yet complete all features

4 Dec 27, 2022

A performant but not-so-accurate time and capacity based cache for Rust.

fastcache A performant but not-so-accurate time and capacity based cache for Rust. This crate provides an implementation of a time-to-live (TTL) and c

3 Aug 17, 2023

A micro-benchmark framework to use with cargo bench

Glassbench is a micro-benchmark library with memory, to use with cargo bench. Why Run benchmarks and get a comparison with the previous execution carg

36 Dec 14, 2022

Benchmark over Node.js binding frameworks in Rust

7 Dec 28, 2022

Benchmark for Rust and humans

bma-benchmark Benchmark for Rust and humans What is this for I like testing different libraries, crates and algorithms. I do benchmarks on prototypes

11 Jan 17, 2022

Rust wrapper for COCO benchmark functions.

Coco Rust bindings for the COCO Numerical Black-Box Optimization Benchmarking Framework. See https://github.com/numbbo/coco and https://numbbo.github.

1 Nov 15, 2022

Parses .off (Object File Format) files. This implementation follows this spec from the Princeton Shape Benchmark.

off-rs - A simple .off file parser Parses .off (Object File Format) files. This implementation follows this spec from the Princeton Shape Benchmark. S

2 Jun 12, 2022

Simple benchmark to compare different Kafka clients performance with similar configuration.

Kafka Producer Benchmark Simple benchmark to compare different clients performance against similar configuration. The project is relatively low tech a

11 Nov 2, 2022

SQL Benchmark derived from TPC-DS

SQLBench-DS Overview SQLBench-DS is a SQL benchmark derived from TPC-DS under the terms of the Transaction Processing Council's Fair Use Policy. This

15 Jan 9, 2023

A rust-based benchmark for BlueField SmartNICs.

Smartbench Smart-bench is a rust-based benchmarking tool for BlueField-series SmartNICs. The purpose is to enable easy testing of BlueField-series Sma

4 Jun 15, 2023

A benchmark of Rust/serde deserializers on configuration files

This program compares the time some serde deserializers take to deserialize some string into a configuration-like struct deriving Deserialize. The ben

4 Oct 30, 2023

Comments

fix test: drop stopwatch in the thread

This code is not as intended. The ownership of stopwatch should be dropped in in the spawned thread.

    fn test_benchman_spawn() {
        let benchman = BenchMan::new("spawn");
        for _ in 0..1 {
            let stopwatch = benchman.get_stopwatch("loop1");
            std::thread::spawn(move || {
                let mut sum: u64 = 0;
                for i in 0..1000000 {
                    sum += i;
                }
            });
        }

opened by akiradeveloper 1