An Aspect Pointcut for Parallelizable Loops

This study investigated the need for a pointcut for parallelizable loops in an aspect-oriented programming environment. Several prototype solutions exist for loop pointcuts, but the solutions are not very granular. In particular, they are not able to differentiate between loops that are parallelizable and those that are not. Being able to identify parallelizable loops automatically, as part of an aspect-oriented compiler\u27s weaving process, is particularly important because (1) manually identifying parallelizable loops is known to be a difficult problem and (2) aspectizing parallelized loops can lead to a reduction in code tangling and an increase in separation of concerns. This paper describes the concepts behind the loop-pointcut problem. It then describes the approach used in this study for implementing a solution in the form of an aspect-oriented Java compiler with a parallelizable loop pointcut. Identifying parallelizable loops is known to be a difficult problem, and as such, this study\u27s parallelizable loop pointcut implements a heuristic solution. The pointcut identifies many parallelizable loops as being parallelizable, but in erring on the side of conservatism, there are some parallelizable loops that the pointcut is unable to identify as parallelizable. To test the parallelizable-loop pointcut, the pointcut was applied to a benchmark set of parallelizable programs. There were two versions of each benchmark program - (1) an aspect-oriented version, where the aspect-oriented compiler\u27s weaver added the multi-threading functionality, and (2) a non-aspect-oriented version, where the benchmark program\u27s source code directly implemented the multi-threading functionality. For each benchmark program, the output from the aspect-oriented version was compared to the output from the non-aspect-oriented version. The study found that each loop that was deemed parallelizable by the aspect-oriented benchmark program was executed in parallel (with multiple threads) by both versions of the program - the aspect-oriented version and the non-aspect-oriented version. There were some loops in the non-aspect-oriented benchmark programs that were deemed parallelizable and executed in parallel, but those same loops were deemed non-parallelizable by their associated aspect-oriented benchmark program. This discrepancy is explained by the study\u27s conservative approach to identifying loops as parallelizable

Statement annotations for fine-grained advising

AspectJ-like languages are currently ineffective at modularizing heterogeneous concerns that are tightly coupled to the source code of the base program, such as logging, invariants, error handling, and optimization. This leads to complicated and fragile pointcuts and large numbers of highly-repetitive and incomprehensible aspects. We propose statement annotations as a robust mechanism for exposing the join points needed by heterogeneous concerns and for enabling declarative fine-grained advising. We propose an extension to Java to support statement annotations and AspectJ’s pointcut language to match them. This allows us to implement heterogeneous concerns using a combination of simple and robust aspects and explicit and local annotations. We illustrate this using a logging aspect that logs messages at specific locations in the source code. Statement annotations also simplify advising specific object instances, local variables, and statements. We demonstrate this using an aspect that traces method calls made to specific object instances and calls made from specific call sites. Keywords statement annotations, byte code annotations, fragile pointcut problem, logging problem, statement-level join points, instance-local advising 1

Realisierung von Softwareproduktlinien durch Komposition von Belangimplementierungen

Softwareproduktlinienentwicklung ist ein Ansatz zur systematischen Wiederverwendung von Softwareartefakten. In dieser Arbeit stellen wir ein Verfahren vor, welches es erlaubt, unterstützte Merkmale einer Produktlinie in Form voneinander abgegrenzter Belangimplementierungen zu spezifizieren und diese zu maßgeschneiderten Varianten der Produktlinie zu komponieren. Das Verfahren vereinigt hierzu Konzepte der mehrdimensionalen Belangtrennung, der generischen Programmierung sowie der Generierung