CIAO - Composite Instrumentations And Optimizations for multicores

Whereas the use of polymorphism and reflection limits the applicability of static analysis in object-oriented programming languages like Java, dynamic analysis techniques are commonly used for profiling and debugging. Java bytecode instrumentation is a prevailing technique for implementing dynamic analyses, although low-level bytecode manipulation is tedious and it is difficult to instrument all methods in the Java class library. In previous work, we developed the bytecode instrumentation framework FERRARI that ensures full method coverage, as well as the aspect-oriented programming (AOP) framework MAJOR that relies on FERRARI and offers a high-level programming model for specifying a wide variety of dynamic analyses as aspects. In this project, we build on the success of the FERRARI and MAJOR frameworks and explore new research directions in optimizing object-oriented systems for execution on modern multicore hardware. This project will contribute (1) several important enhancements to FERRARI and MAJOR, and (2) a new programming model to better leverage multicores. (1) We will explore flexible mechanisms for composing bytecode instrumentations and AOP-based dynamic analysis tools. The FERRARI framework will be enhanced with support for integrating multiple code versions within method bodies, which is essential to switch between different instrumentations at runtime, particularly for methods in the Java class library. The MAJOR framework will be enhanced with a flexible mechanism to configure the composition of dynamic analysis aspects. In this way, complex toolchains of dynamic analyses can be easily specified. We will also support the application of one dynamic analysis to other dynamic analyses, which can be useful for debugging and optimizing the aspect-based dynamic analyses themselves. (2) Many object-oriented applications and dynamic analyses make little use of the available CPU cores. While programming languages such as Java offer built-in constructs for managing concurrency, as well as comprehensive libraries with advanced synchronizers and executor frameworks, writing concurrent code that scales well on multicores remains difficult. We will explore programming models that ease the exploitation of multicores. We will study the use of deferred methods to specify operations that can be executed asynchronously at a later moment. Instead of synchronously executing an invoked method, input arguments will be buffered in thread-local storage. Full buffers may be processed by other threads. All software developed in this project will be released and help a large community of users in the development of dynamic program analyses.