perf: shrink binary by 10% (660K -> 594K) via dead-code removal and HashMap dedup

Author: dylan-sutton-chavez

compiler/src/main.rs

@@ -20,19 +20,27 @@ options:
 #[inline]
 fn eprint_msg(msg: &str) {
     use std::io::Write;
-    let _ = writeln!(std::io::stderr(), "{}", msg);
+    let mut e = std::io::stderr().lock();
+    let _ = e.write_all(msg.as_bytes());
+    let _ = e.write_all(b"\n");
 }
 
 #[inline]
 fn print_msg(level: &str, msg: &str) {
     use std::io::Write;
-    let _ = writeln!(std::io::stdout(), "[{}] {}", level, msg);
+    let mut o = std::io::stdout().lock();
+    let _ = o.write_all(b"[");
+    let _ = o.write_all(level.as_bytes());
+    let _ = o.write_all(b"] ");
+    let _ = o.write_all(msg.as_bytes());
+    let _ = o.write_all(b"\n");
 }
 
 fn parse_args() -> (String, usize, bool, bool) {
     let args: Vec<_> = env::args().skip(1).collect();
     if args.is_empty() || args.iter().any(|a| a == "-h") {
-        print!("{}", HELP);
+        use std::io::Write;
+        let _ = std::io::stdout().lock().write_all(HELP.as_bytes());
         exit(0);
     }
     let q = args.iter().any(|a| a == "-q");
@@ -76,7 +84,14 @@ fn run(path: &str, sandbox: bool, verbosity: usize, quiet: bool) -> Result<(), S
     let mut vm = VM::with_limits(&chunk, limits);
     let exec_result = vm.run();
 
-    vm.output.iter().for_each(|l| println!("{l}"));
+    {
+        use std::io::Write;
+        let mut out = std::io::stdout().lock();
+        for l in &vm.output {
+            let _ = out.write_all(l.as_bytes());
+            let _ = out.write_all(b"\n");
+        }
+    }
 
     if let Err(e) = exec_result {
         return Err(e.render());

compiler/src/modules/parser/expr.rs

@@ -386,7 +386,7 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
             s.chunk.emit(OpCode::ReturnValue, 0);
         });
 
