V.E.L.O.C.I.T.Y.-OS: JIT Math Optimizations – Division-Free and In-Place (Part 5)

At this stage, my closure-based JIT engine was running, but profile traces showed I was still leaving massive amounts of performance on the table.

I was bottlenecked by two classic culprits: variable lookup hashing and unoptimized packed-byte arithmetic.

To close the gap with native Rust compilation, I went to work on a series of low-level optimization passes.

We are building a bare-metal, self-healing operating system running entirely inside the CPU's L3 cache. Here is the roadmap for this 12-part series:

1. 
   Part 1: The Spark — Exposing the "Safe-Room" security leak and building the compiler gate.


2. 
   Part 2: The NDA Language — Designing a content-addressed triplet representation to cure context bloat.


3. 
   Part 3: Ditching the Web Stack — Building a native 30MB IDE with 1,500,000x IPC latency drops.


4. 
   Part 4: The Closure JIT — Compiling AST blocks to nested closures and bypassing borrow checker limits.


5. 
   Part 5: JIT Math Optimizations — Replacing division operations with precomputed 16-bit lookup tables. (You are here)
   


6. 
   Part 6: x86-64 Assembler & SCEV-Lite — Compiling scalar loops directly to native code in constant time.


7. 
   Part 7: Classic Compiler Passes — Implementing inter-procedural Dead Code Elimination and loop unrolling.


8. 
   Part 8: Reclaiming Ring 0 — Exiting UEFI boot services and transitioning the kernel to Ring 0.


9. 
   Part 9: Bare-Metal Drivers — Writing a PCI scanner, NVMe block storage controller, and FAT32 parser.


10. 
    Part 10: Synaptic Canvas — Rendering a spatial, force-directed GUI based on model token activation vectors.


11. 
    Part 11: Swarms & Hot-Patching — Building multi-agent scheduling and zero-downtime RCU driver updates.


12. 
    Part 12: Self-Evolution — Handing system control over to a local LLM Terminal that self-optimizes via telemetry.

Optimization 1: Slot-Based Variable Allocation

Initially, the runtime variables were stored inside a HashMap<u64, NdaVec>. Every time the model executed a Load, Store, or Let instruction, it had to hash the variable name and query the map, adding significant hashing and lookup overhead inside loops.

To fix this, I implemented a compile-time Variable Registry (VarRegistry).

The registry maps variable names to direct array indices (slot_index) at load-time. I pre-allocated a flat array Vec<Option<NdaVec>> inside the runtime JitState. Every variable access inside loop bodies was reduced to a direct offset index lookup (


$O(1)$

), completely eliminating hash calculations.

The Quaternary Pivot: From Ternary to 2-Bit Quantization

Before optimizing the loops, I made a critical architectural shift in the data format itself.

To preserve more detail without inflating the memory footprint, I designed a quaternary 2-bit (b2) format. This changed the quantization structure to map weights to four states ({-2, -1, 1, 2}). This extra resolution dramatically increased model coding fidelity, bridging the gap between small local models and massive cloud reasoning models.

Just like the NDA-KV cache format, this quaternary layout decomposed values into two separate bitmaps: a sign bitmap (encoding positive/negative status) and an extra bitmap (encoding magnitude via XNOR condition with sign). Here is the logical layout mapping: