try to beat LuaJIT

[wtholliday]

Current benchmark results:

  ┌─────────────────┬────────┬─────────────┐                                                                                                                                             
  │     Backend     │  Time  │ vs Lyte JIT │                                                                                                                                             
  ├─────────────────┼────────┼─────────────┤                                                                                                                                             
  │ LuaJIT (JIT)    │ 0.035s │ 1.5x faster │                                                                                                                                             
  ├─────────────────┼────────┼─────────────┤                                                                                                                                             
  │ Lyte JIT        │ 0.054s │ 1x          │
  ├─────────────────┼────────┼─────────────┤
  │ LuaJIT (interp) │ 0.361s │ ~7x slower  │
  ├─────────────────┼────────┼─────────────┤
  │ Lua 5.5         │ 0.752s │ ~14x slower │
  ├─────────────────┼────────┼─────────────┤
  │ Lyte VM         │ 1.980s │ ~37x slower │
  └─────────────────┴────────┴─────────────┘

For the iOS case (no JIT allowed), LuaJIT's interpreter is ~5.5x faster than the Lyte VM. LuaJIT's interpreter benefits from a highly optimized bytecode dispatch loop written in
hand-tuned assembly. That's the gap to close for the Lyte VM on iOS.

[wtholliday]

Given the static typing of Lyte, can Lyte VM beat the LuaJIT interpreter without hand-tuned assembly?

⏺ Yes, absolutely. The static typing is a major advantage that the current VM isn't fully exploiting. Here's why:                                                                        
                                                                                                                                                                                         
  What LuaJIT's interpreter spends time on that Lyte doesn't need to:                                                                                                                    
  - Tag checking on every value (NaN-boxing scheme)                                                                                                                                      
  - Type dispatch for polymorphic operations (+ must check if operands are int, float, string, or metamethod)                                                                            
  - Table hash lookups for bq.b0, bq.x1, etc. (every field access)                                                                                                                       
                                                                                                                                                                                         
  Where Lyte's VM is currently losing that time back:                                                                                                                                    
                                                                                                                                                                                         
  1. match dispatch with 100+ arms — the biggest bottleneck. Every instruction goes through a giant Rust match. LuaJIT uses hand-written assembly with computed goto, which is ~2-3x
  faster for dispatch alone.
  2. No register reuse — the codegen uses a linear next_reg counter and never reclaims temporaries, causing unnecessary register pressure.
  3. Redundant loads/stores — struct fields like bq.b0 get reloaded from memory every iteration because there's no CSE or loop-invariant code motion. The filter coefficients are
  constant across all 10M iterations.

  Concrete wins available without assembly:

  ┌───────────────────────────────────────────────────────────────┬──────────────────┬────────────┐
  │                         Optimization                          │ Estimated impact │ Difficulty │
  ├───────────────────────────────────────────────────────────────┼──────────────────┼────────────┤
  │ Hoist loop-invariant loads (b0, b1, b2, a1, a2 loaded once)   │ ~15-20%          │ Medium     │
  ├───────────────────────────────────────────────────────────────┼──────────────────┼────────────┤
  │ Computed goto dispatch (Rust unsafe label-as-value emulation) │ ~30-40%          │ Medium     │
  ├───────────────────────────────────────────────────────────────┼──────────────────┼────────────┤
  │ Register reuse across expressions                             │ ~10%             │ Low-Medium │
  ├───────────────────────────────────────────────────────────────┼──────────────────┼────────────┤
  │ More superinstructions (load+mul, compare+branch for while)   │ ~10-15%          │ Low        │
  ├───────────────────────────────────────────────────────────────┼──────────────────┼────────────┤
  │ Bytecode encoding (u32-packed instead of Rust enum variants)  │ ~10-15%          │ Medium     │
  └───────────────────────────────────────────────────────────────┴──────────────────┴────────────┘

  The Rust enum Vec<Opcode> representation is cache-unfriendly — each variant is likely 16+ bytes. Packing instructions into 32-bit words (like LuaJIT does) would dramatically improve
  icache and dcache behavior.

  Bottom line: The static typing means Lyte's VM is doing strictly less semantic work per sample than LuaJIT — no tag checks, no hash lookups, direct memory offsets for fields. The 5.5x
   gap is almost entirely dispatch and codegen overhead. With computed goto dispatch and loop-invariant hoisting alone, it should be competitive. Beating LuaJIT's interpreter without
  hand-tuned assembly is realistic.

[wtholliday]

Here's where we are now:

  ┌────────────────────────────┬────────┬─────────────────┐
  │       Implementation       │  Time  │ vs LuaJIT -joff │
  ├────────────────────────────┼────────┼─────────────────┤
  │ Lyte JIT                   │ 0.058s │ 6.3x faster     │
  ├────────────────────────────┼────────┼─────────────────┤
  │ LuaJIT JIT                 │ 0.036s │ 10.2x faster    │
  ├────────────────────────────┼────────┼─────────────────┤
  │ LuaJIT interpreter (-joff) │ 0.37s  │ baseline        │
  ├────────────────────────────┼────────┼─────────────────┤
  │ Lua 5.5                    │ 0.78s  │ 2.1x slower     │
  ├────────────────────────────┼────────┼─────────────────┤
  │ Lyte VM (optimized)        │ 1.14s  │ 3.1x slower     │
  ├────────────────────────────┼────────┼─────────────────┤
  │ Lyte VM (original)         │ 1.98s  │ 5.4x slower     │
  └────────────────────────────┴────────┴─────────────────┘