Stories with Tag JIT compiler

• Turbocharging V8 with mutable heap numbers · V8

  permalink

  Posted: 2025-02-25 15:18:57

  Verbose tl;dr

  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.

  • V8
  • javascript
  • JavaScript engine
  • performance
  • optimization
  • Heap
  • Numbers
  • Mutable numbers
  • TurboFan
  • JIT compiler
  • Garbage Collection
  • memory management

  Summary of Comments ( 2 )
  https://news.ycombinator.com/item?id=43172977

  Verbose tl;dr

  Hacker News commenters generally expressed interest in the performance improvements offered by V8's mutable heap numbers, particularly for data-heavy applications. Some questioned the impact on garbage collection and memory overhead, while others praised the cleverness of the approach. A few commenters delved into specific technical aspects, like the handling of NaN values and the potential for future optimizations using this technique for other data types. Several users also pointed out the real-world benefits, citing improved performance in benchmarks and specific applications like TensorFlow.js. Some expressed concern about the complexity the change introduces and the potential for unforeseen bugs.

  The Hacker News post titled "Turbocharging V8 with mutable heap numbers · V8" has generated several comments discussing the implications and technical details of the change described in the V8 blog post.

  Several commenters express excitement about the performance improvements, particularly for data-heavy applications and numeric computations in JavaScript. They acknowledge the significant engineering effort required to implement this change in a mature and complex system like V8.

  Some commenters delve into the technical intricacies of the "boxing" and "unboxing" of numbers in JavaScript, and how this change optimizes the handling of heap numbers, reducing overhead and improving memory management. They discuss the challenges of maintaining compatibility and ensuring correct behavior with existing JavaScript code. Specific points of discussion include the distinction between Smis (small integers) and heap numbers, and the conditions under which numbers transition between these representations.

  The discussion also touches on the garbage collection implications of mutable heap numbers. Commenters consider how this change might affect garbage collection cycles and overall memory performance.

  One commenter raises a question about the potential impact on Wasm (WebAssembly) performance, wondering if similar optimizations could be applied in that context.

  Another commenter expresses curiosity about the implications for other JavaScript engines like SpiderMonkey (used in Firefox) and JavaScriptCore (used in Safari), and whether they might adopt similar strategies.

  A few commenters mention related concepts, like tagged pointers, and how they relate to the optimization described in the blog post.

  Overall, the comments reflect a general appreciation for the performance improvements achieved by this change in V8, along with a healthy curiosity about the technical details and broader implications for the JavaScript ecosystem.

