Frequently Asked Questions:
- What was the major change in the OpenJDK commit? The major change was replacing the method of parsing /proc files with a syscall to clock_gettime, significantly reducing the complexity and increasing the performance of obtaining thread CPU times.
- Why was the original /proc file parsing method slower? The original method involved multiple system calls and complex parsing in user space, which increased overhead and was particularly slow under concurrent load due to system resource contention.
- How did the new method improve performance? By using the clock_gettime syscall, the new method reduced the number of system calls and eliminated the need for complex parsing, directly accessing the required information and thus speeding up the operation.
- What further optimizations were suggested? Further optimizations included modifying the clockid construction to use a kernel 'fast-path' that avoids certain lookups, potentially reducing overhead even more.
- How does this change impact end users of JDK? End users benefit from significantly improved performance of thread CPU time calculations without having to make any changes to their applications, as the enhancements are integrated directly into the JDK.
Summary
A fascinating exploration of a significant performance optimization in Java's OpenJDK, where a simple code revision eliminated a 400x performance discrepancy. The original implementation used a cumbersome file parsing approach via /proc files to obtain thread CPU times, which was not only slow but also complex due to its reliance on multiple system calls and parsing mechanisms. The revised implementation streamlined this process by directly using the clock_gettime syscall, thereby bypassing the overhead of file I/O and parsing, leading to a substantial increase in efficiency particularly under high concurrency scenarios.
Highlights:
- 40 lines of code removed to fix a 400x performance issue in Java.
- Replaced complex /proc file parsing with a simple clock_gettime syscall.
- Optimization revealed during routine skimming of OpenJDK commit logs.
- Demonstrated substantial performance improvements via benchmarking.
- Potential further optimization by avoiding radix tree lookups in the kernel.
An OpenJDK commit highlighted a significant optimization by replacing the older method of reading /proc files to determine thread CPU times with a streamlined syscall approach using clock_gettime. The original method involved multiple system calls including open, read, and close, alongside complex parsing operations in user space, which were significantly slower and more resource-intensive compared to the new method. This change addressed a performance gap where the old approach was 30x to 400x slower than the new method, particularly under concurrent load conditions where system resource contention was high.
The original method's complexity was due to its adherence to POSIX standards, which required separation of user and system CPU times, a feature not directly supported by the simpler clock_gettime approach. However, with Linux-specific enhancements and understanding of kernel internals, such as the encoding of clock type information directly into the clockid_t value, a more efficient approach was devised. This not only aligned with POSIX requirements but also leveraged Linux-specific features to bypass performance bottlenecks.
Further exploration and benchmarking revealed that even more optimizations could be possible. For instance, modifying the clockid construction to use a 'fast-path' in the kernel, avoiding certain lookups, could further reduce overhead. These continuous improvements underscore the importance of revisiting and questioning old assumptions in code, leveraging both documented and obscure system behaviors to enhance performance. The change was timely, integrated into JDK just before a major release, ensuring significant performance improvements for end users without requiring any changes on their part.