Philipp Lengauer

Accurate and Efficient Object Tracing for Java Applications

Object allocations and garbage collection can have a considerable impact on the performance of Java applications. Without monitoring tools, such performance problems are hard to track down, and if such tools are applied, they often cause a significant overhead and tend to distort the behavior of the monitored application. In this paper we present a new light-weight memory monitoring approach in which we trace allocations, deallocations and movements of objects using VM-specific knowledge. We strive for utmost compactness of the trace by using a binary format with optimized encodings for different cases of memory events and by omitting all information that can be reconstructed offline when the trace is processed. Our approach allows us to reconstruct the heap for any point in time and to do offline analyses both on the heap and on the trace. We evaluated our tracing technique with more than 30 benchmarks from the DaCapo 2009, the DaCapo Scala, the SPECjvm 2008, and the SPECjbb 2005 benchmark suites. The average run-time overhead is 4.68%, which seems to be fast enough for keeping tracing switched on even in production mode.

The taming of the shrew: increasing performance by automatic parameter tuning for java garbage collectors

Garbage collection, if not tuned properly, can considerably impact application performance. Unfortunately, configuring a garbage collector is a tedious task as only few guidelines exist and tuning is often done by trial and error. We present what is, to our knowledge, the first published work on automatically tuning Java garbage collectors in a black-box manner considering all available parameters. We propose the use of iterated local search methods to automatically compute application-specific garbage collector configurations. Our experiments show that automatic tuning can reduce garbage collection time by up to 77% for a specific application and a specific workload and by 35% on average across all benchmarks (compared to the default configuration). We evaluated our approach for 3 different garbage collectors on the DaCapo and SPECjbb benchmarks, as well as on a real-world industrial application.

Efficient Rebuilding of Large Java Heaps from Event Traces

Understanding and tracking down memory-related performance problems, such as long garbage collection times and memory leaks, is a tedious task in large and complex applications. Memory profilers can support developers in this task by recording detailed traces of the applications memory behavior which can then be analyzed offline. Unfortunately, these traces can become huge, and processing them is a real challenge. If the goal is to rebuild the heap from a trace in order to analyze it, most state-of-the-art tools perform badly, because they are either too slow or provide only a coarse-grained view of the monitored application. In this paper we present novel techniques and data structures for efficiently processing large event traces and for reconstructing the heap with only a fraction of the monitored applications memory. The reconstructed heap contains vital information about all objects, such as their addresses, their types, their allocation sites, and their allocating threads. We also provide a detailed evaluation of our approach on 33 benchmarks, showing that we can rebuild the heap from a trace efficiently using only about 18% of the memory that was used in the monitored application.

Where has all my memory gone?: determining memory characteristics of product variants using virtual-machine-level monitoring

Non-functional properties such as memory footprint have recently gained importance in software product line research. However, determining the memory characteristics of individual features and product variants is extremely challenging. We present an approach that supports the monitoring of memory characteristics of individual features at the level of Java virtual machines. Our approach provides extensions to Java virtual machines to track memory allocations and deal-locations of individual features based on a feature-to-code mapping. The approach enables continuous monitoring at the level of features to detect anomalies such as memory leaks, excessive memory consumption, or abnormal garbage collection times in product variants. We provide an evaluation of our approach based on different product variants of the DesktopSearcher product line. Our experiment with different program inputs demonstrates the feasibility of our technique.

Efficient Memory Traces with Full Pointer Information

Tracing objects and their references is paramount for tracking down memory-related performance problems. In this paper, we present a novel approach for recording references between objects at minimal run-time overhead. Extending our memory monitoring tool AntTracks with pointer information allows for a complete reconstruction of the heap before and after garbage collections as well as for an offline analysis of all garbage collection decisions made. Additionally, we describe several trace optimization techniques, such as exploiting VM-internal information, to reduce the tracing overhead even further. We evaluate our approach by means of the DaCapo benchmark suite and a selection of memory-intensive benchmarks from the DaCapoScala benchmark suite and the SPECjvm benchmark suite.

Efficient and Viable Handling of Large Object Traces

Understanding and tracking down memory-related performance problems is a tedious task, especially when it involves automatically managed memory, i.e., garbage collection. A multitude of monitoring tools show the substantial need of developers to deal with these problems efficiently. Unfortunately, state-of-the-art tools either generate an inscrutable amount of trace data or produce only a coarse-grained view of the applications memory behavior. While the first approach generates information that is very detailed albeit difficult to handle, the second approach is more efficient but may fail to provide vital information. In this paper, we propose a method to combine the advantages of both approaches, i.e., a method to handle fine-grained tracing information efficiently. Specifically, we present an on-the-fly compression technique for tracing data with reasonable overhead. Furthermore, we show how to overwrite old parts of the trace to circumvent its unlimited growth, but almost without losing vital information. We also provide a detailed evaluation of our approach, showing that the introduced run-time overhead is negligible compared to similar tracing tools as well as that the information quality recovers quickly after overwriting parts of the old tracing data.

User-centered Offline Analysis of Memory Monitoring Data

State-of-the-art memory monitoring tools collect lots of raw data. Yet, the analysis of this data is often not well supported. Existing tools restrict the user in the way how to analyze the underlying data, how to process it, and how to visualize it. This results in the dilemma that the raw data often contains more information than what can be exploited. We present a novel user-centric approach, allowing custom offline analysis and visualization of memory monitoring data by employing user-defined classification on heap objects. Putting the user in the center of the analysis process and providing flexible query and classification interfaces can change the way how we monitor memory usage. Our goal is to turn special-purpose memory monitoring tools into more general and customizable tools.

A Comprehensive Java Benchmark Study on Memory and Garbage Collection Behavior of DaCapo, DaCapo Scala, and SPECjvm2008

Benchmark suites are an indispensable part of scientific research to compare different approaches against each another. The diversity of benchmarks is an important asset to evaluate novel approaches for effectiveness and weaknesses. In this paper, we describe the memory characteristics and the GC behavior of commonly used Java benchmarks, i.e., the DaCapo benchmark suite, the DaCapo Scala benchmark suite and the SPECjvm2008 benchmark suite. The paper can serve as a useful guide to select benchmarks in accordance with desired application characteristics on modern virtual machines as well as with different compilers and garbage collectors. It also helps to put results that are based on these benchmarks into perspective. Additionally, we compare Javas current default collector to the G1 GC.

Building Custom, Efficient, and Accurate Memory Monitoring Tools for Java Applications

Traditional monitoring techniques can distort application behavior significantly. In this paper, we will provide an evaluation of state-of-the-art monitoring techniques and their impact on memory behavior. We will use AntTracks to show how VM-internal approaches can extract more diverse memory information at object level, vastly outperforming traditional techniques.

DuckTracks: Path-based Object Allocation Tracking

Efficiently tracking an applications object allocations is of interest for areas such as memory leak detection or memory usage optimization. The state-of-the-art approach of instrumenting every allocation site with a counter introduces considerable overhead. This makes allocation tracking in a production environment unattractive. Our approach reduces this overhead by instrumenting control flow paths instead of allocation sites and dynamically determining the hot path through a method. Our ultimate goal is to reduce the amount of required counter increments by such a degree that using it in production environments becomes feasible. We present an implementation of our approach for the Java HotSpot Virtual Machine. First measurements already show a reduction of required increments of up to 30% compared to the state of the art.