benchmark

Author: yesmeck

Cargo.lock

@@ -1,5 +1,5 @@
 [package]
-name = "monkey_in_rust"
+name = "monkey_lang"
 version = "0.1.0"
 edition = "2021"
 
@@ -11,3 +11,10 @@ fxhash = "0.2.1"
 lazy_static = "1.4.0"
 byteorder = "1.4.3"
 clap = { version = "4.1.6", features = ["derive"] }
+
+[dev-dependencies]
+criterion = "0.4"
+
+[[bench]]
+name = "engine"
+harness = false

Cargo.toml

@@ -0,0 +1,50 @@
+use std::{cell::RefCell, rc::Rc};
+
+use monkey_lang::{
+    ast::Program, compiler::Compiler, enviroment::Enviroment, evaluator::Evaluator, lexer::Lexer,
+    parser::Parser, vm::Vm,
+};
+
+use criterion::{criterion_group, criterion_main, Criterion};
+
+static INPUT: &str = "
+let fibonacci = fn(x) {
+    if (x == 0) {
+        return 0;
+    } else {
+        if (x == 1) {
+            return 1;
+        } else {
+            fibonacci(x - 1) + fibonacci(x - 2);
+        }
+    }
+};
+fibonacci(15);
+";
+
+fn eval(program: &Program) {
+    let env = Rc::new(RefCell::new(Enviroment::default()));
+    let mut evaluator = Evaluator::new(env);
+    evaluator.eval(program);
+}
+
+fn vm(program: &Program) {
+    let mut compiler = Compiler::new();
+    compiler.compile(program);
+    let mut vm = Vm::new(compiler.bytecode());
+    vm.run();
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let mut lexer = Lexer::new(INPUT);
+    let mut parser = Parser::new(&mut lexer);
+    let program = parser.parse_program();
+
+    let mut group = c.benchmark_group("Engine");
+    group.bench_function("eval", |b| b.iter(|| eval(&program)));
+    group.bench_function("vm", |b| b.iter(|| vm(&program)));
+    group.finish();
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

benches/engine.rs

@@ -0,0 +1,5 @@
+[toolchain]
+profile = "default"
+# Use nightly for better access to the latest Rust features.
+# This date is aligned to stable release dates.
+channel = "nightly-2023-01-26"

rust-toolchain.toml

@@ -2,20 +2,20 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
 
+use crate::ast::Expression;
 use crate::ast::{
-    ArrayLiteral, BlockStatement, FunctionLiteral, HashLiteral, Identifier, IfExpression,
-    IndexExpression, InfixExpression, LetStatement, PrefixExpression,
-    Program, ReturnStatement, Statement, CallExpression,
+    ArrayLiteral, BlockStatement, CallExpression, FunctionLiteral, HashLiteral, Identifier,
+    IfExpression, IndexExpression, InfixExpression, LetStatement, PrefixExpression, Program,
+    ReturnStatement, Statement,
 };
-use crate::ast::Expression;
 use crate::builtin::Builtin;
 use crate::enviroment::Enviroment;
-use crate::makro::{EvalUnqupteCalls, MacroExpension};
+use crate::makro::EvalUnqupteCalls;
+use crate::object::Hash;
 use crate::object::{
-    Array, BuiltinFunction, Function, HashKeyable, Inspector, Integer, Object,
-    Quote, ReturnValue, RuntimeError, Str,
+    Array, BuiltinFunction, Function, HashKeyable, Inspector, Integer, Object, Quote, ReturnValue,
+    RuntimeError, Str,
 };
-use crate::object::Hash;
 use crate::traverser::Traverable;
 
 #[derive(Debug)]
@@ -32,11 +32,7 @@ impl Evaluator {
         }
     }
 
-    pub fn eval(&mut self, program: &mut Program) -> Rc<Object> {
-        let makro = MacroExpension::new(Rc::clone(&self.env));
-        makro.define_macros(program);
-        makro.expand_macros(program);
-
+    pub fn eval(&mut self, program: &Program) -> Rc<Object> {
         self.eval_program(program)
     }
 
@@ -180,10 +176,10 @@ impl Evaluator {
         }
     }
 
