rustpython 0.1.0

A python interpreter written in rust.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

#![feature(test)]

extern crate cpython;
extern crate rustpython_parser;
extern crate rustpython_vm;
extern crate test;

use rustpython_vm::pyobject::PyResult;
use rustpython_vm::{compile, VirtualMachine};

#[bench]
fn bench_tokenization(b: &mut test::Bencher) {
    use rustpython_parser::lexer::{make_tokenizer, Tok};

    let source = include_str!("./benchmarks/minidom.py");

    b.bytes = source.len() as _;
    b.iter(|| {
        let lexer = make_tokenizer(source);
        for res in lexer {
            let _token: Tok = res.unwrap().1;
        }
    })
}

#[bench]
fn bench_rustpy_parse_to_ast(b: &mut test::Bencher) {
    use rustpython_parser::parser::parse_program;

    let source = include_str!("./benchmarks/minidom.py");

    b.bytes = source.len() as _;
    b.iter(|| parse_program(source).unwrap())
}

#[bench]
fn bench_cpython_parse_to_ast(b: &mut test::Bencher) {
    let source = include_str!("./benchmarks/minidom.py");

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

    let globals = None;
    let locals = cpython::PyDict::new(python);

    locals.set_item(python, "SOURCE_CODE", source).unwrap();

    let code = "compile(SOURCE_CODE, mode=\"exec\", filename=\"minidom.py\")";

    b.bytes = source.len() as _;
    b.iter(|| {
        let res: cpython::PyResult<cpython::PyObject> = python.eval(code, globals, Some(&locals));
        assert!(res.is_ok());
    })
}

#[bench]
fn bench_cpython_nbody(b: &mut test::Bencher) {
    let source = include_str!("./benchmarks/nbody.py");

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

    let globals = None;
    let locals = None;

    b.iter(|| {
        let res: cpython::PyResult<()> = python.run(source, globals, locals);
        assert!(res.is_ok());
    })
}

#[bench]
fn bench_cpython_mandelbrot(b: &mut test::Bencher) {
    let source = include_str!("./benchmarks/mandelbrot.py");

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

    let globals = None;
    let locals = None;

    b.iter(|| {
        let res: cpython::PyResult<()> = python.run(source, globals, locals);
        assert!(res.is_ok());
    })
}

#[bench]
fn bench_rustpy_nbody(b: &mut test::Bencher) {
    // NOTE: Take long time.
    let source = include_str!("./benchmarks/nbody.py");

    let vm = VirtualMachine::new();

    let code = match vm.compile(source, &compile::Mode::Single, "<stdin>".to_string()) {
        Ok(code) => code,
        Err(e) => panic!("{:?}", e),
    };

    b.iter(|| {
        let scope = vm.new_scope_with_builtins();
        let res: PyResult = vm.run_code_obj(code.clone(), scope);
        assert!(res.is_ok());
    })
}

#[bench]
fn bench_rustpy_mandelbrot(b: &mut test::Bencher) {
    // NOTE: Take long time.
    let source = include_str!("./benchmarks/mandelbrot.py");

    let vm = VirtualMachine::new();

    let code = match vm.compile(source, &compile::Mode::Single, "<stdin>".to_string()) {
        Ok(code) => code,
        Err(e) => panic!("{:?}", e),
    };

    b.iter(|| {
        let scope = vm.new_scope_with_builtins();
        let res: PyResult = vm.run_code_obj(code.clone(), scope);
        assert!(res.is_ok());
    })
}