Multilevel analysis of the java virtual machine based on kernel and userspace traces

Highlights

• Proposing a multi-level analysis tool for Java applications.

• Using of a low-overhead tracer to collect Kernel and userspace traces.

• Creating a comprehensive visualization system.

Abstract

Performance analysis of Java applications requires a deep understanding of the Java virtual machine and the system on which it is running. An unexpected latency can be caused by a bug in the source code, a misconfiguration or an external factor like CPU or disk contention. Existing tools have difficulties finding the root cause of some latencies because they do not efficiently collect performance data from the different layers of the system. In this paper, we propose a multilevel analysis framework that uses Kernel and userspace tracing to help developers understand and evaluate the performance of their applications. Kernel tracing is used to gather information about thread scheduling, system calls, I/O operations, etc. and userspace tracing is used to monitor the internal components of the JVM such as the garbage collectors and the JIT compilers. By bridging the gap between kernel and userspace traces, our tool provides full visibility to developers and helps them diagnose difficult performance issues. We show the usefulness of our approach by using it to detect problems in different Java applications.

Introduction

Computer programs are becoming increasingly complex. Modern applications involve different interdependent components interacting together and running on optimized multi-core processors. In recent years, there has been an increasing interest in virtual machine based programming languages, because of their flexibility and ease of deployment. A well known example of these languages is Java. Java has been considered as one of the most widely used programming languages in industry (Cass, 2017). It is platform independent and it offers a great amount of advanced technologies like automatic memory management and Just-in-Time compilation.

However, the advanced mechanisms provided by Java made performance debugging more challenging. The developer is usually not fully aware of the internal behavior of the Java virtual machine (JVM) and, as a result, he is unable to pinpoint issues that may happen at runtime. For example, a misconfigured option can cause unnecessary garbage collection cycles that can be easily avoided once detected.

Unexpected behaviors are very hard to detect without proper tools. A wide range of analysis tools are available for developers to evaluate the performance of Java applications. Those tools may be classified into two main classes: monitoring tools and profilers. Monitoring tools provide high level information about the current state of the virtual machine. They present statistics about object allocation, garbage collection, active threads, etc. Profilers give additional information about the logic of the application. By periodically collecting the callstacks of the different threads, profilers can detect slow functions and the logic of the code behind them.

Existing performance analysis tools provide valuable information about the overall performance of Java applications. However, those tools have some limitations. First, the tracing mechanisms used to collect data are not always very efficient and introduce a significant overhead. Second, those tools do not provide a fully integrated analysis that correlates the data gathered from the different layers of the system.

In this paper, we propose a unified Java performance analysis framework that covers the whole software stack, from the user application down to the operating system. We achieve that by using a hybrid approach based on kernel and userspace tracing (Desnoyers, 2009) (Goulet, 2012). We use Kernel tracing to collect low-level information from the operating system (CPU scheduler, Block devices, network interfaces, etc) and userspace tracing to collect information from the different components of the Java virtual machine, such as the garbage collector and the JIT compiler. The traces are collected, synchronized and analyzed using a correlation model. By collecting data from multiple sources and layers, our tool offers full visibility of the system and helps in detecting problems that are very difficult to see otherwise.

We presented different use cases where our tool was able to detect low-level latencies that are difficult to analyze using traditional tools such as I/O and CPU contention. We also showed that our tool does not introduce a big overhead and can be used without altering the normal behavior of applications.

The main contributions are as follows:

• Instrumentation of the Hotspot(Griswold, 1998) virtual machine using LTTng(Desnoyers and Dagenais, 2006), a low-overhead tracer available in Linux.

• Multilevel performance analysis model that correlates and analyses trace data from different sources.

• A Visualization system that helps users understand and identify performance degradations.

The rest of the paper is organized as follows: in Section 2, we introduce the different components of the JVM and we discuss the existing Java performance analysis tools. Then, we describe the architecture of the proposed solution in sections 3 and 4. We present three use cases in Section 5 and we evaluate the efficiency of the framework in Section 6. The conclusion and future work are then presented.