Path A.3: bench tree-walk vs VM vs JIT-via-dispatch vs JIT-direct

Closes the open question from Session E: how much of the 272x
JIT speedup is "vs tree-walk" vs "vs the bytecode VM"?

Same workload (bench_loop(N) = sum factorial(12) over N iters) run
through four modes:

  Mode             Per-iter ns  vs tree-walk
  Tree-walk         14,462         1.0x
  Bytecode VM        6,929         2.1x
  JIT-via-dispatch      58.2     249x
  JIT-direct            53.1     272x

Two findings worth surfacing:

1. The bytecode VM is 2.1x faster than tree-walk, not 10x. Most of
   the JIT's measured speedup is JIT itself, not VM-vs-tree-walk.
   The honest comparison: JIT is 119x faster than VM on this
   workload, on top of VM being 2x faster than tree-walk. The known
   VM shim costs (vm_call_builtin synthetic-arg path) cap how much
   the bytecode VM can win without further optimization.

2. JIT-via-dispatch is essentially as fast as JIT-direct (58.2 vs
   53.1 ns, 9% overhead). The OMC tree-walk loop wrapping a JIT'd
   fn body adds negligible cost — Session E's 272x microbench number
   IS what real OMC programs experience when the hot fn is JIT'd.

The implication: enabling OMC_HBIT_JIT=1 on a program with a JIT-
eligible hot fn delivers close to the full 250x on those calls,
not just the 5% headroom over JIT-direct that microbenches measure.

docs/jit_benchmark.md updated with the Path A.3 section.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: RandomCoder-lab

docs/jit_benchmark.md

@@ -52,6 +52,24 @@ Each function is called 200,000 times in a tight loop. Wall-clock per call is re
 | `factorial(12)` — 12 recursive calls + multiplies | 14,309 ns | 52.6 ns | **272×** |
 | `sum_to(100)` — 100-iter while loop with locals | 53,202 ns | 267 ns | **200×** |
 
+## Path A.3: same workload, four execution modes
+
+Closes the comparison gap from Session E (which only timed tree-walk vs JIT-direct). The same `bench_loop(N) = sum factorial(12) over N iters` workload runs through four execution strategies; per-iteration time reported as total/N.
+
+| Mode | Per-iter ns | Speedup vs tree-walk | Notes |
+|---|--:|--:|---|
+| Tree-walk only | 14,462 | 1.0× | reference |
+| Bytecode VM | 6,929 | 2.1× | OMC's existing fast-dispatch path |
+| JIT-via-dispatch | 58.2 | 249× | Tree-walk runs the loop; factorial routed through JIT |
+| JIT-direct (Rust loop) | 53.1 | 272× | Bypasses OMC entirely on the hot path |
+
+**Two findings:**
+
+1. **The bytecode VM is 2.1× faster than tree-walk, not 10×.** This matches the prior known costs of `vm_call_builtin`'s synthetic-arg shim and other VM-side dispatch overhead. The JIT's real comparison advantage is **119× faster than the bytecode VM**, on top of VM being 2× faster than tree-walk.
+2. **JIT-via-dispatch (58.2 ns) is essentially as fast as JIT-direct (53.1 ns)** — only ~9% overhead from routing through the Interpreter's dispatch hook. This means the 272× number from the Session E microbench is what real OMC programs experience; the OMC tree-walk loop wrapping a JIT'd fn body is negligible.
+
+The implication: enabling `OMC_HBIT_JIT=1` on a real OMC program where the hot fn is JIT-eligible (pure-int, no strings/arrays/builtins) will give close to the full ~250× speedup on that fn's invocations.
+
 ## Path A.1: `@hbit + @harmony + @predict` (Sessions F+G)
 
 After Sessions F (phi_shadow → divergent β) and G (harmony() intrinsic + extern call), an OMC fn can use harmony as a runtime signal to choose between cheap and expensive code paths. The bench source:

omnimcode-cli/src/bench.rs