-        let param_slots: alloc::collections::BTreeSet<String> = params.iter().map(|p| s!(str p.trim_start_matches('*'), "_0")).collect();
+        let param_slots: crate::modules::fx::FxHashSet<String> = params.iter().map(|p| s!(str p.trim_start_matches('*'), "_0")).collect();
         for name in &body.names {
             if !param_slots.contains(name.as_str()) {
                 self.chunk.push_name(name);

compiler/src/modules/parser/literals.rs

@@ -134,7 +134,9 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
             for_iters.push(fi);
         }
 
-        let mut var_map: HashMap<u16, u16> = HashMap::default();
+        // Tiny mapping (typical size 1-5); linear scan beats HashMap and
+        // avoids monomorphizing a hash table for u16 keys.
+        let mut var_map: Vec<(u16, u16)> = Vec::new();
         for var in &all_vars {
             let old_ver = versions_before.get(var).copied().unwrap_or(0);
             let new_ver = self.current_version(var);
@@ -144,13 +146,13 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
             let Some(&old_slot) = self.chunk.name_index.get(old_name) else { continue };
             let mut nb = [0u8; 128];
             let new_slot = self.chunk.push_name(Self::ssa_name(var, new_ver, &mut nb));
-            var_map.insert(old_slot, new_slot);
+            var_map.push((old_slot, new_slot));
         }
 
         for body in elem_bodies {
             for ins in body {
                 let operand = if matches!(ins.opcode, OpCode::LoadName | OpCode::StoreName) {
-                    var_map.get(&ins.operand).copied().unwrap_or(ins.operand)
+                    var_map.iter().find(|(k, _)| *k == ins.operand).map(|(_, v)| *v).unwrap_or(ins.operand)
                 } else {
                     ins.operand
                 };

compiler/src/modules/parser/types.rs

@@ -279,39 +279,3 @@ pub const BUILTIN_TYPES: &[&str] = &[
     "AssertionError", "ArithmeticError", "LookupError",
 ];
 
-// Functional grouping of opcodes for analysis tooling. Not used by the
-// runtime dispatch (which switches on OpCode directly).
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum OpCategory {
-    Load, Store,
-    Arith, Bitwise, Compare, Logic, Identity,
-    ControlFlow, Iter,
-    Build, Container, Comprehension,
-    Function, Ssa, Yield, Side,
-    Unsupported,
-}
-
-impl OpCode {
-    pub fn category(self) -> OpCategory {
-        use OpCode::*;
-        match self {
-            LoadConst | LoadName | LoadTrue | LoadFalse | LoadNone | LoadEllipsis => OpCategory::Load, StoreName => OpCategory::Store,
-            Add | Sub | Mul | Div | Mod | Pow | FloorDiv | Minus => OpCategory::Arith, BitAnd | BitOr | BitXor | BitNot | Shl | Shr => OpCategory::Bitwise,
-            Eq | NotEq | Lt | Gt | LtEq | GtEq => OpCategory::Compare, And | Or | Not => OpCategory::Logic,
-            In | NotIn | Is | IsNot => OpCategory::Identity, 
-            Jump | JumpIfFalse | JumpIfFalseOrPop | JumpIfTrueOrPop | ReturnValue | PopTop | Dup | Dup2 => OpCategory::ControlFlow,
-            GetIter | ForIter => OpCategory::Iter,
-            BuildList | BuildTuple | BuildDict | BuildSet | BuildSlice | BuildString => OpCategory::Build,
-            GetItem | StoreItem | UnpackSequence | UnpackEx | FormatValue => OpCategory::Container,
-            ListAppend | SetAdd | MapAdd => OpCategory::Comprehension,
-            Call | MakeFunction | MakeCoroutine | CallPrint | CallLen | CallAbs | CallStr | CallInt | CallRange | CallChr | CallType | CallFloat | CallBool | CallRound | CallMin | CallMax | CallSum | CallSorted | CallEnumerate | CallZip | CallList | CallTuple | CallDict | CallIsInstance | CallSet | CallInput | CallOrd | CallMethod | CallMethodArgs  | CallAll | CallAny | CallBin | CallOct | CallHex | CallDivmod | CallPow | CallRepr | CallReversed | CallCallable | CallId | CallHash => OpCategory::Function,
-            Phi => OpCategory::Ssa,
-            Yield => OpCategory::Yield,
-            Assert | Del | Global | Nonlocal | TypeAlias | Import | ImportFrom | SetupExcept | PopExcept | Raise | RaiseFrom | Await | YieldFrom => OpCategory::Side,
-            LoadAttr => OpCategory::Load,
-            SetupWith | ExitWith => OpCategory::ControlFlow,
-            UnpackArgs => OpCategory::Container,
-            MakeClass | StoreAttr => OpCategory::Unsupported,
-        }
-    }
-}

compiler/src/modules/vm/builtins.rs

@@ -134,6 +134,30 @@ impl<'a> VM<'a> {
         self.push(v); Ok(())
     }
 
+    /* Allocate a List from items and push. Centralises the
+       Rc::new(RefCell::new(items)) construction inlined ~15 times. */
+    pub(crate) fn alloc_list(&mut self, items: Vec<Val>) -> Result<Val, VmErr> {
+        self.heap.alloc(HeapObj::List(Rc::new(RefCell::new(items))))
+    }
+
+    /* Allocate a List, push it, return Ok. */
+    pub(crate) fn alloc_and_push_list(&mut self, items: Vec<Val>) -> Result<(), VmErr> {
+        let v = self.alloc_list(items)?;
+        self.push(v); Ok(())
+    }
+
+    /* Allocate a Dict from a DictMap and push. */
+    pub(crate) fn alloc_and_push_dict(&mut self, dm: DictMap) -> Result<(), VmErr> {
+        let v = self.heap.alloc(HeapObj::Dict(Rc::new(RefCell::new(dm))))?;
+        self.push(v); Ok(())
+    }
+
+    /* Allocate a Tuple and push. */
+    pub(crate) fn alloc_and_push_tuple(&mut self, items: Vec<Val>) -> Result<(), VmErr> {
+        let v = self.heap.alloc(HeapObj::Tuple(items))?;
+        self.push(v); Ok(())
+    }
+
     pub fn call_int(&mut self) -> Result<(), VmErr> {
         let o = self.pop()?;
         if o.is_heap()
@@ -262,8 +286,7 @@ impl<'a> VM<'a> {
         let o = self.pop()?;
         let mut items = self.extract_iter(o, false)?;
         self.sort_by_lt(&mut items)?;
-        let val = self.heap.alloc(HeapObj::List(Rc::new(RefCell::new(items))))?;
-        self.push(val); Ok(())
+        self.alloc_and_push_list(items)
     }
 
     /* In-place sort using lt_vals for ordering. Captures the first error
@@ -294,13 +317,10 @@ impl<'a> VM<'a> {
             && let HeapObj::Str(s) = self.heap.get(o) {
                 let s = s.clone();
                 let items = self.str_to_char_vals(&s)?;
-                let val = self.heap.alloc(HeapObj::List(Rc::new(RefCell::new(items))))?;
-                self.push(val);
-                return Ok(());
+                return self.alloc_and_push_list(items);
         }
         let items = self.extract_iter(o, true)?;
-        let val = self.heap.alloc(HeapObj::List(Rc::new(RefCell::new(items))))?;
-        self.push(val); Ok(())
+        self.alloc_and_push_list(items)
     }
 
     pub fn call_tuple(&mut self) -> Result<(), VmErr> {
@@ -310,8 +330,7 @@ impl<'a> VM<'a> {
             HeapObj::List(v)  => v.borrow().clone(),
             _ => return Err(cold_type("tuple() argument must be iterable")),
         }} else { return Err(cold_type("tuple() argument must be iterable")); };
-        let val = self.heap.alloc(HeapObj::Tuple(items))?;
-        self.push(val); Ok(())
+        self.alloc_and_push_tuple(items)
     }
 
     pub fn call_enumerate(&mut self) -> Result<(), VmErr> {
@@ -322,8 +341,7 @@ impl<'a> VM<'a> {
             let t = self.heap.alloc(HeapObj::Tuple(vec![Val::int(i as i64), x]))?;
             pairs.push(t);
         }
-        let val = self.heap.alloc(HeapObj::List(Rc::new(RefCell::new(pairs))))?;
-        self.push(val); Ok(())
+        self.alloc_and_push_list(pairs)
     }
 
     /* Pairs elements from N iterables into tuples, truncating to the shortest. */
@@ -340,8 +358,7 @@ impl<'a> VM<'a> {
             let t = self.heap.alloc(HeapObj::Tuple(tuple))?;
             pairs.push(t);
         }
-        let val = self.heap.alloc(HeapObj::List(Rc::new(RefCell::new(pairs))))?;
-        self.push(val); Ok(())
+        self.alloc_and_push_list(pairs)
     }
 
     /* Type-name based isinstance check. Accepts Type or NativeFn (for the
@@ -486,26 +503,22 @@ impl<'a> VM<'a> {
         }
         let mid = items.len() - after;
         for &v in items[mid..].iter().rev() { self.push(v); }
-        let star = self.heap.alloc(HeapObj::List(Rc::new(RefCell::new(
-            items[before..mid].to_vec()
-        ))))?;
+        let star = self.alloc_list(items[before..mid].to_vec())?;
         self.push(star);
         for &v in items[..before].iter().rev() { self.push(v); }
         Ok(())
     }
 
     pub fn call_dict(&mut self, op: u16) -> Result<(), VmErr> {
-        if op == 0 {
-            let val = self.heap.alloc(HeapObj::Dict(Rc::new(RefCell::new(DictMap::new()))))?;
-            self.push(val);
+        let dm = if op == 0 {
+            DictMap::new()
         } else {
             let args = self.pop_n((op as usize) * 2)?;
             let mut dm = DictMap::with_capacity(op as usize);
             for pair in args.chunks(2) { dm.insert(pair[0], pair[1]); }
-            let val = self.heap.alloc(HeapObj::Dict(Rc::new(RefCell::new(dm))))?;
-            self.push(val);
-        }
-        Ok(())
+            dm
+        };
+        self.alloc_and_push_dict(dm)
     }
 
     pub fn call_set(&mut self, op: u16) -> Result<(), VmErr> {
@@ -716,8 +729,7 @@ impl<'a> VM<'a> {
         let (q, r) = ba.divmod(&bb).ok_or(VmErr::ZeroDiv)?;
         let qv = self.bigint_to_val(q)?;
         let rv = self.bigint_to_val(r)?;
-        let val = self.heap.alloc(HeapObj::Tuple(vec![qv, rv]))?;
-        self.push(val); Ok(())
+        self.alloc_and_push_tuple(vec![qv, rv])
     }
 
     pub fn call_pow(&mut self, op: u16) -> Result<(), VmErr> {
@@ -846,8 +858,7 @@ impl<'a> VM<'a> {
             self.extract_iter(o, true)?
         };
         items.reverse();
-        let v = self.heap.alloc(HeapObj::List(Rc::new(RefCell::new(items))))?;
-        self.push(v); Ok(())
+        self.alloc_and_push_list(items)
     }
 
     // format(value [, spec]).

compiler/src/modules/vm/cache.rs

@@ -1,6 +1,5 @@
 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, string::ToString};
 
@@ -149,21 +148,24 @@ fn hash_args(args: &[Val]) -> u64 {
     h
 }
 
-pub struct Templates { map: HashMap<usize, Vec<TplEntry>> }
+// Indexed by `fi` (function id, dense from 0..N). Vec gives O(1) lookup
+// without a HashMap monomorphization.
+pub struct Templates { slots: Vec<Vec<TplEntry>> }
 
 impl Templates {
-    pub fn new() -> Self { Self { map: HashMap::default() } }
+    pub fn new() -> Self { Self { slots: Vec::new() } }
 
     pub fn lookup(&self, fi: usize, args: &[Val], heap: &super::types::HeapPool) -> Option<Val> {
         let h = hash_args(args);
-        self.map.get(&fi)?.iter()
+        self.slots.get(fi)?.iter()
             .find(|e| e.hits >= TPL_THRESH && args_match(e, args, h, heap))
             .map(|e| e.result)
     }
 
     pub fn record(&mut self, fi: usize, args: &[Val], result: Val, heap: &super::types::HeapPool) {
+        if self.slots.len() <= fi { self.slots.resize_with(fi + 1, Vec::new); }
         let h = hash_args(args);
-        let v = self.map.entry(fi).or_default();
+        let v = &mut self.slots[fi];
         if let Some(e) = v.iter_mut().find(|e| args_match(e, args, h, heap)) {
             e.hits += 1; e.result = result;
         } else if v.len() < 256 {
@@ -172,7 +174,7 @@ impl Templates {
     }
 
     pub fn count(&self) -> usize {
-        self.map.values().flat_map(|v| v.iter()).filter(|e| e.hits >= TPL_THRESH).count()
+        self.slots.iter().flat_map(|v| v.iter()).filter(|e| e.hits >= TPL_THRESH).count()
     }
 }
 

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

@@ -25,7 +25,7 @@ impl<'a> VM<'a> {
             OpCode::Mod => self.exec_mod(a, b)?,
             OpCode::Pow => self.exec_pow(a, b)?,
             OpCode::FloorDiv => self.exec_floordiv(a, b)?,
-            _ => unreachable!("non-arith opcode in handle_arith"),
+            _ => return Err(cold_runtime("non-arith opcode in handle_arith")),
         };
         self.push(result);
         Ok(())
@@ -101,7 +101,7 @@ impl<'a> VM<'a> {
             OpCode::BitXor => self.bitwise_op(a, b, |x, y| x ^ y)?,
             OpCode::Shl => self.exec_shl(a, b)?,
             OpCode::Shr => self.exec_shr(a, b)?,
-            _ => unreachable!("non-bitwise opcode in handle_bitwise"),
+            _ => return Err(cold_runtime("non-bitwise opcode in handle_bitwise")),
         };
         self.push(result);
         Ok(())
@@ -140,7 +140,7 @@ impl<'a> VM<'a> {
             OpCode::Gt => self.lt_vals(b, a)?,
             OpCode::LtEq => !self.lt_vals(b, a)?,
             OpCode::GtEq => !self.lt_vals(a, b)?,
-            _ => unreachable!("non-compare opcode in handle_compare"),
+            _ => return Err(cold_runtime("non-compare opcode in handle_compare")),
         };
         self.push(Val::bool(result));
         Ok(())
@@ -154,7 +154,7 @@ impl<'a> VM<'a> {
                 let v = self.pop()?;
                 self.push(Val::bool(!self.truthy(v)));
             }
-            _ => unreachable!("non-logic opcode in handle_logic"),
+            _ => return Err(cold_runtime("non-logic opcode in handle_logic")),
         }
         Ok(())
     }
@@ -167,7 +167,7 @@ impl<'a> VM<'a> {
             OpCode::NotIn => !self.contains(b, a),
             OpCode::Is => a.0 == b.0,
             OpCode::IsNot => a.0 != b.0,
-            _ => unreachable!("non-identity opcode in handle_identity"),
+            _ => return Err(cold_runtime("non-identity opcode in handle_identity")),
         };
         self.push(Val::bool(result));
         Ok(())

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

@@ -36,7 +36,7 @@ impl<'a> VM<'a> {
             }
             OpCode::BuildSet   => self.build_set(operand)?,
             OpCode::BuildSlice => self.build_slice(operand)?,
-            _ => unreachable!("non-build opcode in handle_build"),
+            _ => return Err(cold_runtime("non-build opcode in handle_build")),
         }
         Ok(())
     }
@@ -58,7 +58,7 @@ impl<'a> VM<'a> {
                 let val = self.heap.alloc(HeapObj::Str(s))?;
                 self.push(val);
             }
-            _ => unreachable!("non-container opcode in handle_container"),
+            _ => return Err(cold_runtime("non-container opcode in handle_container")),
         }
         Ok(())
     }
@@ -69,7 +69,7 @@ impl<'a> VM<'a> {
             OpCode::ListAppend => ("list",  self.pop()?, None),
             OpCode::SetAdd     => ("set",   self.pop()?, None),
             OpCode::MapAdd     => { let v = self.pop()?; let k = self.pop()?; ("dict", v, Some(k)) }
-            _ => unreachable!("non-comprehension opcode in handle_comprehension"),
+            _ => return Err(cold_runtime("non-comprehension opcode in handle_comprehension")),
         };
         let acc = *self.stack.last().ok_or(VmErr::Runtime("stack underflow"))?;
         let corrupt = || VmErr::Runtime(match kind {
@@ -137,7 +137,7 @@ impl<'a> VM<'a> {
                 }
             }
             OpCode::YieldFrom => {}
-            _ => unreachable!("non-side opcode in handle_side"),
+            _ => return Err(cold_runtime("non-side opcode in handle_side")),
         }
         Ok(())
     }