Debugging Support for AspectOriented Program Using Program Slicing

Debugging Support for Aspect-Oriented Program Using Program Slicing and Call Graph Takashi Ishio, Shinji Kusumoto, Katsuro Inoue Osaka University {t-isio, kusumoto, inoue}@ist. osaka-u. ac. jp Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 1

Overview Aspect-Oriented Programming AOP’s advantage and disadvantages Difficulties in debugging AOP program Proposed Method Program Slicing extended for AOP Loop Detection based on Call Graph (not included in this presentation) Implementation Evaluation Conclusion Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 2

Aspect-Oriented Programming Key Idea: Separation of crosscutting concerns In OOP, programmers cannot encapsulate crosscutting concerns: logging, error handling, transactions, security, . . . Code for object interaction is scattered to related classes. It is hard to manage scattered code. In AOP: A crosscutting concern == An aspect When a concern is changed, programmers modify one aspect instead of related classes. Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 3

Aspect. J, an AOP extension for Java Aspect. J: an AOP extension for Java An aspect is defined as a set of advices. Advice: a procedure + a condition when the procedure is executed. A condition = before or after specific events, or instead of the events (around). Around advice uses proceed keyword to execute the original event. Events are specified by Pointcut Designators (PCDs) including: – Method Call and Execution – Field Assignment and Reference – Exception Handling A procedure is written in plain Java with this. Join. Point object representing the event information. Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 4

Simple Example of Aspect aspect Logging. Example { after(): execution(void *. foo(int)) { Logger. logs(this. Join. Point. get. Signature()); } } An advice knows when the advice is executed. Call statements in classes are removed. A. foo(int v) Logger. logs(“A. foo”); A. foo(int v) B. foo(int v) Logging Class B. foo(int v) C. foo(int v) Logger. logs(“C. foo”); when a method is executed, logger. logs(v) is called. Logging Aspect C. foo(int v) Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 5

Advantages of AOP improves: Maintainability Programmers change one aspect instead of multiple classses. Reusability Programmers can reuse classes and aspects independently. – Reuse classes without aspect, or – Reuse aspects for other classes Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 6

Disadvantages of AOP is useful, but. . . several drawbacks exist. Fault localization is difficult since: A programmer needs to investigate related classes and aspects to understand the system behavior. When a class is affected by several aspects, the result is hard to predict. e. g. Logging + Transaction ? ? ? A transaction process is logged, or Logging is transactional, or. . . ? The result depends on the definition of aspects, or compiler/interpreter implementation Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 7

Our Approach Debugging Support esp. fault localization (investigation) task Extending Program Slicing for AOP Program Slicing is a technique to aid fault localization. Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 8

Program Slicing extracts a slice of codes, 　 which affects the value of a specific variable. 1: 2: 3: 4: 5: 6: a = 5; b = a + a; if (b > 0) { c = a; } d = b; a slice based on slice criteria（6, b） 1: 2: 3: 4: 5: 6: a = 5; b = a + a; if (b > 0) { c = a; } d = b; Program Slicing excludes unrelated codes to aid fault localization. Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 9

Slice Calculation Process Phase 1: Extraction of dependence relations Data Dependence Data: assignment reference Control: conditional statement controlled block Phase 2: Construction of Program Dependence Graph node: a statement. edge: a dependence relation Phase 3: Traversal of PDG 1: a = 1; 2: c = 4; 3: b = a; a Control Dependence 4: if (a < 1) { 5: b = a; 6: } Program Dependence Graph traversal backward from a node corresponding a slice criterion Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 10

DC-Slicing for OOP DC-Slicing: a slicing method combining static and dynamic information. control dependence relations static analysis data dependence relations dynamic analysis Dynamic information is used for data dependence analysis to distinguish object instances method call analysis to solve polymorhpic method calls Size and Cost: Size: Dynamic Slice < DC-slice < Static Slice Cost: Static Slice < DC-slice < Dynamic Slice Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 11

DC-Slicing Extended for AOP Basic Idea: Advice Execution is similar to Method Call An advice is executed when a condition is satisfied. A statement which satisfies a condition calls the advice. Aspect. J Developement Tools plug-in indicates an advice execution as a marker. Extending PDG and Call Graph Advice Call Vertex and Advice Execution Edge A vertex is inserted into the place of the statement which calls an advice An edge connected to an advice body Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 12

Control Flow Modified by Aspect A method call statement a. foo(); Advices executed for each method call after: call(A. foo()) {. . . } around: call(A. foo()) {. . . } the part of around advice proceed a path a. foo(); without proceed after advice call the rest part of the around advice Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 13

Dynamic Elements in AOP Dynamic Pointcut: if, cflow if(expr): When expr is true, the advice is executed. cflow(PCD): all events reached from PCD cflow( execution(C. foo() ) ) == all events during C. foo() is executing. Converted to an advice call with “may be executed” control dependence relation. We use dynamic information to resolve dynamic pointcut. Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 14

Implementation Slicing tool as an Eclipse plug-in Environment: Eclipse 2. 1 + Aspect. J 1. 0. 6 Integrated Function: PDG construction – [Compile]-[Rebuild All] constructs PDG – A call graph is also constructed. – A method call loop including advices is recorded as “infinite loop candidates”. Slice Calculation – is started by a button of a tool bar – calculates a slice and indicates a slice on the text editor. Dynamic Analysis is not integerated to IDE. Dynamic analysis code is also inserted using Aspect. J. A programmer need to execute a program once. Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 15

Screenshot Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 16

