Conference Paper

Improved Program Dependence Graph and Algorithm for Static Slicing Concurrent Programs.

DOI: 10.1007/11573937_15 Conference: Advanced Parallel Processing Technologies, 6th InternationalWorkshop, APPT 2005, Hong Kong, China, October 27-28, 2005, Proceedings
Source: DBLP

ABSTRACT Based on the comparison among existing slicing algorithms and analysis of the fact that Krinke’s algorithm [9] produces imprecise
program slice for the program structure which has loops nested with one or more threads, a conclusion is drawn that the reason
for the impreciseness is that Krinke’s data structure—threaded program dependence graph—had over coarse definitions of data
dependence relations between threads, and the constraint put on the execution path in concurrent program is unduly loose.
An improved threaded program dependence graph is proposed which adds a new dependence relation of loop-carried data dependence
crossing thread boundaries. An improved slicing algorithm is also proposed which introduces a new concept of regioned execution
witness to further constrain the execution path. The pseudo code of the algorithm adding loop-carried data dependence relations
crossing thread boundaries is given. The pseudo code of the new slicing algorithm is also given whose complexity has been
analyzed. Examples show that the improved slicing algorithm designed on the improved data structure can restrain the impreciseness
of Krinke’s.

0 Bookmarks
 · 
64 Views
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: A program slice extracts a semantically meaningful portion of a program, based upon a user-selected slicing criterion. As the study of program slicing has matured, a growing body of empirical data has been gathered on the size of slices, slicing tools and techniques, the applications of slicing, and the beneficial psychological effects of slices on the programmers who use them. Empirical work on these topics is surveyed, highlighting trends and areas where additional empirical investigation is desirable, either because of contradictory findings or scarcity of results in the existing body of empirical knowledge.
    Advances in Computers. 01/2004;
  • [Show abstract] [Hide abstract]
    ABSTRACT: Hardware description languages (HDLs) are used today to describe circuits at all levels. In large HDL programs, there is a need for source code reduction techniques to address a myriad of problems in design, simulation, testing, and formal verification. Program slicing is a static program analysis technique that allows an analyst to automatically extract portions of programs relevant to the aspects being analyzed. Slicing is fundamentally based on data and control dependences between program points. However, program slicing algorithms have traditionally been designed for sequential languages, and the presence of concurrent constructs such as those found in HDLs complicates slicing considerably. In this paper, we develop the concepts needed for slicing VHDL. The techniques extend readily to other HDLs such as Verilog. Our techniques are based on a slicing-oriented VHDL execution semantics that augments traditional dependences with inter-procedural dependences between VHDL processes. Based on these concepts, we have developed an automatic VHDL slicing tool composed of a traditional slicer and a front-end that captures VHDL simulation semantics. This paper discusses our techniques for VHDL slicing, the slicer tool, and slicing applications in design, simulation, testing, and formal verification of VHDL programs. A particularly important application of HDL slicing is source code reduction leading to reduced state spaces for model checking, and we also present empirical results for this.
    International Journal on Software Tools for Technology Transfer 01/2002; 4:125-137.
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Program slicing is a technique to identify statements that may influence the computations at other statements. Precise slicing has been shown to be undecidable for concurrent programs. This work presents the first context-sensitive approach to slice concurrent programs accurately. It extends the well known structures of the control flow graph and the (interprocedural) program dependence graph for concurrent programs with interference. This new technique does not require serialization or inlining.
    ACM SIGSOFT Software Engineering Notes 12/2003;