Bytecode instrumentation; Aspect-oriented programming (AOP); Programming models; Executor frameworks; Self-tuning in concurrent systems; Data race detection; Virtual mchines; Multicores; aspect-oriented programming; virtual machines
Villazón Alex, Binder Walter, Moret Philippe, Ansaloni Danilo (2011), Comprehensive Aspect Weaving for Java, in Science of Computer Programming
, 76(11), 1015-1036.
Binder Walter, Ansaloni Danilo, Villazón Alex, Moret Philippe (2011), Flexible and Efficient Profiling with Aspect-oriented Programming, in Concurrency and Computation: Practice and Experience
, 23(15), 1749-1773.
Sarimbekov Aibek, Sewe Andreas, Binder Walter, Moret Philippe, Schoeberl Martin, Mezini Mira (2011), Portable and Accurate Collection of Calling-Context Sensitive Bytecode Metrics for the Java Virtual Machine, ACM, New York, NY, USA.
Moret Philippe, Binder Walter, Tanter Eric (2011), Polymorphic Bytecode Instrumentation, ACM, New York, NY, USA.
Binder Walter, Moret Philippe, Ansaloni Danilo, Sarimbekov Aibek, Yokokawa Akira, Tanter Eric (2011), Towards a Domain-specific Aspect Language for Dynamic Program Analysis, ACM, New York, NY, USA.
Würthinger Thomas, Binder Walter, Ansaloni Danilo, Moret Philippe, Mössenböck Hanspeter (2011), Applications of Enhanced Dynamic Code Evolution for Java in GUI Development and Dynamic Aspect-oriented Programming, in ACM SIGPLAN Notices
, 46(2), 123-126.
Tanter Eric, Moret Philippe, Binder Walter, Ansaloni Danilo (2011), Composition of Dynamic Analysis Aspects, in ACM SIGPLAN Notices
, 46(2), 113-122.
Röthlisberger David, Härry Marcel, Binder Walter, Moret Philippe, Ansaloni Danilo, Villazón Alex, Nierstrasz Oscar, Exploiting Dynamic Information in IDEs Improves Speed and Correctness of Software Maintenance Tasks, in IEEE Transactions on Software Engineering
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 the FERRARI project, we have been developing 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 extension, 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 extension will contribute (1) several important enhancements to FERRARI and MAJOR, (2) new self-tuning concurrent data structures and executors, (3) a new programming model to better leverage multicores, and (4) improved data race detection algorithms and implementations thereof.(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) In many concurrent applications, as well as in dynamic analyses, shared data structures become performance bottlenecks. Thread-safety introduces overheads, particularly if access to the shared data structures is highly contended. We will explore new concurrent data structures, such as for representing various kinds of profiles generated by dynamic analyses. Our investigations will concentrate on self-tuning features, such as switching between representations depending on the level of contention. In addition, we will integrate self-tuning capabilities into executors, such as the thread-pool executors provided in Java, aiming at reducing contention on the task queues and improving locality in task execution. We will study how low-level performance metrics as provided by hardware performance counters can help self-tuning at runtime. While the results of this research will benefit a large variety of concurrent applications and dynamic analyses, they will be also applied for parallelizing and optimizing instrumentation and aspect weaving in the FERRARI and MAJOR frameworks.(3) 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. We will also explore the benefits of executing deferred methods when a thread would otherwise enter a blocking or waiting state.(4) Data races are common errors in concurrent programs that are difficult to detect and reproduce. In the literature, many static and dynamic data race detection algorithms have been presented. Still, most of them suffer from imprecisions, such as false positives or negatives, sensitivity to thread scheduling, and high overhead. We will leverage the FERRARI and MAJOR frameworks, the optimized and self-tuning concurrent data structures and executors, and the programming model for better exploiting multicores, in order to develop an efficient aspect-based data race detector that addresses the aforementioned limitations. All software developed in this project extension will be released open-source and help a large community of users in the development of dynamic program analyses, in optimizing applications for multicores, and in debugging concurrent systems. The developed software will be thoroughly evaluated using large, real-world workloads on different multicore architectures in order to ensure validity over a wide range of different platforms.This project extension, which also fosters national and international collaborations with experts in different areas, asks for the funding of three PhD students; one PhD student for one year, and two new PhD students for three years.