Micro benchmarks are small snippets of code added under the `microbenchmarks/` directory. A microbenchmark file has

two sections:

1. Optional setup code

2. The code to be benchmarked

These two sections are delimited by `# ---`. For example:

a_list = [1,2,3]

len(a_list)

Only `len(a_list)` will be timed. Setup or benchmarked code can optionally reference a variable called `ITERATIONS`. If

present then the benchmark code will be invoked 5 times with `ITERATIONS` set to a value between 100 and 1,000. For

example:

obj = [i for i in range(ITERATIONS)]

`ITERATIONS` can appear in both the setup code and the benchmark code.

use cpython::Python;

use criterion::measurement::WallTime;

use criterion::{

criterion_group, criterion_main, BatchSize, BenchmarkGroup, BenchmarkId, Criterion, Throughput,

use rustpython_compiler::Mode;

use rustpython_vm::pyobject::ItemProtocol;

use rustpython_vm::pyobject::PyResult;

use rustpython_vm::Interpreter;

use std::path::{Path, PathBuf};

use std::{fs, io};

pub struct MicroBenchmark {

name: String,

setup: String,

code: String,

iterate: bool,

fn bench_cpython_code(group: &mut BenchmarkGroup<WallTime>, bench: &MicroBenchmark) {

let gil = cpython::Python::acquire_gil();

let python = gil.python();

let bench_func = |(python, code): (Python, String)| {

let res: cpython::PyResult<()> = python.run(&code, None, None);

if let Err(e) = res {

e.print(python);

panic!("Error running microbenchmark")

}

};

let bench_setup = |iterations| {

let code = if let Some(idx) = iterations {

// We can't easily modify the locals when running cPython. So we just add the

// loop iterations at the top of the code...

format!("ITERATIONS = {}\n{}", idx, bench.code)

} else {

(&bench.code).to_string()

};

let res: cpython::PyResult<()> = python.run(&bench.setup, None, None);

if let Err(e) = res {

e.print(python);

panic!("Error running microbenchmark setup code")

}

(python, code)

};

if bench.iterate {

for idx in (100..=1_000).step_by(200) {

group.throughput(Throughput::Elements(idx as u64));

group.bench_with_input(BenchmarkId::new("cpython", &bench.name), &idx, |b, idx| {

b.iter_batched(

|| bench_setup(Some(*idx)),

bench_func,

BatchSize::PerIteration,

);

});

}

} else {

group.bench_function(BenchmarkId::new("cpython", &bench.name), move |b| {

b.iter_batched(|| bench_setup(None), bench_func, BatchSize::PerIteration);

});

}

fn bench_rustpy_code(group: &mut BenchmarkGroup<WallTime>, bench: &MicroBenchmark) {

Interpreter::default().enter(|vm| {

let setup_code = vm

.compile(&bench.setup, Mode::Exec, bench.name.to_owned())

.expect("Error compiling setup code");

let bench_code = vm

.compile(&bench.code, Mode::Exec, bench.name.to_owned())

.expect("Error compiling bench code");

let bench_func = |(scope, bench_code)| {

let res: PyResult = vm.run_code_obj(bench_code, scope);

vm.unwrap_pyresult(res);

};

let bench_setup = |iterations| {

let scope = vm.new_scope_with_builtins();

if let Some(idx) = iterations {

scope

.locals

.set_item(vm.ctx.new_str("ITERATIONS"), vm.ctx.new_int(idx), vm)

.expect("Error adding ITERATIONS local variable");

}

vm.run_code_obj(setup_code.clone(), scope.clone())

.expect("Error running benchmark setup code");

(scope, bench_code.clone())

};

if bench.iterate {

for idx in (100..=1_000).step_by(200) {

group.throughput(Throughput::Elements(idx as u64));

group.bench_with_input(

BenchmarkId::new("rustpython", &bench.name),

&idx,

|b, idx| {

b.iter_batched(

|| bench_setup(Some(*idx)),

bench_func,

BatchSize::PerIteration,

);

},

);

}

} else {

group.bench_function(BenchmarkId::new("rustpython", &bench.name), move |b| {

b.iter_batched(|| bench_setup(None), bench_func, BatchSize::PerIteration);

});

}

})

pub fn run_micro_benchmark(c: &mut Criterion, benchmark: MicroBenchmark) {

let mut group = c.benchmark_group("microbenchmarks");

bench_cpython_code(&mut group, &benchmark);

bench_rustpy_code(&mut group, &benchmark);

group.finish();

pub fn criterion_benchmark(c: &mut Criterion) {

let benchmark_dir = Path::new("./benches/microbenchmarks/");

let dirs: Vec<fs::DirEntry> = benchmark_dir

.read_dir()

.unwrap()

.collect::<io::Result<_>>()

.unwrap();

let paths: Vec<PathBuf> = dirs.iter().map(|p| p.path()).collect();

let benchmarks: Vec<MicroBenchmark> = paths

.into_iter()

.map(|p| {

let name = p.file_name().unwrap().to_os_string();

let contents = fs::read_to_string(p).unwrap();

let iterate = contents.contains("ITERATIONS");

let (setup, code) = if contents.contains("# ---") {

let split: Vec<&str> = contents.splitn(2, "# ---").collect();

(split[0].to_string(), split[1].to_string())

} else {

("".to_string(), contents)

};

let name = name.into_string().unwrap();

MicroBenchmark {

name,

setup,

code,

iterate,

}

})

.collect();

for benchmark in benchmarks {

run_micro_benchmark(c, benchmark);

}

criterion_group!(benches, criterion_benchmark);

criterion_main!(benches);

total = 0

for i in range(ITERATIONS):

total += i

def add(a, b):

a + b

add(a=1, b=10)

def add(a, b):

a + b

add(1, 2)

class Foo:

ABC = 1

def __init__(self):

super().__init__()

def bar(self):

pass

@classmethod

def bar_2(cls):

pass

obj = {i: i for i in range(ITERATIONS)}

obj = [i for i in range(ITERATIONS)]

obj = {i for i in range(ITERATIONS)}

class Foo:

pass

Foo()

class Foo:

pass

def function():

pass

from contextlib import contextmanager

def try_catch(*args, **kwargs):

try:

yield

except RuntimeError:

pass

with try_catch():

raise RuntimeError()

try:

try:

raise ValueError()

except ValueError as e:

raise RuntimeError() from e

except RuntimeError as e:

pass

try:

raise RuntimeError()

except RuntimeError as e:

pass

obj = []

for i in range(ITERATIONS):

obj.append(i)

string = "a" * ITERATIONS

for char in string:

pass