Experiment Debugging Experiment We have 12 students debug an Aspect. J program. All students have used Java, but not Aspect. J. devided into two groups; a group working with a program slice, another without the slice Environment: Eclipse 2. 1 + Aspect. J Development Tools Procedure: A lecture for using Eclipse Debugging a Java program using Eclipse. (PRE 1) A lecture for Aspect. J Write an Aspect. J program using Eclipse. (PRE 2) Debugging a Aspect. J program using Eclipse. (DEBUG) Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 17

Debugged Program An Aspect. J Program “Eval Expression” Input: an expression represented by a graph. An evaluation = graph traversal Output: (* (+ 2 3) ) = 25 5 classes (Graph nodes) and 4 aspects, 340 LOC Loop Detection, Caching, Print, Cleanup The program contains a bug. Print Aspect generates a String representation of a graph. But the generated string is incorrect in several test cases. Gives test cases to all students. Gives a program slice to one group (6 students). The variable contains the output is specified as a slice criterion. Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 18

A fragment of program slice public aspect Caching. Aspect { // member of this Aspect static private Set workers = new Hash. Set(); // add a member to Worker class private boolean Worker. is. Already. Calculated = false; pointcut work_call() : call(void Worker. work()); pointcut first_work_call() : work_call() && !cflowbelow(work_call()); void around(): work_call() { Worker w = (Worker)this. Join. Point. get. Target(); if (w. is. Already. Calculated) return; else { proceed(); w. is. Already. Calculated = true; workers. add(w); } } // clear the flag when calculation process is finished after(): first_work_call() { for (Iterator it = workers. iterator(); it. has. Next(); ) { Worker w = (Worker)it. next(); w. is. Already. Calculated = false; } workers. clear(); } When a node is already visited, return the value of the node. Otherwise, visit the node and set a “visited” flag. When a node is skipped, Print Aspect’s advice is also skipped. Reset flags after evaluation Excluded because flags do not affect the output. } Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 19

Result Effectiveness is evaluated based on working time. Program slicing is used only “DEBUG” task. Students working with a program slice completed DEBUG task faster than students without a slice. However, the effectiveness is not statistically confirmed. Average Working Time (Unit: Minutes) Group 1 (without a slice) 2 (with a slice) PRE 1　 PRE 2 (Java) (Aspect. J) 150 186 200 210 DEBUG (Aspect. J) 200 190 Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 20

Discussion From an interview to the students: A program slice is useful to investigate the problem. A slice is a good starting point to read a program. A slice is used to reduce the scope of investigation. “unrelated aspects” is very useful information. A program slice is not useful to fix a problem. A programmer must investigate the influence of the modification to fix a problem. Changes of classes and aspects may affect other aspects. Other methods such as impact analysis should be combined to support bug-fixing task. Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 21

Conclusion Debugging Support for AOP Key Idea: Advice Execution == Method Call Loop Detection using Call Graph Application of Program Slicing indicates dependence relations changed by aspects is effective to localize a fault. Future Work Visualization of Inter-aspect relations for large-scale software Combining other technique to fix a fault, e. g. impact analysis Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 22

Any questions/comments ? Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 23

Applicability Our program slicing extension is based on Join Point Model. Dynamic slicing for Java byte-code is also applicable. However, join point shadows are embedded into the byte code. It is hard to untangle byte-code without aspect information. Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 24

Overview of Aspects Relation Two aspects included in the program slice. Print and Cleanup are dominated by Caching included in the Slice join point: ②around call visit a node recursive Caching call ① ③proceed ⑤after before, visit ④after method body Cleanup Loop. Detect Print Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 25

Collected Data Students submitted: What causes a problem How to fix a problem Modified Source Code Time requried to complete the work Thought about Program Slicing Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 26

Experiment 1: Applying tool Apply program slicing to 5 Aspect. J design pattern implementation. Evaluate analysis cost Target: 5 Design Pattern implementation in Aspect. J Observer, Chain. Of. Responsibility, . . . Average size: about 500 lines of code Test: Execute a sample code, and calculates a slice specify a output variable as a slice criterion. Comparation to AJDT’s marker Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 27

Evaluation Program slicing reduces complexity Aspects added dependence relations. tracking by hands is costly since relations crosscutting many modules (files). Slice can indicates a lost of dependence relations. A statement skipped by an aspect (e. g. around advice) Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 28

Modified Dependence Relation A developer tracks: void f 1() { x = f 2(); 　： } int f 2() { return do. Something(); } int f 3() { return do. Something 2(); } aspect redirect. Method. Call { int around(): call(f 2) { return f 3(); An advice replaces a } method call } A calculated slice: void f 1() { x = f 2(); 　： } int f 2() { return do. Something(); } int f 3() { return do. Something 2(); } aspect redirect. Method. Call { int around(): call(f 2) { return f 3(); } } Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 29

Analysis Cost Time Static analysis = a traversal to AST generated by compiler. Dynamic analysis: executes a program with dynamic analysis. The performance depends on a target program and a test case. about 2 times longer than normal execution on the average. Memory The analysis cost depends on a number of join points affected by aspects. Analyze 10000 LOC Java Code 20 MB + 1000 LOC Aspect Logging All Events 100 MB required ! Too many method calls, executions, field set and get are extracted. Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 30

Dynamic Analysis Aspect We implement dynamic analysis using Aspect. J. Dynamic analysis aspect records a position of the assignment statement when a new value is assigned to a field, extracts a dynamic data dependence relation when the field is referred, collects method-call information for each thread (multithreading), collects information when an exception is thrown and which handling clause caught the exception (exceptionhandling). Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 31

Call Graph Example 凡例 Aspect Class call An inifnite loop Software Engineering Laboratory, Department of Computer Science, Graduate School of Information Science and Technology, Osaka University 32