Chris Nuernberger, experienced in making code run faster in the context of the JVM and optimizing C++ code, discusses optimizing code in V8 and the JVM, automatic parallelization, Haskell's success as a language, language design choices in rock, challenges of incorporating dynamic libraries in the rock compiler, and the appeal of having everything in one language.
Optimizing Java code on the JVM requires targeting the hotspot and understanding its optimization capabilities.
Virtual function calls in C++ can lead to cache coherence issues and performance loss.
Using transient data structures in Clojure allows for more efficient program optimization and improved performance.
Deep dives
Optimizing code on the JVM
The podcast episode discusses the experiences of Chris Nurnburger, a closure programmer and co-founder of Tekasent, with optimizing code on the Java Virtual Machine (JVM). In his experience, optimizing Java code on the JVM requires working closely with the hotspot, understanding its limitations and optimization capabilities. It is essential to target hotspot and understand the little things it's likely to optimize and the ones it's not likely to optimize. Hotspot's inlining mechanisms are powerful, allowing for the inlining of virtual function calls into loops, resulting in improved performance. Additionally, Chris highlights the impact of GC on higher core machines, where global locks and memory references become more expensive, emphasizing the need to consider GC implications as the number of cores increases.
Virtual Functions and Performance Overhead
This section delves into the performance overhead associated with virtual function calls compared to ordinary function calls in C++. In C++, invoking virtual functions requires dereferencing the virtual function table, leading to potential cache coherence issues, especially if the object is not located near the data. Multiple virtual function calls in quick succession within tight loops can lead to cache misses and a loss of coherency. Additionally, the discussion touches on the cost of handling garbage collection and the impact of the underlying bus in communicating between cores in high core machines.
Optimizing with Transient Data Structures
Chris discusses the concept of transient data structures in Clojure, which allows for performing heavy mutations and modifications before passing the data structures back in an optimized state. By separating algorithms into blocks and using transient data structures, program optimization becomes more efficient. In addition, the conversation explores the benefits and trade-offs of different functional data structures, such as chunked vectors and bitmap trees, and their impact on performance.
The Advantages of Functional Programming on the Frontend
The podcast episode explores the advantages of functional programming on the frontend, specifically with ClosureScript and Elm. Functional programming provides benefits such as live updating, object identity optimization, and improved performance. The discussion highlights seamless.js as an example of optimizing functional JavaScript through the use of object identity. While the advantages of functional programming on the frontend are numerous, teaching functional programming to newcomers might be more challenging compared to imperative programming.
Parallelized reduction and column major data processing
The podcast episode delves into the concepts of parallelized reduction and column major data processing. In parallelized reduction, the reduction process is split into separate threads, each responsible for determining the initial condition, performing the reduction, and merging the results. This process involves functions like the initializer, reducer, and merger. Column major data processing involves organizing data in columns rather than rows, which allows for homogeneous data representation and enables faster processing. Column major form is particularly useful in array languages, where arrays are homogeneous. The episode also discusses the benefits and challenges of column major data processing in closure and closure compiler.
Dynamic binding and challenges in language compilers
The conversation explores dynamic binding and its significance in language compilers. The episode touches on the use of dynamic binding in CUDA libraries, with the ability to compile specific functions based on hardware characteristics. The advantages and challenges of dynamic binding are discussed, including the issues of dependency management in multi-dimensional dependency matrices. The podcast also highlights the difficulty of optimizing closure compiler due to its language model and the trade-offs involved in optimizing for speed versus startup times.
Richard talks with Chris Nuernberger about his experiences making code run faster in the context of the Java Virtual Machine (JVM) and the similarities and differences between that and trying to make C++ code faster...among several other topics!
