V8 Engine Scores 2.5x Speed Boost by Eliminating Costly Heap Number Allocations in Math.random

Google's V8 JavaScript engine has achieved a staggering 2.5x performance improvement in the async-fs benchmark of JetStream2, thanks to a surgical optimization that eliminates repeated HeapNumber allocations during Math.random calls. The fix, centered on how mutable numeric values are stored in script contexts, directly addresses a previously hidden performance cliff.

“The bottleneck was entirely in the allocation pattern,” a V8 performance engineer explained. “By making the seed variable mutable and storing it directly as an untagged double, we removed the need to create a new HeapNumber on every random number generation.”

Background: The Hidden Cost of Immutable HeapNumbers

V8 traditionally stores numbers in one of two forms: as immediate Small Integers (SMIs) for 31-bit integers, or as pointers to immutable HeapNumber objects on the heap for larger or fractional values. In the async-fs benchmark, the seed variable of a custom Math.random implementation was held in a ScriptContext as a pointer to an immutable HeapNumber.

Every call to Math.random updated this seed, forcing V8 to allocate a new HeapNumber object. This allocation overhead, repeated thousands of times, became the single largest performance liability. The JetStream2 async-fs benchmark, which emulates a real-world file system, was particularly affected.

How the Optimization Works

The V8 team recognized that the seed variable’s value changes frequently – it is mutable by nature. Instead of storing a pointer to an immutable HeapNumber, they reconfigured the ScriptContext slot to hold an untagged 64-bit double value directly. This removes the indirection and allocation entirely.

“In effect, we turned a pointer-to-HeapNumber into a raw double slot,” said a V8 compiler engineer. “The write barrier and heap allocation are gone. The seed is now stored inline, which is both faster and more memory efficient.”

The change was inspired by the benchmark’s pattern, but similar usage appears in real-world applications that depend on custom random number generators or frequently updated numeric state.

What This Means for JavaScript Developers

For end-users, the optimization translates to faster JavaScript execution in any application that repeatedly updates numeric variables held in script contexts. While the immediate gains are most visible in async-heavy workloads, the underlying technique paves the way for similar improvements in mutable numeric storage across the engine.

“This isn’t just a synthetic benchmark fix,” a V8 performance lead emphasized. “Real-world frameworks, games, and data processing code often follow the same pattern – an integer or double that gets updated in a tight loop. Now those loops will run significantly faster.”

The improvement contributed to a noticeable overall score increase in JetStream2, solidifying V8’s position as a high-performance JavaScript engine. The team is now exploring additional opportunities to flatten context-allocated numeric values.

As JavaScript continues to power demanding applications from server-side runtimes to complex web apps, even marginal gains in core engine efficiency pay dividends across the ecosystem. V8’s latest move demonstrates that sometimes the biggest breakthroughs come from removing what was previously considered a necessary overhead.