Philippe Moret

Advanced Java bytecode instrumentation

Bytecode instrumentation is a valuable technique for transparently enhancing virtual execution environments for purposes such as monitoring or profiling. Current approaches to bytecode instrumentation either exclude some methods from instrumentation, severely restrict the ways certain methods may be instrumented, or require the use of native code. In this paper we compare different approaches to bytecode instrumentation in Java and come up with a novel instrumentation framework that goes beyond the aforementioned limitations. We evaluate our approach with an instrumentation for profiling which generates calling context trees of various platform-independent dynamic metrics.

Advanced runtime adaptation for Java

Dynamic aspect-oriented programming (AOP) enables runtime adaptation of aspects, which is important for building sophisticated, aspect-based software engineering tools, such as adaptive profilers or debuggers that dynamically modify instrumentation code in response to user interactions. Today, many AOP frameworks for Java, notably AspectJ, focus on aspect weaving at compile-time or at load-time, and offer only limited support for aspect adaptation and reweaving at runtime. In this paper, we introduce HotWave, an AOP framework based on AspectJ for standard Java Virtual Machines (JVMs). HotWave supports dynamic (re)weaving of previously loaded classes, and it ensures that all classes loaded in a JVM can be (re)woven, including the classes of the standard Java class library. HotWave features a novel mechanism for inter-advice communication, enabling efficient data passing between advices that are woven into the same method. We explain HotWaves programming model and discuss our implementation techniques. As case study, we present an adaptive, aspect-based profiler that leverages HotWaves distinguishing features.

Flexible calling context reification for aspect-oriented programming

Aspect-oriented programming (AOP) eases the development of profilers, debuggers, and reverse engineering tools. Such tools frequently rely on calling context information. However, current AOP technology, such as AspectJ, does not offer dedicated support for accessing complete calling context within aspects. In this paper, we introduce a novel approach to calling context reification that reconciles flexibility, efficiency, accuracy, and portability. It relies on a generic bytecode instrumentation framework ensuring complete bytecode coverage, including the standard Java class library. We compose our program transformations for calling context reification with the AspectJ weaver, providing the aspect developer an efficient mechanism to manipulate a customizable representation of the complete calling context. To highlight the benefits of our approach, we present ReCrash as an aspect using a stack-based calling context representation; ReCrash is an existing tool that generates unit tests to reproduce program failures. In comparison with the original ReCrash tool, our aspect resolves several limitations, is extensible, covers also the standard Java class library, and causes less overhead.

Aspect weaving in standard Java class libraries

Aspect-oriented programming (AOP) has been successfully applied to application code thanks to techniques such as Java bytecode instrumentation. Unfortunately, with current technology, such as AspectJ, aspects cannot be woven into standard Java class libraries. This restriction is particularly unfortunate for aspects that would benefit from a complete bytecode coverage, such as profiling or debugging aspects. In this paper we present an adaptation of the popular AspectJ weaver that is able to weave aspects also into standard Java class libraries. We evaluate our approach with existing profiling aspects, which now cover all bytecode executing in the virtual machine. In addition, we present a new aspect for memory leak detection that also benefits from our approach.

CCCP: complete calling context profiling in virtual execution environments

Calling context profiling is an important technique for locating hotspots in programs. The prevailing data structure is the Calling Context Tree (CCT) that provides dynamic metrics for each calling context. Existing approaches to calling context profiling in Java either limit portability due to the use of native code or of a modified Java Virtual Machine, create incomplete and inaccurate CCTs, or cause excessive overhead. In this paper, we introduce Complete Calling Context Profiling (CCCP), a new approach that reconciles completeness and accuracy of the created CCTs, portability, and moderate overhead. CCCP relies on a generic bytecode instrumentation framework ensuring comprehensive bytecode coverage, including also the standard Java class library. In order to reduce the overhead of accessing the current CCT node, CCCP transforms code such that the caller passes its CCT node to the callee as a special method argument, while ensuring compatibility with native code, reflection, and stack introspection. We use the resulting CCTs for a detailed analysis of the dynamic behavior of Java systems and present a thorough analysis of the origin of runtime overheads.

Reengineering Standard Java Runtime Systems through Dynamic Bytecode Instrumentation

