Projekt

Zurück zur Übersicht

CIAO: Composite Instrumentations And Optimizations for multicores

Gesuchsteller/in Binder Walter
Nummer 132663
Förderungsinstrument Projektförderung (Abt. I-III)
Forschungseinrichtung Facoltà di scienze informatiche Università della Svizzera italiana
Hochschule Università della Svizzera italiana - USI
Hauptdisziplin Informatik
Beginn/Ende 01.10.2010 - 30.09.2011
Bewilligter Betrag 55'168.00
Alle Daten anzeigen

Keywords (10)

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

Lay Summary (Englisch)

Lead
Lay summary
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.
Direktlink auf Lay Summary Letzte Aktualisierung: 21.02.2013

Verantw. Gesuchsteller/in und weitere Gesuchstellende

Mitarbeitende

Name Institut

Publikationen

Publikation
Comprehensive Aspect Weaving for Java
Villazón Alex, Binder Walter, Moret Philippe, Ansaloni Danilo (2011), Comprehensive Aspect Weaving for Java, in Science of Computer Programming, 76(11), 1015-1036.
Flexible and Efficient Profiling with Aspect-oriented Programming
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.
Portable and Accurate Collection of Calling-Context Sensitive Bytecode Metrics for the Java Virtual Machine
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.
Towards a Domain-specific Aspect Language for Dynamic Program Analysis
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.
Polymorphic Bytecode Instrumentation
Moret Philippe, Binder Walter, Tanter Eric (2011), Polymorphic Bytecode Instrumentation, ACM, New York, NY, USA.
Composition of Dynamic Analysis Aspects
Tanter Eric, Moret Philippe, Binder Walter, Ansaloni Danilo (2011), Composition of Dynamic Analysis Aspects, in ACM SIGPLAN Notices, 46(2), 113-122.
Applications of Enhanced Dynamic Code Evolution for Java in GUI Development and Dynamic Aspect-oriented Programming
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.
Exploiting Dynamic Information in IDEs Improves Speed and Correctness of Software Maintenance Tasks
Röthlisberger David, Härry Marcel, Binder Walter, Moret Philippe, Ansaloni Danilo, Villazón Alex, Nierstrasz Oscar (accepted), Exploiting Dynamic Information in IDEs Improves Speed and Correctness of Software Maintenance Tasks, in IEEE Transactions on Software Engineering, PrePrints.

Wissenschaftliche Veranstaltungen

Aktiver Beitrag

Titel Art des Beitrags Titel des Artikels oder Beitrages Datum Ort Beteiligte Personen


Verbundene Projekte

Nummer Titel Start Förderungsinstrument
118016 FERRARI - Framework for Efficient Rewriting and Reification Applying Runtime Instrumentation 01.10.2007 Projektförderung (Abt. I-III)
136225 FAN: Foundations of dynamic program ANalysis 01.04.2012 Sinergia
127386 SOSOA: Self-Organizing Service-Oriented Architectures 01.02.2010 Sinergia

Abstract

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.