feat(jit): implement a bytecode VM

.cargo/config.toml

@@ -1,5 +1,2 @@
-# Uncomment following lines if rustc isn't taking full advantage of your processor
-# Commented by default for CI purposes
-# [build]
-# rustflags = ["-C", "target-cpu=native"]
-
+[build]
+rustflags = ["-C", "target-cpu=native"]

.gitignore

@@ -1,2 +1,3 @@
 /target
 **/.DS_Store
+stdlib/stdlib.ll

Cargo.toml

@@ -1,9 +1,10 @@
 [package]
 name = "koan"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [dependencies]
+rand = "0.9.1"
 rustyline = { version = "14.0.0", features = ["derive"], optional = true }
 syntect = { version = "5.2.0", optional = true }
 thiserror = "1.0.62"
@@ -18,9 +19,14 @@ harness = false
 [features]
 default = ["repl"]
 repl = ["dep:rustyline", "dep:syntect"]
+track_clones = []
 
 [profile.release]
 codegen-units = 1
 opt-level = 3
 lto = "fat"
+debug = 1
+
+[build]
+rustflags = ["-Z", "threads=8"]
 

benches/ast.rs

@@ -1,11 +1,33 @@
-use criterion::{
-    black_box, criterion_group, criterion_main, BatchSize, Criterion,
+use std::rc::Rc;
+
+use criterion::{BatchSize, Criterion, black_box, criterion_group, criterion_main};
+use koan::{
+    compiler::Compiler,
+    interpreter::IntrpCtx,
+    lexer::lex,
+    parser::{Ast, parse},
+    pool::ExprPool,
+    state::State,
+    value::Value,
+    vm::{OpCode, VM},
 };
-use koan::{interpreter::IntrpCtx, lexer::lex, parser::parse, state::State};
+use rand::Rng;
+
+fn twalk_initrun((ast, mut state): ((Vec<Ast>, ExprPool), State)) {
+    let mut ctx = IntrpCtx {
+        writer: vec![],
+        state: &mut state,
+        pool: &ast.1,
+    };
+
+    for s in ast.0 {
+        black_box(ctx.eval_ast(s).unwrap());
+    }
+}
 
 fn criterion_benchmark(c: &mut Criterion) {
     let toks = lex(include_str!("../foo.koan")).unwrap();
-    let ast = parse(toks.clone()).unwrap();
+    let inp = include_str!("lexerdata.txt");
 
     c.bench_function("ast", |b| {
         b.iter_batched(
@@ -15,20 +37,68 @@ fn criterion_benchmark(c: &mut Criterion) {
         )
     });
 
-    c.bench_function("tree-walk interpreter", |b| {
+    c.bench_function("lexer", |b| {
+        b.iter(|| {
+            lex(black_box(inp)).unwrap();
+        });
+    });
+
+    c.bench_function("VM 5000x array mul", |b| {
         b.iter_batched(
-            || (ast.clone(), State::new()),
-            |(ast, mut state)| {
-                let mut ctx = IntrpCtx {
-                    writer: vec![],
-                    state: &mut state,
-                    pool: &ast.1,
-                };
-
-                for s in ast.0 {
-                    black_box(ctx.eval_ast(s).unwrap());
+            || {
+                let mut vm = VM::new();
+                let mut rng = rand::rng();
+
+                let mut a1: Vec<u32> = vec![];
+                let mut a2: Vec<u32> = vec![];
+                for _ in 0..5000 {
+                    a1.push(rng.random());
+                    a2.push(rng.random());
                 }
+
+                vm.stack.push(Value::Array(Rc::new(
+                    a1.into_iter().map(|n| Value::Num(n as f64)).collect(),
+                )));
+
+                vm.stack.push(Value::Array(Rc::new(
+                    a2.into_iter().map(|n| Value::Num(n as f64)).collect(),
+                )));
+
+                vm.chunk.push(OpCode::Mul as u8);
+
+                vm
+            },
+            |mut vm| {
+                vm.run().unwrap();
+            },
+            BatchSize::SmallInput,
+        );
+    });
+
+    c.bench_function("tree-walk interpreter 1000x array mul", |b| {
+        b.iter_batched(
+            || {
+                (
+                    lex(include_str!("thousandmul.koan"))
+                        .and_then(parse)
+                        .unwrap(),
+                    State::new(),
+                )
+            },
+            twalk_initrun,
+            BatchSize::SmallInput,
+        );
+    });
+
+    c.bench_function("tree-walk interpreter fib.koan", |b| {
+        b.iter_batched(
+            || {
+                (
+                    lex(include_str!("../fib.koan")).and_then(parse).unwrap(),
+                    State::new(),
+                )
             },
+            twalk_initrun,
             BatchSize::SmallInput,
         )
     });

fib.koan

@@ -1,3 +1,3 @@
 fun fib(n) { if n <= 1 { n } else { fib(n - 1) + fib(n - 2) } }
 
-print(fib(10))
+print(fib(25))