Program Slicing Tool for Effective Software Evolution Using Aspect-Oriented Technique

1
Program Slicing Tool for Effective Software
Evolution Using Aspect-Oriented Technique

• Takashi Ishio
• Shinji Kusumoto
• Katsuro Inoue
• Osaka University

t-isio, kusumoto, inoue_at_ist.osaka-u.ac.jp
2
Background

• In software evolution process, software is
  modified to adapt for the changes of its
  specification.
• When a programmer changes structure and functions
  of a software, several bugs are usually injected.
• Debugging is an important task in software
  evolution.

3
Debugging Large Scale Software

• Large scale software is difficult to debug.
• Especially, fault localization needs much cost
  since the location where a program crushed is not
  always close to the fault.
• Executed codes for one test case are usually
  small pieces of the program.

Excluding automatically unrelated codes is
effective for fault localization.
4
Program Slicing

• Program Slicing extracts a slice of codes, which
  affects value of a specific variable.
• Program Slicing excludes unrelated codes to aid
  fault localization.

1 a 5 2 b a a 3 if (b gt 0) 4 c
a 5 6 d b
1 a 5 2 b a a 3 if (b gt 0) 4 c
a 5 6 d b
a slice based on slice criteria(6, b)
5
Slice Calculation Process

• Phase 1 Extraction of
• dependence relations
• Data Dependence Relation
• assignment ? reference
• Control Dependence Relation
• conditional statement ? controlled block
• Phase 2 Construction of
• Program Dependence Graph
• node a statement.
• edge a dependence relation
• Phase 3 Traversal of PDG
• traversal backward from a node
• corresponding a slice criteria

slice criteria
6
Dependence-Cache (DC) slicing using dynamic
information

• In slice calculation process, information about
  the statements actually executed is effective to
  decrease the slice size.
• Dynamic information excludes unexecuted codes
  from a slice.
• Dependence-Cache (DC) slicing method uses
• Dynamic Data Dependence Analysis
• Static Control Dependence Analysis
• DC slicing calculates an accurate slice with
  lightweight costs.

7
Implementation of dynamic analysis

• Dynamic analysis, collecting dynamic information
  during program execution, is a kind of logging
  (or tracing).
• Java Virtual Machine (JVM) Customization
• JVM can access all information of the runtime
  environment.
• - Customization depends on a specific JVM
  implementation.
• - Byte code optimization may affect analysis
  results.
• Java Debugger Interface (JDI)
• JDI can access local variables, stack traces,
  ...
• - High runtime cost
• Threads of control are blocked for each logging
  point.
• Although various ways exist in implementing the
  dynamic analysis, each one requires a high cost
  in implementation or in runtime.
• F. Umemori et al. Design and Implementation
  of Bytecode-based Java Slicing System, SCAM
  2003 (to appear)

8
Aspect-Oriented Programming

• A key feature of Aspect-Oriented Programming is
  separation of crosscutting concerns.
• AOP introduces a new module unit named aspect.
• In OOP, programmers cannot encapsulate
  crosscutting concerns
• logging, error handling, some design patterns
• Programmers distribute many call statements into
  related classes for object interaction.
• It is hard to manage the distributed codes.
• In AOP, programmers write a crosscutting concern
  in an aspect.
• An aspect has information when the aspect is
  executed.
• Call statements are needless.
• When a concern is changed, programmers modify one
  aspect instead of related classes.
• AOP improves modularity, maintainability and
  reusability.

9
Example of Aspect

• Logging Logs a method name for each method
  execution.
• In OOP, logging codes are distributed in all
  classes. If logging specification is changed,
  programmers may modify all classes.
• In AOP, logging codes are encapsulated in the
  Logging Aspect. It is easy to maintain and reuse.

when a method is executed, logger.logs(value) is
called.
Class A
Class A
logger.logs(value)
Logging Class
Logging Aspect
Class B
Class B
Class C
Class C
10
AspectJ, an AOP extension for Java

• AspectJ an AOP extension for Java
• An aspect is defined as a set of advices.
• An advice consists of a procedure and pointcut
  designators (PCDs).
• PCDs describe when the procedure is executed.
• AspectJ compiler
• aspects Java class source ? Java bytecode

11
Features of AspectJ

