perf(vm): reduce dispatch and call overhead

Author: dylan-sutton-chavez

compiler/src/modules/parser/literals.rs

@@ -481,6 +481,12 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
             | OpCode::Yield
             | OpCode::YieldFrom
         ));
+        // Pre-compute generator flag once at parse time. Avoids the
+        // O(n_instructions) scan that exec_call would otherwise do per call.
+        body.is_generator = body.instructions.iter().any(|i| matches!(
+            i.opcode,
+            OpCode::Yield | OpCode::YieldFrom
+        ));
         body
     }
 }

compiler/src/modules/parser/types.rs

@@ -100,6 +100,7 @@ pub struct SSAChunk {
     pub phi_sources: Vec<(u16, u16)>,
     pub classes: Vec<SSAChunk>,
     pub is_pure: bool,
+    pub is_generator: bool,
     pub overflow: bool,
     pub prev_slots: Vec<Option<u16>>,
     pub alias_groups: Vec<Vec<u16>>,

compiler/src/modules/vm/cache.rs

@@ -1,10 +1,10 @@
 // vm/cache.rs
 
-use super::types::{Val, eq_vals_with_heap};
-use crate::modules::parser::{OpCode, SSAChunk, Instruction};
+use super::types::{Val, HeapObj, HeapPool, VmErr, BigInt, eq_vals_with_heap};
+use crate::modules::parser::{OpCode, SSAChunk, Instruction, Value};
 use crate::modules::fx::FxHashMap as HashMap;
 
-use alloc::{vec, vec::Vec};
+use alloc::{vec, vec::Vec, string::ToString};
 
 /* Specialized operation types for inline cache type-stable binary dispatch. */
 
@@ -34,13 +34,18 @@ struct CacheSlot {
 pub struct OpcodeCache {
     slots: Vec<CacheSlot>,
     fused: Option<Vec<Instruction>>,
+    /// Pre-materialized constant pool. Built once per chunk on first exec, so
+    /// LoadConst becomes a single indexed load instead of a per-iteration
+    /// match on `Value` + (for strings/bigints) heap alloc.
+    const_vals: Option<Vec<Val>>,
 }
 
 impl OpcodeCache {
     pub fn new(chunk: &SSAChunk) -> Self {
         Self {
             slots: vec![CacheSlot::default(); chunk.instructions.len()],
             fused: None,
+            const_vals: None,
         }
     }
 
@@ -57,6 +62,38 @@ impl OpcodeCache {
         self.fused.as_ref().expect("fused code not compiled")
     }
 
+    /// Materialize the constant pool. Int/Float/Bool/None become inline Vals
+    /// (no heap touch); Str/BigInt allocate once and are shared. Subsequent
+    /// LoadConst executions just index into the resulting slice.
+    pub fn ensure_const_vals(&mut self, chunk: &SSAChunk, heap: &mut HeapPool)
+        -> Result<&[Val], VmErr>
+    {
+        if self.const_vals.is_none() {
+            let mut out = Vec::with_capacity(chunk.constants.len());
+            for c in &chunk.constants {
+                let v = match c {
+                    Value::Int(i) => {
+                        if *i >= Val::INT_MIN && *i <= Val::INT_MAX { Val::int(*i) }
+                        else { heap.alloc(HeapObj::BigInt(BigInt::from_i64(*i)))? }
+                    }
+                    Value::BigInt(s) => heap.alloc(HeapObj::BigInt(BigInt::from_decimal(s)))?,
+                    Value::Float(f) => Val::float(*f),
+                    Value::Bool(b) => Val::bool(*b),
+                    Value::None => Val::none(),
+                    Value::Str(s) => heap.alloc(HeapObj::Str(s.to_string()))?,
+                };
+                out.push(v);
+            }
+            self.const_vals = Some(out);
+        }
+        Ok(self.const_vals.as_ref().unwrap())
+    }
+
+    /// Precomputed constant pool. Caller must have invoked ensure_const_vals.
+    pub fn const_vals_ref(&self) -> &[Val] {
+        self.const_vals.as_ref().expect("const pool not materialized")
+    }
+
     pub fn record(&mut self, ip: usize, opcode: &OpCode, ta: u8, tb: u8) {
         let Some(s) = self.slots.get_mut(ip) else { return };
         let key = (ta << 4) | (tb & 0xF);

compiler/src/modules/vm/handlers/arith.rs

@@ -148,9 +148,9 @@ impl<'a> VM<'a> {
 
     pub(crate) fn handle_compare(&mut self, op: OpCode, rip: usize, cache: &mut OpcodeCache) -> Result<(), VmErr> {
         let (a, b) = self.pop2()?;
-        if matches!(op, OpCode::Eq | OpCode::Lt) {
-            cached_binop!(self.heap, rip, &op, a, b, cache);
-        }
+        // Record type-key for every comparison op; cache::specialize() decides
+        // which ones have a FastOp variant. Eq/Lt/NotEq/Gt/LtEq/GtEq all do.
+        cached_binop!(self.heap, rip, &op, a, b, cache);
         let result = match op {
             OpCode::Eq => eq_vals_with_heap(a, b, &self.heap),
             OpCode::NotEq => !eq_vals_with_heap(a, b, &self.heap),

compiler/src/modules/vm/handlers/data.rs

@@ -6,9 +6,9 @@ impl<'a> VM<'a> {
 
     /* StoreName con back-propagación SSA a versiones previas. */
 
-    pub(crate) fn handle_store(&mut self, operand: u16, slots: &mut [Option<Val>]) -> Result<(), VmErr> {
+    pub(crate) fn handle_store(&mut self, operand: u16, slots: &mut [Val]) -> Result<(), VmErr> {
         let v = self.pop()?;
-        slots[operand as usize] = Some(v);
+        slots[operand as usize] = v;
         Ok(())
     }
 
@@ -119,15 +119,15 @@ impl<'a> VM<'a> {
 
     /* Side-effects and impurities: assert, del, global/nonlocal, import, type aliases, exception handling stubs and await/yield-from. */
 
-    pub(crate) fn handle_side(&mut self, op: OpCode, operand: u16, slots: &mut [Option<Val>]) -> Result<(), VmErr> {
+    pub(crate) fn handle_side(&mut self, op: OpCode, operand: u16, slots: &mut [Val]) -> Result<(), VmErr> {
         match op {
             OpCode::Assert => {
                 let v = self.pop()?;
                 if !self.truthy(v) { return Err(VmErr::Runtime("AssertionError")); }
             }
             OpCode::Del => {
                 let slot = operand as usize;
-                if slot < slots.len() { slots[slot] = None; }
+                if slot < slots.len() { slots[slot] = Val::undef(); }
             }
             OpCode::Global | OpCode::Nonlocal => self.mark_impure(),
             OpCode::TypeAlias => { self.pop()?; }
@@ -140,59 +140,59 @@ impl<'a> VM<'a> {
                 let msg = self.display(exc);
                 return Err(VmErr::Raised(msg));
             }
-            OpCode::Await => {
-                // If awaiting a coroutine, run it to completion or yield
-                let val = self.pop()?;
-                if val.is_heap() && matches!(self.heap.get(val), HeapObj::Coroutine(..)) {
-                    // Resume the inner coroutine
-                    self.push(val);
-                    // Use Call dispatch with 0 args - callee is on stack
-                    let callee = val;
-                    if let HeapObj::Coroutine(ip, saved_slots, saved_stack, fi, saved_iters) = self.heap.get(callee) {
-                        let (ip, fi) = (*ip, *fi);
-                        let mut fn_slots = saved_slots.clone();
-                        let saved_stack_len = self.stack.len();
-                        let saved_iter_len = self.iter_stack.len();
-                        self.stack.extend_from_slice(&saved_stack.clone());
-                        self.iter_stack.extend(saved_iters.clone());
-                        let saved_yielded = self.yielded;
-                        self.yielded = false;
-                        self.depth += 1;
-                        let (_, body, _, _) = self.functions[fi];
-                        let result = self.exec_from(body, &mut fn_slots, ip);
-                        self.depth -= 1;
-                        let result = result?;
-                        if self.yielded {
-                            // Inner coroutine yielded - propagate yield upward
-                            self.yielded = false;
-                            let resume_ip = self.resume_ip;
-                            let remaining = self.stack.split_off(saved_stack_len);
-                            let coro_iters: Vec<super::super::types::IterFrame> = self.iter_stack.drain(saved_iter_len..).collect();
-                            if let HeapObj::Coroutine(sip, ss, sst, _, si) = self.heap.get_mut(callee) {
-                                *sip = resume_ip;
-                                *ss = fn_slots;
-                                *sst = remaining;
-                                *si = coro_iters;
-                            }
-                            // Propagate: yield the value from this coroutine too
-                            self.push(result);
-                            self.yielded = true;
-                        } else {
-                            // Inner coroutine finished - push its return value
-                            self.stack.truncate(saved_stack_len);
-                            self.iter_stack.truncate(saved_iter_len);
-                            self.yielded = saved_yielded;
-                            self.push(result);
-                        }
-                    } else {
-                        // Not a coroutine anymore (shouldn't happen)
-                        self.push(val);
-                    }
-                } else {
-                    // Not a coroutine - just push the value (sync call already resolved)
-                    self.push(val);
-                }
-            }
+            OpCode::Await => {
+                // If awaiting a coroutine, run it to completion or yield
+                let val = self.pop()?;
+                if val.is_heap() && matches!(self.heap.get(val), HeapObj::Coroutine(..)) {
+                    // Resume the inner coroutine
+                    self.push(val);
+                    // Use Call dispatch with 0 args - callee is on stack
+                    let callee = val;
+                    if let HeapObj::Coroutine(ip, saved_slots, saved_stack, fi, saved_iters) = self.heap.get(callee) {
+                        let (ip, fi) = (*ip, *fi);
+                        let mut fn_slots = saved_slots.clone();
+                        let saved_stack_len = self.stack.len();
+                        let saved_iter_len = self.iter_stack.len();
+                        self.stack.extend_from_slice(&saved_stack.clone());
+                        self.iter_stack.extend(saved_iters.clone());
+                        let saved_yielded = self.yielded;
+                        self.yielded = false;
+                        self.depth += 1;
+                        let (_, body, _, _) = self.functions[fi];
+                        let result = self.exec_from(body, &mut fn_slots, ip);
+                        self.depth -= 1;
+                        let result = result?;
+                        if self.yielded {
+                            // Inner coroutine yielded - propagate yield upward
+                            self.yielded = false;
+                            let resume_ip = self.resume_ip;
+                            let remaining = self.stack.split_off(saved_stack_len);
+                            let coro_iters: Vec<super::super::types::IterFrame> = self.iter_stack.drain(saved_iter_len..).collect();
+                            if let HeapObj::Coroutine(sip, ss, sst, _, si) = self.heap.get_mut(callee) {
+                                *sip = resume_ip;
+                                *ss = fn_slots;
+                                *sst = remaining;
+                                *si = coro_iters;
+                            }
+                            // Propagate: yield the value from this coroutine too
+                            self.push(result);
+                            self.yielded = true;
+                        } else {
+                            // Inner coroutine finished - push its return value
+                            self.stack.truncate(saved_stack_len);
+                            self.iter_stack.truncate(saved_iter_len);
+                            self.yielded = saved_yielded;
+                            self.push(result);
+                        }
+                    } else {
+                        // Not a coroutine anymore (shouldn't happen)
+                        self.push(val);
+                    }
+                } else {
+                    // Not a coroutine - just push the value (sync call already resolved)
+                    self.push(val);
+                }
+            }
             OpCode::YieldFrom => {}
             _ => unreachable!("non-side opcode in handle_side"),
         }