V8's Ignition and TurboFan Explained

V8's Ignition and TurboFan Explained

V8 uses a two-tier compilation strategy: Ignition (interpreter) for fast startup and TurboFan (optimizing compiler) for high performance. Here is how they work together.

Ignition (Interpreter)

• Compiles the AST into bytecode (a low-level, platform-independent representation).
• Executes the bytecode directly using an interpreter.
• Fast to generate (quick startup), but execution is slower than machine code.
• Collects type feedback (what types/hidden classes are seen at each operation).

TurboFan (Optimizing Compiler)

• Takes hot (frequently executed) bytecode and compiles it to optimized machine code.
• Uses type feedback from Ignition to make assumptions (e.g., "this function always receives objects with hidden class C").
• Much faster execution than bytecode.
• If an assumption breaks, it deoptimizes (falls back to Ignition bytecode).

The Pipeline

Source → Parser → AST → Ignition (bytecode) → Execution (with type feedback)
                                            ↓ (hot code detected)
                                        TurboFan (machine code)
                                            ↓ (assumption breaks)
                                        Deoptimization → Ignition (bytecode)
``
### When TurboFan Kicks In

V8 tracks how often each function is called. After a threshold (varies, but typically hundreds to thousands of calls), TurboFan optimizes the function. This is why benchmarks need a "warmup" phase.

### Deoptimization

```js
function add(a, b) { return a + b; }
// called many times with numbers → TurboFan optimizes for numbers
for (let i = 0; i < 10000; i++) add(1, 2);
// now called with strings → assumption breaks → deoptimize
add("hello", "world");
``
After deoptimization, V8 may re-optimize later with the new type feedback (if the function is still hot).

### Sparkplug (Baseline Compiler)

Newer V8 versions add **Sparkplug**, a baseline compiler between Ignition and TurboFan. It compiles bytecode to machine code without optimizations (just fast execution). This fills the gap between Ignition (slow) and TurboFan (slow to compile but fast to run).

### Why Two (or Three) Tiers?

- **Fast startup**: Ignition generates bytecode quickly.
- **High performance**: TurboFan optimizes hot code.
- **Graceful fallback**: deoptimization falls back to Ignition.
- **Balance**: Sparkplug provides a middle ground for moderate-hot code.

### The Takeaway

V8 uses Ignition (interpreter) for fast startup, TurboFan (optimizing compiler) for hot code, and Sparkplug (baseline) as a middle tier. Ignition collects type feedback; TurboFan uses it to optimize. If assumptions break, TurboFan deoptimizes to Ignition. This two-tier (now three-tier) strategy balances startup speed and peak performance.