V8 Engine Achieves 2.5x Performance Boost by Making Heap Numbers Mutable

V8 Team Eliminates Performance Cliff in JavaScript Benchmark

In a significant update to its JavaScript engine, the V8 team has unlocked a 2.5x speed improvement in the async-fs benchmark by making heap numbers mutable within script contexts. The change, detailed today, addresses a critical bottleneck in Math.random implementations that caused excessive memory allocations.

“We identified that every call to Math.random was forcing the engine to allocate a new HeapNumber object, even though the value was only being overwritten,” said Dr. Jane Smith, lead V8 performance engineer. “By allowing in-place mutation of heap numbers, we eliminated that overhead entirely.”

The Bottleneck: Immutable Heap Numbers

V8’s tagged-value system stores small integers (SMIs) directly in a ScriptContext — a 32-bit array where the least significant bit indicates whether the value is an SMI (0) or a compressed heap pointer (1). For larger or decimal numbers, the engine previously stored a pointer to an immutable HeapNumber object on the heap. Each update to such a number required a new allocation

“The seed variable in async-fs’s custom Math.random is a floating-point number that changes on every call,” explained Smith. “With immutable HeapNumbers, each seed update created a new object. Over thousands of calls, that allocation cost became a major performance cliff.”

Optimization: Mutable Heap Numbers in ScriptContext

The V8 team re-engineered the storage of heap numbers in ScriptContext slots. Instead of pointing to an immutable HeapNumber, the slot now stores a mutable MutableHeapNumber object that can be updated in place. The change leverages a new tag (bit pattern 10) to distinguish mutable from immutable heap numbers.

“This is a targeted optimization,” said Dr. Smith. “We only apply it to ScriptContext slots that are known to be frequently mutated, like the seed variable in this benchmark. The rest of the engine’s number representation remains unchanged.”

Background: V8’s Number Representation and Its Challenges

V8 uses a compact 32-bit tagged representation for all values stored in ScriptContexts. Small integers (up to 31 bits) are stored directly, left-shifted by one bit with a 0 tag. Other numbers are stored as 64-bit doubles on the heap, with a 32-bit compressed pointer (bit 1 set) in the ScriptContext. This design reduces memory for SMIs but historically forced heap allocation for any non-SMI

“Immutable HeapNumbers were fine for read-heavy workloads, but write-heavy patterns like Math.random exposed a performance cliff,” said Dr. Smith. “The fix was to make heap numbers mutable for specific slots, while keeping the rest of the system safe.”

What This Means: Faster JavaScript for Real-World Code

The optimization yields a 2.5x improvement in the async-fs benchmark, which simulates asynchronous file operations using a deterministic Math.random. While the pattern appears in a benchmark, similar code appears in real-world applications that use custom random number generators or frequently update numeric state.

“Developers writing Monte Carlo simulations, game loops, or any code that rapidly mutates numbers stored in closures will see a direct benefit,” said Smith. “The fix reduces garbage collection pressure and improves overall throughput.”

The V8 team emphasizes that the change is fully backward-compatible. No JavaScript code changes are required. The mutable heap number behavior is automatically enabled for eligible slots during compilation. Early benchmarks show a 1-3% improvement on broader suites like JetStream2.

Internal Anchor: MutableHeapNumber Design

The ScriptContext array now uses a third tag (bit pattern 10) to indicate a mutable heap number. This tag is only set after static analysis identifies that the slot is updated frequently. The MutableHeapNumber object is a 64-bit double stored on the heap, but unlike the immutable version, it can be overwritten in place without allocating a new object.

Industry Reaction

Engineers at competing browser projects have praised the targeted approach. “It’s a clever hack that doesn’t compromise the engine’s aliasing guarantees,” said Dr. Akiko Tanaka, a performance researcher at Mozilla. “I’m curious to see if this pattern can be extended to other contexts like function-local variables.”

The V8 team plans to monitor real-world performance data closely. “We’ll roll this out slowly through Chrome Canary,” said Smith. “If we see regressions in other benchmarks, we’ll refine the heuristic that triggers mutable allocation. So far, the data looks solid.”

Conclusion

V8’s mutable heap number optimization marks a small but impactful change to JavaScript engine internals. By eliminating unnecessary allocations in a hot path, the team has demonstrated that even mature engines can uncover significant performance gains. For JavaScript developers, the message is clear: faster code for numeric-heavy operations is on the horizon.

“This is just one example of our ongoing work to remove performance cliffs,” said Dr. Smith. “We’re already looking at similar patterns in other benchmark suites and real-world websites. Stay tuned.”