Story Details

V8's JavaScript engine now uses "mutable heap numbers" to improve performance, particularly for WebAssembly. Previously, every Number object required a heap allocation, even for simple operations. This new approach allows V8 to directly modify number values already on the heap, avoiding costly allocations and garbage collection cycles. This leads to significant speed improvements in scenarios with frequent number manipulations, like numerical computations in WebAssembly, and reduces memory usage. This change is particularly beneficial for applications like scientific computing, image processing, and other computationally intensive tasks performed in the browser or server-side JavaScript environments.

The V8 JavaScript engine, developed by Google and used in Chrome and Node.js, has traditionally represented all JavaScript numbers as 64-bit floating-point values (doubles) residing in memory. This blog post details a significant performance optimization called "mutable heap numbers" that alters this representation for specific scenarios. This change aims to reduce memory consumption and improve performance, particularly in situations involving large object graphs where numbers are frequently boxed and unboxed.

Previously, when a number needed to be treated as an object (e.g., to add properties to it), V8 would create a new "heap number" object, which contained a pointer to a separate memory location holding the actual 64-bit double value. This process, called "boxing," incurred both memory overhead from allocating the heap object and performance overhead from the indirection required to access the numerical value. Conversely, "unboxing" occurred when retrieving the numeric value from the heap number object.

The mutable heap number optimization introduces a more efficient approach for certain common cases. Instead of always allocating a separate object and pointer, V8 now can directly store the 64-bit double value within the object itself, eliminating the pointer and the extra memory allocation for the separate double. This is achieved by changing the representation of the heap number object in memory. This in-place storage is only possible when the number doesn't require any additional properties beyond what a standard number object needs. Essentially, if a number object is treated as just a number, it can store the number directly within itself.

This optimization provides several benefits. First, it reduces memory consumption by eliminating the need for a separate double value in memory. Second, it improves performance by removing the need for pointer dereferencing during boxing and unboxing operations. This leads to faster execution of JavaScript code, especially in scenarios where numbers are frequently boxed and unboxed, such as when dealing with large object graphs or performing numerical computations within object properties.

The implementation involved carefully considering how garbage collection interacts with these mutable heap numbers. The garbage collector needs to be aware of the different possible object representations (mutable heap number versus traditional heap number) to function correctly.

This optimization has been implemented in V8 v11.3, demonstrably reducing heap size in specific benchmarks and improving performance in certain JavaScript operations involving numbers. While the blog post highlights specific benefits for React applications, the optimization is applicable to any JavaScript code running in a V8 environment. The post also notes potential future extensions of this technique to further enhance V8's performance.