dependence-cache slicing: a slicing method using lightweight dynamic information

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

Dependence-Cache Slicing: A Slicing Method Using Lightweight Dynamic

Information

Tomonori Takada, Fumiaki Ohata, Katsuro Inoue

Osaka University

Background of Research

Software Systems are becoming large and complex

Debugging, testing, and maintaining costs are increasing

To reduce development costs, techniques for improving efficiency of such activities are essential

Comprehension

Comprehending large source programs is difficult

If we could select specific portions in the source programs and we can concentrate our attentions only to those portions, the performance of the activities would increase

A technique of extracting all program statements affecting the value of a variable

Slicing: Extraction

Slice: Collection of extracted statements

Developers can concentrate their attentions to the extracted statements

Program Slicing

Kusumoto, S., Nishimatsu, A., Nishie, K. and Inoue, K. : ``Experimental Evaluation of Program Slicing for Fault Localization'', Empirical Software Engineering, Vol.7, No.1, pp. 49-76 (2002).

To evaluate the validity of slice

With two independent groups

Measured bug detection timewith slice: 122 minutes

without slice: 165 minutes

Experiment Using Program Slice

Static Slicing

Program is analysed statically (without execution)

All possible input data sets are assumed.

Extract all possible statements affecting the value of the focused statement.

Program Dependence Graph (PDG) is used.

Static slices are extracted by traversing edges in PDG.

Program Dependence Graph

PDG shows dependence relations between statements in a source program.

nodes statements

conditional predicates

edges control dependence edges

data dependence edges

Dependences

Control Dependence (CD)Statement s1 has a control dependence to statement s2 if the execution of s2 is decided by s1’s result.

Data Dependence (DD) Def-Use relation.

s1: if a=0 thens2: b :=1;

s3: a := 1;s4: writeln(a);

s3 s4a

Example of PDGprogram test(input, output);var a : array [0..9] of integer;var b, i, c : integer;begin writeln("input array : "); for i:=0 to 9 do a[i] := i * i; writeln("input number : "); readln(b); if b < 10 then c := a[b] else c := -1;

writeln(c)end.