@@ -87,6 +87,20 @@ fn no_pred_always_expensive(x) {
 fn no_pred_always_cheap(x) {
     return cheap_path(x);
 }
+
+# --- Path A.3: same workload, four execution modes ---
+# A loop wrapper around factorial(12). Lets the VM and tree-walk
+# benches measure on the same bytecode shape as JIT does. Per-iter
+# time = total_call_time / N_INNER.
+fn bench_loop(iters) {
+    h sum = 0;
+    h k = 0;
+    while k < iters {
+        sum = sum + factorial(12);
+        k = k + 1;
+    }
+    return sum;
+}
 "#;
 
 fn main() {
@@ -105,6 +119,12 @@ fn main() {
     println!();
     bench_fn("sum_to", iters, 100);
 
+    println!();
+    println!("=== Path A.3: same workload, four execution modes ===");
+    println!("Workload: bench_loop(N) = sum factorial(12) over N inner iters.");
+    println!();
+    bench_four_modes(50_000);
+
     println!();
     println!("=== Path A.1: harmony-gated branch elision ===");
     println!("Two regimes:");
@@ -172,6 +192,126 @@ fn bench_fn(fn_name: &str, iters: usize, arg: i64) {
     }
 }
 
+fn bench_four_modes(n_inner: usize) {
+    use omnimcode_codegen::JittedFn;
+    use omnimcode_core::value::HInt;
+    use std::collections::HashMap;
+    use std::rc::Rc;
+
+    let n_inner_i = n_inner as i64;
+    println!("--- N_INNER = {} (inner loop count) ---", n_inner);
+
+    // Mode 1: tree-walk only.
+    {
+        let mut parser = Parser::new(SOURCE);
+        let statements = parser.parse().expect("parse");
+        let mut interp = Interpreter::new();
+        interp.execute(statements).expect("exec");
+        let start = Instant::now();
+        let _ = interp
+            .call_function_with_values("bench_loop", &[Value::HInt(HInt::new(n_inner_i))])
+            .expect("call");
+        let total_ns = start.elapsed().as_nanos() as f64;
+        println!(
+            "  tree-walk          total={:>10.2}ms  per-iter={:>10.1}ns",
+            total_ns / 1.0e6,
+            total_ns / n_inner as f64
+        );
+    }
+
+    // Mode 2: bytecode VM. Compose a tiny program whose `__main__` is
+    // `bench_loop(N)` and run it through Vm::run_module. The VM sets
+    // up its own scope/dispatch, so we measure the run_module call.
+    {
+        let mut parser = Parser::new(SOURCE);
+        let mut statements = parser.parse().expect("parse");
+        // Append a top-level call so __main__ runs bench_loop(N).
+        let extra = format!("h __vm_result = bench_loop({});", n_inner_i);
+        let mut extra_stmts = Parser::new(&extra).parse().expect("parse extra");
+        statements.append(&mut extra_stmts);
+        let module = omnimcode_core::compiler::compile_program(&statements).expect("compile");
+        let mut vm = omnimcode_core::vm::Vm::new();
+        vm.interp_mut().register_user_functions(&statements);
+        let start = Instant::now();
+        let _ = vm.run_module(&module).expect("run_module");
+        let total_ns = start.elapsed().as_nanos() as f64;
+        println!(
+            "  bytecode VM        total={:>10.2}ms  per-iter={:>10.1}ns",
+            total_ns / 1.0e6,
+            total_ns / n_inner as f64
+        );
+    }
+
+    // Mode 3: JIT-via-dispatch. Tree-walk runs the outer loop; each
+    // factorial(12) call is intercepted by the JIT dispatch hook and
+    // routed through native code. This is what the CLI's
+    // OMC_HBIT_JIT=1 path produces for real OMC programs.
+    {
+        let mut parser = Parser::new(SOURCE);
+        let statements = parser.parse().expect("parse");
+        let module = omnimcode_core::compiler::compile_program(&statements).expect("compile");
+        let context = Context::create();
+        let jit = JitContext::new(&context).expect("jit");
+        let jitted = jit.jit_module(&module).expect("jit_module");
+        let jitted_for_hook: HashMap<String, JittedFn> = jitted.clone();
+        let dispatch: omnimcode_core::interpreter::JitDispatch = Rc::new(
+            move |name: &str, args: &[Value]| {
+                let jf = jitted_for_hook.get(name)?;
+                if args.len() != jf.arity {
+                    return None;
+                }
+                let mut int_args = Vec::with_capacity(args.len());
+                for a in args {
+                    match a {
+                        Value::HInt(h) => int_args.push(h.value),
+                        Value::Bool(b) => int_args.push(if *b { 1 } else { 0 }),
+                        _ => return None,
+                    }
+                }
+                jf.call(&int_args).map(|r| Ok(Value::HInt(HInt::new(r))))
+            },
+        );
+        let mut interp = Interpreter::new();
+        interp.set_jit_dispatch(Some(dispatch));
+        interp.execute(statements).expect("exec");
+        let start = Instant::now();
+        let _ = interp
+            .call_function_with_values("bench_loop", &[Value::HInt(HInt::new(n_inner_i))])
+            .expect("call");
+        let total_ns = start.elapsed().as_nanos() as f64;
+        println!(
+            "  JIT-via-dispatch   total={:>10.2}ms  per-iter={:>10.1}ns  (loop is tree-walk, factorial is JIT)",
+            total_ns / 1.0e6,
+            total_ns / n_inner as f64
+        );
+    }
+
+    // Mode 4: JIT-direct. Skip OMC entirely for the loop — call
+    // factorial's fn pointer in a native Rust loop. This is the
+    // theoretical best (no OMC dispatch on the hot path).
+    {
+        let mut parser = Parser::new(SOURCE);
+        let statements = parser.parse().expect("parse");
+        let module = omnimcode_core::compiler::compile_program(&statements).expect("compile");
+        let context = Context::create();
+        let jit = JitContext::new(&context).expect("jit");
+        let jitted = jit.jit_module(&module).expect("jit_module");
+        let factorial = jitted.get("factorial").expect("factorial JIT'd");
+        let start = Instant::now();
+        let mut sum: i64 = 0;
+        for _ in 0..n_inner {
+            sum = sum.wrapping_add(factorial.call(&[12]).expect("call"));
+        }
+        let total_ns = start.elapsed().as_nanos() as f64;
+        let _ = sum;
+        println!(
+            "  JIT-direct         total={:>10.2}ms  per-iter={:>10.1}ns  (Rust loop, no OMC dispatch)",
+            total_ns / 1.0e6,
+            total_ns / n_inner as f64
+        );
+    }
+}
+
 fn bench_predict(iters: usize) {
     let mut parser = Parser::new(SOURCE);
     let statements = parser.parse().expect("parse");