optimizing the evaluation of patterns in pointcuts
Pointcuts in aspect-oriented programming languages specify runtime events which cause execution of additional functionality. Hereby, pointcuts typically have a pattern-based static component selecting instructions whose execution triggers an event, e.g., a pattern that selects method-call instructions based on the target method's name. Current implementations realize identification of matching instructions by examining all instructions in the executed program and matching them against all patterns found in the program's pointcuts. But such an implementation is slow. An optimized implementation is therefore highly desirable in runtime environments which support the dynamic deployment of aspects; slow pattern evaluation invariably causes a slowdown of the entire application. The patterns used in pointcuts as well as the signatures against they are matched, i.e., method, constructor, and field signatures, are well structured. We present two case studies that survey patterns and signatures actually occurring in the wild. From the resulting data we derive several heuristics that can drive pattern-evaluation optimizations, both by creating indexes over the relevant instructions and by optimizing the order in which the sub-patterns are evaluated.
patterns pointcuts aspect-oriented programming signatures pattern matching