Java Application Performance Research Articles

Research on the performance optimization issue in the Java programming language

The Java programming language, renowned and widely used, provides developers with a powerful platform for creating programs that can scale and respond quickly to user demands. However, to fully harness Java’s potential, it is necessary to delve deeper into optimization possibilities. This article explores the principles, techniques, and best practices that assist Java developers in crafting programs distinguished by speed, efficiency, and responsiveness. Additionally, it examines tools and strategies that aid in identifying problem areas, fine-tuning code, and enhancing the overall performance of Java applications. A fundamental starting point in optimizing Java applications is profiling and analysis. Profiling tools like VisualVM, YourKit, or built-in options like jVisualVM are indispensable for identifying performance bottlenecks. By uncovering areas in need of improvement, these tools facilitate the fine-tuning of applications Efficient memory management plays a critical role in Java optimization. Proper utilization of Java’s Garbage Collection mechanisms is essential. Different GC algorithms should be explored, and heap sizes tailored to the specific needs of the application. This ensures that memory is allocated and deallocated efficiently, minimizing the risk of memory leaks. Java’s support for multithreading is a powerful resource for enhancing performance. In conclusion, Java is a powerful programming language, and optimizing Java applications is a continuous process. By following these principles, techniques, and best practices, developers can create high-performance applications that respond quickly to user demands. Regular profiling, analysis, and testing are essential to maintaining and improving the efficiency and responsiveness of Java applications. Remember that performance optimization is an ongoing journey, not a one-time task.

High Performance Message-passing InfiniBand Communication Device for Java HPC

MPJ Express is a Java messaging system that implements an MPI-like interface. It is used for writing parallel Java applications on High Performance Computing (HPC) hardware including commodity clusters. The software is capable of executing in multicore and cluster mode. In the cluster mode, it currently supports Ethernet and Myrinet based interconnects and provide specialized communication devices for these networks. One recent trend in distributed memory parallel hardware is the emergence of InfiniBand interconnect, which is a high-performance proprietary network and provides low latency and high bandwidth for parallel MPI applications. Currently there is no direct support available in Java (and hence MPJ Express) to exploit the performance benefits of InfiniBand networks. The only option to run distributed Java programs over InfiniBand networks is to rely on TCP/IP emulation layers like IP over InfiniBand (IPoIB) and Sockets Direct Protocol (SDP), which provide poor communication performance. To tackle this issue in the context of MPJ Express, this paper presents a low-level communication device called ibdev that can be used to execute parallel Java applications on InfiniBand clusters. MPJ Express is based on a layered architecture and hence users can opt to use ibdev at runtime on an InfiniBand equipped commodity cluster. ibdev improves Java application performance with access to InfiniBand hardware using native verbs API. Our performance evaluation reveals that MPJ Express achieves much better latency and bandwidth using this new device, compared to IPoIB and SDP. Improvement in communication performance is also evident in NAS parallel benchmark results where ibdev helps MPJ Express achieve better scalability and speedups as compared to IPoIB and SDP. The results show that it is possible to reduce the performance gap between Java and native languages with efficient support for low level communication libraries.

Exploring multi-threaded Java application performance on multicore hardware

While there have been many studies of how to schedule applications to take advantage of increasing numbers of cores in modern-day multicore processors, few have focused on multi-threaded managed language applications which are prevalent from the embedded to the server domain. Managed languages complicate performance studies because they have additional virtual machine threads that collect garbage and dynamically compile, closely interacting with application threads. Further complexity is introduced as modern multicore machines have multiple sockets and dynamic frequency scaling options, broadening opportunities to reduce both power and running time. In this paper, we explore the performance of Java applications, studying how best to map application and virtual machine (JVM) threads to a multicore, multi-socket environment. We explore both the cost of separating JVM threads from application threads, and the opportunity to speed up or slow down the clock frequency of isolated threads. We perform experiments with the multi-threaded DaCapo benchmarks and pseudojbb2005 running on the Jikes Research Virtual Machine, on a dual-socket, 8-core Intel Nehalem machine to reveal several novel, and sometimes counter-intuitive, findings. We believe these insights are a first but important step towards understanding and optimizing managed language performance on modern hardware.