Clones are code segments that have been created by copying-and-pasting from other code segments. Clones occur often in large software systems. It is reported that 5 to 50% of the source code of a large software system is cloned. A major challenge when studying code cloning in large software systems is handling the large amount of clone candidates produced by leading edge clone detection tools. For example, the CCFinder, clone detection tool, produces over 7 million pairs of clone candidates for the Linux kernel (which consists of over 4MLOC). Moreover, the output of clone detection tools grows rapidly as a software system evolves. Researchers and developers need tools to help them study the large amount of clone data in order to better understand the clone phenomena in large systems. In this paper, we propose a data mining framework to help researchers cope with the large amount of data produced by clone detection tools. We propose techniques to reduce, abstract and highlight the most interesting data produced by clone detection tools. Our framework also introduces a visualization tool which allows users to query and explore clone data at various abstraction levels. We demonstrate our framework on a case study of the clone phenomena in the Linux kernel.Java bytecode instrumentation is a widely used technique, especially for profiling purposes. In order to ensure the instrumentation of all classes in the system, including dynamically generated or downloaded code, instrumentation has to be performed at runtime. The standard JDK offers some mechanisms for dynamic instrumentation, which however either require the use of native code or impose severe restrictions on the instrumentation of certain core classes of the JDK. These limitations prevent several instrumentation techniques that are important for efficient, calling context-sensitive profiling. In this paper we present a generic bytecode instrumentation framework that goes beyond these restrictions and enables the customized, dynamic instrumentation of all classes in pure Java. Our framework addresses important issues, such as bootstrapping an instrumented JDK, as well as avoiding measurement perturbations due to dynamic instrumentation or execution of instrumentation code. We validated and evaluated our framework using an instrumentation for exact profiling which generates complete calling context trees of various platform-independent dynamic metrics.

Augmenting static source views in IDEs with dynamic metrics

Mainstream IDEs such as Eclipse support developers in managing software projects mainly by offering static views of the source code. Such a static perspective neglects any information about runtime behavior. However, object-oriented programs heavily rely on polymorphism and late-binding, which makes them difficult to understand just based on their static structure. Developers thus resort to debuggers or profilers to study the systems dynamics. However, the information provided by these tools is volatile and hence cannot be exploited to ease the navigation of the source space. In this paper we present an approach to augment the static source perspective with dynamic metrics such as precise runtime type information, or memory and object allocation statistics. Dynamic metrics can leverage the understanding for the behavior and structure of a system. We rely on dynamic data gathering based on aspects to analyze running Java systems. By solving concrete use cases we illustrate how dynamic metrics directly available in the IDE are useful. We also comprehensively report on the efficiency of our approach to gather dynamic metrics.

Exploiting Dynamic Information in IDEs Improves Speed and Correctness of Software Maintenance Tasks

Modern IDEs such as Eclipse offer static views of the source code, but such views ignore information about the runtime behavior of software systems. Since typical object-oriented systems make heavy use of polymorphism and dynamic binding, static views will miss key information about the runtime architecture. In this paper, we present an approach to gather and integrate dynamic information in the Eclipse IDE with the goal of better supporting typical software maintenance activities. By means of a controlled experiment with 30 professional developers, we show that for typical software maintenance tasks, integrating dynamic information into the Eclipse IDE yields a significant 17.5 percent decrease of time spent while significantly increasing the correctness of the solutions by 33.5 percent. We also provide a comprehensive performance evaluation of our approach.

Parallel dynamic analysis on multicores with aspect-oriented programming

In most aspects, advice are synchronously executed by application threads, which may cause high overhead if advice execution is frequent or computationally expensive. When synchronous advice execution is not a necessity, asynchronous advice execution has the potential to parallelize program and advice execution on multicores. However, asynchronous advice execution requires communication between threads, causing some overhead. In order to mitigate such overhead, we introduce buffered advice, a new AOP mechanism for aggregating advice invocations in a thread-local buffer, which is processed when it is full. For asynchronous processing of full buffers, the communication overhead is paid only once per buffer, instead of once per advice invocation. We present an enhanced AOP programming model and framework based on AspectJ, which ease the use of buffered advice and support pluggable, custom buffer processing strategies. As case study, we optimize an existing aspect for data race detection using buffered advice. A thorough evaluation with standard benchmarks confirms that the use of buffered advice yields significant speedup on multicores.

A Quantitative Evaluation of the Contribution of Native Code to Java Workloads

Many performance analysis tools for Java focus on tracking executed bytecodes, but provide little support in determining the specific contribution of native code libraries. This paper introduces and assesses a portable approach for characterizing the amount of native code executed by Java applications. A profiling agent based on the JVM Tool Interface (JVMTI) accurately keeps track of all runtime transitions between bytecode and native code. It relies on a combination of JVMTI events, Java Native Interface (JNI) function interception, bytecode instrumentation, and hardware performance counters