• AspectJ provides the following PCDs
• Method Call and Execution
• Field Assignment and Reference
• Exception Handling
• An advice body is written in plain Java code.
• An advice can access context information through
  thisJoinPoint object.
• Context information is
• Which method is actually executed ?
• What type of object is accessed ?

12
Example of AspectJ

• How to implement logging in AspectJ
• aspect LoggingAspect
• pointcut allMethods()
• execution( (..)) !within(java.io.)
• before() allMethods()
• Logger.println(thisJoinPoint.getSignature())

keyword for Aspect definition
Pointcut is defined by PCDs. Pointcut represents
events during program execution.
When the advice is executed.
In the advice body, programmers can access
context information via thisJoinPoint object.
It is needless to change logging target classes.
13
Dynamic Analysis Aspect

• We implement dynamic analysis using AspectJ.
• 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
  (multi-threading),
• collects information when an exception is thrown
  and which handling clause caught the exception
  (exception-handling).

14
Advantages of Aspect Approach

• Advantages
• Modularization of dynamic analysis
• Independent of a specific JVM implementation
• Independent of a byte-code optimizer ( JIT
  compiler )
• Lightweight Analysis
• for large scale software.
• No local variables are dynamically analyzed.
• Local variables affects dependencies in one
  method.
• Little difference comes from dynamic information
  of local variables.
• No library classes are analyzed.
• We assume that library classes are reliable.
• less overhead The aspect is linked to target
  program at compile time.

15
Aspect-based Dynamic Analysis and Slice
Calculation System ADAS

• Debugging Support Tool using Program Slicing for
  Java
• Dynamic Analysis Aspect (written in AspectJ)
• Simple logging-like Implementation
• size about 1000 LOC
• Program Slicing System (written in Java)
• Program Slicing is an application using dynamic
  information.
• The prototype is implemented as Eclipse plug-in.

16
Architecture and Use Case of ADAS
1.edit
program slice
slice criteria
4.slice calculation
Dynamic Analysis Aspect
Java Source
Slice Calculation Tool
Static Analyzer
2.compile
Java VM
AspectJ
Java Bytecode
3.execute a test case
17
Demonstration
18
Evaluation size of a slice

• Compare with customized JVM implementation
• JVM approach Precise DC Slice
• Our apparoch omitting analysis for local
  variables.
• Target programs
• P1 A simple database (4 classes, 262 LOC)
• P2 A sorting program (5 classes, 228 LOC)
• P3 A slice calculation program (125 classes,
  about 16000 LOC)
• Our approach calculates
• a slice including
• some redundant code
• JVM can extract a precise
• slice using fine-grained
• information.

size of a slice (LOC)
Aspect JVM Aspect/JVM
P1 36 29 1.24
P2 50 28 1.70
P3 839 708 1.19
F. Umemori et al. Design and Implementation
of Bytecode-based Java Slicing System, SCAM 2003
(to appear)
19
Evaluation analysis cost

• Our approach shows good performance.
• Our approach is a coarse-grained, lightweight
  analysis.
• JVM approach is hard to apply a large scale
  software.

ratio
Running Time seconds
Normal Execution Aspect Approach JVM Approach Aspect/Normal JVM/Normal
P1 0.18 0.26 1.8 1.4 10.0
P2 0.19 0.39 2.8 2.1 14.7
P3 1.2 10.3 81.0 8.6 67.5
20
Evaluation Cost of Implementation

• Aspect approach
• Our module consists of the dynamic analysis
  aspect and data management classes.
• The total size is 1000 LOC.
• JVM approach
• System consists of customized JVM and Java
  compiler.
• Customized compiler insert source code
  information into bytecode files.
• Size of additional code for the customization is
  about 50,000 LOC.
• Source code of the original JVM and compiler is
  300,000 LOC.
• Programmers must re-customize the JVM whenever
  new version of JVM is released.
• Aspect approach is inexpensive.

21
Remark and Future Work

• Debugging is an important task for software
  evolution.
• Program slicing shows related code to a user.
• Dynamic information exclude unexecuted code.
• Dynamic Analysis Aspect is
• simple implementation,
• easy to maintain, customize.
• Future Work
• Extension of ADAS to calculate AspectJ slice,
• Improvement of Usability.