Run‐time optimizations for a Java DSM implementation

AbstractJackal is a fine‐grained distributed shared memory implementation of the Java programming language. Jackal implements Java's memory model and allows multithreaded Java programs to run unmodified on distributed‐memory systems.This paper focuses on Jackal's run‐time system, which implements a multiple‐writer, home‐based consistency protocol. Protocol actions are triggered by software access checks that Jackal's compiler inserts before object and array references. To reduce access‐check overhead, the compiler exploits source‐level information and performs extensive static analysis to optimize, lift, and remove access checks. We describe optimizations for Jackal's run‐time system, which mainly consists of discovering opportunities to dispense with flushing of cached data. We give performance results for different run‐time optimizations, and compare their impact with the impact of one compiler optimization. We find that our run‐time optimizations are necessary for good Jackal performance, but only in conjunction with the Jackal compiler optimizations described by Veldema et al. As a yardstick, we compare the performance of Java applications run on Jackal with the performance of equivalent applications that use a fast implementation of Java's Remote Method Invocation instead of shared memory. Copyright © 2003 John Wiley & Sons, Ltd.

Java runtime systems: characterization and architectural implications

The Java Virtual Machine (JVM) is the cornerstone of Java technology and its efficiency in executing the portable Java bytecodes is crucial for the success of this technology. Interpretation, Just-in-Time (JIT) compilation, and hardware realization are well-known solutions for a JVM and previous research has proposed optimizations for each of these techniques. However, each technique has its pros and cons and may not be uniformly attractive for all hardware platforms. Instead, an understanding of the architectural implications of JVM implementations with real applications can be crucial to the development of enabling technologies for efficient Java runtime system development on a wide range of platforms. Toward this goal, this paper examines architectural issues from both the hardware and JVM implementation perspectives. The paper starts by identifying the important execution characteristics of Java applications from a bytecode perspective. It then explores the potential of a smart JIT compiler strategy that can dynamically interpret or compile based on associated costs and investigates the CPU and cache architectural support that would benefit JVM implementations. We also study the available parallelism during the different execution modes using applications from the SPECjvm98 benchmarks. At the bytecode level, it is observed that less than 5 out of the 256 bytecodes constitute 90 percent of the dynamic bytecode stream. Method sizes fall into a trinodal distribution with peak of 1, 9, and 26 bytecodes across all benchmarks. The architectural issues explored in this study show that, when Java applications are executed with a JIT compiler, selective translation using good heuristics can improve performance, but the saving is only 10-15 percent at best. The instruction and data cache performance of Java applications are seen to be better than that of C/C/sub +/+ applications except in the case of data cache performance in the JIT mode. Write misses resulting from installation of JIT compiler output dominate the misses and deteriorate the data cache performance in JIT mode. A study on the available parallelism shows that Java programs executed using JIT compilers have parallelism comparable to C/C++ programs for small window sizes, but falls behind when the window size is increased. Java programs executed using the interpreter have very little parallelism due to the stack nature of the SVM instruction set, which is dominant in the interpreted execution mode. In addition, this work gives revealing insights and architectural proposals for designing an efficient Java runtime system.

The evolution of a high-performing Java virtual machine

Early JavaTM virtual machines (Jvms) possessed several significant performance bottlenecks that inhibited the speed of Java workloads. This paper presents the methodology that was used by IBM to identify and eliminate these bottlenecks for improving the performance of Java applications running on several operating system platforms. In addition, several of the key performance problems that were common to all early Java virtual machine implementations and how they were solved for IBM enhanced Jvms are described in detail. The issues discussed in this paper are focused on problems found in core Jvm components, such as object synchronization, object allocation, heap management, text rendering, run-time resolution, and Java class library methods. The results obtained from applying the described methodology and eliminating the identified performance bottlenecks increased the performance of IBM Java virtual machines by as much as four times on some workloads. The technology discussed in this paper is applicable to other Jvm implementations.