Results 1 
6 of
6
Equivalence of linear, free, liberal, structured program schemas is decidable in polynomial time
, 2004
"... A program schema defines a class of programs, all of which have identical statement structure, but whose expressions may differ. We define a class of syntactic similarity binary relations between linear structured schemas, which characterise schema equivalence for structured schemas that are linear ..."
Abstract

Cited by 7 (7 self)
 Add to MetaCart
(Show Context)
A program schema defines a class of programs, all of which have identical statement structure, but whose expressions may differ. We define a class of syntactic similarity binary relations between linear structured schemas, which characterise schema equivalence for structured schemas that are linear, free and liberal. In this paper we report that similarity implies equivalence for linear schemas, and that a nearconverse holds for schemas that are linear, free and liberal. We also show that the similarity of two linear schemas is polynomialtime decidable. Our main result considerably extends the class of program schemas for which equivalence is known to be decidable, and suggests that linearity is a constraint worthy of further investigation. Key words: structured program schemas, conservative schemas, liberal schemas, free schemas, linear schemas, schema equivalence, static analysis, program slicing Preprint submitted to Elsevier Science 25 November 2006 1
Characterizing Minimal Semanticspreserving Slices of predicatelinear, Free, Liberal Program Schemas
"... Aprogramschemadefinesaclassofprograms,allofwhichhaveidenticalstatement structure, but whose functions and predicates may differ. A schema thus defines an entire class of programs according to how its symbols are interpreted. A slice of a schema is obtained from a schema by deleting some of its state ..."
Abstract
 Add to MetaCart
(Show Context)
Aprogramschemadefinesaclassofprograms,allofwhichhaveidenticalstatement structure, but whose functions and predicates may differ. A schema thus defines an entire class of programs according to how its symbols are interpreted. A slice of a schema is obtained from a schema by deleting some of its statements. We prove that given a schema S which is predicatelinear, free and liberal, such that the true and false parts of every if predicate satisfy a simple additional condition, and a slicing Preprint submitted to Elsevier Sciencecriterion defined by the final value of a given variable after execution of any program defined by S, theminimalsliceofSwhich respects this slicing criterion contains all the symbols ‘needed ’ by the variable according to the data dependence and control dependence relations used in program slicing, which is the symbol set given by Weiser’s static slicing algorithm. Thus this algorithm gives predicateminimal slices for classes of programs represented by schemas satisfying our set of conditions. We also give an example to show that the corresponding result with respect to the slicing criterion defined by termination behaviour is incorrect. This strengthens a recent result in which S was required to be linear, free and liberal, and termination behaviour as a slicing criterion was not considered.
On the computational complexity of dynamic slicing problems for
"... program schemas ..."
(Show Context)
Under consideration for publication in Math. Struct. in Comp. Science On the computational complexity of dynamic slicing problems for program schemas
, 2010
"... Given a program, a quotient can be obtained from it by deleting zero or more statements. The field of program slicing is concerned with computing a quotient of a program which preserves part of the behaviour of the original program. All program slicing algorithms take account of the structural prope ..."
Abstract
 Add to MetaCart
(Show Context)
Given a program, a quotient can be obtained from it by deleting zero or more statements. The field of program slicing is concerned with computing a quotient of a program which preserves part of the behaviour of the original program. All program slicing algorithms take account of the structural properties of a program such as control dependence and data dependence rather than the semantics of its functions and predicates, and thus work, in effect, with program schemas. The dynamic slicing criterion of Korel and Laski requires only that program behaviour is preserved in cases where the original program follows a particular path, and that the slice/quotient follows this path. In this paper we formalise Korel and Laski’s definition of a dynamic slice as applied to linear schemas, and also formulate a less restrictive definition in which the path through the original program need not be preserved by the slice. The less restrictive definition has the benefit of leading to smaller slices. For both definitions, we compute complexity bounds for the problems of establishing whether a given slice of a linear schema is a dynamic slice and whether a linear schema has a nontrivial dynamic slice and prove that the latter problem is NPhard in both cases. We also give an example to prove that minimal dynamic slices (whether or not they preserve the original path) need not be unique. 1.
A Very Efficient and Scalable Forward Static Slicing Approach
"... Abstract—A highly efficient lightweight forward static slicing method is introduced. The method is implemented as a tool on top of srcML, an XML representation of source code. The approach does not compute the program dependence graph but instead dependency information is computed as needed while co ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract—A highly efficient lightweight forward static slicing method is introduced. The method is implemented as a tool on top of srcML, an XML representation of source code. The approach does not compute the program dependence graph but instead dependency information is computed as needed while computing the slice on a variable. The result is a list of line numbers, dependent variables, aliases, and function calls that are part of the slice for a given variable. The tool produces the slice in this manner for all variables in a given system. The approach is highly scalable and can generate the slices for all variables of the Linux kernel in less than 13 minutes. Benchmark results are compared with the CodeSurfer slicing tool and the approach compares well with regards to accuracy of slices. Keywords program slicing; software maintenance; impact analysis; minimal slice I.
Complexity of Data Dependence problems for Program Schemas with Concurrency
, 1007
"... The problem of deciding whether one point in a program is data dependent upon another is fundamental to program analysis and has been widely studied. In this paper we consider this problem at the abstraction level of program schemas in which computations occur in the Herbrand domain of terms and pre ..."
Abstract
 Add to MetaCart
(Show Context)
The problem of deciding whether one point in a program is data dependent upon another is fundamental to program analysis and has been widely studied. In this paper we consider this problem at the abstraction level of program schemas in which computations occur in the Herbrand domain of terms and predicate symbols, which represent arbitrary predicate functions, are allowed. Given a vertex l inthe flowchart ofaschema S having only equality (variable copying) assignments, and variables v,w, we show that it is PSPACEhard to decide whether there exists an execution of a program defined by S in which v holds the initial value of w at at least one occurrence of l on the path of execution, with membership in PSPACE holding provided there is a constant upper bound on the arity of any predicate in S. We also consider the ‘dual ’ problem in which v is required to hold the initial value of w at every occurrence of l, for which the analogous results hold. Additionally, the former problem for programs with nondeterministic branching (in effect, free schemas) in which assignments with functions are allowed is proved to be polynomialtime decidable provided a constant upper bound is placed upon the number of occurrences of the concurrency operator in the schemas being considered. This result is promising since many concurrent systems have a relatively small number of threads (concurrent processes), especially