writeln(“inp..

a[i] := i * i

readln(b)

writeln(“inp..

c := a[b]

if b<10

c := -1

writeln(c)

for i:=0 to 9

Example of static sliceprogram test(input, output);var a : array [0..9] of integer;var b, i, c : integer;begin writeln("input array : "); for i:=0 to 9 do a[i] := i * i; writeln("input number : "); readln(b); if b < 10 then c := a[b] else c := -1;

writeln(c)end.

writeln(“inp..

a[i] := i * i

readln(b)

writeln(“inp..

c := a[b]

if b<10

c := -1

writeln(c)

for i:=0 to 9

Slicing Criteria writeln(c)

writeln(c)

for i:=0 to 9 do a[i] := i * i;

readln(b); if b < 10 then c := a[b] else c := -1;

Dynamic Slicing

Program is analysed dynamically (executed with a particular input data)

Extract statements actually affecting the value of a slicing criteria

Execution trace is recorded

Dynamic Dependence Graph(DDG) is constructed from the exection trace.

Dynamic slices are extracted by traversing edges in DDG.

writeln("input array : ");for i:=0 to 9 doa[0] := 0 *0;for i:=0 to 9 doa[1] := 1 *1;for i:=0 to 9 doa[2] :=2 *2;for i:=0 to 9 doa[3] := 3 *3;for i:=0 to 9 doa[4] := 4 *4;for i:=0 to 9 doa[5] := 5 *5;for i:=0 to 9 doa[6] := 6 *6;for i:=0 to 9 doa[7] := 7 *7;for i:=0 to 9 doa[8] := 8 *8;for i:=0 to 9 doa[9] := 9 *9;writeln("input number : ");readln(b);if b < 10 thenc := a[b]writeln(c)

Example of dynamic sliceprogram test(input, output);var a : array [0..9] of integer;var b, i, c : integer;begin writeln("input array : "); for i:=0 to 9 do a[i] := i * i; writeln("input number : "); readln(b); if b < 10 then c := a[b] else c := -1;

writeln(c)end.

for i:=0 to 9 do a[i] := i * i;

readln(b); if b < 10 then c := a[b]

readln(b) writeln(“inp..

c := a[5]

if b<10

writeln(c)

for i:=0 to 9

writeln(“inp..

a[0] := 0*0

for a[1] := 1 * 1

for a[2] := 2 * 2

for a[3] := 3 * 3

for a[4] := 4 * 4

fora[5] := 5 * 5

fora[6] := 6 * 6

fora[7] := 7 * 7

for a[8] := 8 * 8for

a[9] := 9 * 9

inputb=5

writeln(c)

Static and Dynamic Slicing

Analysis cost: static < dynamicRecording execution trace is exhaustive

Determining data dependence and cotrol dependence on execution trace is expensive

Slice size: static > dynamicStatic slicing considers all possible flows

Dynamic slicing only considers one trace

Efficient and Effective SlicingEfficient and Effective Slicing

Unified Slicing MethodsFocusing on Dynamic Control-Flow Information

Hybird Slicing (Gupta, 1997)Collect all traces between break points and procedure callsNeed to specify break points / Trace can be huge

Call-Mark Slicing (Nishimatsu, 1999; our group)Dynamically set call-marks (flags that shows a caller statement is executed or not) Eliminate non-executed statements from PDG by using call-mark and execution dependence relations.

Focusing on Dynamic Data-Flow Information Reduced DDG Method (Agrawal, 1990)

The same sub-structure of DDG is shared with one structure.Run-time overhead is serious.

Dependence-Cache Slicing

Dependence-Cache Slicing (DC slicing) : A slicing method focused on dynamic data-flow information

Control Dependence Easily obtained by syntax analysis

Data Dependence static analysis is difficult

Computation Step1: Pre-Execution Analysis

Statically compute control dependence relations and

construct PDG having control dependence edges and

Computation Step2: Execution-time Analysis

Collect dynamic data dependence relations by using

Caches and add data dependence edges to PDG

s1: a[0]:=0;s2: a[1]:=3;s3: readln(b);s4: a[b]:=2;s5: c:=a[0]+4;s6: writeln(c);

a[0] a[1] b c

s1s1 s2s1 s2 s3

Data Dependence Collection

Input: b=0

Value of cache

s4 s2 s3s4 s2 s3 s5

Each cache holds the statement where the variable is defined

Example of DC sliceprogram test(input, output);var a : array [0..9] of integer;var b, i, c : integer;begin writeln("input array : "); for i:=0 to 9 do a[i] := i * i; writeln("input number : "); readln(b); if b < 10 then c := a[b] else c := -1;

writeln(c)end.

writeln(“inp..

a[i] := i * i

readln(b)

writeln(“inp..

c := a[b]

if b<10

c := -1

writeln(c)

for i:=0 to 9

inputb=5

writeln(c)writeln(c)

for i:=0 to 9 do a[i] := i * i;

readln(b); if b < 10 then c := a[b]

ExperimentMeasured some metric values on our slicing system “Osaka Slicing System (OSS)”

OSS had already implemented features to extract static, call-mark and dynamic slices.

Add function to compute DC slice

Three sample PASCAL programsP1: calendar program (85 lines)

P2 ： wholesaler program (387 lines)

P3 ： wholesaler program2 (871 lines)

Slicing criterion were randomly chosen

Slice Size

182 187

162 166

5 5 80

P1 P2 P3

staticcall-markdependence-cachedynamic

static ＞ call-mark ＞＞ DC ＞ dynamic

DC and dynamic slicing can analyze actual dependence.P2, P3 use array variables.

Pre-Execution Analysis Time

5 19 48N/AN/AN/A

P1 P2 P3

static

call-mark

dependence-cache

dynamic

time(ms)

static call-mark ≒ ＞ DC

DC slicing analyses only control dependence relations.

51 45174

206464

P1 P2 P3

staticcall-markdependence-cachedynamic

Execution time

time(ms)

Static CM DC ≒ ≒ ＜＜ Dynamic

DC slicing can be computed with small overhead increase.

Execution time for static slicing shows the execution time for “original” program.

Slice Computation Time

1.93.0

0.3 0.71.2

76 101 24969

P1 P2 P3

static

call-mark

dependence-cachedynamic

time(ms)

DC ＜ static call-mark ≒ ＜＜ dynamic

DC slicing uses PDG that has less DD edges than that of static slicing.

DiscussionAnalysis cost: static DC << dynamic

Collect dynamic data dependence relatios by simple method

Slice size: static DC dynamiconly “actual” data dependence relations are added to PDG

Reasonable slice results with reasonable analysis timePromising approach to get effective program localization

Limit of DC slicing

DC slice’s accuracy is less than dynamic slice’s.s1: a[0] := 0;s2: a[1] := 1;s3: i:= 0;s4: while i<2 do begins5: b := a[i];s6: i := i + 1 end;s7: writeln(b);

DC slicing analyse dependence relations between statements, not between execution trace.

For this program, DC slicing can’t distinct between first and second execution of s5. (Dynamic slicing can distinct it.)

ApplicationsWe have applied DC slicing to several language environments.

Pascal (Interpreter) OSS mentioned before.

Java source code (Preprocessor) Translate program to collect dynamic data dependence relations.

Java byte code (Compiler, VM) Virtual Machine collects dynamic data dependence Relations Most of Java libraries are provided by byte code

Conclusions and Future Works

Proposed dependence-cache slicingPractical and efficient approach to get reasonable slices

Confirmed validity through an experiment

Applicable to various environments

Future Works

Evaluation through user testing

Apply to other language environments

dependence-cache slicing: a slicing method using lightweight dynamic information

Documents

bamboo slicing machine

the use of program dependence graphs in software...

english salad spinner/ multi-chopper · using the...

bitplane slicing

introducción program slicing pattern matching problema:...

locating dependence structures using search-based...

1 program slicing purvi patel. 2 contents introduction what...

string slicing

program slicing program testing and analysis€¦ · 4....

1 the system dependence graph and its use in program slicing

dynamic slicing

slicing and non slicing floor planning

practical slicing and non-slicing block-packing without...

using dependence graphs for slicing functional programs

brain slicing

garlicginger slicing machine

banana slicing machine

kanshaworkshop slicing

amdocs open 5g network slicing management platform...

program analysis - georgia institute of...