• OpenLDK: A Java JIT compiler and runtime in Common Lisp

  permalink

  Posted: 2025-02-05 12:17:47

  Verbose tl;dr

  OpenLDK is a project that implements a Java Virtual Machine (JVM) and Just-In-Time (JIT) compiler written entirely in Common Lisp. It aims to be a high-performance JVM alternative, leveraging Lisp's metaprogramming capabilities for dynamic code generation and optimization. The project features a modular design, encompassing a bytecode interpreter, a tiered JIT compiler using a method-based compilation strategy, and a garbage collector. OpenLDK is considered experimental and under active development, focusing on performance enhancements and broader Java compatibility.

  OpenLDK (Open Lisp Development Kit) is an ambitious project aiming to create a high-performance Java implementation entirely within Common Lisp. It strives to not simply interpret Java bytecode, but to leverage the power of Lisp's metaprogramming capabilities to compile Java code into efficient native machine code using a Just-In-Time (JIT) compiler. This approach offers the potential for significant performance gains compared to traditional Java interpreters or even some existing JIT compilers.

  The project's core is a custom-built JIT compiler written in Common Lisp. This compiler takes Java bytecode as input and translates it into native machine instructions for the target architecture. The choice of Common Lisp as the implementation language is driven by its powerful macro system and flexible runtime environment, which facilitate complex code transformations and optimizations required for an effective JIT compiler. This allows for a potentially more adaptable and extensible JIT compilation process compared to compilers written in lower-level languages.

  OpenLDK also includes a runtime environment written in Common Lisp. This environment provides the necessary infrastructure for executing compiled Java code, including features like garbage collection, thread management, and access to the underlying operating system. By implementing the runtime in Lisp, OpenLDK gains greater control over these crucial aspects of Java execution and can potentially tailor them to specific needs or hardware platforms. This could theoretically enable experimentation with novel garbage collection strategies or concurrency models.

  The project aims to be a fully compliant Java implementation, supporting a wide range of Java features and libraries. While still in its early stages of development, the roadmap indicates intentions to eventually support the full Java standard library and potentially even some popular third-party libraries. This implies significant ongoing development efforts are required to achieve full Java compatibility.

  OpenLDK leverages several existing Lisp libraries for its functionality, including the cl-jclasslib library for parsing Java class files and accessing bytecode information. This reliance on existing components demonstrates a pragmatic approach to development, building upon the mature Lisp ecosystem rather than reinventing the wheel.

  While the project presents a novel and intriguing approach to Java implementation, it is important to note its experimental nature. The project's documentation acknowledges that it is still under active development and may not be suitable for production use. There's likely a considerable amount of work remaining to achieve a stable and performant Java environment. However, the project's potential to explore new frontiers in JIT compilation and language interoperability makes it a compelling endeavor.

  • Java
  • JIT compiler
  • Just-in-Time compiler
  • Runtime
  • Common Lisp
  • OpenLDK
  • compiler
  • virtual machine
  • JVM
  • Lisp
  • Programming Languages
  • Software Development
  • Open Source

  Summary of Comments ( 16 )
  https://news.ycombinator.com/item?id=42947447

  Verbose tl;dr

  Commenters on Hacker News express interest in OpenLDK, primarily focusing on its unusual implementation of a Java Virtual Machine (JVM) in Common Lisp. Several question the practical applications and performance implications of this approach, wondering about its speed and suitability for real-world projects. Some highlight the potential benefits of Lisp's dynamic nature for tasks like debugging and introspection. Others draw parallels to similar projects like Clojure and GraalVM, discussing their respective advantages and disadvantages. A few express skepticism about the long-term viability of the project, while others praise the technical achievement and express curiosity about its potential. The novelty of using Lisp for JVM implementation clearly sparks the most discussion.

  The Hacker News discussion on OpenLDK, a Java JIT compiler and runtime written in Common Lisp, features a moderate number of comments that explore several interesting facets of the project.

  A recurring theme is the perceived unusual choice of Lisp for implementing a Java Virtual Machine (JVM). Several commenters express surprise or curiosity about this decision, questioning the performance implications and rationale behind it. Some speculate about potential benefits, like the flexibility and metaprogramming capabilities of Lisp, which could facilitate experimentation and potentially lead to innovative JVM features. However, skepticism regarding performance, particularly garbage collection and runtime speed, is also voiced.

  There's significant discussion surrounding the practical applications and target audience of OpenLDK. Commenters ponder whether it's intended for specialized use cases like embedded systems or niche applications where the dynamic nature of Lisp might be advantageous. Others question its competitiveness against established JVMs like Hotspot in terms of performance for general-purpose Java development.

  Some commenters delve into the technical details of the project, inquiring about specific implementation choices, like garbage collection strategies and the interaction between Lisp and the generated Java bytecode. There's interest in understanding how the Lisp environment influences the JIT compilation process and the overall runtime behavior.

  The maintainability and future development of the project are also brought up. Given the relatively niche nature of Lisp, some commenters express concern about the long-term viability and potential for community contributions. There are questions about the project's roadmap and whether it aims to become a fully featured, production-ready JVM.

  Finally, the historical context of Lisp in the JVM ecosystem is mentioned. Commenters recall previous attempts to bridge these two worlds, referencing projects like Clojure and ABCL, and discussing the lessons learned from those endeavors. This historical perspective adds another layer to the conversation, highlighting the challenges and opportunities of combining Lisp and Java technologies.