-    fn eval_program(&mut self, program: &mut Program) -> Rc<Object> {
+    fn eval_program(&mut self, program: &Program) -> Rc<Object> {
         let mut result = Rc::clone(&self.env.borrow().null_object);
 
-        for stmt in program.statements.iter_mut() {
+        for stmt in program.statements.iter() {
             result = self.eval_statement(stmt);
 
             match *result {
@@ -539,11 +535,15 @@ mod tests {
         enviroment::Enviroment,
         lexer::Lexer,
         object::{Boolean, HashKey, HashKeyable, Integer, Object, Str},
-        parser::Parser, test_helper::{test_integer_object, test_boolean_object, test_null_object, test_string_object, test_error_object},
+        parser::Parser,
+        test_helper::{
+            test_boolean_object, test_error_object, test_integer_object, test_null_object,
+            test_string_object,
+        },
     };
 
     fn test_eval(input: &str) -> Rc<Object> {
-        let mut lexer = Lexer::new(input.into());
+        let mut lexer = Lexer::new(input);
         let mut parser = Parser::new(&mut lexer);
         let env = Rc::new(RefCell::new(Enviroment::default()));
         let mut program = parser.parse_program();

src/evaluator.rs

@@ -0,0 +1,29 @@
+use clap::ValueEnum;
+
+pub mod ast;
+mod builtin;
+pub mod enviroment;
+pub mod evaluator;
+pub mod lexer;
+mod object;
+pub mod parser;
+pub mod repl;
+mod token;
+mod traverser;
+pub mod makro;
+mod code;
+pub mod compiler;
+mod symbol_table;
+pub mod vm;
+mod frame;
+
+#[cfg(test)]
+pub mod test_helper;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
+pub enum Engine {
+    Vm,
+    Eval
+}
+
+

src/lib.rs

@@ -1,36 +1,11 @@
-use std::{env::args, fs, process, cell::RefCell, rc::Rc, path::PathBuf};
+#![feature(test)]
+use std::{cell::RefCell, env::args, fs, path::PathBuf, process, rc::Rc};
 
-use clap::{Parser, ValueEnum};
-use enviroment::Enviroment;
-use evaluator::Evaluator;
-use lexer::Lexer;
-use crate::{repl::Repl, compiler::Compiler, vm::Vm};
-
-mod ast;
-mod builtin;
-mod enviroment;
-mod evaluator;
-mod lexer;
-mod object;
-mod parser;
-mod repl;
-mod token;
-mod traverser;
-mod makro;
-mod code;
-mod compiler;
-mod symbol_table;
-mod vm;
-mod frame;
-
-#[cfg(test)]
-mod test_helper;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
-pub enum Engine {
-    Vm,
-    Eval
-}
+use clap::Parser;
+use monkey_lang::{
+    compiler::Compiler, enviroment::Enviroment, evaluator::Evaluator, lexer::Lexer,
+    makro::MacroExpension, parser, repl::Repl, vm::Vm, Engine,
+};
 
 #[derive(Parser)]
 #[command(author, version, about, long_about= None)]
@@ -53,14 +28,12 @@ fn main() {
 
 fn run(file: &PathBuf, engine: &Engine) {
     let script = fs::read_to_string(file).expect("Unable to read file");
-    let env = Rc::new(RefCell::new(Enviroment::default()));
-    let mut evaluator = Evaluator::new(env);
     let mut lexer = Lexer::new(&script);
     let mut parser = parser::Parser::new(&mut lexer);
     let mut program = parser.parse_program();
-   if !parser.errors.is_empty() {
+    if !parser.errors.is_empty() {
         for error in parser.errors.iter() {
-            println!("\t{}", error);
+            println!("\t{error}");
         }
         process::exit(1);
     }
@@ -72,13 +45,17 @@ fn run(file: &PathBuf, engine: &Engine) {
             vm.run();
             let result = vm.last_popped_stack_elem();
             println!("{}", result.inspect());
-        },
+        }
         Engine::Eval => {
+            let env = Rc::new(RefCell::new(Enviroment::default()));
+            let makro = MacroExpension::new(Rc::clone(&env));
+            makro.define_macros(&mut program);
+            makro.expand_macros(&mut program);
+            let mut evaluator = Evaluator::new(env);
             let result = evaluator.eval(&mut program);
             println!("{}", result.inspect());
-        },
+        }
     };
- 
 }
 
 fn repl(engine: &Engine) {

src/main.rs

@@ -6,7 +6,7 @@ use std::{
 
 use crate::{
     compiler::Compiler, enviroment::Enviroment, evaluator::Evaluator, lexer::Lexer, parser::Parser,
-    vm::Vm, Engine,
+    vm::Vm, Engine, makro::MacroExpension,
 };
 
 const MONKEY_FACE: &str = r#"            __,__
@@ -96,6 +96,11 @@ impl<'a> Repl<'a> {
                 continue;
             }
 
+            let makro = MacroExpension::new(Rc::clone(&env));
+            makro.define_macros(&mut program);
+            makro.expand_macros(&mut program);
+
+
             let mut evaluator = Evaluator::new(Rc::clone(&env));
             let result = evaluator.eval(&mut program);
             println!("{}", result.inspect());

src/repl.rs

@@ -1034,4 +1034,25 @@ mod tests {
 
         run_vm_tests(&tests);
     }
+
+    #[test]
+    fn test_recursive_fibonacci() {
+        let test = VmTestCase(
+            "let fibonacci = fn(x) {
+                if (x == 0) {
+                    return 0;
+                } else {
+                    if (x == 1) {
+                        return 1;
+                    } else {
+                        fibonacci(x - 1) + fibonacci(x - 2);
+                    }
+                }
+            };
+            fibonacci(15);",
+            ExpectedValue::Integer(610),
+        );
+
+        run_vm_tests(&[test]);
+    }
 }