Crate criterion_polyglot 

criterion-polyglot provides an extension trait for criterion::Criterion and criterion::BenchmarkGroup that provides benchmark methods for non-Rust programming languages.

criterion-polyglot currently supports the following languages:

• Python 3
• Ruby
• Go
• Zig
• C

See CriterionPolyglotExt for detailed documentation on constructing benchmarks.

Examples

Rust Vec versus Python list

use criterion::{black_box, criterion_group, criterion_main, Criterion};
use criterion_polyglot::{BenchSpec, CriterionPolyglotExt};

fn bench(c: &mut Criterion) {
    const LENGTH: u64 = 65_536;
    let mut source = Vec::with_capacity(LENGTH as usize);
    source.extend(0..LENGTH);

    c.bench_function("Vec", |b| b.iter(||
        Vec::new().extend(black_box(source.iter().copied()))
    ));

    c.python_benchmark("list",
        BenchSpec::new(r#"
            l = list()
            l += source
        "#).with_global_init(r#"
            source = [n for n in range(0, 65536)]
        "#)
    );
}

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

Rust vs. Zig Hypothetical Tree Structure

use criterion::{black_box, BatchSize, Criterion};
use criterion_polyglot::{BenchSpec, CriterionPolyglotExt};
use some_tree::SomeTree;
 
fn make_elements() -> Vec<Element> {
    /* */
}
 
fn bench(c: &mut Criterion) {
    let mut g = c.benchmark_group("some_tree");
 
    g.bench_function("Rust", |b| {
        let mut tree = SomeTree::new();
        let elements = make_elements();
        b.iter_batched(
            || elements.clone(),
            |elements| for element in elements { tree.insert(black_box(element)); },
            BatchSize::SmallInput,
        );
    });
    g.zig_benchmark("Zig",
        BenchSpec::new(r#"
            for (elements) |element| {
                tree.insert(element);
            }
        "#).with_sample_init(r#"
            const elements = make_elements(allocator);
            var tree = new_tree(allocator);
        "#).with_global_init(r#"
            var arena = ArenaAllocator.init(std.heap.page_allocator);
            defer arena.deinit();
            const allocator = arena.allocator();
        "#)
        .with_imports(r#"
            const std = @import("std");
            const Allocator = std.mem.Allocator;
            const ArenaAllocator = std.heap.ArenaAllocator;
        "#)
        .with_declarations(r#"
            const SomeTree = struct {
                pub fn insert(self: *SomeTree, value: u8) void {
                    // ... tree implementation ...
                }
                // ...
            };
            fn make_elements(allocator: Allocator) []u8 {
                // ...
            }
            fn new_tree(allocator: Allocator) SomeTree {
                // ...
            }
        "#)
    );
 
}

Re-exports

pub use cc;

Structs

BenchSpec

BenchSpec specifies various code fragments, most optional, that will be run during a benchmarking run for any supported language.

Traits

CriterionPolyglotExt

CriterionPolyglotExt is an extension trait for criterion::Criterion and criterion::BenchmarkGroup that provides benchmark methods for various non-Rust programming languages.