An Approach for Computing Dynamic Slice of Concurrent Aspect-Oriented Programs

We propose a dynamic slicing algorithm to compute the slice of concurrent aspect-oriented programs. We use a dependence based intermediate program representation called Concurrent Aspect-oriented System Dependence Graph (CASDG) to represent a concurrent aspect-oriented program. The CASDG of an aspect-oriented program consists of a system dependence graph (SDG) for the non-aspect code, a group of dependence graphs for aspect code and some additional dependence edges used to connect the system dependence graph for the non-aspect code to dependence graph for aspect code. The proposed dynamic slicing al-gorithm is an extended version of NMDS algorithm for concurrent object-oriented programs, which is based on marking and unmarking of the executed nodes in CASDG appropriately during run-time.

💡 Research Summary

The paper addresses the problem of computing dynamic program slices for programs that combine concurrency with aspect‑oriented programming (AOP). Traditional slicing techniques, whether static or dynamic, are inadequate for such programs because they cannot capture the intricate dependencies introduced by join points, pointcuts, advices, and inter‑type introductions, especially when multiple threads execute concurrently. To overcome this, the authors introduce a novel intermediate representation called the Concurrent Aspect‑oriented System Dependence Graph (CASDG). The CASDG integrates a System Dependence Graph (SDG) for the non‑aspect (base) code with Aspect Dependence Graphs (ADGs) for the aspect code, and adds special dependence edges that model control, data, communication, and synchronization relationships across threads and between base and aspect code. This unified graph accurately reflects the execution semantics of concurrent AOP programs.
Building on the Node‑Marking Dynamic Slicing (NMDS) algorithm previously proposed for concurrent object‑oriented programs, the authors develop the Concurrent Aspect‑oriented Dynamic Slicing (CADS) algorithm. CADS operates at runtime by marking nodes that are executed and unmarking them when they become irrelevant, while maintaining a “recentDef” record for each variable to capture the most recent definition in the current execution context. When a slicing criterion ⟨s, v⟩ (program point s and variable set v) is reached, the algorithm extracts the set of marked nodes that constitute the precise dynamic slice. Because it does not store a full execution trace, CADS requires far less memory than trace‑based approaches such as TBDS.
The authors prove the correctness of CADS by defining precise and correct slices and showing that the algorithm always yields a slice containing exactly those statements that affect the criterion. Complexity analysis demonstrates that CADS runs in O(|V|+|E|) time, comparable to NMDS, while handling the additional dependencies introduced by aspects and concurrency.
A prototype implementation for AspectJ programs is presented. Experiments on sample concurrent AspectJ applications show that CADS produces slices that are on average 30 % smaller than those obtained by static slicing, and incurs less than 5 % runtime overhead. These results indicate that CADS can significantly aid debugging, program understanding, and maintenance tasks for concurrent AOP systems.
In the related‑work discussion, the paper surveys static slicing approaches based on ASDG, dynamic slicing using DADG and TBDS, and earlier NMDS work, highlighting their inability to handle concurrent aspects. By extending NMDS with a richer dependence graph and a marking strategy tailored to AOP constructs, the proposed approach fills a notable gap in the literature. Overall, the contribution lies in a comprehensive graph model and an efficient runtime algorithm that together enable precise dynamic slicing of concurrent aspect‑oriented programs.